Fix missing +360 degree lon gridline issues

Author: lukelbd

proplot/axes/geo.py

@@ -213,23 +213,22 @@ def _pad_ticks(ticks, vmin, vmax):
         # giant lists of 10,000 gridline locations.
         if len(ticks) == 0:
             return ticks
-        range_ = max(ticks) - min(ticks)
+        range_ = np.max(ticks) - np.min(ticks)
         vmin = max(vmin, ticks[0] - range_)
         vmax = min(vmax, ticks[-1] + range_)
 
         # Pad the reported tick range up to specified range
         step = ticks[1] - ticks[0]  # MaxNLocator/AutoMinorLocator steps are equal
-        ticks_lo = np.arange(ticks[0], vmin, -step)[1:][::-1].tolist()
-        ticks_hi = np.arange(ticks[-1], vmax, step)[1:].tolist()
-        ticks = ticks_lo + ticks + ticks_hi
+        ticks_lo = np.arange(ticks[0], vmin, -step)[1:][::-1]
+        ticks_hi = np.arange(ticks[-1], vmax, step)[1:]
+        ticks = np.concatenate((ticks_lo, ticks, ticks_hi))
         return ticks
 
     def get_scale(self):
         return 'linear'
 
     def get_tick_space(self):
-        # Just use the long-standing default of nbins=9
-        return 9
+        return 9  # longstanding default of nbins=9
 
     def get_major_formatter(self):
         return self.major.formatter
@@ -241,14 +240,14 @@ def get_minor_locator(self):
         return self.minor.locator
 
     def get_majorticklocs(self):
-        return self._get_sanitized_ticks(self.major.locator)
+        return self._get_ticklocs(self.major.locator)
 
     def get_minorticklocs(self):
-        return self._get_sanitized_ticks(self.minor.locator)
+        return self._get_ticklocs(self.minor.locator)
 
     def set_major_formatter(self, formatter, default=False):
-        # NOTE: Cartopy formatters check Formatter.axis.axes.projection and has
-        # special projection-dependent behavior.
+        # NOTE: Cartopy formatters check Formatter.axis.axes.projection
+        # in order to implement special projection-dependent behavior.
         self.major.formatter = formatter
         formatter.set_axis(self)
         self.isDefault_majfmt = default
@@ -286,27 +285,41 @@ def __init__(self, axes):
         self.set_major_locator(constructor.Locator(locator), default=True)
         self.set_minor_locator(mticker.AutoMinorLocator(), default=True)
 
-    def _get_sanitized_ticks(self, locator):
+    def _get_ticklocs(self, locator):
         # Prevent ticks from looping around
-        eps = 5e-10  # more than 1e-10 because we use 1e-10 in _LongitudeLocator
-        ticks = sorted(locator())
-        while ticks and ticks[-1] - eps > ticks[0] + 360 + eps:  # cut off looped ticks
-            ticks = ticks[:-1]
+        # NOTE: Cartopy 0.17 formats numbers offset by eps with the cardinal indicator
+        # (e.g. 0 degrees for map centered on 180 degrees). So skip in that case.
+        # NOTE: Common strange issue is e.g. MultipleLocator(60) starts out at
+        # -60 degrees for a map from 0 to 360 degrees. If always trimmed circular
+        # locations from right then would cut off rightmost gridline. Workaround is
+        # to trim on the side closest to central longitude (in this case the left).
+        eps = 1e-10
+        lon0 = self.axes._get_lon0()
+        ticks = np.sort(locator())
+        while ticks.size:
+            if np.isclose(ticks[0] + 360, ticks[-1]):
+                if _version_cartopy >= '0.18' or not np.isclose(ticks[0] % 360, 0):
+                    ticks[-1] -= eps  # ensure label appears on *right* not left
+                break
+            elif ticks[0] + 360 < ticks[-1]:
+                idx = (1, None) if lon0 - ticks[0] > ticks[-1] - lon0 else (None, -1)
+                ticks = ticks[slice(*idx)]  # cut off ticks looped over globe
+            else:
+                break
 
         # Append extra ticks in case longitude/latitude limits do not encompass
         # the entire view range of map, e.g. for Lambert Conformal sectors.
         # NOTE: Try to avoid making 10,000 element lists. Just wrap extra ticks
         # up to the width of *reported* longitude range.
         if isinstance(locator, (mticker.MaxNLocator, mticker.AutoMinorLocator)):
-            lon0 = self.axes._get_lon0()
             ticks = self._pad_ticks(ticks, lon0 - 180 + eps, lon0 + 180 - eps)
 
         return ticks
 
     def get_view_interval(self):
         # NOTE: Proplot tries to set its *own* view intervals to avoid dateline
-        # weirdness, but if geo.extent is 'auto' the interval will be unset, so
-        # we are forced to use _get_extent().
+        # weirdness, but if rc['geo.extent'] is 'auto' the interval will be unset.
+        # In this case we use _get_extent() as a backup.
         interval = self._interval
         if interval is None:
             extent = self._get_extent()
@@ -332,12 +345,12 @@ def __init__(self, axes, latmax=90):
         self.set_major_locator(constructor.Locator(locator), default=True)
         self.set_minor_locator(mticker.AutoMinorLocator(), default=True)
 
