@rjp23 with the latest update to the PR (thanks to @jklymak), your example code produced identical figures without changing it.

I’m not sure that’s a solution if we argue that xarray should do what matplotlib does with the same keywords.

I can test if this “works” and will report back but it’s still not a fix.

@rjp23: could you close the issue if this indeed resolves your problem?

As suggested by https://github.com/pydata/xarray/pull/7553#discussion_r1117264787, pass levels=bounds instead of norm=norm to data.plot(). Your example code results in a plot as expected. Would this solve your issue?

``` import numpy as np import matplotlib.pyplot as plt import matplotlib.colors as colors import xarray

example from https://matplotlib.org/3.1.1/tutorials/colors/colormapnorms.html

for colormap normalisation

N = 100 X, Y = np.mgrid[-3:3:complex(0, N), -2:2:complex(0, N)] Z1 = np.exp(-X2 - Y2) Z2 = np.exp(-(X - 1)2 - (Y - 1)2) Z = (Z1 - Z2) * 2

fig, ax = plt.subplots(2, 1, figsize=(8, 8)) ax = ax.flatten()

bounds = np.linspace(-1, 1, 10) norm = colors.BoundaryNorm(boundaries=bounds, ncolors=256)

ax[0].pcolormesh(X, Y, Z, norm=norm, cmap='RdBu_r')

now add data into dataset and plot it using same normalisation

data = xarray.DataArray(Z, dims=('x', 'y'), coords={'x': X[:,0], 'y': Y[0,:]}) data.plot(ax=ax[1], x='x', y='y', levels=bounds, add_colorbar=False) ```

I also have an issue where xarray doesn't produce the correct plot when normalizing with BoundaryNorm:

```python import xarray as xr import matplotlib.pyplot as plt import matplotlib.colors as colors from cmcrameri import cm

airtemps = xr.tutorial.open_dataset("air_temperature")

Convert to Celsius.

air = airtemps.air - 273.15 air.attrs = airtemps.air.attrs air.attrs["units"] = "deg C"

Select a timestep.

air2d = air.isel(time=500)

Plotting discrete bounds with matplotlib works fine.

bounds = [x for x in range(-30, 31, 10)] norm = colors.BoundaryNorm(boundaries=bounds, extend='both', ncolors=cm.vik.N)

fig, ax = plt.subplots() cs = ax.pcolormesh(air2d.lon, air2d.lat, air2d, cmap=cm.vik, norm=norm) fig.colorbar(cs) plt.show()

Plotting with xarray doesn't work.

fig, ax = plt.subplots() air2d.plot.pcolormesh(ax=ax, norm=norm) plt.show() ``` First one is from matplotlib:

Second one is from xarray:

I also get the following traceback after running the script:

bash Traceback (most recent call last): File "/home/michael/miniconda3/envs/testing_xarray/lib/python3.10/site-packages/matplotlib/cbook/__init__.py", line 287, in process func(*args, **kwargs) File "/home/michael/miniconda3/envs/testing_xarray/lib/python3.10/site-packages/matplotlib/backend_bases.py", line 3056, in mouse_move s = self._mouse_event_to_message(event) File "/home/michael/miniconda3/envs/testing_xarray/lib/python3.10/site-packages/matplotlib/backend_bases.py", line 3048, in _mouse_event_to_message data_str = a.format_cursor_data(data).rstrip() File "/home/michael/miniconda3/envs/testing_xarray/lib/python3.10/site-packages/matplotlib/artist.py", line 1282, in format_cursor_data neighbors = self.norm.inverse( File "/home/michael/miniconda3/envs/testing_xarray/lib/python3.10/site-packages/matplotlib/colors.py", line 1832, in inverse raise ValueError("BoundaryNorm is not invertible") ValueError: BoundaryNorm is not invertible

Seems like we should do whatever mpl does when given a norm and a colormap

That's probably gonna need a extend="both"

Neither of those solutions seem to work for diverging colormaps where the data extends outside the range, i.e. the < and > data ends up with no colour.

If you use python norm = colors.BoundaryNorm(boundaries=bounds, ncolors=9) it works. A new norm with ncolors=9 is built in _build_discrete_cmap - however, it is not used as norm is already defined:

https://github.com/pydata/xarray/blob/2542a63f6ebed1a464af7fc74b9f3bf302925803/xarray/plot/utils.py#L290-L292

The fix might be to use:

python if levels is not None or isinstance(norm, mpl.colors.BoundaryNorm): cmap, norm = _build_discrete_cmap(cmap, levels, extend, filled) this breaks one test which is probably fixable (it tests that the norm is not changed when it is given).

Note that mpl seems to use a LinearSegmentedColormap while xarray creates a ListedColormap.

What should also work is img = ds['var'].plot(ax=ax, cmap=cmap, levels=levels)

It might be useful to note here that my solution for now was just to pass the arrays directly to pcolormesh rather than going through the xarray plot interface.

i.e. I changed from

img = ds['var'].plot(ax=ax, cmap=cmap, norm=norm) to img = ax.pcolormesh(ds.x.values, ds.y.values, ds.tas.values, cmap=cmap, norm=norm)