Merge pull request matplotlib#20245 from greglucas/collection-deps

MAINT: Removing deprecated `offset_position` from Collection

Author: QuLogic

doc/api/next_api_changes/removals/20245-GL.rst

@@ -0,0 +1,7 @@
+Collection's offset_position has been removed
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The deprecated keyword argument *offset_position* has been removed from
+the Collection class, along with the setter and getter
+``Collection.set_offset_position()`` and ``Collection.get_offset_position()``.
+The ``offset_position`` of the Collection class is now "screen".

lib/matplotlib/backend_bases.py

@@ -228,8 +228,8 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
         *offsets* are first transformed by *offsetTrans* before being
         applied.
 
-        *offset_position* may be either "screen" or "data" depending on the
-        space that the offsets are in; "data" is deprecated.
+        *offset_position* is unused now, but the argument is kept for
+        backwards compatibility.
 
         This provides a fallback implementation of
         :meth:`draw_path_collection` that makes multiple calls to
@@ -401,11 +401,6 @@ def _iter_collection(self, gc, master_transform, all_transforms,
         Naa = len(antialiaseds)
         Nurls = len(urls)
 
-        if offset_position == "data":
-            _api.warn_deprecated(
-                "3.3", message="Support for offset_position='data' is "
-                "deprecated since %(since)s and will be removed %(removal)s.")
-
         if (Nfacecolors == 0 and Nedgecolors == 0) or Npaths == 0:
             return
         if Noffsets:
@@ -425,17 +420,6 @@ def _iter_collection(self, gc, master_transform, all_transforms,
             path_id = path_ids[i % Npaths]
             if Noffsets:
                 xo, yo = toffsets[i % Noffsets]
-                if offset_position == 'data':
-                    if Ntransforms:
-                        transform = (
-                            Affine2D(all_transforms[i % Ntransforms]) +
-                            master_transform)
-                    else:
-                        transform = master_transform
-                    (xo, yo), (xp, yp) = transform.transform(
-                        [(xo, yo), (0, 0)])
-                    xo = -(xp - xo)
-                    yo = -(yp - yo)
             if not (np.isfinite(xo) and np.isfinite(yo)):
                 continue
             if Nfacecolors:

lib/matplotlib/backends/backend_agg.py

@@ -109,9 +109,7 @@ def _update_methods(self):
         self.draw_gouraud_triangles = self._renderer.draw_gouraud_triangles
         self.draw_image = self._renderer.draw_image
         self.draw_markers = self._renderer.draw_markers
-        # This is its own method for the duration of the deprecation of
-        # offset_position = "data".
-        # self.draw_path_collection = self._renderer.draw_path_collection
+        self.draw_path_collection = self._renderer.draw_path_collection
         self.draw_quad_mesh = self._renderer.draw_quad_mesh
         self.copy_from_bbox = self._renderer.copy_from_bbox
 
@@ -163,19 +161,6 @@ def draw_path(self, gc, path, transform, rgbFace=None):
                 raise OverflowError("Exceeded cell block limit (set "
                                     "'agg.path.chunksize' rcparam)") from err
 
-    def draw_path_collection(self, gc, master_transform, paths, all_transforms,
-                             offsets, offsetTrans, facecolors, edgecolors,
-                             linewidths, linestyles, antialiaseds, urls,
-                             offset_position):
-        if offset_position == "data":
-            _api.warn_deprecated(
-                "3.3", message="Support for offset_position='data' is "
-                "deprecated since %(since)s and will be removed %(removal)s.")
-        return self._renderer.draw_path_collection(
-            gc, master_transform, paths, all_transforms, offsets, offsetTrans,
-            facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls,
-            offset_position)
-
     def draw_mathtext(self, gc, x, y, s, prop, angle):
         """Draw mathtext using :mod:`matplotlib.mathtext`."""
         ox, oy, width, height, descent, font_image, used_characters = \

lib/matplotlib/collections.py

@@ -73,7 +73,6 @@ class Collection(artist.Artist, cm.ScalarMappable):
     # subclass-by-subclass basis.
     _edge_default = False
 
-    @_api.delete_parameter("3.3", "offset_position")
     @docstring.interpd
     def __init__(self,
                  edgecolors=None,
@@ -90,7 +89,7 @@ def __init__(self,
                  pickradius=5.0,
                  hatch=None,
                  urls=None,
-                 offset_position='screen',
+                 *,
                  zorder=1,
                  **kwargs
                  ):
@@ -130,9 +129,6 @@ def __init__(self,
         transOffset : `~.transforms.Transform`, default: `.IdentityTransform`
             A single transform which will be applied to each *offsets* vector
             before it is used.
-        offset_position : {{'screen' (default), 'data' (deprecated)}}
-            If set to 'data' (deprecated), *offsets* will be treated as if it
-            is in data coordinates instead of in screen coordinates.
         norm : `~.colors.Normalize`, optional
             Forwarded to `.ScalarMappable`. The default of
             ``None`` means that the first draw call will set ``vmin`` and
@@ -184,8 +180,6 @@ def __init__(self,
         self.set_urls(urls)
         self.set_hatch(hatch)
         self._offset_position = "screen"
-        if offset_position != "screen":
-            self.set_offset_position(offset_position)  # emit deprecation.
         self.set_zorder(zorder)
 
         if capstyle:
@@ -561,35 +555,6 @@ def get_offsets(self):
         else:
             return self._uniform_offsets
 
-    @_api.deprecated("3.3")
-    def set_offset_position(self, offset_position):
-        """
-        Set how offsets are applied.  If *offset_position* is 'screen'
-        (default) the offset is applied after the master transform has
-        been applied, that is, the offsets are in screen coordinates.
-        If offset_position is 'data', the offset is applied before the
-        master transform, i.e., the offsets are in data coordinates.
-
-        Parameters
-        ----------
-        offset_position : {'screen', 'data'}
-        """
-        _api.check_in_list(['screen', 'data'], offset_position=offset_position)
-        self._offset_position = offset_position
-        self.stale = True
-
-    @_api.deprecated("3.3")
-    def get_offset_position(self):
-        """
-        Return how offsets are applied for the collection.  If
-        *offset_position* is 'screen', the offset is applied after the
-        master transform has been applied, that is, the offsets are in
-        screen coordinates.  If offset_position is 'data', the offset
-        is applied before the master transform, i.e., the offsets are
-        in data coordinates.
-        """
-        return self._offset_position
-
     def _get_default_linewidth(self):
         # This may be overridden in a subclass.
         return mpl.rcParams['patch.linewidth']  # validated as float

src/_backend_agg.h

@@ -176,8 +176,7 @@ class RendererAgg
                               ColorArray &edgecolors,
                               LineWidthArray &linewidths,
                               DashesVector &linestyles,
-                              AntialiasedArray &antialiaseds,
-                              e_offset_position offset_position);
+                              AntialiasedArray &antialiaseds);
 
     template <class CoordinateArray, class OffsetArray, class ColorArray>
     void draw_quad_mesh(GCAgg &gc,
@@ -277,7 +276,6 @@ class RendererAgg
                                        LineWidthArray &linewidths,
                                        DashesVector &linestyles,
                                        AntialiasedArray &antialiaseds,
-                                       e_offset_position offset_position,
                                        bool check_snap,
                                        bool has_curves);
 
@@ -911,7 +909,6 @@ inline void RendererAgg::_draw_path_collection_generic(GCAgg &gc,
                                                        LineWidthArray &linewidths,
                                                        DashesVector &linestyles,
                                                        AntialiasedArray &antialiaseds,
-                                                       e_offset_position offset_position,
                                                        bool check_snap,
                                                        bool has_curves)
 {
@@ -969,11 +966,7 @@ inline void RendererAgg::_draw_path_collection_generic(GCAgg &gc,
             double xo = offsets(i % Noffsets, 0);
             double yo = offsets(i % Noffsets, 1);
             offset_trans.transform(&xo, &yo);
-            if (offset_position == OFFSET_POSITION_DATA) {
-                trans = agg::trans_affine_translation(xo, yo) * trans;
-            } else {
-                trans *= agg::trans_affine_translation(xo, yo);
-            }
+            trans *= agg::trans_affine_translation(xo, yo);
         }
 
         // These transformations must be done post-offsets
@@ -1047,8 +1040,7 @@ inline void RendererAgg::draw_path_collection(GCAgg &gc,
                                               ColorArray &edgecolors,
                                               LineWidthArray &linewidths,
                                               DashesVector &linestyles,
-                                              AntialiasedArray &antialiaseds,
-                                              e_offset_position offset_position)
+                                              AntialiasedArray &antialiaseds)
 {
     _draw_path_collection_generic(gc,
                                   master_transform,
@@ -1064,7 +1056,6 @@ inline void RendererAgg::draw_path_collection(GCAgg &gc,
                                   linewidths,
                                   linestyles,
                                   antialiaseds,
-                                  offset_position,
                                   true,
                                   true);
 }
@@ -1175,7 +1166,6 @@ inline void RendererAgg::draw_quad_mesh(GCAgg &gc,
                                   linewidths,
                                   linestyles,
                                   antialiaseds,
-                                  OFFSET_POSITION_FIGURE,
                                   true, // check_snap
                                   false);
 }

src/_backend_agg_basic_types.h

@@ -69,11 +69,6 @@ class Dashes
 
 typedef std::vector<Dashes> DashesVector;
 
-enum e_offset_position {
-    OFFSET_POSITION_FIGURE,
-    OFFSET_POSITION_DATA
-};
-
 class GCAgg
 {
   public:

src/_backend_agg_wrapper.cpp

@@ -330,10 +330,10 @@ PyRendererAgg_draw_path_collection(PyRendererAgg *self, PyObject *args, PyObject
     DashesVector dashes;
     numpy::array_view<const uint8_t, 1> antialiaseds;
     PyObject *ignored;
-    e_offset_position offset_position;
+    PyObject *offset_position; // offset position is no longer used
 
     if (!PyArg_ParseTuple(args,
-                          "O&O&OO&O&O&O&O&O&O&O&OO&:draw_path_collection",
+                          "O&O&OO&O&O&O&O&O&O&O&OO:draw_path_collection",
                           &convert_gcagg,
                           &gc,
                           &convert_trans_affine,
@@ -356,7 +356,6 @@ PyRendererAgg_draw_path_collection(PyRendererAgg *self, PyObject *args, PyObject
                           &antialiaseds.converter,
                           &antialiaseds,
                           &ignored,
-                          &convert_offset_position,
                           &offset_position)) {
         return NULL;
     }
@@ -376,8 +375,7 @@ PyRendererAgg_draw_path_collection(PyRendererAgg *self, PyObject *args, PyObject
                                                 edgecolors,
                                                 linewidths,
                                                 dashes,
-                                                antialiaseds,
-                                                offset_position)));
+                                                antialiaseds)));
     }
     catch (const py::exception &)
     {

src/_path.h

@@ -442,7 +442,6 @@ void point_in_path_collection(double x,
                               OffsetArray &offsets,
                               agg::trans_affine &offset_trans,
                               bool filled,
-                              e_offset_position offset_position,
                               std::vector<int> &result)
 {
     size_t Npaths = paths.size();
@@ -478,11 +477,7 @@ void point_in_path_collection(double x,
             double xo = offsets(i % Noffsets, 0);
             double yo = offsets(i % Noffsets, 1);
             offset_trans.transform(&xo, &yo);
-            if (offset_position == OFFSET_POSITION_DATA) {
-                trans = agg::trans_affine_translation(xo, yo) * trans;
-            } else {
-                trans *= agg::trans_affine_translation(xo, yo);
-            }
+            trans *= agg::trans_affine_translation(xo, yo);
         }
 
         if (filled) {

src/_path_wrapper.cpp

@@ -332,11 +332,11 @@ static PyObject *Py_point_in_path_collection(PyObject *self, PyObject *args, PyO
     numpy::array_view<const double, 2> offsets;
     agg::trans_affine offset_trans;
     bool filled;
-    e_offset_position offset_position;
+    PyObject *offset_position; // no longer used
     std::vector<int> result;
 
     if (!PyArg_ParseTuple(args,
-                          "dddO&OO&O&O&O&O&:point_in_path_collection",
+                          "dddO&OO&O&O&O&O:point_in_path_collection",
                           &x,
                           &y,
                           &radius,
@@ -351,7 +351,6 @@ static PyObject *Py_point_in_path_collection(PyObject *self, PyObject *args, PyO
                           &offset_trans,
                           &convert_bool,
                           &filled,
-                          &convert_offset_position,
                           &offset_position)) {
         return NULL;
     }
@@ -370,7 +369,6 @@ static PyObject *Py_point_in_path_collection(PyObject *self, PyObject *args, PyO
                                            offsets,
                                            offset_trans,
                                            filled,
-                                           offset_position,
                                            result)));
     }
     catch (const py::exception &)

src/py_converters.cpp

@@ -492,22 +492,6 @@ int convert_gcagg(PyObject *pygc, void *gcp)
     return 1;
 }
 
-int convert_offset_position(PyObject *obj, void *offsetp)
-{
-    e_offset_position *offset = (e_offset_position *)offsetp;
-    const char *names[] = {"data", NULL};
-    int values[] = {OFFSET_POSITION_DATA};
-    int result = (int)OFFSET_POSITION_FIGURE;
-
-    if (!convert_string_enum(obj, "offset_position", names, values, &result)) {
-        PyErr_Clear();
-    }
-
-    *offset = (e_offset_position)result;
-
-    return 1;
-}
-
 int convert_face(PyObject *color, GCAgg &gc, agg::rgba *rgba)
 {
     if (!convert_rgba(color, rgba)) {