Merge 8b8b359 into 3b997dc

holoviews/plotting/bokeh/annotation.py

@@ -17,13 +17,13 @@
 from ...core.util import dimension_sanitizer, basestring
 from ...element import HLine
 from ..plot import GenericElementPlot
-from .element import (ElementPlot, CompositeElementPlot, ColorbarPlot,
-                      text_properties, line_properties)
+from .element import (AnnotationPlot, CompositeElementPlot, ColorbarPlot,
+                      ElementPlot, text_properties, line_properties)
 from .plot import BokehPlot
 
 
 
-class TextPlot(ElementPlot):
+class TextPlot(ElementPlot, AnnotationPlot):
 
     style_opts = text_properties+['color', 'angle']
     _plot_methods = dict(single='text', batched='text')
@@ -66,7 +66,7 @@ def get_extents(self, element, ranges=None, range_type='combined'):
 
 
 
-class LabelsPlot(ColorbarPlot):
+class LabelsPlot(ColorbarPlot, AnnotationPlot):
 
     color_index = param.ClassSelector(default=None, class_=(basestring, int),
                                       allow_None=True, doc="""
@@ -118,7 +118,7 @@ def get_data(self, element, ranges, style):
 
 
 
-class LineAnnotationPlot(ElementPlot):
+class LineAnnotationPlot(ElementPlot, AnnotationPlot):
 
     style_opts = line_properties + ['level']
 
@@ -147,7 +147,7 @@ def get_extents(self, element, ranges=None, range_type='combined'):
 
 
 
-class SplinePlot(ElementPlot):
+class SplinePlot(ElementPlot, AnnotationPlot):
     """
     Draw the supplied Spline annotation (see Spline docstring).
     Does not support matplotlib Path codes.
@@ -180,7 +180,7 @@ def get_data(self, element, ranges, style):
 
 
 
-class ArrowPlot(CompositeElementPlot):
+class ArrowPlot(CompositeElementPlot, AnnotationPlot):
 
     style_opts = (['arrow_%s' % p for p in line_properties+['size']] + text_properties)
 
@@ -249,7 +249,7 @@ def get_extents(self, element, ranges=None, range_type='combined'):
 
 
 
-class DivPlot(BokehPlot, GenericElementPlot):
+class DivPlot(BokehPlot, GenericElementPlot, AnnotationPlot):
 
     height = param.Number(default=300)
 

holoviews/plotting/bokeh/element.py

@@ -1297,6 +1297,12 @@ def _process_legend(self, plot=None):
 
 
 
+class AnnotationPlot(object):
+    """
+    Mix-in plotting subclass for AnnotationPlots which do not have a legend.
+    """
+
+
 class OverlayPlot(GenericOverlayPlot, LegendPlot):
 
     tabs = param.Boolean(default=False, doc="""
@@ -1323,7 +1329,14 @@ def __init__(self, overlay, **params):
 
     def _process_legend(self):
         plot = self.handles['plot']
-        if not self.show_legend or len(plot.legend) == 0:
+        subplots = self.traverse(lambda x: x, [lambda x: x is not self])
+        legend_plots = any(p is not None for p in subplots
+                           if isinstance(p, LegendPlot) and
+                           not isinstance(p, OverlayPlot))
+        non_annotation = [p for p in subplots if not
+                          (isinstance(p, OverlayPlot) or isinstance(p, AnnotationPlot))]
+        if (not self.show_legend or len(plot.legend) == 0 or
+            (len(non_annotation) <= 1 and not (self.dynamic or legend_plots))):
             return super(OverlayPlot, self)._process_legend()
 
         options = {}
@@ -1359,19 +1372,27 @@ def _process_legend(self):
 
         legend.orientation = orientation
 
-        legend_items = []
-        legend_labels = {}
+        if 'legend_items' not in self.handles:
+            self.handles['legend_items'] = []
+        legend_items = self.handles['legend_items']
+        legend_labels = {tuple(i.label.items()) if isinstance(i.label, dict) else i.label: i
+                         for i in legend_items}
         for item in legend.items:
             label = tuple(item.label.items()) if isinstance(item.label, dict) else item.label
             if not label or (isinstance(item.label, dict) and not item.label.get('value', True)):
                 continue
+            if item not in legend_items:
+                for oitem in legend_items:
+                    oitem.renderers[:] = [r for r in oitem.renderers if r not in item.renderers]
             if label in legend_labels:
                 prev_item = legend_labels[label]
-                prev_item.renderers += item.renderers
+                prev_item.renderers[:] = list(util.unique_iterator(prev_item.renderers+item.renderers))
             else:
                 legend_labels[label] = item
                 legend_items.append(item)
-        legend.items[:] = legend_items
+                self.handles['legend_items'].append(item)
+        legend_items = [item for item in legend_items if any(r.visible for r in item.renderers)]
+        legend.items[:] = list(util.unique_iterator(legend_items))
 
         if self.multiple_legends:
             plot.legend.pop(plot.legend.index(legend))
@@ -1579,7 +1600,8 @@ def update_frame(self, key, ranges=None, element=None):
 
                 # Skip updates to subplots when its streams is not one of
                 # the streams that initiated the update
-                if triggering and all(s not in triggering for s in subplot.streams):
+                if (triggering and all(s not in triggering for s in subplot.streams) and
+                    not subplot in self.dynamic_subplots):
                     continue
             subplot.update_frame(key, ranges, element=el)
 
@@ -1594,4 +1616,6 @@ def update_frame(self, key, ranges=None, element=None):
         if element and not self.overlaid and not self.tabs and not self.batched:
             self._update_plot(key, self.handles['plot'], element)
 
+        self._process_legend()
+
         self._execute_hooks(element)

holoviews/plotting/plot.py

@@ -1050,6 +1050,7 @@ def __init__(self, overlay, ranges=None, batched=True, keys=None, group_counter=
         self.subplots = self._create_subplots(ranges)
         self.traverse(lambda x: setattr(x, 'comm', self.comm))
         self.top_level = keys is None
+        self.dynamic_subplots = []
         if self.top_level:
             self.comm = self.init_comm()
             self.traverse(lambda x: setattr(x, 'comm', self.comm))
@@ -1144,6 +1145,8 @@ def _create_subplot(self, key, obj, streams, ranges):
             oidx = 0
         else:
             vtype = type(obj.last)
+            if style_key not in ordering:
+                ordering.append(style_key)
             oidx = ordering.index(style_key)
 
         plottype = registry.get(vtype, None)
@@ -1200,17 +1203,16 @@ def _create_dynamic_subplots(self, key, items, ranges, **init_kwargs):
         """
         length = self.style_grouping
         group_fn = lambda x: (x.type.__name__, x.last.group, x.last.label)
-        keys, vmaps = self.hmap.split_overlays()
-        for k, m in items:
-            self.map_lengths[group_fn(vmaps[keys.index(k)])[:length]] += 1
-
-        for k, obj in items:
-            subplot = self._create_subplot(k, vmaps[keys.index(k)], [], ranges)
+        for i, (k, obj) in enumerate(items):
+            vmap = self.hmap.clone([(key, obj)])
+            self.map_lengths[group_fn(vmap)[:length]] += 1
+            subplot = self._create_subplot(k, vmap, [], ranges)
             if subplot is None:
                 continue
             self.subplots[k] = subplot
             subplot.initialize_plot(ranges, **init_kwargs)
             subplot.update_frame(key, ranges, element=obj)
+            self.dynamic_subplots.append(subplot)
 
 
     def _update_subplot(self, subplot, spec):