Merge 128c3cd into 26d2072

doc/Tutorials/Bokeh_Elements.ipynb

@@ -38,7 +38,7 @@
     "  <dt><a href=\"#BoxWhisker\"><code>BoxWhisker</code></a></dt><dd>Distributions of data varying by 0-N key dimensions.<font color='green'>&#x2713;</font></dd>\n",
     "  <dt><a href=\"#Scatter\"><code>Scatter</code></a></dt><dd>Discontinuous collection of points indexed over a single dimension. <font color='green'>&#x2713;</font></dd>\n",
     "  <dt><a href=\"#Points\"><code>Points</code></a></dt><dd>Discontinuous collection of points indexed over two dimensions. <font color='green'>&#x2713;</font></dd>\n",
-    "  <dt><a href=\"#VectorField\"><code>VectorField</code></a></dt><dd>Cyclic variable (and optional auxiliary data) distributed over two-dimensional space. <font color='red'>&#x2717;</font></dd>\n",
+    "  <dt><a href=\"#VectorField\"><code>VectorField</code></a></dt><dd>Cyclic variable (and optional auxiliary data) distributed over two-dimensional space. <font color='green'>&#x2713;</font></dd>\n",
     "  <dt><a href=\"#Spikes\"><code>Spikes</code></a></dt><dd>A collection of horizontal or vertical lines at various locations with fixed height (1D) or variable height (2D). <font color='green'>&#x2713;</font></dd>\n",
     "  <dt><a href=\"#SideHistogram\"><code>SideHistogram</code></a></dt><dd>Histogram binning data contained by some other <code>Element</code>. <font color='green'>&#x2713;</font></dd>\n",
     "  </dl>\n",
@@ -674,6 +674,7 @@
    },
    "outputs": [],
    "source": [
+    "%%opts VectorField [size_index=3]\n",
     "x,y  = np.mgrid[-10:10,-10:10] * 0.25\n",
     "sine_rings  = np.sin(x**2+y**2)*np.pi+np.pi\n",
     "exp_falloff = 1/np.exp((x**2+y**2)/8)\n",
@@ -699,8 +700,8 @@
    },
    "outputs": [],
    "source": [
-    "%%opts VectorField.A [color_dim='angle'] VectorField.M [color_dim='magnitude']\n",
-    "hv.VectorField(vector_data, group='A')"
+    "%%opts VectorField [size_index=3] VectorField.A [color_index=2] VectorField.M [color_index=3]\n",
+    "hv.VectorField(vector_data, group='A') + hv.VectorField(vector_data, group='M')"
    ]
   },
   {

holoviews/plotting/bokeh/__init__.py

@@ -6,7 +6,8 @@
                         RGB, Histogram, Spread, HeatMap, Contours, Bars,
                         Box, Bounds, Ellipse, Polygons, BoxWhisker,
                         ErrorBars, Text, HLine, VLine, Spline, Spikes,
-                        Table, ItemTable, Area, HSV, QuadMesh, GridImage)
+                        Table, ItemTable, Area, HSV, QuadMesh, GridImage,
+                        VectorField)
 from ...core.options import Options, Cycle
 
 try:
