Fix incorrect dims in CompositeAffine [skip ci]

trananso · trananso · commit 022303575164 · 2024-04-19T01:03:49.000-04:00
diff --git a/lib/matplotlib/tests/test_transforms.py b/lib/matplotlib/tests/test_transforms.py
@@ -381,12 +381,12 @@ def test_rotate(self):
         assert_array_almost_equal(r90[1].transform(self.single_point), [1, 1, -1])
         assert_array_almost_equal(r90[2].transform(self.single_point), [-1, 1, 1])
 
-        assert_array_almost_equal(r90[0].transform(self.multiple_points), [
-            [2, 0, 0], [0, 0, 3], [0, -4, 0], [5, 0, 5], [6, -6, 6]])
-        assert_array_almost_equal(r90[1].transform(self.multiple_points), [
-            [0, 0, -2], [0, 3, 0], [4, 0, 0], [0, 5, -5], [6, 6, -6]])
-        assert_array_almost_equal(r90[2].transform(self.multiple_points), [
-            [0, 2, 0], [-3, 0, 0], [0, 0, 4], [-5, 5, 0], [-6, 6, 6]])
+        assert_array_almost_equal(r90[0].transform(self.multiple_points),
+            [[2, 0, 0], [0, 0, 3], [0, -4, 0], [5, 0, 5], [6, -6, 6]])
+        assert_array_almost_equal(r90[1].transform(self.multiple_points),
+            [[0, 0, -2], [0, 3, 0], [4, 0, 0], [0, 5, -5], [6, 6, -6]])
+        assert_array_almost_equal(r90[2].transform(self.multiple_points),
+            [[0, 2, 0], [-3, 0, 0], [0, 0, 4], [-5, 5, 0], [-6, 6, 6]])
 
         r_pi = [Affine3D().rotate(np.pi, dim) for dim in range(3)]
         r180 = [Affine3D().rotate_deg(180, dim) for dim in range(3)]
@@ -395,12 +395,12 @@ def test_rotate(self):
         assert_array_almost_equal(r180[1].transform(self.single_point), [-1, 1, -1])
         assert_array_almost_equal(r180[2].transform(self.single_point), [-1, -1, 1])
 
-        assert_array_almost_equal(r180[0].transform(self.multiple_points), [
-            [2, 0, 0], [0, -3, 0], [0, 0, -4], [5, -5, 0], [6, -6, -6]])
-        assert_array_almost_equal(r180[1].transform(self.multiple_points), [
-            [-2, 0, 0], [0, 3, 0], [0, 0, -4], [-5, 5, 0], [-6, 6, -6]])
-        assert_array_almost_equal(r180[2].transform(self.multiple_points), [
-            [-2, 0, 0], [0, -3, 0], [0, 0, 4], [-5, -5, 0], [-6, -6, 6]])
+        assert_array_almost_equal(r180[0].transform(self.multiple_points),
+            [[2, 0, 0], [0, -3, 0], [0, 0, -4], [5, -5, 0], [6, -6, -6]])
+        assert_array_almost_equal(r180[1].transform(self.multiple_points),
+            [[-2, 0, 0], [0, 3, 0], [0, 0, -4], [-5, 5, 0], [-6, 6, -6]])
+        assert_array_almost_equal(r180[2].transform(self.multiple_points),
+            [[-2, 0, 0], [0, -3, 0], [0, 0, 4], [-5, -5, 0], [-6, -6, 6]])
 
         r_pi_3_2 = [Affine3D().rotate(3 * np.pi / 2, dim) for dim in range(3)]
         r270 = [Affine3D().rotate_deg(270, dim) for dim in range(3)]
@@ -409,12 +409,12 @@ def test_rotate(self):
         assert_array_almost_equal(r270[1].transform(self.single_point), [-1, 1, 1])
         assert_array_almost_equal(r270[2].transform(self.single_point), [1, -1, 1])
 
-        assert_array_almost_equal(r270[0].transform(self.multiple_points), [
-            [2, 0, 0], [0, 0, -3], [0, 4, 0], [5, 0, -5], [6, 6, -6]])
-        assert_array_almost_equal(r270[1].transform(self.multiple_points), [
-            [0, 0, 2], [0, 3, 0], [-4, 0, 0], [0, 5, 5], [-6, 6, 6]])
-        assert_array_almost_equal(r270[2].transform(self.multiple_points), [
-            [0, -2, 0], [3, 0, 0], [0, 0, 4], [5, -5, 0], [6, -6, 6]])
+        assert_array_almost_equal(r270[0].transform(self.multiple_points),
+            [[2, 0, 0], [0, 0, -3], [0, 4, 0], [5, 0, -5], [6, 6, -6]])
+        assert_array_almost_equal(r270[1].transform(self.multiple_points),
+            [[0, 0, 2], [0, 3, 0], [-4, 0, 0], [0, 5, 5], [-6, 6, 6]])
+        assert_array_almost_equal(r270[2].transform(self.multiple_points),
+            [[0, -2, 0], [3, 0, 0], [0, 0, 4], [5, -5, 0], [6, -6, 6]])
 
         for dim in range(3):
             assert_array_equal(r_pi_2[dim].get_matrix(), r90[dim].get_matrix())
@@ -430,35 +430,35 @@ def test_rotate_around(self):
                   for dim in range(3)]
         r90 = [Affine3D().rotate_deg_around(*self.pivot, 90, dim) for dim in range(3)]
 
