Support hatching in cairo backends.

anntzer · anntzer · commit 8fc0ba44e378 · 2024-03-14T11:10:47.000+01:00
Direct transposition of the mplcairo implementation (except for the lack
of proper stacking, which was already present for the alpha state so
it's not really "worse"), itself translated from the agg implementation.
diff --git a/lib/matplotlib/backends/backend_cairo.py b/lib/matplotlib/backends/backend_cairo.py
@@ -34,6 +34,13 @@
 from matplotlib.transforms import Affine2D
 
 
+def _set_rgba(ctx, color, alpha, forced_alpha):
+    if len(color) == 3 or forced_alpha:
+        ctx.set_source_rgba(*color[:3], alpha)
+    else:
+        ctx.set_source_rgba(*color)
+
+
 def _append_path(ctx, path, transform, clip=None):
     for points, code in path.iter_segments(
             transform, remove_nans=True, clip=clip):
@@ -100,13 +107,11 @@ def set_context(self, ctx):
         self.gc.ctx = ctx
         self.width, self.height = size
 
-    def _fill_and_stroke(self, ctx, fill_c, alpha, alpha_overrides):
+    @staticmethod
+    def _fill_and_stroke(ctx, fill_c, alpha, alpha_overrides):
         if fill_c is not None:
             ctx.save()
-            if len(fill_c) == 3 or alpha_overrides:
-                ctx.set_source_rgba(fill_c[0], fill_c[1], fill_c[2], alpha)
-            else:
-                ctx.set_source_rgba(fill_c[0], fill_c[1], fill_c[2], fill_c[3])
+            _set_rgba(ctx, fill_c, alpha, alpha_overrides)
             ctx.fill_preserve()
             ctx.restore()
         ctx.stroke()
@@ -122,8 +127,31 @@ def draw_path(self, gc, path, transform, rgbFace=None):
                      + Affine2D().scale(1, -1).translate(0, self.height))
         ctx.new_path()
         _append_path(ctx, path, transform, clip)
-        self._fill_and_stroke(
-            ctx, rgbFace, gc.get_alpha(), gc.get_forced_alpha())
+        if rgbFace is not None:
+            ctx.save()
+            _set_rgba(ctx, rgbFace, gc.get_alpha(), gc.get_forced_alpha())
+            ctx.fill_preserve()
+            ctx.restore()
+        hatch_path = gc.get_hatch_path()
+        if hatch_path:
+            dpi = int(self.dpi)
+            hatch_surface = ctx.get_target().create_similar(
+                cairo.Content.COLOR_ALPHA, dpi, dpi)
+            hatch_ctx = cairo.Context(hatch_surface)
+            _append_path(hatch_ctx, hatch_path,
+                         Affine2D().scale(dpi, -dpi).translate(0, dpi),
+                         None)
+            hatch_ctx.set_line_width(self.points_to_pixels(gc.get_hatch_linewidth()))
+            hatch_ctx.set_source_rgba(*gc.get_hatch_color())
+            hatch_ctx.fill_preserve()
+            hatch_ctx.stroke()
+            hatch_pattern = cairo.SurfacePattern(hatch_surface)
+            hatch_pattern.set_extend(cairo.Extend.REPEAT)
+            ctx.save()
+            ctx.set_source(hatch_pattern)
+            ctx.fill_preserve()
+            ctx.restore()
+        ctx.stroke()
 
     def draw_markers(self, gc, marker_path, marker_trans, path, transform,
                      rgbFace=None):
@@ -267,8 +295,13 @@ def get_text_width_height_descent(self, s, prop, ismath):
     def new_gc(self):
         # docstring inherited
         self.gc.ctx.save()
+        # FIXME: The following doesn't properly implement a stack-like behavior
+        # and relies instead on the (non-guaranteed) fact that artists never
+        # rely on nesting gc states, so directly resetting the attributes (IOW
+        # a single-level stack) is enough.
         self.gc._alpha = 1
         self.gc._forced_alpha = False  # if True, _alpha overrides A from RGBA
+        self.gc._hatch = None
         return self.gc
 
     def points_to_pixels(self, points):
@@ -298,12 +331,8 @@ def restore(self):
 
     def set_alpha(self, alpha):
         super().set_alpha(alpha)
-        _alpha = self.get_alpha()
-        rgb = self._rgb
-        if self.get_forced_alpha():
-            self.ctx.set_source_rgba(rgb[0], rgb[1], rgb[2], _alpha)
-        else:
-            self.ctx.set_source_rgba(rgb[0], rgb[1], rgb[2], rgb[3])
+        _set_rgba(
+            self.ctx, self._rgb, self.get_alpha(), self.get_forced_alpha())
 
     def set_antialiased(self, b):
         self.ctx.set_antialias(