-    def _get_sanitized_ticks(self, locator):
+    def _get_ticklocs(self, locator):
         # Adjust latitude ticks to fix bug in some projections. Harmless for basemap.
-        # NOTE: Maybe this is fixed by cartopy 0.18?
-        eps = 5e-10
-        ticks = sorted(locator())
-        if ticks:
+        # NOTE: Maybe this was fixed by cartopy 0.18?
+        eps = 1e-10
+        ticks = np.sort(locator())
+        if ticks.size:
             if ticks[0] == -90:
                 ticks[0] += eps
             if ticks[-1] == 90:
@@ -350,7 +363,7 @@ def _get_sanitized_ticks(self, locator):
 
         # Filter ticks to latmax range
         latmax = self.get_latmax()
-        ticks = [l for l in ticks if -latmax <= l <= latmax]
+        ticks = ticks[(ticks >= -latmax) & (ticks <= latmax)]
 
         return ticks
 

proplot/ticker.py

@@ -243,9 +243,11 @@ def tick_values(self, vmin, vmax):  # noqa: U100
 
 class DegreeLocator(mticker.MaxNLocator):
     """
-    Locate geographic gridlines with degree-minute-second support.
-    Adapted from cartopy.
+    Locate geographic gridlines with degree-minute-second support. Adapted from cartopy.
     """
+    # NOTE: This is identical to cartopy except they only define LongitutdeLocator
+    # for common methods whereas we use DegreeLocator. More intuitive this way in
+    # case users need degree-minute-seconds for non-specific degree axis.
     # NOTE: Locator implementation is weird AF. __init__ just calls set_params with all
     # keyword args and fills in missing params with default_params class attribute.
     # Unknown params result in warning instead of error.
@@ -280,14 +282,13 @@ def _raw_ticks(self, vmin, vmax):
         self._guess_steps(vmin, vmax)
         return super()._raw_ticks(vmin, vmax)
 
-    def bin_boundaries(self, vmin, vmax):  # matplotlib <2.2.0
-        return self._raw_ticks(vmin, vmax)  # may call Latitude/LongitudeLocator copies
+    def bin_boundaries(self, vmin, vmax):  # matplotlib < 2.2.0
+        return self._raw_ticks(vmin, vmax)  # may call Latitude/Longitude Locator copies
 
 
 class LongitudeLocator(DegreeLocator):
     """
-    Locate longitude gridlines with degree-minute-second support.
-    Adapted from cartopy.
+    Locate longitude gridlines with degree-minute-second support. Adapted from cartopy.
     """
     @docstring._snippet_manager
     def __init__(self, *args, **kwargs):
@@ -296,28 +297,10 @@ def __init__(self, *args, **kwargs):
         """
         super().__init__(*args, **kwargs)
 
-    def tick_values(self, vmin, vmax):
-        # NOTE: Proplot ensures vmin, vmax are always the *actual* longitude range
-        # accounting for central longitude position.
-        ticks = super().tick_values(vmin, vmax)
-        if np.isclose(ticks[0] + 360, ticks[-1]):
-            eps = 1e-10
-            if ticks[-1] % 360 > 0:
-                # Make sure the label appears on *right*, not on
-                # top of the leftmost label.
-                ticks[-1] -= eps
-            else:
-                # Formatter formats label as 1e-10... so there is simply no way to
-                # put label on right. Just shift this location off the map edge so
-                # parallels still extend all the way to the edge, but label disappears.
-                ticks[-1] += eps
-        return ticks
-
 
 class LatitudeLocator(DegreeLocator):
     """
-    Locate latitude gridlines with degree-minute-second support.
-    Adapted from cartopy.
+    Locate latitude gridlines with degree-minute-second support. Adapted from cartopy.
     """
     @docstring._snippet_manager
     def __init__(self, *args, **kwargs):
@@ -741,7 +724,7 @@ def __init__(self, symbol='', number=1):
         ----------
         symbol : str, default: ''
             The constant symbol, e.g. ``r'$\pi$'``.
-        number : float, default: 1`
+        number : float, default: 1
             The constant value, e.g. `numpy.pi`.
         """
         self._symbol = symbol
@@ -782,7 +765,7 @@ class _CartopyFormatter(object):
     # NOTE: Cartopy formatters pre 0.18 required axis, and *always* translated
     # input values from map projection coordinates to Plate Carrée coordinates.
     # After 0.18 you can avoid this behavior by not setting axis but really
-    # dislike that inconsistency. Solution is temporarily change projection.
+    # dislike that inconsistency. Solution is temporarily assign PlateCarre().
     def __init__(self, *args, **kwargs):
         import cartopy  # noqa: F401 (ensure available)
         super().__init__(*args, **kwargs)
@@ -797,8 +780,7 @@ def __call__(self, value, pos=None):
 
 class DegreeFormatter(_CartopyFormatter, _PlateCarreeFormatter):
     """
-    Format longitude and latitude gridline labels.
-    Adapted from cartopy.
+    Formatter for longitude and latitude gridline labels. Adapted from cartopy.
     """
     @docstring._snippet_manager
     def __init__(self, *args, **kwargs):