add hatchcolors param for collections

r3kste · r3kste · commit d7da1fce96e1 · 2025-02-08T16:43:44.000+05:30
diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
@@ -208,7 +208,7 @@ def draw_markers(self, gc, marker_path, marker_trans, path,
     def draw_path_collection(self, gc, master_transform, paths, all_transforms,
                              offsets, offset_trans, facecolors, edgecolors,
                              linewidths, linestyles, antialiaseds, urls,
-                             offset_position):
+                             offset_position, hatchcolors=None):
         """
         Draw a collection of *paths*.
 
@@ -217,8 +217,8 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
         *master_transform*.  They are then translated by the corresponding
         entry in *offsets*, which has been first transformed by *offset_trans*.
 
-        *facecolors*, *edgecolors*, *linewidths*, *linestyles*, and
-        *antialiased* are lists that set the corresponding properties.
+        *facecolors*, *edgecolors*, *linewidths*, *linestyles*, *antialiased*
+        and *hatchcolors* are lists that set the corresponding properties.
 
         *offset_position* is unused now, but the argument is kept for
         backwards compatibility.
@@ -235,10 +235,13 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
         path_ids = self._iter_collection_raw_paths(master_transform,
                                                    paths, all_transforms)
 
+        if hatchcolors is None:
+            hatchcolors = []
+
         for xo, yo, path_id, gc0, rgbFace in self._iter_collection(
                 gc, list(path_ids), offsets, offset_trans,
                 facecolors, edgecolors, linewidths, linestyles,
-                antialiaseds, urls, offset_position):
+                antialiaseds, urls, offset_position, hatchcolors):
             path, transform = path_id
             # Only apply another translation if we have an offset, else we
             # reuse the initial transform.
@@ -252,7 +255,7 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
 
     def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,
                        coordinates, offsets, offsetTrans, facecolors,
-                       antialiased, edgecolors):
+                       antialiased, edgecolors, hatchcolors=None):
         """
         Draw a quadmesh.
 
@@ -265,11 +268,13 @@ def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,
 
         if edgecolors is None:
             edgecolors = facecolors
+        if hatchcolors is None:
+            hatchcolors = []
         linewidths = np.array([gc.get_linewidth()], float)
 
         return self.draw_path_collection(
             gc, master_transform, paths, [], offsets, offsetTrans, facecolors,
-            edgecolors, linewidths, [], [antialiased], [None], 'screen')
+            edgecolors, linewidths, [], [antialiased], [None], 'screen', hatchcolors)
 
     def draw_gouraud_triangles(self, gc, triangles_array, colors_array,
                                transform):
@@ -337,7 +342,7 @@ def _iter_collection_uses_per_path(self, paths, all_transforms,
 
     def _iter_collection(self, gc, path_ids, offsets, offset_trans, facecolors,
                          edgecolors, linewidths, linestyles,
-                         antialiaseds, urls, offset_position):
+                         antialiaseds, urls, offset_position, hatchcolors=None):
         """
         Helper method (along with `_iter_collection_raw_paths`) to implement
         `draw_path_collection` in a memory-efficient manner.
@@ -360,16 +365,20 @@ def _iter_collection(self, gc, path_ids, offsets, offset_trans, facecolors,
         *path_ids*; *gc* is a graphics context and *rgbFace* is a color to
         use for filling the path.
         """
+        if hatchcolors is None:
+            hatchcolors = []
+
         Npaths = len(path_ids)
         Noffsets = len(offsets)
         N = max(Npaths, Noffsets)
         Nfacecolors = len(facecolors)
         Nedgecolors = len(edgecolors)
+        Nhatchcolors = len(hatchcolors)
         Nlinewidths = len(linewidths)
         Nlinestyles = len(linestyles)
         Nurls = len(urls)
 
-        if (Nfacecolors == 0 and Nedgecolors == 0) or Npaths == 0:
+        if (Nfacecolors == 0 and Nedgecolors == 0 and Nhatchcolors == 0) or Npaths == 0:
             return
 
         gc0 = self.new_gc()
@@ -384,6 +393,7 @@ def cycle_or_default(seq, default=None):
         toffsets = cycle_or_default(offset_trans.transform(offsets), (0, 0))
         fcs = cycle_or_default(facecolors)
         ecs = cycle_or_default(edgecolors)
+        hcs = cycle_or_default(hatchcolors)
         lws = cycle_or_default(linewidths)
         lss = cycle_or_default(linestyles)
         aas = cycle_or_default(antialiaseds)
@@ -392,8 +402,8 @@ def cycle_or_default(seq, default=None):
         if Nedgecolors == 0:
             gc0.set_linewidth(0.0)
 
