Merge 50ec5b6 into c1efb5c

holoviews/operation/datashader.py

@@ -631,15 +631,15 @@ def _process(self, element, key=None):
 class spikes_aggregate(AggregationOperation):
     """
     Aggregates Spikes elements by drawing individual line segments
-    over the entire y_range if no value dimension is defined and 
+    over the entire y_range if no value dimension is defined and
     between zero and the y-value if one is defined.
     """
 
     def _process(self, element, key=None):
         agg_fn = self._get_aggregator(element)
 
         if element.vdims:
-            x, y = element.dimensions()
+            x, y = element.dimensions()[:2]
             if not self.p.y_range:
                 y0, y1 = element.range(1)
                 if y0 >= 0:
@@ -650,9 +650,12 @@ def _process(self, element, key=None):
                     default = (y0, y1)
             else:
                 default = None
+
+            rename_dict = {'x': x.name, 'y': y.name}
         else:
             x, y = element.kdims[0], None
             default = (0, 1)
+            rename_dict = {'x': x.name}
         info = self._get_sampling(element, x, y, ndim=1, default=default)
         (x_range, y_range), (xs, ys), (width, height), (xtype, ytype) = info
         ((x0, x1), (y0, y1)), (xs, ys) = self._dt_transform(x_range, y_range, xs, ys, xtype, ytype)
@@ -685,7 +688,7 @@ def _process(self, element, key=None):
         cvs = ds.Canvas(plot_width=width, plot_height=height,
                         x_range=x_range, y_range=y_range)
 
-        agg = cvs.line(df, x.name, yagg, agg_fn, axis=1)
+        agg = cvs.line(df, x.name, yagg, agg_fn, axis=1).rename(rename_dict)
         if xtype == "datetime":
             agg[x.name] = (agg[x.name]/1e3).astype('datetime64[us]')
 

holoviews/plotting/bokeh/chart.py

@@ -10,7 +10,7 @@
 
 from ...plotting.bokeh.selection import BokehOverlaySelectionDisplay
 from ...selection import NoOpSelectionDisplay
-from ...core.data import Dataset
+from ...core.data import Dataset, Dimension
 from ...core.dimension import dimension_name
 from ...core.util import (
     OrderedDict, max_range, basestring, dimension_sanitizer,
@@ -676,14 +676,29 @@ class SpikesPlot(ColorbarPlot):
 
     selection_display = BokehOverlaySelectionDisplay()
 
+    def _get_axis_dims(self, element):
+        if 'spike_length' in self.lookup_options(element, 'plot').options:
+            return  [element.dimensions()[0], None, None]
+        return super(SpikesPlot, self)._get_axis_dims(element)
+
     def get_extents(self, element, ranges, range_type='combined'):
-        if len(element.dimensions()) > 1:
+        opts = self.lookup_options(element, 'plot').options
+        if len(element.dimensions()) > 1 and 'spike_length' not in opts:
             ydim = element.get_dimension(1)
             s0, s1 = ranges[ydim.name]['soft']
             s0 = min(s0, 0) if isfinite(s0) else 0
             s1 = max(s1, 0) if isfinite(s1) else 0
             ranges[ydim.name]['soft'] = (s0, s1)
-        l, b, r, t = super(SpikesPlot, self).get_extents(element, ranges, range_type)
+        proxy_dim = None
+        if 'spike_length' in opts:
+            proxy_dim = Dimension('proxy_dim')
+            proxy_range = (self.position, self.position + opts['spike_length'])
+            ranges['proxy_dim'] = {'data':    proxy_range,
+                                  'hard':     (np.nan, np.nan),
+                                  'soft':     (np.nan, np.nan),
+                                  'combined': proxy_range}
+        l, b, r, t = super(SpikesPlot, self).get_extents(element, ranges, range_type,
+                                                         ydim=proxy_dim)
         if len(element.dimensions()) == 1 and range_type != 'hard':
             if self.batched:
                 bs, ts = [], []
@@ -706,12 +721,13 @@ def get_data(self, element, ranges, style):
 
         data = {}
         pos = self.position
+        opts = self.lookup_options(element, 'plot').options
         if len(element) == 0 or self.static_source:
             data = {'x': [], 'y0': [], 'y1': []}
         else:
             data['x'] = element.dimension_values(0)
             data['y0'] = np.full(len(element), pos)
-            if len(dims) > 1:
+            if len(dims) > 1 and 'spike_length' not in opts:
                 data['y1'] = element.dimension_values(1)+pos
             else:
                 data['y1'] = data['y0']+self.spike_length

holoviews/plotting/mpl/chart.py

@@ -1140,13 +1140,25 @@ def init_artists(self, ax, plot_args, plot_kwargs):
         return {'artist': line_segments}
 
     def get_extents(self, element, ranges, range_type='combined'):
+        opts = self.lookup_options(element, 'plot').options
         if len(element.dimensions()) > 1:
             ydim = element.get_dimension(1)
             s0, s1 = ranges[ydim.name]['soft']
             s0 = min(s0, 0) if isfinite(s0) else 0
             s1 = max(s1, 0) if isfinite(s1) else 0
             ranges[ydim.name]['soft'] = (s0, s1)
-        l, b, r, t = super(SpikesPlot, self).get_extents(element, ranges, range_type)
+
+        proxy_dim = None
+        if 'spike_length' in opts:
+            proxy_dim = Dimension('proxy_dim')
+            proxy_range = (self.position, self.position + opts['spike_length'])
+            ranges['proxy_dim'] = {'data':    proxy_range,
+                                  'hard':     (np.nan, np.nan),
+                                  'soft':     (np.nan, np.nan),
+                                  'combined': proxy_range}
+
+        l, b, r, t = super(SpikesPlot, self).get_extents(element, ranges, range_type,
+                                                         ydim=proxy_dim)
         if len(element.dimensions()) == 1 and range_type != 'hard':
             if self.batched:
                 bs, ts = [], []
@@ -1167,9 +1179,10 @@ def get_extents(self, element, ranges, range_type='combined'):
     def get_data(self, element, ranges, style):
         dimensions = element.dimensions(label=True)
         ndims = len(dimensions)
+        opts = self.lookup_options(element, 'plot').options
 
         pos = self.position
-        if ndims > 1:
+        if ndims > 1 and 'spike_length' not in opts:
             data = element.columns([0, 1])
             xs, ys = data[dimensions[0]], data[dimensions[1]]
             data = [[(x, pos), (x, pos+y)] for x, y in zip(xs, ys)]
@@ -1209,9 +1222,16 @@ def get_data(self, element, ranges, style):
             style['array'] = element.dimension_values(cdim)
             self._norm_kwargs(element, ranges, style, cdim)
 
+        if 'spike_length' in opts:
+            axis_dims =  (element.dimensions()[0], None)
+        elif len(element.dimensions()) == 1:
+            axis_dims =  (element.dimensions()[0], None)
+        else:
+            axis_dims =  (element.dimensions()[0], element.dimensions()[1])
         with abbreviated_exception():
             style = self._apply_transforms(element, ranges, style)
-        return (clean_spikes,), style, {'dimensions': dims}
+
+        return (clean_spikes,), style, {'dimensions': axis_dims}
 
 
     def update_handles(self, key, axis, element, ranges, style):