-        assert_array_almost_equal(r90[0].transform(self.multiple_points), [
-            [2, 2, 0], [0, 2, 3], [0, -2, 0], [5, 2, 5], [6, -4, 6]])
-        assert_array_almost_equal(r90[1].transform(self.multiple_points), [
-            [0, 0, 0], [0, 3, 2], [4, 0, 2], [0, 5, -3], [6, 6, -4]])
-        assert_array_almost_equal(r90[2].transform(self.multiple_points), [
-            [2, 2, 0], [-1, 0, 0], [2, 0, 4], [-3, 5, 0], [-4, 6, 6]])
+        assert_array_almost_equal(r90[0].transform(self.multiple_points),
+            [[2, 2, 0], [0, 2, 3], [0, -2, 0], [5, 2, 5], [6, -4, 6]])
+        assert_array_almost_equal(r90[1].transform(self.multiple_points),
+            [[0, 0, 0], [0, 3, 2], [4, 0, 2], [0, 5, -3], [6, 6, -4]])
+        assert_array_almost_equal(r90[2].transform(self.multiple_points),
+            [[2, 2, 0], [-1, 0, 0], [2, 0, 4], [-3, 5, 0], [-4, 6, 6]])
 
 
         r_pi = [Affine3D().rotate_around(*self.pivot, np.pi, dim) for dim in range(3)]
         r180 = [Affine3D().rotate_deg_around(*self.pivot, 180, dim) for dim in range(3)]
 
-        assert_array_almost_equal(r180[0].transform(self.multiple_points), [
-            [2, 2, 2], [0, -1, 2], [0, 2, -2], [5, -3, 2], [6, -4, -4]])
-        assert_array_almost_equal(r180[1].transform(self.multiple_points), [
-            [0, 0, 2], [2, 3, 2], [2, 0, -2], [-3, 5, 2], [-4, 6, -4]])
-        assert_array_almost_equal(r180[2].transform(self.multiple_points), [
-            [0, 2, 0], [2, -1, 0], [2, 2, 4], [-3, -3, 0], [-4, -4, 6]])
+        assert_array_almost_equal(r180[0].transform(self.multiple_points),
+            [[2, 2, 2], [0, -1, 2], [0, 2, -2], [5, -3, 2], [6, -4, -4]])
+        assert_array_almost_equal(r180[1].transform(self.multiple_points),
+            [[0, 0, 2], [2, 3, 2], [2, 0, -2], [-3, 5, 2], [-4, 6, -4]])
+        assert_array_almost_equal(r180[2].transform(self.multiple_points),
+            [[0, 2, 0], [2, -1, 0], [2, 2, 4], [-3, -3, 0], [-4, -4, 6]])
 
 
         r_pi_3_2 = [Affine3D().rotate_around(*self.pivot, 3 * np.pi / 2, dim)
                     for dim in range(3)]
         r270 = [Affine3D().rotate_deg_around(*self.pivot, 270, dim) for dim in range(3)]
 
-        assert_array_almost_equal(r270[0].transform(self.multiple_points), [
-            [2, 0, 2], [0, 0, -1], [0, 4, 2], [5, 0, -3], [6, 6, -4]])
-        assert_array_almost_equal(r270[1].transform(self.multiple_points), [
-            [2, 0, 2], [2, 3, 0], [-2, 0, 0], [2, 5, 5], [-4, 6, 6]])
-        assert_array_almost_equal(r270[2].transform(self.multiple_points), [
-            [0, 0, 0], [3, 2, 0], [0, 2, 4], [5, -3, 0], [6, -4, 6]])
+        assert_array_almost_equal(r270[0].transform(self.multiple_points),
+            [[2, 0, 2], [0, 0, -1], [0, 4, 2], [5, 0, -3], [6, 6, -4]])
+        assert_array_almost_equal(r270[1].transform(self.multiple_points),
+            [[2, 0, 2], [2, 3, 0], [-2, 0, 0], [2, 5, 5], [-4, 6, 6]])
+        assert_array_almost_equal(r270[2].transform(self.multiple_points),
+            [[0, 0, 0], [3, 2, 0], [0, 2, 4], [5, -3, 0], [6, -4, 6]])
 
         for dim in range(3):
             assert_array_almost_equal(r90[dim].transform(self.single_point), [1, 1, 1])
@@ -472,6 +472,15 @@ def test_rotate_around(self):
             assert_array_almost_equal(
                 (r90[dim] + r180[dim]).get_matrix(), r270[dim].get_matrix())
 
+    def test_scale(self):
+        sx = Affine3D().scale(3, 1, 1)
+        sy = Affine3D().scale(1, -2, 1)
+        sz = Affine3D().scale(1, 1, 4)
+        trans = Affine3D().scale(3, -2, 4)
+        assert_array_equal((sx + sy + sz).get_matrix(), trans.get_matrix())
+        assert_array_equal(trans.transform(self.single_point), [3, -2, 4])
+        assert_array_equal(trans.transform(self.multiple_points),
+            [[6, 0, 0], [0, -6, 0], [0, 0, 16], [15, -10, 0], [18, -12, 24]])
 
 def test_non_affine_caching():
     class AssertingNonAffineTransform(mtransforms.Transform):
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
@@ -2833,10 +2833,8 @@ def __init__(self, a, b, **kwargs):
         if a.output_dims != b.input_dims:
             raise ValueError("The output dimension of 'a' must be equal to "
                              "the input dimensions of 'b'")
-        self.input_dims = a.input_dims
-        self.output_dims = b.output_dims
+        super().__init__(dims=a.output_dims, **kwargs)
 
-        super().__init__(**kwargs)
         self._a = a
         self._b = b
         self.set_children(a, b)
