Merge pull request matplotlib#9421 from anntzer/transforms-repr

QuLogic · web-flow · commit 07d2e94dd16b · 2017-12-01T03:12:51.000-05:00
Improve reprs of transforms.
diff --git a/doc/users/next_whats_new/20171119-transforms-repr.rst b/doc/users/next_whats_new/20171119-transforms-repr.rst
@@ -0,0 +1,32 @@
+Improved `repr` for `Transform`\s
+---------------------------------
+
+`Transform`\s now indent their `repr`\s in a more legible manner:
+
+.. code-block:: ipython
+
+   In [1]: l, = plt.plot([]); l.get_transform()
+   Out[1]: 
+   CompositeGenericTransform(
+      TransformWrapper(
+         BlendedAffine2D(
+               IdentityTransform(),
+               IdentityTransform())),
+      CompositeGenericTransform(
+         BboxTransformFrom(
+               TransformedBbox(
+                  Bbox(x0=-0.05500000000000001, y0=-0.05500000000000001, x1=0.05500000000000001, y1=0.05500000000000001),
+                  TransformWrapper(
+                     BlendedAffine2D(
+                           IdentityTransform(),
+                           IdentityTransform())))),
+         BboxTransformTo(
+               TransformedBbox(
+                  Bbox(x0=0.125, y0=0.10999999999999999, x1=0.9, y1=0.88),
+                  BboxTransformTo(
+                     TransformedBbox(
+                           Bbox(x0=0.0, y0=0.0, x1=6.4, y1=4.8),
+                           Affine2D(
+                              [[ 100.    0.    0.]
+                              [   0.  100.    0.]
+                              [   0.    0.    1.]])))))))
diff --git a/lib/matplotlib/projections/geo.py b/lib/matplotlib/projections/geo.py
@@ -17,13 +17,11 @@
 import matplotlib.spines as mspines
 import matplotlib.axis as maxis
 from matplotlib.ticker import Formatter, Locator, NullLocator, FixedLocator, NullFormatter
-from matplotlib.transforms import Affine2D, Affine2DBase, Bbox, \
-    BboxTransformTo, IdentityTransform, Transform, TransformWrapper
+from matplotlib.transforms import Affine2D, BboxTransformTo, Transform
+
 
 class GeoAxes(Axes):
-    """
-    An abstract base class for geographic projections
-    """
+    """An abstract base class for geographic projections."""
     class ThetaFormatter(Formatter):
         """
         Used to format the theta tick labels.  Converts the native
@@ -248,25 +246,37 @@ def drag_pan(self, button, key, x, y):
         pass
 
 
-class AitoffAxes(GeoAxes):
-    name = 'aitoff'
+class _GeoTransform(Transform):
+    # Factoring out some common functionality.
+    input_dims = 2
+    output_dims = 2
+    is_separable = False
 
-    class AitoffTransform(Transform):
+    def __init__(self, resolution):
         """
