FIX: remove along-pixel logic; not needed

jklymak · jklymak · commit c9a8f222dd74 · 2018-09-14T14:01:25.000-07:00
diff --git a/lib/matplotlib/axis.py b/lib/matplotlib/axis.py
@@ -1052,50 +1052,8 @@ def _update_ticks(self, renderer):
                     ihigh = locs[-1]
             tick_tups = [ti for ti in tick_tups if ilow <= ti[1] <= ihigh]
 
-        # so that we don't lose ticks on the end, expand out the interval ever
-        # so slightly.  The "ever so slightly" is defined to be the width of a
-        # half of a pixel.  We don't want to draw a tick that even one pixel
-        # outside of the defined axis interval.
-        if interval[0] <= interval[1]:
-            interval_expanded = interval
-        else:
-            interval_expanded = interval[1], interval[0]
-
-        if hasattr(self, '_get_pixel_distance_along_axis'):
-            # normally, one does not want to catch all exceptions that
-            # could possibly happen, but it is not clear exactly what
-            # exceptions might arise from a user's projection (their
-            # rendition of the Axis object).  So, we catch all, with
-            # the idea that one would rather potentially lose a tick
-            # from one side of the axis or another, rather than see a
-            # stack trace.
-            # We also catch users warnings here. These are the result of
-            # invalid numpy calculations that may be the result of out of
-            # bounds on axis with finite allowed intervals such as geo
-            # projections i.e. Mollweide.
-            with np.errstate(invalid='ignore'):
-                try:
-                    ds1 = self._get_pixel_distance_along_axis(
-                        interval_expanded[0], -0.5)
-                except Exception:
-                    warnings.warn("Unable to find pixel distance along axis "
-                                  "for interval padding of ticks; assuming no "
-                                  "interval padding needed.")
-                    ds1 = 0.0
-                if np.isnan(ds1):
-                    ds1 = 0.0
-                try:
-                    ds2 = self._get_pixel_distance_along_axis(
-                        interval_expanded[1], +0.5)
-                except Exception:
-                    warnings.warn("Unable to find pixel distance along axis "
-                                  "for interval padding of ticks; assuming no "
-                                  "interval padding needed.")
-                    ds2 = 0.0
-                if np.isnan(ds2):
-                    ds2 = 0.0
-            interval_expanded = (interval_expanded[0] - ds1,
-                                 interval_expanded[1] + ds2)
+        if interval[1] <= interval[0]:
+            interval = interval[1], interval[0]
 
         ticks_to_draw = []
         for tick, loc, label in tick_tups:
@@ -1105,7 +1063,7 @@ def _update_ticks(self, renderer):
             tick.update_position(loc)
             tick.set_label1(label)
             tick.set_label2(label)
-            if not mtransforms.interval_contains(interval_expanded, loc):
+            if not mtransforms.interval_contains(interval, loc):
                 continue
             ticks_to_draw.append(tick)
 
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
@@ -2892,7 +2892,7 @@ def nonsingular(vmin, vmax, expander=0.001, tiny=1e-15, increasing=True):
     return vmin, vmax
 
 
-def interval_contains(interval, val):
+def interval_contains(interval, val, rtol=1e-10):
     """
     Check, inclusively, whether an interval includes a given value.
 
@@ -2902,14 +2902,18 @@ def interval_contains(interval, val):
         A 2-length sequence, endpoints that define the interval.
     val : scalar
         Value to check is within interval.
+    rtol : float
+        Floating point tolerance relatice to b-a. So tol = (b - a) * rtol, and
+        return True if a - tol <= val <= b + tol (for b>a).
 
     Returns
     -------
     bool
         Returns true if given val is within the interval.
     """
     a, b = interval
-    return a <= val <= b or a >= val >= b
+    rtol = np.abs(b - a) * rtol
+    return a - rtol <= val <= b + rtol or a + rtol >= val >= b - rtol
 
 
 def interval_contains_open(interval, val):
