barebones impl for custom hatch

r3kste · r3kste · commit e83d1f2c69eb · 2025-02-26T15:35:24.000+05:30
diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
@@ -695,6 +695,7 @@ def __init__(self):
         self._hatch = None
         self._hatch_color = None
         self._hatch_linewidth = rcParams['hatch.linewidth']
+        self._hatchstyle = []
         self._url = None
         self._gid = None
         self._snap = None
@@ -712,6 +713,7 @@ def copy_properties(self, gc):
         self._joinstyle = gc._joinstyle
         self._linestyle = gc._linestyle
         self._linewidth = gc._linewidth
+        self._hatchstyle = gc._hatchstyle
         self._rgb = gc._rgb
         self._hatch = gc._hatch
         self._hatch_color = gc._hatch_color
@@ -937,6 +939,9 @@ def set_snap(self, snap):
         """
         self._snap = snap
 
+    def set_hatch_buffer_scale(self, scale):
+        self._hatch_buffer_scale = scale
+
     def set_hatch(self, hatch):
         """Set the hatch style (for fills)."""
         self._hatch = hatch
@@ -946,7 +951,9 @@ def get_hatch(self):
         return self._hatch
 
     def get_hatch_path(self, density=6.0):
-        """Return a `.Path` for the current hatch."""
+        """Return a `.Path` for the current hatch or hatchstyle"""
+        if len(self.get_hatchstyle()):
+            return Path.hatchstyle(self.get_hatchstyle(), self._hatch_buffer_scale)
         hatch = self.get_hatch()
         if hatch is None:
             return None
@@ -968,6 +975,14 @@ def set_hatch_linewidth(self, hatch_linewidth):
         """Set the hatch linewidth."""
         self._hatch_linewidth = hatch_linewidth
 
+    def get_hatchstyle(self):
+        """Get the hatch style."""
+        return self._hatchstyle
+
+    def set_hatchstyle(self, hatchstyle):
+        """Set the hatch style."""
+        self._hatchstyle = hatchstyle
+
     def get_sketch_params(self):
         """
         Return the sketch parameters for the artist.
diff --git a/lib/matplotlib/backends/backend_agg.py b/lib/matplotlib/backends/backend_agg.py
@@ -66,7 +66,12 @@ def __init__(self, width, height, dpi):
         self.dpi = dpi
         self.width = width
         self.height = height
-        self._renderer = _RendererAgg(int(width), int(height), dpi)
+        hatchstyles_enabled = True
+        self.hatch_buffer_scale = (
+            (max(width, height) / dpi) if hatchstyles_enabled else 1.0
+        )
+        self._renderer = _RendererAgg(int(width), int(height), dpi,
+                                      self.hatch_buffer_scale)
         self._filter_renderers = []
 
         self._update_methods()
@@ -94,6 +99,7 @@ def draw_path(self, gc, path, transform, rgbFace=None):
         # docstring inherited
         nmax = mpl.rcParams['agg.path.chunksize']  # here at least for testing
         npts = path.vertices.shape[0]
+        gc.set_hatch_buffer_scale(self.hatch_buffer_scale)
 
         if (npts > nmax > 100 and path.should_simplify and
                 rgbFace is None and gc.get_hatch() is None):
diff --git a/lib/matplotlib/hatch.py b/lib/matplotlib/hatch.py
@@ -223,3 +223,233 @@ def get_path(hatchpattern, density=6):
             cursor += pattern.num_vertices
 
     return Path(vertices, codes)