-        for pathid, (xo, yo), fc, ec, lw, ls, aa, url in itertools.islice(
-                zip(pathids, toffsets, fcs, ecs, lws, lss, aas, urls), N):
+        for pathid, (xo, yo), fc, ec, hc, lw, ls, aa, url in itertools.islice(
+                zip(pathids, toffsets, fcs, ecs, hcs, lws, lss, aas, urls), N):
             if not (np.isfinite(xo) and np.isfinite(yo)):
                 continue
             if Nedgecolors:
@@ -405,6 +415,8 @@ def cycle_or_default(seq, default=None):
                     gc0.set_linewidth(0)
                 else:
                     gc0.set_foreground(ec)
+            if Nhatchcolors:
+                gc0.set_hatch_color(hc)
             if fc is not None and len(fc) == 4 and fc[3] == 0:
                 fc = None
             gc0.set_antialiased(aa)
diff --git a/lib/matplotlib/backend_bases.pyi b/lib/matplotlib/backend_bases.pyi
@@ -63,6 +63,7 @@ class RendererBase:
         antialiaseds: bool | Sequence[bool],
         urls: str | Sequence[str],
         offset_position: Any,
+        hatchcolors: ColorType | Sequence[ColorType] | None = None,
     ) -> None: ...
     def draw_quad_mesh(
         self,
@@ -76,6 +77,7 @@ class RendererBase:
         facecolors: Sequence[ColorType],
         antialiased: bool,
         edgecolors: Sequence[ColorType] | ColorType | None,
+        hatchcolors: Sequence[ColorType] | ColorType | None = None,
     ) -> None: ...
     def draw_gouraud_triangles(
         self,
diff --git a/lib/matplotlib/backends/backend_pdf.py b/lib/matplotlib/backends/backend_pdf.py
@@ -2030,14 +2030,17 @@ def draw_path(self, gc, path, transform, rgbFace=None):
     def draw_path_collection(self, gc, master_transform, paths, all_transforms,
                              offsets, offset_trans, facecolors, edgecolors,
                              linewidths, linestyles, antialiaseds, urls,
-                             offset_position):
+                             offset_position, hatchcolors=None):
         # We can only reuse the objects if the presence of fill and
         # stroke (and the amount of alpha for each) is the same for
         # all of them
         can_do_optimization = True
         facecolors = np.asarray(facecolors)
         edgecolors = np.asarray(edgecolors)
 
+        if hatchcolors is None:
+            hatchcolors = []
+
         if not len(facecolors):
             filled = False
             can_do_optimization = not gc.get_hatch()
@@ -2072,7 +2075,7 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
                 self, gc, master_transform, paths, all_transforms,
                 offsets, offset_trans, facecolors, edgecolors,
                 linewidths, linestyles, antialiaseds, urls,
-                offset_position)
+                offset_position, hatchcolors)
 
         padding = np.max(linewidths)
         path_codes = []
@@ -2088,7 +2091,7 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
         for xo, yo, path_id, gc0, rgbFace in self._iter_collection(
                 gc, path_codes, offsets, offset_trans,
                 facecolors, edgecolors, linewidths, linestyles,
-                antialiaseds, urls, offset_position):
+                antialiaseds, urls, offset_position, hatchcolors):
 
             self.check_gc(gc0, rgbFace)
             dx, dy = xo - lastx, yo - lasty
diff --git a/lib/matplotlib/backends/backend_ps.py b/lib/matplotlib/backends/backend_ps.py
@@ -674,7 +674,9 @@ def draw_markers(
     def draw_path_collection(self, gc, master_transform, paths, all_transforms,
                              offsets, offset_trans, facecolors, edgecolors,
                              linewidths, linestyles, antialiaseds, urls,
-                             offset_position):
+                             offset_position, hatchcolors=None):
+        if hatchcolors is None:
+            hatchcolors = []
         # Is the optimization worth it? Rough calculation:
         # cost of emitting a path in-line is
         #     (len_path + 2) * uses_per_path
@@ -690,7 +692,7 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
                 self, gc, master_transform, paths, all_transforms,
                 offsets, offset_trans, facecolors, edgecolors,
                 linewidths, linestyles, antialiaseds, urls,
