Different plotting reaults compared to matplotlib

[zxdawn]

What happened?

I got different results when I tried to plot 2D data test.npy.zip using matplotlib and xarray.

matplotlib

xarray

What did you expect to happen?

Same plot.

Minimal Complete Verifiable Example

import numpy as np
import xarray as xr
import matplotlib.pyplot as plt

test = np.load('test.npy')

plt.imshow(test, vmin=0, vmax=200)
plt.colorbar()

xr.DataArray(test).plot.imshow(vmin=0, vmax=200)

MVCE confirmation

• Minimal example — the example is as focused as reasonably possible to demonstrate the underlying issue in xarray.
• Complete example — the example is self-contained, including all data and the text of any traceback.
• Verifiable example — the example copy & pastes into an IPython prompt or Binder notebook, returning the result.
• New issue — a search of GitHub Issues suggests this is not a duplicate.
• Recent environment — the issue occurs with the latest version of xarray and its dependencies.

Relevant log output

No response

Anything else we need to know?

No response

Environment

Details

INSTALLED VERSIONS

commit: None
python: 3.10.12 | packaged by conda-forge | (main, Jun 23 2023, 22:41:52) [Clang 15.0.7 ]
python-bits: 64
OS: Darwin
OS-release: 22.3.0
machine: arm64
processor: arm
byteorder: little
LC_ALL: None
LANG: None
LOCALE: (None, 'UTF-8')
libhdf5: None
libnetcdf: None

xarray: 2023.9.0
pandas: 2.1.1
numpy: 1.26.0
scipy: None
netCDF4: None
pydap: None
h5netcdf: None
h5py: None
Nio: None
zarr: None
cftime: None
nc_time_axis: None
PseudoNetCDF: None
iris: None
bottleneck: None
dask: None
distributed: None
matplotlib: 3.8.0
cartopy: None
seaborn: None
numbagg: None
fsspec: None
cupy: None
pint: None
sparse: None
flox: None
numpy_groupies: None
setuptools: 68.2.2
pip: 23.2.1
conda: None
pytest: None
mypy: None
IPython: 8.16.1
sphinx: None

[ksunden]

xarray changes two parameters from the mpl defaults:

xarray/xarray/plot/dataarray_plot.py

Line 1855 in dafd726

defaults: dict[str, Any] = {"origin": "upper", "interpolation": "nearest"}

One just flips the y axis, which defaults to an inverted axis for mpl.imshow but is more consistent for xarray users as a normal axis (because this is the convention for actual images e.g. jpgs/pngs).

the other is the interpolation strategy.

You can get the xarray produced plot with mpl by doing:

plt.imshow(test, vmin=0, vmax=200, interpolation="nearest", origin="lower")

And you can get the mpl plot in xarray by doing:

xr.DataArray(test).plot.imshow(vmin=0, vmax=200, origin="upper", interpolation="antialiased")

(note that for this plot, "antialiased effectively equates to 'hanning', also note that mpl's default behavior is affected by rcParameters, where xarray overrides the default regardless of the rcParam)

I think that the antialiasing is actually hiding the noise of the data as provided (there aren't enough pixels to show the actual data, so some resampling has to be done, but what is most representative is not easy to know without context, mpl's defaults will tend to be better for actual images, but xarrays are probably better for measured data)

[zxdawn]

Thanks for your explanation @ksunden. The data is produced from satellite retrieval, which is a kind of measured data.

BTW, what do you mean by actual images?

mpl's defaults will tend to be better for actual images, but xarrays are probably better for measured data

I also checked plt.pcolor(test, vmin=0, vmax=200) which should show the original data:

So, if I understand correctly, default mpl's plt.imshow() tends to show smooth images while xarray's plot.imshow() is more like plot() which is pcolormesh in mpl.

[ksunden]

"actual" is not quite the best term, though "smooth" is also not quite what I mean, either.. not quite sure what word to use here...

But mpl's imshow falls into this awkward dual function of displaying full rgb(a) images as well as colormapped data. and thus the choices of default parameters are not able to suit all usecases. Such full color images or even black and white images taken with a standard consumer camera, but also digital images like logos etc all fall into the category I had used the term "actual image" for. Any measurement where an individual pixel should be considered separately falls into the category of "measured data" rather clearly. The inverted Y-axis is one of the things that I think actually more distinctly separates the groups, as the orientation of an image mattering is a key part of it to me.

Scientific cameras (including telescopes and e.g. laser lab cameras) fall into a bit of a mushy middle, but I would tend to prefer any smoothing to be done a bit more explicitly than relying on the downsampling of the image viewer, so I would tend to say that "nearest" (xarrays default) tends to be more representative, though context does matter (and if the purpose is "quick view of if the global trends of the data are 'interesting'" then perhaps using mpl's antialiased downsampling is sufficient. But my bias would be towards more explicit means of smoothing for final figures. They also fall into a strange zone where you have to know the particulars of the camera/etc to know which convention of origin and numbering pixels they use, as it is less standardized.

I've tended to use pcolor(and friends) for most of my data, though often because I find it easier to control the x/y axes values which for me are often not just 'pixels' (yes you can provide extents to imshow, but less control that way), but imshow does certainly have performance improvements over that for rectangular data.

[zxdawn]

Thank you a lot for the detailed comparisons. Because xarray is designed for scientific data (weather, satellite, observations, etc.), it sounds reasonable to use interpolation=nearest for DataArray.plot().