Merge pull request matplotlib#17165 from Tillsten/optimize_transform

Small optimizations to scale and translate of Affine2D

Author: timhoffm

lib/matplotlib/backend_bases.py

@@ -43,8 +43,8 @@
 
 import matplotlib as mpl
 from matplotlib import (
-    backend_tools as tools, cbook, colors, textpath, tight_bbox, transforms,
-    widgets, get_backend, is_interactive, rcParams)
+    backend_tools as tools, cbook, colors, textpath, tight_bbox,
+    transforms, widgets, get_backend, is_interactive, rcParams)
 from matplotlib._pylab_helpers import Gcf
 from matplotlib.backend_managers import ToolManager
 from matplotlib.transforms import Affine2D
@@ -222,18 +222,22 @@ def draw_path_collection(self, gc, master_transform, paths, all_transforms,
         recommended to use those generators, so that changes to the
         behavior of :meth:`draw_path_collection` can be made globally.
         """
-        path_ids = [
-            (path, transforms.Affine2D(transform))
-            for path, transform in self._iter_collection_raw_paths(
-                    master_transform, paths, all_transforms)]
+        path_ids = self._iter_collection_raw_paths(master_transform,
+                                                   paths, all_transforms)
 
         for xo, yo, path_id, gc0, rgbFace in self._iter_collection(
-                gc, master_transform, all_transforms, path_ids, offsets,
+                gc, master_transform, all_transforms, list(path_ids), offsets,
                 offsetTrans, facecolors, edgecolors, linewidths, linestyles,
                 antialiaseds, urls, offset_position):
             path, transform = path_id
-            transform = transforms.Affine2D(
-                            transform.get_matrix()).translate(xo, yo)
+            # Only apply another translation if we have an offset, else we
+            # resuse the inital transform.
+            if xo != 0 or yo != 0:
+                # The transformation can be used by multiple paths. Since
+                # translate is a inplace operation, we need to copy the
+                # transformation by .frozen() before applying the translation.
+                transform = transform.frozen()
+                transform.translate(xo, yo)
             self.draw_path(gc0, path, transform, rgbFace)
 
     def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,

lib/matplotlib/tests/test_backend_bases.py

@@ -14,7 +14,7 @@
 def test_uses_per_path():
     id = transforms.Affine2D()
     paths = [path.Path.unit_regular_polygon(i) for i in range(3, 7)]
-    tforms = [id.rotate(i) for i in range(1, 5)]
+    tforms_matrices = [id.rotate(i).get_matrix().copy() for i in range(1, 5)]
     offsets = np.arange(20).reshape((10, 2))
     facecolors = ['red', 'green']
     edgecolors = ['red', 'green']
@@ -38,17 +38,18 @@ def check(master_transform, paths, all_transforms,
             seen = np.bincount(ids, minlength=len(raw_paths))
             assert set(seen).issubset([uses - 1, uses])
 
-    check(id, paths, tforms, offsets, facecolors, edgecolors)
-    check(id, paths[0:1], tforms, offsets, facecolors, edgecolors)
-    check(id, [], tforms, offsets, facecolors, edgecolors)
-    check(id, paths, tforms[0:1], offsets, facecolors, edgecolors)
+    check(id, paths, tforms_matrices, offsets, facecolors, edgecolors)
+    check(id, paths[0:1], tforms_matrices, offsets, facecolors, edgecolors)
+    check(id, [], tforms_matrices, offsets, facecolors, edgecolors)
+    check(id, paths, tforms_matrices[0:1], offsets, facecolors, edgecolors)
     check(id, paths, [], offsets, facecolors, edgecolors)
     for n in range(0, offsets.shape[0]):
-        check(id, paths, tforms, offsets[0:n, :], facecolors, edgecolors)
-    check(id, paths, tforms, offsets, [], edgecolors)
-    check(id, paths, tforms, offsets, facecolors, [])
-    check(id, paths, tforms, offsets, [], [])
-    check(id, paths, tforms, offsets, facecolors[0:1], edgecolors)
+        check(id, paths, tforms_matrices, offsets[0:n, :],
+              facecolors, edgecolors)
+    check(id, paths, tforms_matrices, offsets, [], edgecolors)
+    check(id, paths, tforms_matrices, offsets, facecolors, [])
+    check(id, paths, tforms_matrices, offsets, [], [])
+    check(id, paths, tforms_matrices, offsets, facecolors[0:1], edgecolors)
 
 
 def test_get_default_filename(tmpdir):

lib/matplotlib/transforms.py

@@ -36,6 +36,7 @@
 import functools
 import textwrap
 import weakref
+import math
 
 import numpy as np
 from numpy.linalg import inv
@@ -1842,7 +1843,7 @@ def __init__(self, matrix=None, **kwargs):
         if matrix is None:
             # A bit faster than np.identity(3).
             matrix = IdentityTransform._mtx.copy()
-        self._mtx = matrix
+        self._mtx = matrix.copy()
         self._invalid = 0
 
     __str__ = _make_str_method("_mtx")
@@ -1925,8 +1926,8 @@ def rotate(self, theta):
         calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
         and :meth:`scale`.
         """
-        a = np.cos(theta)
-        b = np.sin(theta)
+        a = math.cos(theta)
+        b = math.sin(theta)
         rotate_mtx = np.array([[a, -b, 0.0], [b, a, 0.0], [0.0, 0.0, 1.0]],
                               float)
         self._mtx = np.dot(rotate_mtx, self._mtx)
@@ -1941,7 +1942,7 @@ def rotate_deg(self, degrees):
         calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
         and :meth:`scale`.
         """
-        return self.rotate(np.deg2rad(degrees))
+        return self.rotate(math.radians(degrees))
 
     def rotate_around(self, x, y, theta):
         """
@@ -1973,9 +1974,8 @@ def translate(self, tx, ty):
         calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
         and :meth:`scale`.
         """
-        translate_mtx = np.array(
-            [[1.0, 0.0, tx], [0.0, 1.0, ty], [0.0, 0.0, 1.0]], float)
-        self._mtx = np.dot(translate_mtx, self._mtx)
+        self._mtx[0, 2] += tx
+        self._mtx[1, 2] += ty
         self.invalidate()
         return self
 
@@ -1992,9 +1992,13 @@ def scale(self, sx, sy=None):
         """
         if sy is None:
             sy = sx
-        scale_mtx = np.array(
-            [[sx, 0.0, 0.0], [0.0, sy, 0.0], [0.0, 0.0, 1.0]], float)
-        self._mtx = np.dot(scale_mtx, self._mtx)
+        # explicit element-wise scaling is fastest
+        self._mtx[0, 0] *= sx
+        self._mtx[0, 1] *= sx
+        self._mtx[0, 2] *= sx
+        self._mtx[1, 0] *= sy
+        self._mtx[1, 1] *= sy
+        self._mtx[1, 2] *= sy
         self.invalidate()
         return self
 
@@ -2009,8 +2013,8 @@ def skew(self, xShear, yShear):
         calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
         and :meth:`scale`.
         """
-        rotX = np.tan(xShear)
-        rotY = np.tan(yShear)
+        rotX = math.tan(xShear)
+        rotY = math.tan(yShear)
         skew_mtx = np.array(
             [[1.0, rotX, 0.0], [rotY, 1.0, 0.0], [0.0, 0.0, 1.0]], float)
         self._mtx = np.dot(skew_mtx, self._mtx)
@@ -2028,7 +2032,7 @@ def skew_deg(self, xShear, yShear):
         calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
         and :meth:`scale`.
         """
-        return self.skew(np.deg2rad(xShear), np.deg2rad(yShear))
+        return self.skew(math.radians(xShear), math.radians(yShear))
 
 
 class IdentityTransform(Affine2DBase):