Move major/minor tick overstrike logic to Axis.

anntzer · anntzer · commit 35c95de78218 · 2019-01-29T12:10:20.000+01:00
The Axis knows what the major and the minor ticker are so it makes sense
to let it handle the deduplication logic.

Revert some heuristic deduplication logic from the Locators themselves
(which effectively tests that the new code works).
diff --git a/doc/api/next_api_changes/2018-01-30-AL.rst b/doc/api/next_api_changes/2018-01-30-AL.rst
@@ -0,0 +1,10 @@
+Minor Locator no longer try to avoid overstriking major Locators
+````````````````````````````````````````````````````````````````
+
+Previously, various locator classes contained custom logic to detect whether
+they are used as minor locators, and, if so, attempted to avoid emitting tick
+locations that collided with major ticks.
+
+This logic has now moved to the Axis class; thus, for example,
+``xaxis.minor.locator()`` now includes positions that collide with
+``xaxis.major.locator()``, but ``xaxis.get_minorticklocs()`` does not.
diff --git a/lib/matplotlib/axis.py b/lib/matplotlib/axis.py
@@ -930,16 +930,25 @@ def iter_ticks(self):
         Iterate through all of the major and minor ticks.
         """
         major_locs = self.major.locator()
-        major_ticks = self.get_major_ticks(len(major_locs))
         self.major.formatter.set_locs(major_locs)
         major_labels = self.major.formatter.format_ticks(major_locs)
-
-        minor_locs = self.minor.locator()
-        minor_ticks = self.get_minor_ticks(len(minor_locs))
+        major_ticks = self.get_major_ticks(len(major_locs))
+        yield from zip(major_ticks, major_locs, major_labels)
+        # Remove minor ticks duplicating major ticks; use the range of major
+        # tick values to set the scale.  1e-5 is the default rtol for isclose.
+        # If there are no major_locs, tol doesn't matter.
+        # Ideally, we would like to apply e.g. ax.get_xaxis_transform() to
+        # the tick locs and decide based on screen-space proximity, but as
+        # of now the axis object doesn't know whether it is associated with
+        # ax.get_xaxis_transform(), ax.get_yaxis_transform(), or something
+        # else.
+        tol = np.abs(major_locs).ptp() * 1e-5 if len(major_locs) else 0
+        minor_locs = [
+            loc for loc in self.minor.locator()
+            if not np.isclose(loc, major_locs, atol=tol, rtol=0).any()]
         self.minor.formatter.set_locs(minor_locs)
         minor_labels = self.minor.formatter.format_ticks(minor_locs)
-
-        yield from zip(major_ticks, major_locs, major_labels)
+        minor_ticks = self.get_minor_ticks(len(minor_locs))
         yield from zip(minor_ticks, minor_locs, minor_labels)
 
     def get_ticklabel_extents(self, renderer):
@@ -1220,18 +1229,23 @@ def get_ticklines(self, minor=False):
         return self.get_majorticklines()
 
     def get_majorticklocs(self):
-        "Get the major tick locations in data coordinates as a numpy array"
+        "Get the major tick locations in data coordinates as a numpy array."
         return self.major.locator()
 
     def get_minorticklocs(self):
-        "Get the minor tick locations in data coordinates as a numpy array"
-        return self.minor.locator()
+        "Get the minor tick locations in data coordinates as a numpy array."
+        # See rationale for tol in iter_ticks (which does not reuse this
+        # implementation to avoid calling the major locator twice).
+        major_locs = self.major.locator()
+        tol = np.abs(major_locs).ptp() * 1e-5 if major_locs.size else 0
+        minor_locs = [
+            loc for loc in self.minor.locator()
+            if not np.isclose(loc, major_locs, atol=tol, rtol=0).any()]
+        return minor_locs
 
     def get_ticklocs(self, minor=False):
-        "Get the tick locations in data coordinates as a numpy array"
-        if minor:
-            return self.minor.locator()
-        return self.major.locator()
+        "Get the tick locations in data coordinates as a numpy array."
+        return self.get_minorticklocs() if minor else self.get_majorticklocs()
 
     def get_ticks_direction(self, minor=False):
         """
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -2258,13 +2258,9 @@ def tick_values(self, vmin, vmax):
             # If we're a minor locator *that expects at least two ticks per
             # decade* and the major locator stride is 1 and there's no more
             # than one minor tick, switch to AutoLocator.
-            ticklocs = AutoLocator().tick_values(vmin, vmax)
-            # Don't overstrike the major labels.  Assumes major locs are
-            # at b = self._base
-            ticklocs = ticklocs[
-                ~is_close_to_int(np.log(ticklocs) / np.log(b))]
-            return ticklocs
-        return self.raise_if_exceeds(ticklocs)
+            return AutoLocator().tick_values(vmin, vmax)
+        else:
+            return self.raise_if_exceeds(ticklocs)
 
     def view_limits(self, vmin, vmax):
         'Try to choose the view limits intelligently'
@@ -2643,10 +2639,6 @@ def __call__(self):
         tmin = ((vmin - t0) // minorstep + 1) * minorstep
         tmax = ((vmax - t0) // minorstep + 1) * minorstep
         locs = np.arange(tmin, tmax, minorstep) + t0
-        mod = np.abs((locs - t0) % majorstep)
-        cond1 = mod > minorstep / 10.0
-        cond2 = ~np.isclose(mod, majorstep, atol=0)
-        locs = locs.compress(cond1 & cond2)
 
         return self.raise_if_exceeds(np.array(locs))
 
