Add Datashader operations

.travis.yml

@@ -24,7 +24,7 @@ install:
   - conda update -q conda
   # Useful for debugging any issues with conda
   - conda info -a
-  - conda create -q -n test-environment python=$TRAVIS_PYTHON_VERSION scipy numpy freetype nose bokeh pandas jupyter ipython=4.2.0 param matplotlib=1.5.1 xarray
+  - conda create -q -n test-environment python=$TRAVIS_PYTHON_VERSION scipy numpy freetype nose bokeh pandas jupyter ipython=4.2.0 param matplotlib=1.5.1 xarray datashader
   - source activate test-environment
   - conda install -c conda-forge  -c scitools iris sip=4.18 plotly
   - if [[ "$TRAVIS_PYTHON_VERSION" == "3.4" ]]; then

holoviews/core/data/xarray.py

@@ -37,7 +37,17 @@ def init(cls, eltype, data, kdims, vdims):
         kdim_param = element_params['kdims']
         vdim_param = element_params['vdims']
 
-        if not isinstance(data, xr.Dataset):
+        if isinstance (data, xr.DataArray):
+            if data.name:
+                vdim = Dimension(data.name)
+            elif vdims:
+                vdim = vdims[0]
+            elif len(vdim_param.default) == 1:
+                vdim = vdim_param.default[0]
+            vdims = [vdim]
+            kdims = [Dimension(d) for d in data.dims[::-1]]
+            data = xr.Dataset({vdim.name: data})
+        elif not isinstance(data, xr.Dataset):
             if kdims is None:
                 kdims = kdim_param.default
             if vdims is None:

holoviews/core/operation.py

@@ -70,80 +70,6 @@ def get_overlay_bounds(cls, overlay):
             raise ValueError("Extents across the overlay are inconsistent")
 
 
-class DynamicOperation(Operation):
-    """
-    Dynamically applies an operation to the elements of a HoloMap
-    or DynamicMap. Will return a DynamicMap wrapping the original
-    map object, which will lazily evaluate when a key is requested.
-    The _process method should be overridden in subclasses to apply
-    a specific operation, DynamicOperation itself applies a no-op,
-    making the DynamicOperation baseclass useful for converting
-    existing HoloMaps to a DynamicMap.
-    """
-
-    def __call__(self, map_obj, **params):
-        self.p = param.ParamOverrides(self, params)
-        callback = self._dynamic_operation(map_obj)
-        if isinstance(map_obj, DynamicMap):
-            return map_obj.clone(callback=callback, shared_data=False)
-        else:
-            return self._make_dynamic(map_obj, callback)
-
-
-    def _process(self, element):
-        return element
-
-
-    def _dynamic_operation(self, map_obj):
-        """
-        Generate function to dynamically apply the operation.
-        Wraps an existing HoloMap or DynamicMap.
-        """
-        if not isinstance(map_obj, DynamicMap):
-            def dynamic_operation(*key):
-                return self._process(map_obj[key])
-            return dynamic_operation
-
-        def dynamic_operation(*key):
-            key = key[0] if map_obj.mode == 'open' else key
-            _, el = util.get_dynamic_item(map_obj, map_obj.kdims, key)
-            return self._process(el)
-
-        return dynamic_operation
-
-
-    def _make_dynamic(self, hmap, dynamic_fn):
-        """
-        Accepts a HoloMap and a dynamic callback function creating
-        an equivalent DynamicMap from the HoloMap.
-        """
-        dim_values = zip(*hmap.data.keys())
-        params = util.get_param_values(hmap)
-        kdims = [d(values=list(set(values))) for d, values in
-                 zip(hmap.kdims, dim_values)]
-        return DynamicMap(dynamic_fn, **dict(params, kdims=kdims))
-
-
-
-class DynamicFunction(DynamicOperation):
-    """
-    Dynamically applies a function to the Elements in a DynamicMap
-    or HoloMap. Must supply a HoloMap or DynamicMap type and will
-    return another DynamicMap type, which will apply the supplied
-    function with the supplied kwargs whenever a value is requested
-    from the map.
-    """
-
-    function = param.Callable(default=lambda x: x, doc="""
-        Function to apply to DynamicMap items dynamically.""")
-
-    kwargs = param.Dict(default={}, doc="""
-        Keyword arguments passed to the function.""")
-
-    def _process(self, element):
-        return self.p.function(element, **self.p.kwargs)
-
-
 
 class ElementOperation(Operation):
     """
@@ -152,6 +78,12 @@ class ElementOperation(Operation):
     input, a processed holomap is returned as output where the
     individual elements have been transformed accordingly. An
     ElementOperation may turn overlays in new elements or vice versa.
+
+    An ElementOperation can be set to be dynamic, which will return a
+    DynamicMap with a callback that will apply the operation
+    dynamically. An ElementOperation may also supply a list of Stream
+    classes on the streams attribute, which can allow dynamic control
+    over the parameters on the operation.
     """
 
     dynamic = param.ObjectSelector(default='default',
@@ -171,7 +103,6 @@ class ElementOperation(Operation):
        first component is a Normalization.ranges list and the second
        component is Normalization.keys. """)
 
-
     def _process(self, view, key=None):
         """
         Process a single input element and outputs new single element
@@ -197,16 +128,19 @@ def __call__(self, element, **params):
                     isinstance(element, DynamicMap))
                    or self.p.dynamic is True)
 
-        if isinstance(element, ViewableElement):
-            processed = self._process(element)
-        elif isinstance(element, GridSpace):
+        if isinstance(element, GridSpace):
             # Initialize an empty axis layout
             grid_data = ((pos, self(cell, **params))
                          for pos, cell in element.items())
             processed = GridSpace(grid_data, label=element.label,
                                   kdims=element.kdims)
         elif dynamic:
-            processed = DynamicFunction(element, function=self, kwargs=params)
+            from ..util import Dynamic
+            streams = getattr(self, 'streams', [])
+            processed = Dynamic(element, streams=streams,
+                                operation=self, kwargs=params)
+        elif isinstance(element, ViewableElement):
+            processed = self._process(element)
         elif isinstance(element, DynamicMap):
             if any((not d.values) for d in element.kdims):
                 raise ValueError('Applying a non-dynamic operation requires '

holoviews/core/overlay.py

@@ -24,10 +24,10 @@ class Overlayable(object):
 
     def __mul__(self, other):
         if type(other).__name__ == 'DynamicMap':
-            from .operation import DynamicFunction
+            from ..util import Dynamic
             def dynamic_mul(element):
                 return self * element
-            return DynamicFunction(other, function=dynamic_mul)
+            return Dynamic(other, operation=dynamic_mul)
         if isinstance(other, UniformNdMapping) and not isinstance(other, CompositeOverlay):
             items = [(k, self * v) for (k, v) in other.items()]
             return other.clone(items)

holoviews/core/spaces.py

@@ -204,10 +204,10 @@ def __mul__(self, other):
             return self.clone(items, kdims=dimensions, label=self._label, group=self._group)
         elif isinstance(other, self.data_type):
             if isinstance(self, DynamicMap):
-                from .operation import DynamicFunction
+                from ..util import Dynamic
                 def dynamic_mul(element):
                     return element * other
-                return DynamicFunction(self, function=dynamic_mul)
+                return Dynamic(self, operation=dynamic_mul)
             items = [(k, v * other) for (k, v) in self.data.items()]
             return self.clone(items, label=self._label, group=self._group)
         else: