Remove deprecated draw_gouraud_triangle

Author: oscargus

doc/api/next_api_changes/removals/26797-OG.rst

@@ -0,0 +1,17 @@
+``draw_gouraud_triangle``
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+... is removed. Use `~.RendererBase.draw_gouraud_triangles` instead.
+
+A ``draw_gouraud_triangle`` call in a custom `~matplotlib.artist.Artist` can readily be
+replaced as::
+
+    self.draw_gouraud_triangles(gc, points.reshape((1, 3, 2)),
+                                colors.reshape((1, 3, 4)), trans)
+
+A `~.RendererBase.draw_gouraud_triangles` method can be implemented from an
+existing ``draw_gouraud_triangle`` method as::
+
+    transform = transform.frozen()
+    for tri, col in zip(triangles_array, colors_array):
+        self.draw_gouraud_triangle(gc, tri, col, transform)

lib/matplotlib/backend_bases.py

@@ -292,24 +292,6 @@ def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,
             gc, master_transform, paths, [], offsets, offsetTrans, facecolors,
             edgecolors, linewidths, [], [antialiased], [None], 'screen')
 
-    @_api.deprecated("3.7", alternative="draw_gouraud_triangles")
-    def draw_gouraud_triangle(self, gc, points, colors, transform):
-        """
-        Draw a Gouraud-shaded triangle.
-
-        Parameters
-        ----------
-        gc : `.GraphicsContextBase`
-            The graphics context.
-        points : (3, 2) array-like
-            Array of (x, y) points for the triangle.
-        colors : (3, 4) array-like
-            RGBA colors for each point of the triangle.
-        transform : `~matplotlib.transforms.Transform`
-            An affine transform to apply to the points.
-        """
-        raise NotImplementedError
-
     def draw_gouraud_triangles(self, gc, triangles_array, colors_array,
                                transform):
         """

lib/matplotlib/backend_bases.pyi

@@ -77,13 +77,6 @@ class RendererBase:
         antialiased: bool,
         edgecolors: Sequence[ColorType] | ColorType | None,
     ) -> None: ...
-    def draw_gouraud_triangle(
-        self,
-        gc: GraphicsContextBase,
-        points: ArrayLike,
-        colors: ArrayLike,
-        transform: Transform,
-    ) -> None: ...
     def draw_gouraud_triangles(
         self,
         gc: GraphicsContextBase,

lib/matplotlib/backends/backend_agg.py

@@ -84,7 +84,6 @@ def __setstate__(self, state):
         self.__init__(state['width'], state['height'], state['dpi'])
 
     def _update_methods(self):
-        self.draw_gouraud_triangle = self._renderer.draw_gouraud_triangle
         self.draw_gouraud_triangles = self._renderer.draw_gouraud_triangles
         self.draw_image = self._renderer.draw_image
         self.draw_markers = self._renderer.draw_markers

lib/matplotlib/backends/backend_pdf.py

@@ -2132,10 +2132,6 @@ def draw_markers(self, gc, marker_path, marker_trans, path, trans,
                 lastx, lasty = x, y
         output(Op.grestore)
 
-    def draw_gouraud_triangle(self, gc, points, colors, trans):
-        self.draw_gouraud_triangles(gc, points.reshape((1, 3, 2)),
-                                    colors.reshape((1, 3, 4)), trans)
-
     def draw_gouraud_triangles(self, gc, points, colors, trans):
         assert len(points) == len(colors)
         if len(points) == 0:

lib/matplotlib/backends/backend_ps.py

@@ -691,11 +691,6 @@ def draw_mathtext(self, gc, x, y, s, prop, angle):
             self._pswriter.write(f"{ox} {oy} {w} {h} rectfill\n")
         self._pswriter.write("grestore\n")
 
-    @_log_if_debug_on
-    def draw_gouraud_triangle(self, gc, points, colors, trans):
-        self.draw_gouraud_triangles(gc, points.reshape((1, 3, 2)),
-                                    colors.reshape((1, 3, 4)), trans)
-
     @_log_if_debug_on
     def draw_gouraud_triangles(self, gc, points, colors, trans):
         assert len(points) == len(colors)

lib/matplotlib/backends/backend_svg.py

@@ -770,10 +770,6 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
 
         self._path_collection_id += 1
 
-    def draw_gouraud_triangle(self, gc, points, colors, trans):
-        # docstring inherited
-        self._draw_gouraud_triangle(gc, points, colors, trans)
-
     def _draw_gouraud_triangle(self, gc, points, colors, trans):
         # This uses a method described here:
         #

src/_backend_agg.h

@@ -190,12 +190,6 @@ class RendererAgg
                         bool antialiased,
                         ColorArray &edgecolors);
 
-    template <class PointArray, class ColorArray>
-    void draw_gouraud_triangle(GCAgg &gc,
-                               PointArray &points,
-                               ColorArray &colors,
-                               agg::trans_affine &trans);
-
     template <class PointArray, class ColorArray>
     void draw_gouraud_triangles(GCAgg &gc,
                                 PointArray &points,
@@ -1229,20 +1223,6 @@ inline void RendererAgg::_draw_gouraud_triangle(PointArray &points,
     }
 }
 
-template <class PointArray, class ColorArray>
-inline void RendererAgg::draw_gouraud_triangle(GCAgg &gc,
-                                               PointArray &points,
-                                               ColorArray &colors,
-                                               agg::trans_affine &trans)
-{
-    theRasterizer.reset_clipping();
-    rendererBase.reset_clipping(true);
-    set_clipbox(gc.cliprect, theRasterizer);
-    bool has_clippath = render_clippath(gc.clippath.path, gc.clippath.trans, gc.snap_mode);
-
-    _draw_gouraud_triangle(points, colors, trans, has_clippath);
-}
-
 template <class PointArray, class ColorArray>
 inline void RendererAgg::draw_gouraud_triangles(GCAgg &gc,
                                                 PointArray &points,

src/_backend_agg_wrapper.cpp

@@ -436,49 +436,6 @@ static PyObject *PyRendererAgg_draw_quad_mesh(PyRendererAgg *self, PyObject *arg
     Py_RETURN_NONE;
 }
 
-static PyObject *
-PyRendererAgg_draw_gouraud_triangle(PyRendererAgg *self, PyObject *args)
-{
-    GCAgg gc;
-    numpy::array_view<const double, 2> points;
-    numpy::array_view<const double, 2> colors;
-    agg::trans_affine trans;
-
-    if (!PyArg_ParseTuple(args,
-                          "O&O&O&O&|O:draw_gouraud_triangle",
-                          &convert_gcagg,
-                          &gc,
-                          &points.converter,
-                          &points,
-                          &colors.converter,
-                          &colors,
-                          &convert_trans_affine,
-                          &trans)) {
-        return NULL;
-    }
-
-    if (points.dim(0) != 3 || points.dim(1) != 2) {
-        PyErr_Format(PyExc_ValueError,
-                     "points must have shape (3, 2), "
-                     "got (%" NPY_INTP_FMT ", %" NPY_INTP_FMT ")",
-                     points.dim(0), points.dim(1));
-        return NULL;
-    }
-
-    if (colors.dim(0) != 3 || colors.dim(1) != 4) {
-        PyErr_Format(PyExc_ValueError,
-                     "colors must have shape (3, 4), "
-                     "got (%" NPY_INTP_FMT ", %" NPY_INTP_FMT ")",
-                     colors.dim(0), colors.dim(1));
-        return NULL;
-    }
-
-
-    CALL_CPP("draw_gouraud_triangle", (self->x->draw_gouraud_triangle(gc, points, colors, trans)));
-
-    Py_RETURN_NONE;
-}
-
 static PyObject *
 PyRendererAgg_draw_gouraud_triangles(PyRendererAgg *self, PyObject *args)
 {
@@ -603,7 +560,6 @@ static PyTypeObject *PyRendererAgg_init_type()
         {"draw_image", (PyCFunction)PyRendererAgg_draw_image, METH_VARARGS, NULL},
         {"draw_path_collection", (PyCFunction)PyRendererAgg_draw_path_collection, METH_VARARGS, NULL},
         {"draw_quad_mesh", (PyCFunction)PyRendererAgg_draw_quad_mesh, METH_VARARGS, NULL},
-        {"draw_gouraud_triangle", (PyCFunction)PyRendererAgg_draw_gouraud_triangle, METH_VARARGS, NULL},
         {"draw_gouraud_triangles", (PyCFunction)PyRendererAgg_draw_gouraud_triangles, METH_VARARGS, NULL},
 
         {"clear", (PyCFunction)PyRendererAgg_clear, METH_NOARGS, NULL},