Add quadmesh glyph with rectilinear and curvilinear support

datashader/__init__.py

@@ -12,6 +12,7 @@
 from . import transfer_functions as tf                   # noqa (API import)
 
 from . import pandas                         # noqa (build backend dispatch)
+from . import xarray                         # noqa (build backend dispatch)
 try:
     from . import dask                       # noqa (build backend dispatch)
 except ImportError:

datashader/core.py

@@ -11,7 +11,8 @@
 from collections import OrderedDict
 
 from datashader.spatial.points import SpatialPointsFrame
-from .utils import Dispatcher, ngjit, calc_res, calc_bbox, orient_array, compute_coords
+from .utils import Dispatcher, ngjit, calc_res, calc_bbox, orient_array, \
+    compute_coords, dshape_from_xarray_dataset
 from .utils import get_indices, dshape_from_pandas, dshape_from_dask
 from .utils import Expr # noqa (API import)
 from .resampling import resample_2d, resample_2d_distributed
@@ -564,6 +565,75 @@ def area(self, source, x, y, agg=None, axis=0, y_stack=None):
 
         return bypixel(source, self, glyph, agg)
 
+    def quadmesh(self, source, x=None, y=None, agg=None):
+        """Samples a recti- or curvi-linear quadmesh by canvas size and bounds.
+        Parameters
+        ----------
+        source : xarray.DataArray or Dataset
+            The input datasource.
+        x, y : str
+            Column names for the x and y coordinates of each point.
+        agg : Reduction, optional
+            Reduction to compute. Default is ``mean()``.
+        Returns
+        -------
+        data : xarray.DataArray
+        """
+        from .glyphs import QuadMeshRectilinear, QuadMeshCurvialinear
+
+        # Determine reduction operation
+        from .reductions import mean as mean_rnd
+
+        if isinstance(source, Dataset):
+            if agg is None or agg.column is None:
+                name = list(source.data_vars)[0]
+            else:
+                name = agg.column
+            # Keep as dataset so that source[agg.column] works
+            source = source[[name]]
+        elif isinstance(source, DataArray):
+            # Make dataset so that source[agg.column] works
+            name = source.name
+            source = source.to_dataset()
+        else:
+            raise ValueError("Invalid input type")
+
+        if agg is None:
+            agg = mean_rnd(name)
+
+        if x is None and y is None:
+            y, x = source[name].dims
+        elif not x or not y:
+            raise ValueError("Either specify both x and y coordinates"
+                             "or allow them to be inferred.")
+        yarr, xarr = source[y], source[x]
+
+        if (yarr.ndim > 1 or xarr.ndim > 1) and xarr.dims != yarr.dims:
+            raise ValueError("Ensure that x- and y-coordinate arrays "
+                             "share the same dimensions. x-coordinates "
+                             "are indexed by %s dims while "
+                             "y-coordinates are indexed by %s dims." %
+                             (xarr.dims, yarr.dims))
+
+        if (name is not None
+                and agg.column is not None
+                and agg.column != name):
+            raise ValueError('DataArray name %r does not match '
+                             'supplied reduction %s.' %
+                             (source.name, agg))
+
+        if xarr.ndim == 1:
+            glyph = QuadMeshRectilinear(x, y, name)
+        elif xarr.ndim == 2:
+            glyph = QuadMeshCurvialinear(x, y, name)
+        else:
+            raise ValueError("""\
+x- and y-coordinate arrays must have 1 or 2 dimensions.
+    Received arrays with dimensions: {dims}""".format(
+                dims=list(xarr.dims)))
+
+        return bypixel(source, self, glyph, agg)
+
     # TODO re 'untested', below: Consider replacing with e.g. a 3x3
     # array in the call to Canvas (plot_height=3,plot_width=3), then
     # show the output as a numpy array that has a compact
@@ -910,11 +980,13 @@ def bypixel(source, canvas, glyph, agg):
     glyph : Glyph
     agg : Reduction
     """
-    if isinstance(source, DataArray):
+
+    # Convert 1D xarray DataArrays and DataSets into Dask DataFrames
+    if isinstance(source, DataArray) and source.ndim == 1:
         if not source.name:
             source.name = 'value'
         source = source.reset_coords()
-    if isinstance(source, Dataset):
+    if isinstance(source, Dataset) and len(source.dims) == 1:
         columns = list(source.coords.keys()) + list(source.data_vars.keys())
         cols_to_keep = _cols_to_keep(columns, glyph, agg)
         source = source.drop([col for col in columns if col not in cols_to_keep])
@@ -931,6 +1003,9 @@ def bypixel(source, canvas, glyph, agg):
         dshape = dshape_from_pandas(source)
     elif isinstance(source, dd.DataFrame):
         dshape = dshape_from_dask(source)
+    elif isinstance(source, Dataset):
+        # Multi-dimensional Dataset
+        dshape = dshape_from_xarray_dataset(source)
     else:
         raise ValueError("source must be a pandas or dask DataFrame")
     schema = dshape.measure

datashader/dask.py

@@ -3,6 +3,7 @@
 import dask
 import pandas as pd
 import dask.dataframe as dd
+from collections import OrderedDict
 from dask.base import tokenize, compute
 
 from .core import bypixel
@@ -51,7 +52,7 @@ def shape_bounds_st_and_axis(df, canvas, glyph):
 
     x_axis = canvas.x_axis.compute_index(x_st, width)
     y_axis = canvas.y_axis.compute_index(y_st, height)
-    axis = [y_axis, x_axis]
+    axis = OrderedDict([(glyph.x_label, x_axis), (glyph.y_label, y_axis)])
 
     return shape, bounds, st, axis
 

datashader/glyphs/__init__.py

@@ -23,4 +23,7 @@
     AreaToLineAxis1Ragged,
 )
 from .trimesh import Triangles  # noqa (API import)
+from .quadmesh import (  # noqa (API import)
+    QuadMeshRectilinear, QuadMeshCurvialinear
+)
 from .glyph import Glyph  # noqa (API import)

datashader/glyphs/glyph.py

@@ -62,6 +62,22 @@ def _compute_y_bounds(ys):
 
         return minval, maxval
 
+    @staticmethod
+    @ngjit
+    def _compute_bounds_2d(vals):
+        minval = np.inf
+        maxval = -np.inf
+        for i in range(vals.shape[0]):
+            for j in range(vals.shape[1]):
+                v = vals[i][j]
+                if not np.isnan(v):
+                    if v < minval:
+                        minval = v
+                    if v > maxval:
+                        maxval = v
+
+        return minval, maxval
+
     def expand_aggs_and_cols(self, append):
         """
         Create a decorator that can be used on functions that accept