issue_comments

A max_spacing argument sounds interesting, but definitely makes me think I need to meditate for awhile on the scope of raised issue. A basic semantic distinction of importance here is where the coordinates are "point like", or represent the centers of intervals of some volume or something else entirely (e.g., in the case of non-interval or float data). Depending on what they represent you might want to plot one thing or another.

I think the behavior makes sense in 1d (pandas does the same linear interpolation I think)

I'm not so sure it makes sense in 1D, either. Most of the time I've wished that large gaps were replaced with empty gaps. I've learned to be suspicious of long straight lines.

One option would be to add a max_spacing argument to plot() that indicates a maximum "valid" spacing to plot continuously over. If a gap is larger than the spacing, then it would plotted empty instead.

Potentially we could even default to some heuristic choice for max_spacing, but I'm not sure exactly what that heuristic would be.

I'm also not entirely sure how to implement max_spacing for pcolormesh, contour or line plots. I suspect it would be impossible to do for imshow (but that's OK, imshow is only for completely regular data).

Note that this is related to https://github.com/pydata/xarray/issues/1852 . xarray 2d graphics currently make assumptions about the coordinates (monotonically ascending / descending, more or less -but not strictly- evenly spaced), which are very sensible in the geosciences but which become less true when the data becomes messy as in these two cases.

Here again I think that it will be hard to find a generic solution which will work same for all 2d graphics (contourf, imshow and pcolormesh), but I would be happy for any suggestion you have. At the very least we should raise an error or warning (similar to https://github.com/pydata/xarray/issues/1852)

Without coordinate values in between, what should xarray assume for the intermediate values?

I guess I had imagined it would not try to plot those intermediate values.

I think the behavior makes sense in 1d (pandas does the same linear interpolation I think) xrYsum = xrAB.sum(dim = 'x') xrYsum.plot() but in 2d it seems weird. Is there are common use case where this interpolation is desirable? Perhaps its just my ignorance speaking, but it feels like the behavior violates the principle of least astonishment, especially in light of the fact that irregular grids are one of the main use cases for xarray with explicit support in the docs.

Probably the simplest way to fix this is to start with an all NaN array of the appropriate size.

👍

I'd be happy to take a stab at implementing plotting that gives (by default or through an optional argument) a result equivalent to the last plot you made if you imagine xarray users would find it useful.

I'm not 100% sure if we're doing the right thing here or not :).

The fundamental issue here is that your coordinates are not evenly spaced: ```

xrAB <xarray.DataArray (x: 32, y: 32)> array([[ 0.805096, 0.339439, 0.889917, ..., nan, nan, nan], [ 0.796546, 0.465788, 0.022211, ..., nan, nan, nan], [ 0.075146, 0.261747, 0.029072, ..., nan, nan, nan], ..., [ nan, nan, nan, ..., 0.297032, 0.707947, 0.617284], [ nan, nan, nan, ..., 0.673249, 0.507685, 0.807462], [ nan, nan, nan, ..., 0.68973 , 0.786864, 0.04618 ]]) Coordinates: * y (y) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 48 49 50 51 52 ... * x (x) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 48 49 50 51 52 ... ```

Notice the jump from 15 to 48. Without coordinate values in between, what should xarray assume for the intermediate values? Here we seem to be treating the function as piece-wise constant.

Probably the simplest way to fix this is to start with an all NaN array of the appropriate size. This yields a sensible looking plot: python empty = xr.DataArray(np.full((N, N), np.nan), [('x', x), ('y', y)]) xrAB = empty.combine_first(xrA).combine_first(xrB) xrAB.plot()