+
+
+attrs = {
+    "scale": 6,
+    "weight": 1.0,
+    "angle": 0.0,
+    "random_rotation": False,
+    "random_placement": False,
+    "x_stagger": 0.5,
+    "y_stagger": 0.0,
+    "filled": True,
+}
+
+
+class HatchStyle:
+    def __init__(self, hatchpattern, **kwargs):
+        self.hatchpattern = hatchpattern
+        self.kwargs = {
+            attr: kwargs.get(attr, default) for attr, default in attrs.items()
+        }
+
+    def rotate_vertices(self, vertices, angle=None, scale_correction=True):
+        vertices = vertices.copy()
+
+        if angle is None:
+            angle = self.kwargs["angle"]
+        angle_rad = np.deg2rad(angle)
+
+        center = np.mean(vertices, axis=0)
+        vertices -= center
+
+        if scale_correction:
+            scaling = abs(np.sin(angle_rad)) + abs(np.cos(angle_rad))
+            vertices *= scaling
+
+        rotation_matrix = np.array(
+            [
+                [np.cos(angle_rad), -np.sin(angle_rad)],
+                [np.sin(angle_rad), np.cos(angle_rad)],
+            ]
+        )
+        vertices = np.dot(vertices, rotation_matrix)
+        vertices += center
+        return vertices
+
+    def get_vertices_and_codes(self, hatch_buffer_scale=1.0):
+        self.hatch_buffer_scale = hatch_buffer_scale
+        vertices, codes = np.empty((0, 2)), np.empty(0, Path.code_type)
+
+        if self.hatchpattern in hatchpatterns:
+            # This is for line hatches
+            for func in np.atleast_1d(hatchpatterns[self.hatchpattern]):
+                vertices_part, codes_part = func(self)
+                vertices_part = self.rotate_vertices(vertices_part)
+
+                vertices = np.concatenate((vertices, vertices_part))
+                codes = np.concatenate((codes, codes_part))
+        else:
+            # This is for marker hatches
+            if self.hatchpattern not in MarkerHatchStyle.marker_paths:
+                raise ValueError(f"Unknown hatch pattern: {self.hatchpattern}")
+            func = MarkerHatchStyle.marker_pattern
+            vertices_part, codes_part = func(self)
+
+            vertices = np.concatenate((vertices, vertices_part))
+            codes = np.concatenate((codes, codes_part))
+
+        return vertices, codes
+
+
+class MarkerHatchStyle(HatchStyle):
+    marker_paths = {
+        "o": Path.unit_circle,
+        "O": Path.unit_circle,
+        "*": (Path.unit_regular_star, 5),  # TODO: is there a better way to do this?
+    }
+
+    # TODO: saner defaults or no?
+    marker_sizes = {
+        "o": 0.2,
+        "O": 0.35,
+        "*": 1.0 / 3.0,
+    }
+
+    def _get_marker_path(marker):
+        func = np.atleast_1d(MarkerHatchStyle.marker_paths[marker])
+        path = func[0](*func[1:])
+        size = MarkerHatchStyle.marker_sizes.get(marker, attrs["weight"])
+
+        return Path(
+            vertices=path.vertices * size,
+            codes=path.codes,
+        )
+
+    def marker_pattern(hatchstyle):
+        size = hatchstyle.kwargs["weight"]
+        num_rows = round(hatchstyle.kwargs["scale"] * hatchstyle.hatch_buffer_scale)
+        path = MarkerHatchStyle._get_marker_path(hatchstyle.hatchpattern)
+        marker_vertices = hatchstyle.rotate_vertices(
+            path.vertices, scale_correction=False
+        )
+        marker_codes = path.codes
+
+        offset = 1.0 / num_rows
+        marker_vertices = marker_vertices * offset * size
+        x_stagger = hatchstyle.kwargs["x_stagger"] * offset
+        y_stagger = hatchstyle.kwargs["y_stagger"] * offset
+
+        if not hatchstyle.kwargs["filled"]:
+            marker_vertices = np.concatenate(
+                [marker_vertices, marker_vertices[::-1] * 0.9]
+            )
+            marker_codes = np.concatenate([marker_codes, marker_codes])
+
+        vertices = np.empty((0, 2))
+        codes = np.empty(0, Path.code_type)
+        for row in range(num_rows + 1):
+            row_pos = row * offset
+            if row % 2 == 0:
+                cols = np.linspace(0, 1, num_rows + 1)
+            else:
+                cols = np.linspace(x_stagger, 1 + x_stagger, num_rows + 1)
+
+            for i, col_pos in enumerate(cols):
+                vertices_part = marker_vertices + [col_pos, row_pos]
+                if i % 2 == 1:
+                    vertices_part += [0, y_stagger]
+
+                if hatchstyle.kwargs["random_rotation"]:
+                    vertices_part = hatchstyle.rotate_vertices(
+                        vertices_part, np.random.uniform(0, 360), scale_correction=False
+                    )
+
+                if hatchstyle.kwargs["random_placement"]:
+                    vertices_part += np.random.uniform(-offset / 4, offset / 4, 2)
+
+                vertices = np.concatenate((vertices, vertices_part))
+                codes = np.concatenate((codes, marker_codes))
+
+        return vertices, codes
+
+
+class LineHatchStyle(HatchStyle):
+    def horizontal(hatchstyle):
+        num_lines = round(hatchstyle.kwargs["scale"] * hatchstyle.hatch_buffer_scale)
+        if num_lines:
+            num_vertices = num_lines * 2
+        else:
+            num_vertices = 0
+
+        vertices = np.empty((num_vertices, 2))
+        codes = np.empty(num_vertices, Path.code_type)
+        steps, stepsize = np.linspace(0.0, 1.0, num_lines, False, retstep=True)
+        steps += stepsize / 2.0
+        vertices[0::2, 0] = 0.0
+        vertices[0::2, 1] = steps
+        vertices[1::2, 0] = 1.0
+        vertices[1::2, 1] = steps
+        codes[0::2] = Path.MOVETO
+        codes[1::2] = Path.LINETO
+
+        return vertices, codes
+
+    def vertical(hatchstyle):
+        num_lines = round(hatchstyle.kwargs["scale"] * hatchstyle.hatch_buffer_scale)
+        if num_lines:
+            num_vertices = num_lines * 2
+        else:
+            num_vertices = 0
+
+        vertices = np.empty((num_vertices, 2))
+        codes = np.empty(num_vertices, Path.code_type)
+        steps, stepsize = np.linspace(0.0, 1.0, num_lines, False, retstep=True)
+        steps += stepsize / 2.0
+        vertices[0::2, 0] = steps
+        vertices[0::2, 1] = 0.0
+        vertices[1::2, 0] = steps
+        vertices[1::2, 1] = 1.0
+        codes[0::2] = Path.MOVETO
+        codes[1::2] = Path.LINETO
+
+        return vertices, codes
+
+    def north_east(hatchstyle):
+        num_lines = round(hatchstyle.kwargs["scale"] * hatchstyle.hatch_buffer_scale)
+        if num_lines:
+            num_vertices = (num_lines + 1) * 2
+        else:
+            num_vertices = 0
+
+        vertices = np.empty((num_vertices, 2))
+        codes = np.empty(num_vertices, Path.code_type)
+        steps = np.linspace(-0.5, 0.5, num_lines + 1)
+        vertices[0::2, 0] = 0.0 + steps
+        vertices[0::2, 1] = 0.0 - steps
+        vertices[1::2, 0] = 1.0 + steps
+        vertices[1::2, 1] = 1.0 - steps
+        codes[0::2] = Path.MOVETO
+        codes[1::2] = Path.LINETO
+
+        return vertices, codes
+
+    def south_east(hatchstyle):
+        num_lines = round(hatchstyle.kwargs["scale"] * hatchstyle.hatch_buffer_scale)
+        if num_lines:
+            num_vertices = (num_lines + 1) * 2
+        else:
+            num_vertices = 0
+
+        vertices = np.empty((num_vertices, 2))
+        codes = np.empty(num_vertices, Path.code_type)
+        steps = np.linspace(-0.5, 0.5, num_lines + 1)
+        vertices[0::2, 0] = 0.0 + steps
+        vertices[0::2, 1] = 1.0 + steps
+        vertices[1::2, 0] = 1.0 + steps
+        vertices[1::2, 1] = 0.0 + steps
+        codes[0::2] = Path.MOVETO
+        codes[1::2] = Path.LINETO
+
+        return vertices, codes
+
+
+hatchpatterns = {
+    "-": LineHatchStyle.horizontal,
+    "|": LineHatchStyle.vertical,
+    "/": LineHatchStyle.north_east,
+    "\\": LineHatchStyle.south_east,
+    "+": (LineHatchStyle.horizontal, LineHatchStyle.vertical),
+    "x": (LineHatchStyle.north_east, LineHatchStyle.south_east),
+}
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -57,6 +57,7 @@ def __init__(self, *,
                  capstyle=None,
                  joinstyle=None,
                  hatchcolor=None,
+                 hatchstyle=None,
                  **kwargs):
         """
         The following kwarg properties are supported
@@ -95,6 +96,7 @@ def __init__(self, *,
         self.set_hatch(hatch)
         self.set_capstyle(capstyle)
         self.set_joinstyle(joinstyle)
+        self.set_hatchstyle(hatchstyle)
 
         if len(kwargs):
             self._internal_update(kwargs)
@@ -603,6 +605,17 @@ def get_hatch_linewidth(self):
         """Return the hatch linewidth."""
         return self._hatch_linewidth
 
+    def set_hatchstyle(self, hatchstyle):
+        """Set the hatchstyle(s) for the patch."""
+        if hatchstyle is None:
+            hatchstyle = []
+        self._hatchstyle = np.atleast_1d(hatchstyle)
+        self.stale = True
+
+    def get_hatchstyle(self):
+        """Return the hatchstyle(s)"""
+        return self._hatchstyle
+
     def _draw_paths_with_artist_properties(
             self, renderer, draw_path_args_list):
         """
