Cursor's Z coordinate display for NonUniformImage is inconsistent with image #18652
Comments
|
.. .does seem a problem. But out of curiosity, why are you using |
|
It's a general way to display data with a possibly uneven grid that should be faster than contouring methods, right? Is there a better way that I'm missing? |
|
|
|
I'm having trouble using pcolorfast when x and y aren't uniformly spaced (it throws a ValueError, copied below). NonUniformImage seems to have a substantial speed advantage over pcolormesh, and pcolormesh doesn't give a Z value for the cursor. The three methods also don't draw the boxes in the same places, which can be seen when z doesn't have many elements. For a 5x5:
I discovered another problem: NonUniformImage reports z values according to cell boundaries similar to those shown by pcolorfast. That is, the transition from [7] to [8] in the 5x5 doesn't occur where the edge appears to be in the panel that used NonUniformImage; it appears along where the corresponding line from pcolorfast would be. I couldn't see this before with the 200x200 sample. Timing data (code below): When x and y are generated by Alright, so for fewer than a few thousand by a few thousand, I might not notice, but at the 5001x5001, level, it's > 1 sec vs 0.06 s. That might matter. On the other hand, if pcolorfast worked better (consistent mapping of cell edges to X values and able to handle nonuniform X values), it might be the best, since it's not much slower than NonUniformImage for evenly spaced data. Test codeimport numpy as np
import matplotlib
import matplotlib.pyplot as plt
import platform
import time
print(platform.python_version())
print(matplotlib.__version__)
print(matplotlib.get_backend())
fig, axs = plt.subplots(3)
use_arange = True
if use_arange:
x = np.arange(201)
y = np.arange(len(x))
else:
x = np.linspace(0, 1, 201) ** 2 * 200 + 10
y = np.linspace(0, 1, len(x)) ** 2 * 200 - 10
z = x[:, np.newaxis] + y[np.newaxis, :]
print(f'shape(x) = {np.shape(x)}, shape(y) = {np.shape(y)}, shape(z) = {np.shape(z)}')
t0 = time.time()
ax = axs[0]
obj = matplotlib.image.NonUniformImage(ax=ax)
obj.set_data(x, y, z)
ax.add_image(obj)
ax.set_xlim(x.min(), x.max())
ax.set_ylim(y.min(), y.max())
t1 = time.time()
ax = axs[1]
ax.pcolormesh(x, y, z)
t2 = time.time()
ax = axs[2]
ax.pcolorfast(x, y, z)
t3 = time.time()
print(
f'{len(x)} points: NonUniformImage: {t1 - t0:0.3e}, '
f'pcolormesh: {t2 - t1:0.3e} ({(t2 - t1) / (t1 - t0):0.2f}x), '
f'pcolorfast: {t3 - t2:0.3e} ({(t3 - t2) / (t1 - t0):0.2f}x)'
)
plt.show()ValueError produced when pcolorfast is attempted with irregular x,y data |
|
@eldond When using |
|
@dopplershift Thank you, that makes sense. I should've caught that. Anyway, I can probably use pcolorfast, but my data would be more naturally described by Z(x, y); that is, I have x, y centers and I have to make up edges (pcolorfast doesn't accept When used correctly, pcolorfast isn't much slower than NonUniformImage: |
|
Have you tried using |
|
I tested it just now, but it doesn't change speed much and it doesn't put the Z (color) coordinate with the x, y coordinates. pcolorfast does everything I want except it's somewhat less convenient, but I can fix that. I'm going to make a wrapper for pcolorfast that accepts bin centers and makes up reasonable edges to go with them. |
def pcolorfast_centers(xc, yc, z, ax=None, **kw):
"""
Estimates bin edges given bin centers and passes them to pcolorfast
pcolorfast accepts x,y arrays that are one element longer than the corresponding dimensions of z,
which is awkward when the data are z = f(x, y). Yet pcolorfast is useful enough that we'd like to
use it, anyway.
:param xc: 1D float array
Bin centers in X; length should match first dimension of z
:param yc: 1D float array
Bin centers in Y; length should match second dimension of z
:param z: 2D float array
Z or color values at the bin centers
:param ax: Axes instance
Axes to plot in
:param kw: additional keywords passed to pcolorfast
"""
if ax is None:
ax = plt.gca()
inner_edges = (xc[:-1] + xc[1:]) / 2.0
x = np.append(np.append(inner_edges[0] - xc[1] + xc[0], inner_edges), inner_edges[-1] + xc[-1] - xc[-2])
inner_edges = (yc[:-1] + yc[1:]) / 2.0
y = np.append(np.append(inner_edges[0] - yc[1] + yc[0], inner_edges), inner_edges[-1] + yc[-1] - yc[-2])
print(np.shape(x), np.shape(xc), np.shape(z))
return ax.pcolorfast(x, y, z, **kw) |
|
Possibly |
|
Yeah, I don't see why not.... Seems a reasonable addition. |
|
Labeling as good first issue, as there's no API decision to be made here, and figuring out the correct value to display should be straightforward(?). |
|
Is this issue being worked on? If not, I'd like to work on it |
|
Nobody has spoken up to work on this. So go for it. |
Bug report
Bug summary
When using
matplotlib.image.NonUniformImage, the coordinates of the cursor are wrong: the Z-coordinate is inconsistent with the image (it appears to be based on howimshowwould display the data (flipped in Y)).The Z values also don't change at the visible boundaries between "pixels" or cells, they change somewhere else that might be consistent with different cell alignment to the x,y values.
Code for reproduction
Actual outcome
Notice that when the cursor is at the top right (value should approach 400), the value is about 200. When the cursor is at the bottom right (value should be about 200), the value approaches 400.
Expected outcome
It should be like the actual outcome, but with the correct Z-coordinates reported: should be close to 400 at the top right and close to 200 at the bottom right.
Matplotlib version
print(matplotlib.get_backend())): Qt5Agg, TkAggThe text was updated successfully, but these errors were encountered: