feat: Add histline tests + cleanup

andrzejnovak · andrzejnovak · commit 67c15ecedc8a · 2020-09-09T17:50:57.000+02:00
diff --git a/lib/matplotlib/axes/_axes.py b/lib/matplotlib/axes/_axes.py
@@ -6871,18 +6871,52 @@ def hist(self, x, bins=None, range=None, density=False, weights=None,
                           else "List[Polygon]")
             return tops, bins, cbook.silent_list(patch_type, patches)
 
+    @_preprocess_data()
     def histline(self, vals, bins=None, *,
-                 orientation='horizontal', baseline=0, fill=False, **kwargs):
+                 orientation='vertical', baseline=0, fill=False, **kwargs):
+        """
+        A histogram-like line or filled plot.
 
-        _color = self._get_lines.get_next_color()
-        if not fill:
-            kwargs.setdefault('edgecolor', _color)
+        Parameters
+        ----------
+        vals : array
+            An array of y-values.
+
+        bins : array, default: ``range(len(vals)+1)``
+            A array of x-values, with ``len(bins) == len(vals) + 1``,
+            between which the curve takes on vals values.
+
+        orientation : {'vertical', 'horizontal'}, default: 'vertical'
+
+        baseline : float or None, default: 0
+            Determines starting value of the bounding edges or when
+            "fill" == True, position of lower edge.
+
+        fill : bool, default: False
+
+        Returns
+        -------
+        patch : `.StepPatch`
+
+        Other Parameters
+        ----------------
+        **kwargs
+            `~matplotlib.patches.Patch` properties
+
+        """
+
+        if 'color' in kwargs:
+            _color = kwargs.pop('color')
         else:
+            _color = self._get_lines.get_next_color()
+        if fill:
             kwargs.setdefault('edgecolor', 'none')
             kwargs.setdefault('facecolor', _color)
+        else:
+            kwargs.setdefault('edgecolor', _color)
 
         if bins is None:
-            bins = np.arange(len(vals)+1)
+            bins = np.arange(len(vals) + 1)
 
         patch = mpatches.StepPatch(vals,
                                    bins,
@@ -6891,18 +6925,15 @@ def histline(self, vals, bins=None, *,
                                    fill=fill,
                                    **kwargs)
         self.add_patch(patch)
-
         if baseline is None:
             baseline = 0
-        if orientation == 'horizontal':
+        if orientation == 'vertical':
             patch.sticky_edges.y.append(baseline)
         else:
             patch.sticky_edges.x.append(baseline)
-
         self._request_autoscale_view()
         return patch
 
-
     @_preprocess_data(replace_names=["x", "y", "weights"])
     @docstring.dedent_interpd
     def hist2d(self, x, y, bins=10, range=None, density=False, weights=None,
diff --git a/lib/matplotlib/legend.py b/lib/matplotlib/legend.py
@@ -624,7 +624,7 @@ def draw(self, renderer):
         ErrorbarContainer: legend_handler.HandlerErrorbar(),
         Line2D: legend_handler.HandlerLine2D(),
         Patch: legend_handler.HandlerPatch(),
-        StepPatch: legend_handler.HandlerLinePatch(),
+        StepPatch: legend_handler.HandlerStepPatch(),
         LineCollection: legend_handler.HandlerLineCollection(),
         RegularPolyCollection: legend_handler.HandlerRegularPolyCollection(),
         CircleCollection: legend_handler.HandlerCircleCollection(),
diff --git a/lib/matplotlib/legend_handler.py b/lib/matplotlib/legend_handler.py
@@ -302,44 +302,24 @@ def create_artists(self, legend, orig_handle,
         return [p]
 
 
-class HandlerLinePatch(HandlerBase):
+class HandlerStepPatch(HandlerBase):
     """
-    Handler for `.HistLine` instances.
+    Handler for `.StepPatch` instances.
     """
-    def __init__(self, patch_func=None, **kw):
+    def __init__(self, **kw):
         """
-        Parameters
-        ----------
-        patch_func : callable, optional
-            The function that creates the legend key artist.
-            *patch_func* should have the signature::
-
-                def patch_func(legend=legend, orig_handle=orig_handle,
-                               xdescent=xdescent, ydescent=ydescent,
-                               width=width, height=height, fontsize=fontsize)
-
-            Subsequently the created artist will have its ``update_prop``
-            method called and the appropriate transform will be applied.
-
-        Notes
-        -----
         Any other keyword arguments are given to `HandlerBase`.
         """
         super().__init__(**kw)
-        self._patch_func = patch_func
 
     def _create_patch(self, legend, orig_handle,
                       xdescent, ydescent, width, height, fontsize):
-        if self._patch_func is None:
-            p = Rectangle(xy=(-xdescent, -ydescent),
-                          color=orig_handle.get_facecolor(),
-                          width=width, height=height)
-        else:
-            p = self._patch_func(legend=legend, orig_handle=orig_handle,
-                                 xdescent=xdescent, ydescent=ydescent,
-                                 width=width, height=height, fontsize=fontsize)
+        p = Rectangle(xy=(-xdescent, -ydescent),
+                      color=orig_handle.get_facecolor(),
+                      width=width, height=height)
         return p
 
+    # Unfilled StepPatch should show as a line
     def _create_line(self, legend, orig_handle,
                      xdescent, ydescent, width, height, fontsize):
 
@@ -356,15 +336,14 @@ def _create_line(self, legend, orig_handle,
 
     def create_artists(self, legend, orig_handle,
                        xdescent, ydescent, width, height, fontsize, trans):
-        if orig_handle.get_fill():
+        if orig_handle.get_fill() or (orig_handle.get_hatch() is not None):
             p = self._create_patch(legend, orig_handle,
                                    xdescent, ydescent, width, height, fontsize)
             self.update_prop(p, orig_handle, legend)
         else:
             p = self._create_line(legend, orig_handle,
                                   xdescent, ydescent, width, height, fontsize)
         p.set_transform(trans)
-
         return [p]
 
 
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -990,72 +990,71 @@ def set_path(self, path):
 
 
 class StepPatch(PathPatch):
-    """A stepline path patch."""
+    """An unclosed stepline path patch."""
 
     @docstring.dedent_interpd
-    def __init__(self, vals, bins=None, *,
+    def __init__(self, vals, edges, *,
                  orientation='horizontal', baseline=0, **kwargs):
         """
         Parameters
         ----------
-        vals : array, len N
+        vals : array
             An array of y-values.
 
-        bins : array, len N+1
-            A array of x-values, between which the curve takes on
-            vals values.
+        edges : array
+            A array of x-value edges, with ``len(edges) == len(vals) + 1``,
+            between which the curve takes on vals values.
 
         orientation : {'vertical', 'horizontal'}, default: 'vertical'
 
         baseline : float or None, default: 0
             Determines starting value of the bounding edges or when
             "fill" == True, position of lower edge.
 
-        **kwargs
-            `Patch` properties:
+        Other valid keyword arguments are:
 
-            %(Patch)s
+        %(Patch)s
         """
         self.baseline = baseline
         self.orientation = orientation
-        self._bins = bins
-        self._vals = vals
+        self._edges = np.asarray(edges)
+        self._vals = np.asarray(vals)
         verts, codes = self._update_data()
         path = Path(verts, codes)
         super().__init__(path, **kwargs)
 
     def _update_data(self):
-        if self._bins.size - 1 != self._vals.size:
-            raise ValueError('the length of the bins is wrong')
+        if self._edges.size - 1 != self._vals.size:
+            raise ValueError('Size mismatch between "vals" and "edges"')
         verts, codes = [], []
         for idx0, idx1 in cbook.contiguous_regions(~np.isnan(self._vals)):
-            x = np.vstack((self._bins[idx0:idx1+1],
-                           self._bins[idx0:idx1+1])).T.flatten()
+            x = np.vstack((self._edges[idx0:idx1+1],
+                           self._edges[idx0:idx1+1])).T.flatten()
             y = np.vstack((self._vals[idx0:idx1],
                            self._vals[idx0:idx1])).T.flatten()
             if self.baseline is not None:
                 y = np.hstack((self.baseline, y, self.baseline))
             else:
                 y = np.hstack((y[0], y, y[-1]))
-            if self.orientation == 'horizontal':
+            if self.orientation == 'vertical':
                 xy = np.vstack([x, y]).T
             else:
                 xy = np.vstack([y, x]).T
             verts.append(xy)
             codes.append(np.array([Path.MOVETO] + [Path.LINETO]*(len(xy)-1)))
         return np.vstack(verts), np.hstack(codes)
 
-    def set_bins(self, bins):
-        self._bins = bins
+    def set_edges(self, edges):
+        self._edges = np.asarray(edges)
         self._update_data()
 
     def set_vals(self, vals):
-        self._vals = vals
+        self._vals = np.asarray(vals)
         self._update_data()
 
-    def set_vals_bins(self, vals, bins):
-        self._vals = vals
-        self._bins = bins
+    def set_vals_edges(self, vals, edges):
+        self._vals = np.asarray(vals)
+        self._edegs = np.asarray(edges)
         self._update_data()
 
 
diff --git a/lib/matplotlib/tests/baseline_images/test_axes/test_histline_options.svg b/lib/matplotlib/tests/baseline_images/test_axes/test_histline_options.svg
diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py
