Substantial change to transform to make it work as documented. The upshot is that the dataLim determination is now working.

Phil Elson · pelson · commit 8bbe2e55f29b · 2012-08-20T16:50:47.000+01:00
diff --git a/lib/matplotlib/axes.py b/lib/matplotlib/axes.py
@@ -1461,17 +1461,44 @@ def add_line(self, line):
 
         self._update_line_limits(line)
         if not line.get_label():
-            line.set_label('_line%d'%len(self.lines))
+            line.set_label('_line%d' % len(self.lines))
         self.lines.append(line)
         line._remove_method = lambda h: self.lines.remove(h)
         return line
 
     def _update_line_limits(self, line):
-        p = line.get_path()
-        if p.vertices.size > 0:
-            self.dataLim.update_from_path(p, self.ignore_existing_data_limits,
-                                            updatex=line.x_isdata,
-                                            updatey=line.y_isdata)
+        """Figures out the data limit of the given line, updating self.dataLim."""
+        path = line.get_path()
+        if path.vertices.size == 0:
+            return
+
+        line_trans = line.get_transform()
+
+        if line.get_transform() == self.transData:
+            data_path = path
+
+        elif line_trans.contains_branch(self.transData):
+            # transform the path all the way down (to device coordinates)
+            # then come back up (by inverting transData) to data coordinates.
+            # it would be possible to do this by identifying the transform
+            # needed to go from line_trans directly to transData, doing it
+            # this way means that the line instance has an opportunity to
+            # cache the transformed path.
+            device2data = self.transData.inverted()
+            data_path = device2data.transform_path(line.get_transformed_path())
+        else:
+            # for backwards compatibility we update the dataLim with the
+            # coordinate range of the given path, even though the coordinate
+            # systems are completely different. This may occur in situations
+            # such as when ax.transAxes is passed through for absolute
+            # positioning.
+            data_path = path
+
+        if data_path.vertices.size > 0:
+            self.dataLim.update_from_path(data_path,
+                                          self.ignore_existing_data_limits,
+                                          updatex=line.x_isdata,
+                                          updatey=line.y_isdata)
             self.ignore_existing_data_limits = False
 
     def add_patch(self, p):
@@ -3909,7 +3936,6 @@ def plot(self, *args, **kwargs):
             self.add_line(line)
             lines.append(line)
 
-
         self.autoscale_view(scalex=scalex, scaley=scaley)
         return lines
 
diff --git a/lib/matplotlib/lines.py b/lib/matplotlib/lines.py
@@ -446,13 +446,22 @@ def recache(self, always=False):
         self._invalidy = False
 
     def _transform_path(self, subslice=None):
+        """
+        Puts a TransformedPath instance at self._transformed_path,
+        all invalidation of the transform is then handled by the TransformedPath instance.
+        """
         # Masked arrays are now handled by the Path class itself
         if subslice is not None:
             _path = Path(self._xy[subslice,:])
         else:
             _path = self._path
         self._transformed_path = TransformedPath(_path, self.get_transform())
 
