Factor out common _GeoTransform code.

anntzer · anntzer · commit cbb72b14b2ef · 2017-11-19T10:33:19.000-08:00
diff --git a/lib/matplotlib/projections/geo.py b/lib/matplotlib/projections/geo.py
@@ -19,10 +19,9 @@
 from matplotlib.ticker import Formatter, Locator, NullLocator, FixedLocator, NullFormatter
 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
@@ -247,28 +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 __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
+    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__
+
+
+class AitoffAxes(GeoAxes):
+    name = 'aitoff'
 
-        def __str__(self):
-            return "{}({})".format(type(self).__name__, self._resolution)
+    class AitoffTransform(_GeoTransform):
+        """The base Aitoff transform."""
 
         def transform_non_affine(self, ll):
             longitude = ll[:, 0:1]
@@ -291,27 +299,11 @@ def transform_non_affine(self, ll):
             return np.concatenate((x.filled(0), y.filled(0)), 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 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
-
-        def __str__(self):
-            return "{}({})".format(type(self).__name__, self._resolution)
+    class InvertedAitoffTransform(_GeoTransform):
 
         def transform_non_affine(self, xy):
             # MGDTODO: Math is hard ;(
@@ -335,25 +327,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
-
-        def __str__(self):
-            return "{}({})".format(type(self).__name__, self._resolution)
+    class HammerTransform(_GeoTransform):
+        """The base Hammer transform."""
 
         def transform_non_affine(self, ll):
             longitude = ll[:, 0:1]
@@ -370,27 +345,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
-
-        def __str__(self):
-            return "{}({})".format(type(self).__name__, self._resolution)
+    class InvertedHammerTransform(_GeoTransform):
 
         def transform_non_affine(self, xy):
             x, y = xy.T
@@ -417,25 +376,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
-
-        def __str__(self):
-            return "{}({})".format(type(self).__name__, self._resolution)
+    class MollweideTransform(_GeoTransform):
+        """The base Mollweide transform."""
 
         def transform_non_affine(self, ll):
             def d(theta):
@@ -471,27 +413,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
-
-        def __str__(self):
-            return "{}({})".format(type(self).__name__, self._resolution)
+    class InvertedMollweideTransform(_GeoTransform):
 
         def transform_non_affine(self, xy):
             x = xy[:, 0:1]
@@ -523,28 +449,19 @@ 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
 
-        def __str__(self):
-            return "{}({})".format(type(self).__name__, self._resolution)
-
         def transform_non_affine(self, ll):
             longitude = ll[:, 0:1]
             latitude  = ll[:, 1:2]
@@ -568,33 +485,20 @@ 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
 
-        def __str__(self):
-            return "{}({})".format(type(self).__name__, self._resolution)
-
         def transform_non_affine(self, xy):
             x = xy[:, 0:1]
             y = xy[:, 1:2]
