Merge 9ef9c64 into b2697bd

holoviews/plotting/bokeh/annotation.py

@@ -42,7 +42,6 @@ def get_data(self, element, ranges=None, empty=False):
         data['text'] = [element.text]
         return (data, mapping)
 
-
     def get_batched_data(self, element, ranges=None, empty=False):
         data = defaultdict(list)
         for key, el in element.data.items():
@@ -51,7 +50,6 @@ def get_batched_data(self, element, ranges=None, empty=False):
                 data[k].extend(eld)
         return data, elmapping
 
-
     def get_extents(self, element, ranges=None):
         return None, None, None, None
 
@@ -100,7 +98,10 @@ class SplinePlot(ElementPlot):
     _plot_methods = dict(single='bezier')
 
     def get_data(self, element, ranges=None, empty=False):
-        data_attrs = ['x0', 'y0', 'cx0', 'cy0', 'cx1', 'cy1', 'x1', 'y1',]
+        if self.invert_axes:
+            data_attrs = ['y0', 'x0', 'cy0', 'cx0', 'cy1', 'cx1', 'y1', 'x1']
+        else:
+            data_attrs = ['x0', 'y0', 'cx0', 'cy0', 'cx1', 'cy1', 'x1', 'y1']
         verts = np.array(element.data[0])
         inds = np.where(np.array(element.data[1])==1)[0]
         data = {da: [] for da in data_attrs}

holoviews/plotting/bokeh/chart.py

@@ -183,8 +183,12 @@ def get_data(self, element, ranges=None, empty=False):
         input_scale = style.pop('scale', 1.0)
 
         # Get x, y, angle, magnitude and color data
-        xidx, yidx = (1, 0) if self.invert_axes else (0, 1)
         rads = element.dimension_values(2)