-                offset_position)
+                offset_position, hatchcolors)
 
         path_codes = []
         for i, (path, transform) in enumerate(self._iter_collection_raw_paths(
@@ -709,7 +711,7 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
         for xo, yo, path_id, gc0, rgbFace in self._iter_collection(
                 gc, path_codes, offsets, offset_trans,
                 facecolors, edgecolors, linewidths, linestyles,
-                antialiaseds, urls, offset_position):
+                antialiaseds, urls, offset_position, hatchcolors):
             ps = f"{xo:g} {yo:g} {path_id}"
             self._draw_ps(ps, gc0, rgbFace)
 
diff --git a/lib/matplotlib/backends/backend_svg.py b/lib/matplotlib/backends/backend_svg.py
@@ -736,7 +736,9 @@ def draw_markers(
     def draw_path_collection(self, gc, master_transform, paths, all_transforms,
                              offsets, offset_trans, facecolors, edgecolors,
                              linewidths, linestyles, antialiaseds, urls,
-                             offset_position):
+                             offset_position, hatchcolors=None):
+        if hatchcolors is None:
+            hatchcolors = []
         # Is the optimization worth it? Rough calculation:
         # cost of emitting a path in-line is
         #    (len_path + 5) * uses_per_path
@@ -752,7 +754,7 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
                 gc, master_transform, paths, all_transforms,
                 offsets, offset_trans, facecolors, edgecolors,
                 linewidths, linestyles, antialiaseds, urls,
-                offset_position)
+                offset_position, hatchcolors)
 
         writer = self.writer
         path_codes = []
@@ -770,7 +772,7 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
         for xo, yo, path_id, gc0, rgbFace in self._iter_collection(
                 gc, path_codes, offsets, offset_trans,
                 facecolors, edgecolors, linewidths, linestyles,
-                antialiaseds, urls, offset_position):
+                antialiaseds, urls, offset_position, hatchcolors):
             url = gc0.get_url()
             if url is not None:
                 writer.start('a', attrib={'xlink:href': url})
diff --git a/lib/matplotlib/collections.py b/lib/matplotlib/collections.py
@@ -79,6 +79,7 @@ class Collection(mcolorizer.ColorizingArtist):
     def __init__(self, *,
                  edgecolors=None,
                  facecolors=None,
+                 hatchcolors=None,
                  linewidths=None,
                  linestyles='solid',
                  capstyle=None,
@@ -174,13 +175,6 @@ def __init__(self, *,
         self._face_is_mapped = None
         self._edge_is_mapped = None
         self._mapped_colors = None  # calculated in update_scalarmappable
-
-        # Temporary logic to set hatchcolor. This eager resolution is temporary
-        # and will be replaced by a proper mechanism in a follow-up PR.
-        hatch_color = mpl.rcParams['hatch.color']
-        if hatch_color == 'edge':
-            hatch_color = mpl.rcParams['patch.edgecolor']
-        self._hatch_color = mcolors.to_rgba(hatch_color)
         self._hatch_linewidth = mpl.rcParams['hatch.linewidth']
         self.set_facecolor(facecolors)
         self.set_edgecolor(edgecolors)
@@ -190,6 +184,7 @@ def __init__(self, *,
         self.set_pickradius(pickradius)
         self.set_urls(urls)
         self.set_hatch(hatch)
+        self.set_hatchcolor(hatchcolors)
         self.set_zorder(zorder)
 
         if capstyle:
@@ -371,7 +366,6 @@ def draw(self, renderer):
 
         if self._hatch:
             gc.set_hatch(self._hatch)
-            gc.set_hatch_color(self._hatch_color)
             gc.set_hatch_linewidth(self._hatch_linewidth)
 
         if self.get_sketch_params() is not None:
@@ -431,15 +425,16 @@ def draw(self, renderer):
                     [mcolors.to_rgba("none")], self._gapcolor,
                     self._linewidths, ilinestyles,
                     self._antialiaseds, self._urls,
-                    "screen")
+                    "screen", self.get_hatchcolor())
 
             renderer.draw_path_collection(
                 gc, transform.frozen(), paths,
                 self.get_transforms(), offsets, offset_trf,
                 self.get_facecolor(), self.get_edgecolor(),
                 self._linewidths, self._linestyles,
                 self._antialiaseds, self._urls,
-                "screen")  # offset_position, kept for backcompat.
+                "screen",  # offset_position, kept for backcompat.
+                self.get_hatchcolor())
 
         gc.restore()
         renderer.close_group(self.__class__.__name__)
@@ -814,23 +809,27 @@ def _get_default_edgecolor(self):
         # This may be overridden in a subclass.
         return mpl.rcParams['patch.edgecolor']
 
+    def get_hatchcolor(self):
+        if cbook._str_equal(self._hatchcolors, 'edge'):
+            if self.get_edgecolor().size == 0:
+                return mpl.colors.to_rgba_array(self._get_default_edgecolor(),
+                                                self._alpha)
+            return self.get_edgecolor()
+        return self._hatchcolors
+
     def _set_edgecolor(self, c):
-        set_hatch_color = True
         if c is None:
             if (mpl.rcParams['patch.force_edgecolor']
                     or self._edge_default
                     or cbook._str_equal(self._original_facecolor, 'none')):
                 c = self._get_default_edgecolor()
             else:
                 c = 'none'
-                set_hatch_color = False
         if cbook._str_lower_equal(c, 'face'):
             self._edgecolors = 'face'
             self.stale = True
             return
         self._edgecolors = mcolors.to_rgba_array(c, self._alpha)
