Finall improvements to plot extent calculation.

Phil Elson · pelson · commit dfbe69c47d65 · 2012-08-20T16:53:15.000+01:00
diff --git a/lib/matplotlib/axes.py b/lib/matplotlib/axes.py
@@ -1478,17 +1478,22 @@ def _update_line_limits(self, line):
             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
+            # identify the transform to go from line's coordinates
+            # to data coordinates
+            trans_to_data = line_trans - self.transData
+
+            # if transData is affine we can use the cached non-affine component
+            # of line's path. (since the non-affine part of line_trans is
+            # entirely encapsulated in trans_to_data).
+            if self.transData.is_affine:
+                line_trans_path = line._get_transformed_path()
+                na_path, _ = line_trans_path.get_transformed_path_and_affine()
+                data_path = trans_to_data.transform_path_affine(na_path)
+            else:
+                data_path = trans_to_data.transform_path(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.
diff --git a/lib/matplotlib/lines.py b/lib/matplotlib/lines.py
@@ -249,9 +249,7 @@ def contains(self, mouseevent):
         if len(self._xy)==0: return False,{}
 
         # Convert points to pixels
-        if self._transformed_path is None:
-            self._transform_path()
-        path, affine = self._transformed_path.get_transformed_path_and_affine()
+        path, affine = self._get_transformed_path().get_transformed_path_and_affine()
         path = affine.transform_path(path)
         xy = path.vertices
         xt = xy[:, 0]
@@ -457,11 +455,14 @@ def _transform_path(self, subslice=None):
             _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."""
+    def _get_transformed_path(self):
+        """
+        Return the :class:`~matplotlib.transforms.TransformedPath` instance
+        of this line.
+        """
         if self._transformed_path is None:
             self._transform_path()
-        return self._transformed_path.get_fully_transformed_path()
+        return self._transformed_path
 
     def set_transform(self, t):
         """
@@ -491,8 +492,8 @@ def draw(self, renderer):
             subslice = slice(max(i0-1, 0), i1+1)
             self.ind_offset = subslice.start
             self._transform_path(subslice)
-        if self._transformed_path is None:
-            self._transform_path()
+
+        transformed_path = self._get_transformed_path()
 
         if not self.get_visible(): return
 
@@ -516,7 +517,7 @@ def draw(self, renderer):
 
         funcname = self._lineStyles.get(self._linestyle, '_draw_nothing')
         if funcname != '_draw_nothing':
-            tpath, affine = self._transformed_path.get_transformed_path_and_affine()
+            tpath, affine = transformed_path.get_transformed_path_and_affine()
             if len(tpath.vertices):
                 self._lineFunc = getattr(self, funcname)
                 funcname = self.drawStyles.get(self._drawstyle, '_draw_lines')
@@ -537,7 +538,7 @@ def draw(self, renderer):
                 gc.set_linewidth(self._markeredgewidth)
             gc.set_alpha(self._alpha)
             marker = self._marker
-            tpath, affine = self._transformed_path.get_transformed_points_and_affine()
+            tpath, affine = transformed_path.get_transformed_points_and_affine()
             if len(tpath.vertices):
                 # subsample the markers if markevery is not None
                 markevery = self.get_markevery()
diff --git a/lib/matplotlib/tests/test_transforms.py b/lib/matplotlib/tests/test_transforms.py
@@ -248,6 +248,8 @@ def test_transform_shortcuts(self):
         self.assertEqual(self.stack1 - self.ta3, self.ta1 + (self.tn1 + self.ta2))
         self.assertEqual(self.stack2 - self.ta3, self.ta1 + self.tn1 + self.ta2)
         
+        self.assertEqual((self.ta2 + self.ta3) - self.ta3 + self.ta3, self.ta2 + self.ta3)
+
     def test_contains_branch(self):
         r1 = (self.ta2 + self.ta1)
         r2 = (self.ta2 + self.ta1)
@@ -346,10 +348,24 @@ def test_pathc_extents_affine(self):
         patch = mpatches.PathPatch(pth, transform=offset + ax.transData)
         ax.add_patch(patch)
         expeted_data_lim = np.array([[0., 0.], [10.,  10.]]) + 10
+        np.testing.assert_array_almost_equal(ax.dataLim.get_points(), 
+                                             expeted_data_lim)
+
+
+    def test_line_extents_for_non_affine_transData(self):
+        ax = plt.axes(projection='polar')
+        # add 10 to the radius of the data
+        offset = mtrans.Affine2D().translate(0, 10)
+
+        plt.plot(range(10), transform=offset + ax.transData)
+        # the data lim of a polar plot is stored in coordinates
+        # before a transData transformation, hence the data limits
+        # are not what is being shown on the actual plot.
+        expeted_data_lim = np.array([[0., 0.], [9.,  9.]]) + [0, 10]
         np.testing.assert_array_almost_equal(ax.dataLim.get_points(),
                                              expeted_data_lim)
 
 
 if __name__=='__main__':
     import nose
-    nose.runmodule(argv=['-s','--with-doctest'], exit=False)
+    nose.runmodule(argv=['-s','--with-doctest'], exit=False)
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
@@ -1040,7 +1040,7 @@ class Transform(TransformNode):
       - :meth:`transform`
       - :attr:`is_separable`
       - :attr:`has_inverse`
-      - :meth:`inverted` (if :meth:`has_inverse` can return True)
+      - :meth:`inverted` (if :attr:`has_inverse` is True)
 
     If the transform needs to do something non-standard with
     :class:`matplotlib.path.Path` objects, such as adding curves
@@ -1141,6 +1141,8 @@ def __sub__(self, other):
             # similarly, when B contains tree A, we can avoid decending A at all, basically:
             A - B == (B - A).inverted() or B-1
 
+        For clarity, the result of ``(A + B) - B + B == (A + B)``.
+
         """
         # we only know how to do this operation if other is a Transform.
         if not isinstance(other, Transform):
@@ -1164,7 +1166,6 @@ def __sub__(self, other):
             raise ValueError('It is not possible to compute transA - transB '
                              'since transB cannot be inverted and there is no '
                              'shortcut possible.')
->>>>>>> Several bugs fixed, particularly with Polar & Geo.
 
     def __array__(self, *args, **kwargs):
         """