@@ -639,6 +652,11 @@ def _draw_paths_with_artist_properties(
             gc.set_hatch_color(self.get_hatchcolor())
             gc.set_hatch_linewidth(self._hatch_linewidth)
 
+        if self._hatchstyle.size > 0:
+            gc.set_hatchstyle(self._hatchstyle)
+            gc.set_hatch_color(self._hatch_color)
+            gc.set_hatch_linewidth(self._hatch_linewidth)
+
         if self.get_sketch_params() is not None:
             gc.set_sketch_params(*self.get_sketch_params())
 
diff --git a/lib/matplotlib/path.py b/lib/matplotlib/path.py
@@ -1036,6 +1036,14 @@ def hatch(hatchpattern, density=6):
         return (get_path(hatchpattern, density)
                 if hatchpattern is not None else None)
 
+    def hatchstyle(hatchstyles, hatch_buffer_scale=1.0):
+        vertices, codes = np.empty((0, 2)), np.empty(0, Path.code_type)
+        for hatchstyle in hatchstyles:
+            verts, cods = hatchstyle.get_vertices_and_codes(hatch_buffer_scale)
+            vertices = np.concatenate([vertices, verts])
+            codes = np.concatenate([codes, cods])
+        return Path(vertices, codes)
+
     def clip_to_bbox(self, bbox, inside=True):
         """
         Clip the path to the given bounding box.
diff --git a/src/_backend_agg.cpp b/src/_backend_agg.cpp
@@ -5,7 +5,7 @@
 #include <Python.h>
 #include "_backend_agg.h"
 
-RendererAgg::RendererAgg(unsigned int width, unsigned int height, double dpi)
+RendererAgg::RendererAgg(unsigned int width, unsigned int height, double dpi, double hatch_buffer_scale)
     : width(width),
       height(height),
       dpi(dpi),
@@ -48,7 +48,7 @@ RendererAgg::RendererAgg(unsigned int width, unsigned int height, double dpi)
     rendererBase.clear(_fill_color);
     rendererAA.attach(rendererBase);
     rendererBin.attach(rendererBase);
-    hatch_size = int(dpi);
+    hatch_size = int(dpi * hatch_buffer_scale);
     hatchBuffer = new agg::int8u[hatch_size * hatch_size * 4];
     hatchRenderingBuffer.attach(hatchBuffer, hatch_size, hatch_size, hatch_size * 4);
 }
diff --git a/src/_backend_agg.h b/src/_backend_agg.h
@@ -127,7 +127,7 @@ class RendererAgg
     /* TODO: Remove facepair_t */
     typedef std::pair<bool, agg::rgba> facepair_t;
 
-    RendererAgg(unsigned int width, unsigned int height, double dpi);
+    RendererAgg(unsigned int width, unsigned int height, double dpi, double hatch_buffer_scale=1.0);
 
     virtual ~RendererAgg();
 
diff --git a/src/_backend_agg_wrapper.cpp b/src/_backend_agg_wrapper.cpp
