Added appropriate change logs for new transform mechanims, fixed a bug (and updated appropriate test).

pelson · pelson · commit 8dbe07438c3c · 2012-08-20T16:54:52.000+01:00
diff --git a/doc/api/api_changes.rst b/doc/api/api_changes.rst
@@ -72,9 +72,53 @@ Changes in 1.2.x
   original keyword arguments will override any value provided by
   *capthick*.
 
-* Aritsts no longer have ``x_isdata`` or ``y_isdata`` attributes. Instead
+* Transform subclassing behaviour is now subtly changed. If your transform
+  implements a non-affine transformation, then it should override the 
+  ``transform_non_affine`` method, rather than the generic ``transform`` method.
+  Previously transforms would define ``transform`` and then copy the
+  method into ``transform_non_affine``:
+  
+     class MyTransform(mtrans.Transform):
+         def transform(self, xy):
+             ...
+         transform_non_affine = transform
+         
+  This approach will no longer function correctly and should be changed to:
+  
+     class MyTransform(mtrans.Transform):
+         def transform_non_affine(self, xy):
+             ...
+  
+* Artists no longer have ``x_isdata`` or ``y_isdata`` attributes; instead
   any artist's transform can be interrogated with
-  ``artist_instance.get_transform().is_data(ax.transData)``
+  ``artist_instance.get_transform().contains_branch(ax.transData)``
+  
+* Lines added to an axes now take into account their transform when updating the
+  data and view limits. This means transforms can now be used as a pre-transform.
+  For instance:
+  
+      >>> import matplotlib.pyplot as plt
+      >>> import matplotlib.transforms as mtrans
+      >>> ax = plt.axes()
+      >>> ax.plot(range(10), transform=mtrans.Affine2D().scale(10) + ax.transData)
+      >>> print(ax.viewLim)
+      Bbox('array([[  0.,   0.],\n       [ 90.,  90.]])')
+  
+* One can now easily get a transform which goes from one transform's coordinate system
+  to another, in an optimized way, using the new subtract method on a transform. For instance,
+  to go from data coordinates to axes coordinates::
+  
+      >>> import matplotlib.pyplot as plt
+      >>> ax = plt.axes()
+      >>> data2ax = ax.transData - ax.transAxes
+      >>> print(ax.transData.depth, ax.transAxes.depth)
+      3, 1
+      >>> print(data2ax.depth)
+      2
+      
+  for versions before 2.0 this could only be achieved in a sub-optimal way, using 
+  ``ax.transData + ax.transAxes.inverted()`` (depth is a new concept, but had it existed 
+  it would return 4 for this example).      
 
 Changes in 1.1.x
 ================
diff --git a/lib/matplotlib/tests/test_transforms.py b/lib/matplotlib/tests/test_transforms.py
@@ -240,9 +240,11 @@ def test_transform_shortcuts(self):
         self.assertEqual(self.stack1 - self.stack2_subset, self.ta1)
         self.assertEqual(self.stack2 - self.stack2_subset, self.ta1)
 
-        # check that we cannot find a chain from the subset back to the superset
-        # (since the inverse of the Transform is not defined.)
-        assert_raises(ValueError, self.stack2_subset.__sub__, self.stack2)
+        assert_equal((self.stack2_subset - self.stack2), 
+                                   self.ta1.inverted(),
+                                   )
+        assert_equal((self.stack2_subset - self.stack2).depth, 1)
+
         assert_raises(ValueError, self.stack1.__sub__, self.stack2)
 
         aff1 = self.ta1 + (self.ta2 + self.ta3)
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
@@ -1181,8 +1181,8 @@ def __sub__(self, other):
             if sub_tree == other:
                 return remainder
 
-        for remainder, sub_tree in self._iter_break_from_left_to_right():
-            if sub_tree == other:
+        for remainder, sub_tree in other._iter_break_from_left_to_right():
+            if sub_tree == self:
                 if not remainder.has_inverse:
                     raise ValueError("The shortcut cannot be computed since "
                      "other's transform includes a non-invertable component.")