-        The base Aitoff transform.
+        Create a new geographical transform.
+
+        Resolution is the number of steps to interpolate between each input
+        line segment to approximate its path in curved space.
         """
-        input_dims = 2
-        output_dims = 2
-        is_separable = False
+        Transform.__init__(self)
+        self._resolution = resolution
+
+    def __str__(self):
+        return "{}({})".format(type(self).__name__, self._resolution)
+
+    def transform_path_non_affine(self, path):
+        vertices = path.vertices
+        ipath = path.interpolated(self._resolution)
+        return Path(self.transform(ipath.vertices), ipath.codes)
+    transform_path_non_affine.__doc__ = Transform.transform_path_non_affine.__doc__
 
-        def __init__(self, resolution):
-            """
-            Create a new Aitoff transform.  Resolution is the number of steps
-            to interpolate between each input line segment to approximate its
-            path in curved Aitoff space.
-            """
-            Transform.__init__(self)
-            self._resolution = resolution
+
+class AitoffAxes(GeoAxes):
+    name = 'aitoff'
+
+    class AitoffTransform(_GeoTransform):
+        """The base Aitoff transform."""
 
         def transform_non_affine(self, ll):
             longitude = ll[:, 0]
@@ -288,24 +298,11 @@ def transform_non_affine(self, ll):
             return xy
         transform_non_affine.__doc__ = Transform.transform_non_affine.__doc__
 
-        def transform_path_non_affine(self, path):
-            vertices = path.vertices
-            ipath = path.interpolated(self._resolution)
-            return Path(self.transform(ipath.vertices), ipath.codes)
-        transform_path_non_affine.__doc__ = Transform.transform_path_non_affine.__doc__
-
         def inverted(self):
             return AitoffAxes.InvertedAitoffTransform(self._resolution)
         inverted.__doc__ = Transform.inverted.__doc__
 
-    class InvertedAitoffTransform(Transform):
-        input_dims = 2
-        output_dims = 2
-        is_separable = False
-
-        def __init__(self, resolution):
-            Transform.__init__(self)
-            self._resolution = resolution
+    class InvertedAitoffTransform(_GeoTransform):
 
         def transform_non_affine(self, xy):
             # MGDTODO: Math is hard ;(
@@ -329,22 +326,8 @@ def _get_core_transform(self, resolution):
 class HammerAxes(GeoAxes):
     name = 'hammer'
 
-    class HammerTransform(Transform):
-        """
-        The base Hammer transform.
-        """
-        input_dims = 2
-        output_dims = 2
-        is_separable = False
-
-        def __init__(self, resolution):
-            """
-            Create a new Hammer transform.  Resolution is the number of steps
-            to interpolate between each input line segment to approximate its
-            path in curved Hammer space.
-            """
-            Transform.__init__(self)
-            self._resolution = resolution
+    class HammerTransform(_GeoTransform):
+        """The base Hammer transform."""
 
         def transform_non_affine(self, ll):
             longitude = ll[:, 0:1]
@@ -361,24 +344,11 @@ def transform_non_affine(self, ll):
             return np.concatenate((x, y), 1)
         transform_non_affine.__doc__ = Transform.transform_non_affine.__doc__
 
-        def transform_path_non_affine(self, path):
-            vertices = path.vertices
-            ipath = path.interpolated(self._resolution)
-            return Path(self.transform(ipath.vertices), ipath.codes)
-        transform_path_non_affine.__doc__ = Transform.transform_path_non_affine.__doc__
-
         def inverted(self):
             return HammerAxes.InvertedHammerTransform(self._resolution)
         inverted.__doc__ = Transform.inverted.__doc__
 
-    class InvertedHammerTransform(Transform):
-        input_dims = 2
-        output_dims = 2
-        is_separable = False
-
-        def __init__(self, resolution):
-            Transform.__init__(self)
-            self._resolution = resolution
+    class InvertedHammerTransform(_GeoTransform):
 
         def transform_non_affine(self, xy):
             x, y = xy.T
@@ -405,22 +375,8 @@ def _get_core_transform(self, resolution):
 class MollweideAxes(GeoAxes):
     name = 'mollweide'
 
-    class MollweideTransform(Transform):
-        """
-        The base Mollweide transform.
-        """
-        input_dims = 2
-        output_dims = 2
-        is_separable = False
-
-        def __init__(self, resolution):
-            """
-            Create a new Mollweide transform.  Resolution is the number of steps
-            to interpolate between each input line segment to approximate its
-            path in curved Mollweide space.
-            """
-            Transform.__init__(self)
-            self._resolution = resolution
+    class MollweideTransform(_GeoTransform):
+        """The base Mollweide transform."""
 
         def transform_non_affine(self, ll):
             def d(theta):
@@ -456,24 +412,11 @@ def d(theta):
             return xy
         transform_non_affine.__doc__ = Transform.transform_non_affine.__doc__
 
-        def transform_path_non_affine(self, path):
-            vertices = path.vertices
-            ipath = path.interpolated(self._resolution)
-            return Path(self.transform(ipath.vertices), ipath.codes)
-        transform_path_non_affine.__doc__ = Transform.transform_path_non_affine.__doc__
-
         def inverted(self):
             return MollweideAxes.InvertedMollweideTransform(self._resolution)
         inverted.__doc__ = Transform.inverted.__doc__
 
-    class InvertedMollweideTransform(Transform):
-        input_dims = 2
-        output_dims = 2
-        is_separable = False
-
-        def __init__(self, resolution):
-            Transform.__init__(self)
-            self._resolution = resolution
+    class InvertedMollweideTransform(_GeoTransform):
 
         def transform_non_affine(self, xy):
             x = xy[:, 0:1]
@@ -505,22 +448,16 @@ def _get_core_transform(self, resolution):
 class LambertAxes(GeoAxes):
     name = 'lambert'
 
-    class LambertTransform(Transform):
-        """
-        The base Lambert transform.
-        """
-        input_dims = 2
-        output_dims = 2
-        is_separable = False
+    class LambertTransform(_GeoTransform):
+        """The base Lambert transform."""
 
         def __init__(self, center_longitude, center_latitude, resolution):
             """
             Create a new Lambert transform.  Resolution is the number of steps
             to interpolate between each input line segment to approximate its
             path in curved Lambert space.
             """
-            Transform.__init__(self)
-            self._resolution = resolution
+            _GeoTransform.__init__(self, resolution)
             self._center_longitude = center_longitude
             self._center_latitude = center_latitude
 
@@ -547,27 +484,17 @@ def transform_non_affine(self, ll):
             return np.concatenate((x, y), 1)
         transform_non_affine.__doc__ = Transform.transform_non_affine.__doc__
 
-        def transform_path_non_affine(self, path):
-            vertices = path.vertices
-            ipath = path.interpolated(self._resolution)
-            return Path(self.transform(ipath.vertices), ipath.codes)
-        transform_path_non_affine.__doc__ = Transform.transform_path_non_affine.__doc__
-
         def inverted(self):
             return LambertAxes.InvertedLambertTransform(
                 self._center_longitude,
                 self._center_latitude,
                 self._resolution)
         inverted.__doc__ = Transform.inverted.__doc__
 
-    class InvertedLambertTransform(Transform):
-        input_dims = 2
-        output_dims = 2
-        is_separable = False
+    class InvertedLambertTransform(_GeoTransform):
 
         def __init__(self, center_longitude, center_latitude, resolution):
-            Transform.__init__(self)
-            self._resolution = resolution
+            _GeoTransform.__init__(self, resolution)
             self._center_longitude = center_longitude
             self._center_latitude = center_latitude
 
diff --git a/lib/matplotlib/projections/polar.py b/lib/matplotlib/projections/polar.py
@@ -39,6 +39,16 @@ def __init__(self, axis=None, use_rmin=True,
         self._use_rmin = use_rmin
         self._apply_theta_transforms = _apply_theta_transforms
 
+    def __str__(self):
+        return ("{}(\n"
+                    "{},\n"
+                "    use_rmin={},\n"
+                "    _apply_theta_transforms={})"
+                .format(type(self).__name__,
+                        mtransforms._indent_str(self._axis),
+                        self._use_rmin,
+                        self._apply_theta_transforms))
+
     def transform_non_affine(self, tr):
         xy = np.empty(tr.shape, float)
 
@@ -95,6 +105,14 @@ def __init__(self, scale_transform, limits):
         self.set_children(scale_transform, limits)
         self._mtx = None
 
+    def __str__(self):
+        return ("{}(\n"
+                    "{},\n"
+                    "{})"
+                .format(type(self).__name__,
+                        mtransforms._indent_str(self._scale_transform),
+                        mtransforms._indent_str(self._limits)))
+
     def get_matrix(self):
         if self._invalid:
             limits_scaled = self._limits.transformed(self._scale_transform)
@@ -125,6 +143,16 @@ def __init__(self, axis=None, use_rmin=True,
         self._use_rmin = use_rmin
         self._apply_theta_transforms = _apply_theta_transforms
 
+    def __str__(self):
+        return ("{}(\n"
+                    "{},\n"
+                "    use_rmin={},\n"
+                "    _apply_theta_transforms={})"
+                .format(type(self).__name__,
+                        mtransforms._indent_str(self._axis),
+                        self._use_rmin,
+                        self._apply_theta_transforms))
+
     def transform_non_affine(self, xy):
         x = xy[:, 0:1]
         y = xy[:, 1:]
@@ -459,6 +487,16 @@ def __init__(self, axes, pad, mode):
         self.mode = mode
         self.pad = pad
 
+    def __str__(self):
+        return ("{}(\n"
+                    "{},\n"
+                    "{},\n"
+                    "{})"
+                .format(type(self).__name__,
+                        mtransforms._indent_str(self.axes),
+                        mtransforms._indent_str(self.pad),
+                        mtransforms._indent_str(repr(self.mode))))
+
     def get_matrix(self):
         if self._invalid:
             if self.mode == 'rlabel':
@@ -697,9 +735,15 @@ def __init__(self, center, viewLim, originLim, **kwargs):
         self._originLim = originLim
         self.set_children(viewLim, originLim)
 
-    def __repr__(self):
-        return "_WedgeBbox(%r, %r, %r)" % (self._center, self._viewLim,
-                                           self._originLim)
+    def __str__(self):
+        return ("{}(\n"
+                    "{},\n"
+                    "{},\n"
+                    "{})"
+                .format(type(self).__name__,
+                        mtransforms._indent_str(self._center),
+                        mtransforms._indent_str(self._viewLim),
+                        mtransforms._indent_str(self._originLim)))
 
     def get_points(self):
         if self._invalid:
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