+    def get_transformed_path(self):
+        """Return the path of this line, (fully) transformed using the line's transform."""
+        if self._transformed_path is None:
+            self._transform_path()
+        return self._transformed_path.get_fully_transformed_path()
 
     def set_transform(self, t):
         """
diff --git a/lib/matplotlib/tests/test_transforms.py b/lib/matplotlib/tests/test_transforms.py
@@ -1,6 +1,9 @@
 from __future__ import print_function
+import itertools
+import unittest
+
 from nose.tools import assert_equal
-from numpy.testing import assert_almost_equal
+import numpy.testing as np_test, assert_almost_equal
 from matplotlib.transforms import Affine2D, BlendedGenericTransform
 from matplotlib.path import Path
 from matplotlib.scale import LogScale
@@ -11,7 +14,6 @@
 import matplotlib.pyplot as plt
 
 
-
 @cleanup
 def test_non_affine_caching():
     class AssertingNonAffineTransform(mtrans.Transform):
@@ -106,37 +108,37 @@ def test_pre_transform_plotting():
     
 
 def test_Affine2D_from_values():
-    points = [ [0,0],
+    points = np.array([ [0,0],
                [10,20],
                [-1,0],
-               ]
+               ])
 
-    t = Affine2D.from_values(1,0,0,0,0,0)
+    t = mtrans.Affine2D.from_values(1,0,0,0,0,0)
     actual = t.transform(points)
     expected = np.array( [[0,0],[10,0],[-1,0]] )
     assert_almost_equal(actual,expected)
 
-    t = Affine2D.from_values(0,2,0,0,0,0)
+    t = mtrans.Affine2D.from_values(0,2,0,0,0,0)
     actual = t.transform(points)
     expected = np.array( [[0,0],[0,20],[0,-2]] )
     assert_almost_equal(actual,expected)
 
-    t = Affine2D.from_values(0,0,3,0,0,0)
+    t = mtrans.Affine2D.from_values(0,0,3,0,0,0)
     actual = t.transform(points)
     expected = np.array( [[0,0],[60,0],[0,0]] )
     assert_almost_equal(actual,expected)
 
-    t = Affine2D.from_values(0,0,0,4,0,0)
+    t = mtrans.Affine2D.from_values(0,0,0,4,0,0)
     actual = t.transform(points)
     expected = np.array( [[0,0],[0,80],[0,0]] )
     assert_almost_equal(actual,expected)
 
-    t = Affine2D.from_values(0,0,0,0,5,0)
+    t = mtrans.Affine2D.from_values(0,0,0,0,5,0)
     actual = t.transform(points)
     expected = np.array( [[5,0],[5,0],[5,0]] )
     assert_almost_equal(actual,expected)
 
-    t = Affine2D.from_values(0,0,0,0,0,6)
+    t = mtrans.Affine2D.from_values(0,0,0,0,0,6)
     actual = t.transform(points)
     expected = np.array( [[0,6],[0,6],[0,6]] )
     assert_almost_equal(actual,expected)
@@ -165,6 +167,115 @@ def test_clipping_of_log():
     assert np.allclose(tpoints[-1], tpoints[0])
 
 
+class BasicTransformTests(unittest.TestCase):
+    def setUp(self):
+        class NonAffineForTest(mtrans.Transform):
+            is_affine = False
+            output_dims = 2
+            input_dims = 2
+
+            def __init__(self, real_trans, *args, **kwargs):
+                self.real_trans = real_trans
+                r = mtrans.Transform.__init__(self, *args, **kwargs)
+
+            def transform_non_affine(self, values):
+                return self.real_trans.transform(values)
+
+            def transform_path_non_affine(self, path):
+                return self.real_trans.transform_path(path)
+
+        self.ta1 = mtrans.Affine2D(shorthand_name='ta1').rotate(np.pi / 2)
+        self.ta2 = mtrans.Affine2D(shorthand_name='ta2').translate(10, 0)
+        self.ta3 = mtrans.Affine2D(shorthand_name='ta3').scale(1, 2)
+
+        self.tn1 = NonAffineForTest(mtrans.Affine2D().translate(1, 2), shorthand_name='tn1')
+        self.tn2 = NonAffineForTest(mtrans.Affine2D().translate(1, 2), shorthand_name='tn2')
+        self.tn3 = NonAffineForTest(mtrans.Affine2D().translate(1, 2), shorthand_name='tn3')
+
+        # creates a transform stack which looks like ((A, (N, A)), A)
+        self.stack1 = (self.ta1 + (self.tn1 + self.ta2)) + self.ta3
+        # creates a transform stack which looks like (((A, N), A), A)
+        self.stack2 = self.ta1 + self.tn1 + self.ta2 + self.ta3
+        # creates a transform stack which is a subset of stack2
+        self.stack2_subset = self.tn1 + self.ta2 + self.ta3
+
+        # when in debug, the transform stacks can produce dot images:
+#        self.stack1.write_graphviz(file('stack1.dot', 'w'))
+#        self.stack2.write_graphviz(file('stack2.dot', 'w'))
+#        self.stack2_subset.write_graphviz(file('stack2_subset.dot', 'w'))
+
+    def test_left_to_right_iteration(self):
+        stack3 = (self.ta1 + (self.tn1 + (self.ta2 + self.tn2))) + self.ta3
+#        stack3.write_graphviz(file('stack3.dot', 'w'))
+
+        target_transforms = [stack3,
+                             (self.tn1 + (self.ta2 + self.tn2)) + self.ta3,
+                             (self.ta2 + self.tn2) + self.ta3,
+                             self.tn2 + self.ta3,
+                             self.ta3,
+                             ]
+        r = list(self.stack3._iter_break_from_left_to_right())
+        self.assertEqual(len(r), len(target_transforms))
+
+        for target_stack, stack in itertools.izip(target_transforms, r):
+            self.assertEqual(target_stack, stack)
+
+    def test_contains_branch(self):
+        r1 = (self.ta2 + self.ta1)
+        r2 = (self.ta2 + self.ta1)
+        self.assertEqual(r1, r2)
+        self.assertNotEqual(r1, self.ta1)
+        self.assertTrue(r1.contains_branch(r2))
+        self.assertTrue(r1.contains_branch(self.ta1))
+        self.assertFalse(r1.contains_branch(self.ta2))
+        self.assertFalse(r1.contains_branch((self.ta2 + self.ta2)))
+
+        self.assertEqual(r1, r2)
+
+        self.assertTrue(self.stack1.contains_branch(self.ta3))
+        self.assertTrue(self.stack2.contains_branch(self.ta3))
+
+        self.assertTrue(self.stack1.contains_branch(self.stack2_subset))
+        self.assertTrue(self.stack2.contains_branch(self.stack2_subset))
+
+        self.assertFalse(self.stack2_subset.contains_branch(self.stack1))
+        self.assertFalse(self.stack2_subset.contains_branch(self.stack2))
+
+        self.assertTrue(self.stack1.contains_branch((self.ta2 + self.ta3)))
+        self.assertTrue(self.stack2.contains_branch((self.ta2 + self.ta3)))
+
+        self.assertFalse(self.stack1.contains_branch((self.tn1 + self.ta2)))
+
+    def test_affine_simplification(self):
+        points = np.array([[0, 0], [10, 20], [np.nan, 1], [-1, 0]], dtype=np.float64)
+        na_pts = self.stack1.transform_non_affine(points)
+        all_pts = self.stack1.transform(points)
+
+        na_expected = np.array([[1., 2.], [-19., 12.],
+                                [np.nan, np.nan], [1., 1.]], dtype=np.float64)
+        all_expected = np.array([[11., 4.], [-9., 24.],
+                                 [np.nan, np.nan], [11., 2.]], dtype=np.float64)
+
+        # check we have the expected results from doing the affine part only
+        np_test.assert_array_almost_equal(na_pts, na_expected)
+        # check we have the expected results from a full transformation
+        np_test.assert_array_almost_equal(all_pts, all_expected)
+        # check we have the expected results from doing the transformation in two steps
+        np_test.assert_array_almost_equal(self.stack1.transform_affine(na_pts), all_expected)
+        # check that getting the affine transformation first, then fully transforming using that
+        # yields the same result as before.
+        np_test.assert_array_almost_equal(self.stack1.get_affine().transform(na_pts), all_expected)
+
+        # check that the affine part of stack1 & stack2 are equivalent (i.e. the optimization
+        # is working)
+        expected_result = (self.ta2 + self.ta3).get_matrix()
+        result = self.stack1.get_affine().get_matrix()
+        np_test.assert_array_equal(expected_result, result)
+
+        result = self.stack2.get_affine().get_matrix()
+        np_test.assert_array_equal(expected_result, result)
+
+
 if __name__=='__main__':
     import nose
     nose.runmodule(argv=['-s','--with-doctest'], exit=False)
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