-        if set_hatch_color and len(self._edgecolors):
-            self._hatch_color = tuple(self._edgecolors[0])
         self.stale = True
 
     def set_edgecolor(self, c):
@@ -851,6 +850,29 @@ def set_edgecolor(self, c):
         self._original_edgecolor = c
         self._set_edgecolor(c)
 
+    def _set_hatchcolor(self, c):
+        c = mpl._val_or_rc(c, 'hatch.color')
+        if c == 'edge':
+            self._hatchcolors = 'edge'
+        else:
+            self._hatchcolors = mcolors.to_rgba_array(c, self._alpha)
+        self.stale = True
+
+    def set_hatchcolor(self, c):
+        """
+        Set the hatchcolor(s) of the collection.
+
+        Parameters
+        ----------
+        c : :mpltype:`color` or list of :mpltype:`color` or 'edge'
+            The collection hatchcolor(s).  If a sequence, the patches cycle
+            through it.
+        """
+        if cbook._str_equal(c, 'edge'):
+            c = 'edge'
+        self._original_hatchcolor = c
+        self._set_hatchcolor(c)
+
     def set_alpha(self, alpha):
         """
         Set the transparency of the collection.
@@ -968,6 +990,7 @@ def update_from(self, other):
         self._us_linestyles = other._us_linestyles
         self._pickradius = other._pickradius
         self._hatch = other._hatch
+        self._hatchcolors = other._hatchcolors
 
         # update_from for scalarmappable
         self._A = other._A
@@ -2465,7 +2488,8 @@ def draw(self, renderer):
                 coordinates, offsets, offset_trf,
                 # Backends expect flattened rgba arrays (n*m, 4) for fc and ec
                 self.get_facecolor().reshape((-1, 4)),
-                self._antialiased, self.get_edgecolors().reshape((-1, 4)))
+                self._antialiased, self.get_edgecolors().reshape((-1, 4)),
+                self.get_hatchcolor().reshape((-1, 4)))
         gc.restore()
         renderer.close_group(self.__class__.__name__)
         self.stale = False
diff --git a/lib/matplotlib/collections.pyi b/lib/matplotlib/collections.pyi
@@ -21,6 +21,7 @@ class Collection(colorizer.ColorizingArtist):
         *,
         edgecolors: ColorType | Sequence[ColorType] | None = ...,
         facecolors: ColorType | Sequence[ColorType] | None = ...,
+        hatchcolors: ColorType | Sequence[ColorType] | None = ...,
         linewidths: float | Sequence[float] | None = ...,
         linestyles: LineStyleType | Sequence[LineStyleType] = ...,
         capstyle: CapStyleType | None = ...,
@@ -66,6 +67,10 @@ class Collection(colorizer.ColorizingArtist):
     def get_facecolor(self) -> ColorType | Sequence[ColorType]: ...
     def get_edgecolor(self) -> ColorType | Sequence[ColorType]: ...
     def set_edgecolor(self, c: ColorType | Sequence[ColorType]) -> None: ...
+    def get_hatchcolor(self) -> ColorType | Sequence[ColorType]: ...
+    def set_hatchcolor(
+        self, c: ColorType | Sequence[ColorType] | Literal["edge"]
+    ) -> None: ...
     def set_alpha(self, alpha: float | Sequence[float] | None) -> None: ...
     def get_linewidth(self) -> float | Sequence[float]: ...
     def get_linestyle(self) -> LineStyleType | Sequence[LineStyleType]: ...
diff --git a/lib/matplotlib/legend_handler.py b/lib/matplotlib/legend_handler.py
@@ -790,12 +790,11 @@ def get_first(prop_array):
         # Directly set Patch color attributes (must be RGBA tuples).
         legend_handle._facecolor = first_color(orig_handle.get_facecolor())
         legend_handle._edgecolor = first_color(orig_handle.get_edgecolor())
+        legend_handle._hatch_color = first_color(orig_handle.get_hatchcolor())
         legend_handle._original_facecolor = orig_handle._original_facecolor
         legend_handle._original_edgecolor = orig_handle._original_edgecolor
         legend_handle._fill = orig_handle.get_fill()
         legend_handle._hatch = orig_handle.get_hatch()
-        # Hatch color is anomalous in having no getters and setters.
-        legend_handle._hatch_color = orig_handle._hatch_color
         # Setters are fine for the remaining attributes.
         legend_handle.set_linewidth(get_first(orig_handle.get_linewidths()))
         legend_handle.set_linestyle(get_first(orig_handle.get_linestyles()))
diff --git a/lib/matplotlib/tests/test_collections.py b/lib/matplotlib/tests/test_collections.py
diff --git a/src/_backend_agg.h b/src/_backend_agg.h
diff --git a/src/_backend_agg_wrapper.cpp b/src/_backend_agg_wrapper.cpp