@@ -21,7 +22,7 @@
 from .element import OverlayPlot, BokehMPLWrapper
 from .chart import (PointPlot, CurvePlot, SpreadPlot, ErrorPlot, HistogramPlot,
                     SideHistogramPlot, BoxPlot, BarPlot, SpikesPlot,
-                    SideSpikesPlot, AreaPlot)
+                    SideSpikesPlot, AreaPlot, VectorFieldPlot)
 from .path import PathPlot, PolygonPlot
 from .plot import GridPlot, LayoutPlot, AdjointLayoutPlot
 from .raster import (RasterPlot, ImagePlot, RGBPlot, HeatmapPlot,
@@ -47,6 +48,7 @@
                 Spread: SpreadPlot,
                 Spikes: SpikesPlot,
                 Area: AreaPlot,
+                VectorField: VectorFieldPlot,
 
                 # Rasters
                 Image: RasterPlot,
@@ -130,6 +132,7 @@
 
 options.Spikes = Options('style', color='black')
 options.Area = Options('style', color=Cycle(), line_color='black')
+options.VectorField = Options('style', line_color='black')
 
 # Paths
 options.Contours = Options('style', color=Cycle())

holoviews/plotting/bokeh/chart.py

@@ -14,7 +14,8 @@
 from ...core.util import max_range, basestring, dimension_sanitizer
 from ...core.options import abbreviated_exception
 from ...operation import interpolate_curve
-from ..util import compute_sizes, get_sideplot_ranges, match_spec, map_colors
+from ..util import (compute_sizes, get_sideplot_ranges, match_spec,
+                    map_colors, get_min_distance)
 from .element import ElementPlot, ColorbarPlot, LegendPlot, line_properties, fill_properties
 from .path import PathPlot, PolygonPlot
 from .util import get_cmap, mpl_to_bokeh, update_plot, rgb2hex, bokeh_version
@@ -50,6 +51,26 @@ class PointPlot(LegendPlot, ColorbarPlot):
 
     _plot_methods = dict(single='scatter', batched='scatter')
 
+    def _get_size_data(self, element, ranges, style):
+        data, mapping = {}, {}
+        sdim = element.get_dimension(self.size_index)
+        if sdim:
+            map_key = 'size_' + sdim.name
+            ms = style.get('size', np.sqrt(6))**2
+            sizes = element.dimension_values(self.size_index)
+            sizes = compute_sizes(sizes, self.size_fn,
+                                  self.scaling_factor,
+                                  self.scaling_method, ms)
+            if sizes is None:
+                eltype = type(element).__name__
+                self.warning('%s dimension is not numeric, cannot '
+                             'use to scale %s size.' % (sdim, eltype))
+            else:
+                data[map_key] = np.sqrt(sizes)
+                mapping['size'] = map_key
+        return data, mapping
+
+
     def get_data(self, element, ranges=None, empty=False):
         style = self.style[self.cyclic_index]
         dims = element.dimensions(label=True)
@@ -63,39 +84,13 @@ def get_data(self, element, ranges=None, empty=False):
         data[ydim] = [] if empty else element.dimension_values(yidx)
         self._categorize_data(data, (xdim, ydim), element.dimensions())
 
-        cdim = element.get_dimension(self.color_index)
-        if cdim:
-            cdata = data[cdim.name] if cdim.name in data else element.dimension_values(cdim)
-            factors = None
-            if isinstance(cdata, list) or cdata.dtype.kind in 'OSU':
-                factors = list(np.unique(cdata))
-            mapper = self._get_colormapper(cdim, element, ranges, style,
-                                           factors)
-            data[cdim.name] = cdata
-            if factors is not None:
-                mapping['legend'] = {'field': cdim.name}
-            mapping['color'] = {'field': cdim.name,
-                                'transform': mapper}
+        cdata, cmapping = self._get_color_data(element, ranges, style)
+        data.update(cdata)
+        mapping.update(cmapping)
 
-        sdim = element.get_dimension(self.size_index)
-        if sdim:
-            map_key = 'size_' + sdim.name
-            if empty:
-                data[map_key] = []
-                mapping['size'] = map_key
-            else:
-                ms = style.get('size', np.sqrt(6))**2
-                sizes = element.dimension_values(self.size_index)
-                sizes = compute_sizes(sizes, self.size_fn,
-                                      self.scaling_factor,
-                                      self.scaling_method, ms)
-                if sizes is None:
-                    eltype = type(element).__name__
-                    self.warning('%s dimension is not numeric, cannot '
-                                 'use to scale %s size.' % (sdim, eltype))
-                else:
-                    data[map_key] = np.sqrt(sizes)
-                    mapping['size'] = map_key
+        sdata, smapping = self._get_size_data(element, ranges, style)
+        data.update(sdata)
+        mapping.update(smapping)
 
         self._get_hover_data(data, element, empty)
         return data, mapping
@@ -152,6 +147,93 @@ def _init_glyph(self, plot, mapping, properties):
         return renderer, renderer.glyph
 
 
+class VectorFieldPlot(ColorbarPlot):
+
+    arrow_heads = param.Boolean(default=True, doc="""
+       Whether or not to draw arrow heads.""")
+
+    color_index = param.ClassSelector(default=None, class_=(basestring, int),
+                                      allow_None=True, doc="""
+      Index of the dimension from which the color will the drawn""")
+
+    size_index = param.ClassSelector(default=None, class_=(basestring, int),
+                                     allow_None=True, doc="""
+      Index of the dimension from which the sizes will the drawn.""")
+
+    normalize_lengths = param.Boolean(default=True, doc="""
+       Whether to normalize vector magnitudes automatically. If False,
+       it will be assumed that the lengths have already been correctly
+       normalized.""")
+
+    rescale_lengths = param.Boolean(default=True, doc="""
+       Whether the lengths will be rescaled to take into account the
+       smallest non-zero distance between two vectors.""")
+
+    style_opts = ['color'] + line_properties
+    _plot_methods = dict(single='segment')
+
+    def _get_lengths(self, element, ranges):
+        mag_dim = element.get_dimension(self.size_index)
+        (x0, x1), (y0, y1) = (element.range(i) for i in range(2))
+        base_dist = get_min_distance(element)
+        if mag_dim:
+            magnitudes = element.dimension_values(mag_dim)
+            _, max_magnitude = ranges[mag_dim.name]
+            if self.normalize_lengths and max_magnitude != 0:
+                magnitudes = magnitudes / max_magnitude
+            if self.rescale_lengths:
+                magnitudes *= base_dist
+        else:
+            magnitudes = np.ones(len(element))*base_dist
+        return magnitudes
+
+
+    def get_data(self, element, ranges=None, empty=False):
+        style = self.style[self.cyclic_index]
+
+        # Get x, y, angle, magnitude and color data
+        xidx, yidx = (1, 0) if self.invert_axes else (0, 1)
+        angle_dim = element.get_dimension(2).name
+        rads = element.dimension_values(2)
+        lens = self._get_lengths(element, ranges)
+        cdim = element.get_dimension(self.color_index)
+        cdata, cmapping = self._get_color_data(element, ranges, style,
+                                               name='line_color')
+
+        # Compute segments and arrowheads
+        xs = element.dimension_values(xidx)
+        ys = element.dimension_values(yidx)
+        xoffsets = np.cos(rads)*lens/2.
+        yoffsets = np.sin(rads)*lens/2.
+        x0s, x1s = (xs + xoffsets, xs - xoffsets)
+        y0s, y1s = (ys + yoffsets, ys - yoffsets)
+
+        if self.arrow_heads:
+            arrow_len = (lens/4.)
+            xa1s = x0s - np.cos(rads+np.pi/4)*arrow_len
+            ya1s = y0s - np.sin(rads+np.pi/4)*arrow_len
+            xa2s = x0s - np.cos(rads-np.pi/4)*arrow_len
+            ya2s = y0s - np.sin(rads-np.pi/4)*arrow_len
+            x0s = np.concatenate([x0s, x0s, x0s])
+            x1s = np.concatenate([x1s, xa1s, xa2s])
+            y0s = np.concatenate([y0s, y0s, y0s])
+            y1s = np.concatenate([y1s, ya1s, ya2s])
+            if cdim:
+                color = cdata.get(cdim.name)
+                color = np.concatenate([color, color, color])
+        elif cdim:
+            color = cdata.get(cdim.name)
+
+        data = {'x0': x0s, 'x1': x1s, 'y0': y0s, 'y1': y1s}
+        mapping = dict(x0='x0', x1='x1', y0='y0', y1='y1')
+        if cdim:
+            data[cdim.name] = color
+            mapping.update(cmapping)
+
+        return (data, mapping)
+
+
+
 class CurvePlot(ElementPlot):
 
     interpolation = param.ObjectSelector(objects=['linear', 'steps-mid',

holoviews/plotting/bokeh/element.py

@@ -940,6 +940,24 @@ def _get_colormapper(self, dim, element, ranges, style, factors=None):
         return cmapper
 
 
+    def _get_color_data(self, element, ranges, style, name='color'):
+        data, mapping = {}, {}
+        cdim = element.get_dimension(self.color_index)
+        if cdim:
+            cdata = element.dimension_values(cdim)
+            factors = None
+            if isinstance(cdata, list) or cdata.dtype.kind in 'OSU':
+                factors = list(np.unique(cdata))
+            mapper = self._get_colormapper(cdim, element, ranges, style,
+                                           factors)
+            data[cdim.name] = cdata
+            if factors is not None:
+                mapping['legend'] = {'field': cdim.name}
+            mapping[name] = {'field': cdim.name,
+                             'transform': mapper}
+        return data, mapping
+
+
     def _get_cmapper_opts(self, low, high, factors, colors):
         if factors is None:
             colormapper = LogColorMapper if self.logz else LinearColorMapper

holoviews/plotting/mpl/chart.py

@@ -20,7 +20,8 @@
                           basestring, max_range, unicode)
 from ...element import Points, Raster, Polygons, HeatMap
 from ...operation import interpolate_curve
-from ..util import compute_sizes, get_sideplot_ranges, map_colors
+from ..util import (compute_sizes, get_sideplot_ranges, map_colors,
+                    get_min_distance)
 from .element import ElementPlot, ColorbarPlot, LegendPlot
 from .path  import PathPlot
 from .plot import AdjoinedPlot
@@ -633,16 +634,7 @@ def _get_map_info(self, vmap):
         """
         Get the minimum sample distance and maximum magnitude
         """
-        return np.min([self._get_min_dist(vfield) for vfield in vmap])
-
-
-    def _get_min_dist(self, vfield):
-        "Get the minimum sampling distance."
-        xys = vfield.array([0, 1]).view(dtype=np.complex128)
-        m, n = np.meshgrid(xys, xys)
-        distances = np.abs(m-n)
-        np.fill_diagonal(distances, np.inf)
-        return distances[distances>0].min()
+        return np.min([get_min_distance(vfield) for vfield in vmap])
 
 
     def get_data(self, element, ranges, style):

holoviews/plotting/util.py

@@ -336,6 +336,17 @@ def traverse_setter(obj, attribute, value):
     obj.traverse(lambda x: setattr(x, attribute, value))
 
 
+def get_min_distance(element):
+    """
+    Gets the minimum sampling distance of the x- and y-coordinates
+    in a grid.
+    """
+    xys = element.array([0, 1]).view(dtype=np.complex128)
+    m, n = np.meshgrid(xys, xys)
+    distances = np.abs(m-n)
+    np.fill_diagonal(distances, np.inf)
+    return distances[distances>0].min()
+
 
 # linear_kryw_0_100_c71 (aka "fire"):
 # A perceptually uniform equivalent of matplotlib's "hot" colormap, from