+        if self.invert_axes:
+            xidx, yidx = (1, 0)
+            rads = rads+1.5*np.pi
+        else:
+            xidx, yidx = (0, 1)
         lens = self._get_lengths(element, ranges)/input_scale
         cdim = element.get_dimension(self.color_index)
         cdata, cmapping = self._get_color_data(element, ranges, style,
@@ -950,7 +954,7 @@ def _get_factors(self, element):
         Get factors for categorical axes.
         """
         if not element.kdims:
-            return [element.label], []
+            xfactors, yfactors =  [element.label], []
         else:
             if bokeh_version < '0.12.7':
                 factors = [', '.join([d.pprint_value(v).replace(':', ';')
@@ -960,10 +964,8 @@ def _get_factors(self, element):
                 factors = [tuple(d.pprint_value(v) for d, v in zip(element.kdims, key))
                            for key in element.groupby(element.kdims).data.keys()]
                 factors = [f[0] if len(f) == 1 else f for f in factors]
-            if self.invert_axes:
-                return [], factors
-            else:
-                return factors, []
+            xfactors, yfactors = factors, []
+        return (yfactors, xfactors) if self.invert_axes else (xfactors, yfactors)
 
     def get_data(self, element, ranges=None, empty=False):
         if element.kdims:

holoviews/plotting/bokeh/raster.py

@@ -43,6 +43,12 @@ def get_data(self, element, ranges=None, empty=False):
                 img = img[::-1]
         dh, dw = t-b, r-l
 
+        if self.invert_axes:
+            dh, dw, l, b = dw, dh, b, l
+            if self.invert_yaxis: l = t
+            if self.invert_yaxis: b = r
+            img = np.rot90(img)
+
         mapping = dict(image='image', x='x', y='y', dw='dw', dh='dh')
         if empty:
             data = dict(image=[], x=[], y=[], dw=[], dh=[])
@@ -93,6 +99,12 @@ def get_data(self, element, ranges=None, empty=False):
             img = img[::-1]
         dh, dw = t-b, r-l
 
+        if self.invert_axes:
+            dh, dw, l, b = dw, dh, b, l
+            if self.invert_yaxis: l = t
+            if self.invert_yaxis: b = r
+            img = np.rot90(img)
+
         mapping = dict(image='image', x='x', y='y', dw='dw', dh='dh')
         if empty:
             data = dict(image=[], x=[], y=[], dw=[], dh=[])
@@ -138,16 +150,18 @@ def get_data(self, element, ranges=None, empty=False):
         aggregate = element.gridded
         style = self.style[self.cyclic_index]
         cmapper = self._get_colormapper(element.vdims[0], element, ranges, style)
-        if empty:
-            data = {x: [], y: [], z: []}
-        else:
-            xdim, ydim = aggregate.dimensions()[:2]
-            xvals, yvals, zvals = (aggregate.dimension_values(i) for i in range(3))
-            if xvals.dtype.kind not in 'SU':
-                xvals = [xdim.pprint_value(xv) for xv in xvals]
-            if yvals.dtype.kind not in 'SU':
-                yvals = [ydim.pprint_value(yv) for yv in yvals]
-            data = {x: xvals, y: yvals, 'zvalues': zvals}
+
+        xdim, ydim = aggregate.dimensions()[:2]
+        xvals, yvals, zvals = (aggregate.dimension_values(i) for i in range(3))
+        if xvals.dtype.kind not in 'SU':
+            xvals = [xdim.pprint_value(xv) for xv in xvals]
+        if yvals.dtype.kind not in 'SU':
+            yvals = [ydim.pprint_value(yv) for yv in yvals]
+
+        if self.invert_axes:
+            x, y = y, x
+            xvals, yvals = yvals, xvals
+        data = {x: xvals, y: yvals, 'zvalues': zvals}
 
         if any(isinstance(t, HoverTool) for t in self.state.tools):
             for vdim in element.vdims:
@@ -168,18 +182,23 @@ class QuadMeshPlot(ColorbarPlot):
 
     def get_data(self, element, ranges=None, empty=False):
         x, y, z = element.dimensions(label=True)
+        if self.invert_axes: x, y = y, x
         style = self.style[self.cyclic_index]
         cmapper = self._get_colormapper(element.vdims[0], element, ranges, style)
         if empty:
-            data = {x: [], y: [], z: [], 'height': [], 'width': []}
+            xs, ys, zvals, ws, hs = []*5
         else:
             if len(set(v.shape for v in element.data)) == 1:
                 raise SkipRendering("Bokeh QuadMeshPlot only supports rectangular meshes")
-            zvals = element.data[2].T.flatten()
             xvals = element.dimension_values(0, False)
             yvals = element.dimension_values(1, False)
             widths = np.diff(element.data[0])
             heights = np.diff(element.data[1])
+            if self.invert_axes:
+                zvals = element.data[2].flatten()
+                xvals, yvals, widths, heights = yvals, xvals, heights, widths
+            else:
+                zvals = element.data[2].T.flatten()
             xs, ys = cartesian_product([xvals, yvals], copy=True)
             ws, hs = cartesian_product([widths, heights], copy=True)
             data = {x: xs, y: ys, z: zvals, 'widths': ws, 'heights': hs}

holoviews/plotting/mpl/annotation.py

@@ -45,7 +45,10 @@ class VLinePlot(AnnotationPlot):
     style_opts = ['alpha', 'color', 'linewidth', 'linestyle', 'visible']
 
     def draw_annotation(self, axis, position, opts):
-        return [axis.axvline(position, **opts)]
+        if self.invert_axes:
+            return [axis.axhline(position, **opts)]
+        else:
+            return [axis.axvline(position, **opts)]
 
 
 
@@ -56,7 +59,10 @@ class HLinePlot(AnnotationPlot):
 
     def draw_annotation(self, axis, position, opts):
         "Draw a horizontal line on the axis"
-        return [axis.axhline(position, **opts)]
+        if self.invert_axes:
+            return [axis.axvline(position, **opts)]
+        else:
+            return [axis.axhline(position, **opts)]
 
 
 class TextPlot(AnnotationPlot):
@@ -67,6 +73,7 @@ class TextPlot(AnnotationPlot):
     def draw_annotation(self, axis, data, opts):
         (x,y, text, fontsize,
          horizontalalignment, verticalalignment, rotation) = data
+        if self.invert_axes: x, y = y, x
         opts['fontsize'] = fontsize
         return [axis.text(x,y, text,
                           horizontalalignment = horizontalalignment,
@@ -85,6 +92,7 @@ class ArrowPlot(AnnotationPlot):
 
     def draw_annotation(self, axis, data, opts):
         x, y, text, direction, points, arrowstyle = data
+        if self.invert_axes: x, y = y, x
         direction = direction.lower()
         arrowprops = dict({'arrowstyle':arrowstyle},
                           **{k: opts[k] for k in self._arrow_style_opts if k in opts})

holoviews/plotting/mpl/chart.py

@@ -621,7 +621,8 @@ def get_data(self, element, ranges, style):
         xs = element.dimension_values(xidx) if len(element.data) else []
         ys = element.dimension_values(yidx) if len(element.data) else []
         radians = element.dimension_values(2) if len(element.data) else []
-        angles = list(np.rad2deg(radians))
+        if self.invert_axes: radians = radians+1.5*np.pi
+        angles = list(np.rad2deg(radians)) 
         if self.rescale_lengths:
             input_scale = input_scale / self._min_dist
 

holoviews/plotting/mpl/raster.py

@@ -65,6 +65,10 @@ def get_data(self, element, ranges, style):
             l, b, r, t = element.bounds.lbrt()
 
         data = get_raster_array(element)
+        if self.invert_axes:
+            data = data[::-1]
+            data = data.transpose([1, 0, 2]) if isinstance(element, RGB) else data.T
+            l, b, r, t = b, l, t, r
         vdim = element.vdims[0]
         self._norm_kwargs(element, ranges, style, vdim)
         style['extent'] = [l, r, b, t]
@@ -151,6 +155,7 @@ def get_data(self, element, ranges, style):
 
         data = np.flipud(element.gridded.dimension_values(2, flat=False))
         data = np.ma.array(data, mask=np.logical_not(np.isfinite(data)))
+        if self.invert_axes: data = data.T
         shape = data.shape
         style['aspect'] = shape[0]/shape[1]
         style['extent'] = (0, shape[1], 0, shape[0])
@@ -187,9 +192,12 @@ class ImagePlot(RasterPlot):
     def get_data(self, element, ranges, style):
         data = np.flipud(element.dimension_values(2, flat=False))
         data = np.ma.array(data, mask=np.logical_not(np.isfinite(data)))
+        l, b, r, t = element.bounds.lbrt()
+        if self.invert_axes:
+            data = data[::-1].T
+            l, b, r, t = b, l, t, r
         vdim = element.vdims[0]
         self._norm_kwargs(element, ranges, style, vdim)
-        l, b, r, t = element.bounds.lbrt()
         style['extent'] = [l, r, b, t]
         return (data,), style, {}
 
@@ -211,7 +219,11 @@ class QuadMeshPlot(ColorbarPlot):
     def get_data(self, element, ranges, style):
         data = np.ma.array(element.data[2],
                            mask=np.logical_not(np.isfinite(element.data[2])))
-        cmesh_data = list(element.data[:2]) + [data]
+        coords = list(element.data[:2])
+        if self.invert_axes:
+            coords = coords[::-1]
+            data = data.T
+        cmesh_data = coords + [data]
         style['locs'] = np.concatenate(element.data[:2])
         vdim = element.vdims[0]
         self._norm_kwargs(element, ranges, style, vdim)