Merge pull request #4007 from t20100/plot-update-mpl-tick-formatter

silx.gui.plot.PlotWidget: Updated plot axes tick labels behavior

Author: vallsv

src/silx/gui/plot/backends/BackendMatplotlib.py

@@ -44,7 +44,11 @@
 from ... import qt
 
 # First of all init matplotlib and set its backend
-from ...utils.matplotlib import FigureCanvasQTAgg, qFontToFontProperties
+from ...utils.matplotlib import (
+    DefaultTickFormatter,
+    FigureCanvasQTAgg,
+    qFontToFontProperties,
+)
 import matplotlib
 from matplotlib.container import Container
 from matplotlib.figure import Figure
@@ -54,7 +58,7 @@
 from matplotlib.lines import Line2D
 from matplotlib.text import Text
 from matplotlib.collections import PathCollection, LineCollection
-from matplotlib.ticker import Formatter, ScalarFormatter, Locator
+from matplotlib.ticker import Formatter, Locator
 from matplotlib.tri import Triangulation
 from matplotlib.collections import TriMesh
 from matplotlib import path as mpath
@@ -544,21 +548,9 @@ def __init__(self, plot, parent=None):
         # Set axis zorder=0.5 so grid is displayed at 0.5
         self.ax.set_axisbelow(True)
 
-        # disable the use of offsets
-        try:
-            axes = [
-                self.ax.get_yaxis().get_major_formatter(),
-                self.ax.get_xaxis().get_major_formatter(),
-                self.ax2.get_yaxis().get_major_formatter(),
-                self.ax2.get_xaxis().get_major_formatter(),
-            ]
-            for axis in axes:
-                axis.set_useOffset(False)
-                axis.set_scientific(False)
-        except:
-            _logger.warning(
-                "Cannot disabled axes offsets in %s " % matplotlib.__version__
-            )
+        # Configure axes tick label formatter
+        for axis in (self.ax.yaxis, self.ax.xaxis, self.ax2.yaxis, self.ax2.xaxis):
+            axis.set_major_formatter(DefaultTickFormatter())
 
         self.ax2.set_autoscaley_on(True)
 
@@ -1263,6 +1255,23 @@ def setGraphYLimits(self, ymin, ymax, axis):
 
     # Graph axes
 
+    def __initXAxisFormatterAndLocator(self):
+        if self.ax.xaxis.get_scale() != "linear":
+            return  # Do not override formatter and locator
+
+        if not self.isXAxisTimeSeries():
+            self.ax.xaxis.set_major_formatter(DefaultTickFormatter())
+            return
+
+        # We can't use a matplotlib.dates.DateFormatter because it expects
+        # the data to be in datetimes. Silx works internally with
+        # timestamps (floats).
+        locator = NiceDateLocator(tz=self.getXAxisTimeZone())
+        self.ax.xaxis.set_major_locator(locator)
+        self.ax.xaxis.set_major_formatter(
+            NiceAutoDateFormatter(locator, tz=self.getXAxisTimeZone())
+        )
+
     def setXAxisTimeZone(self, tz):
         super(BackendMatplotlib, self).setXAxisTimeZone(tz)
 
@@ -1274,24 +1283,7 @@ def isXAxisTimeSeries(self):
 
     def setXAxisTimeSeries(self, isTimeSeries):
         self._isXAxisTimeSeries = isTimeSeries
-        if self._isXAxisTimeSeries:
-            # We can't use a matplotlib.dates.DateFormatter because it expects
-            # the data to be in datetimes. Silx works internally with
-            # timestamps (floats).
-            locator = NiceDateLocator(tz=self.getXAxisTimeZone())
-            self.ax.xaxis.set_major_locator(locator)
-            self.ax.xaxis.set_major_formatter(
-                NiceAutoDateFormatter(locator, tz=self.getXAxisTimeZone())
-            )
-        else:
-            try:
-                scalarFormatter = ScalarFormatter(useOffset=False)
-            except:
-                _logger.warning(
-                    "Cannot disabled axes offsets in %s " % matplotlib.__version__
-                )
-                scalarFormatter = ScalarFormatter()
-            self.ax.xaxis.set_major_formatter(scalarFormatter)
+        self.__initXAxisFormatterAndLocator()
 
     def setXAxisLogarithmic(self, flag):
         # Workaround for matplotlib 2.1.0 when one tries to set an axis
@@ -1303,8 +1295,10 @@ def setXAxisLogarithmic(self, flag):
                 self.ax.set_xlim(1, 10)
                 self.draw()
 
-        self.ax2.set_xscale("log" if flag else "linear")
-        self.ax.set_xscale("log" if flag else "linear")
+        xscale = "log" if flag else "linear"
+        self.ax2.set_xscale(xscale)
+        self.ax.set_xscale(xscale)
+        self.__initXAxisFormatterAndLocator()
 
     def setYAxisLogarithmic(self, flag):
         # Workaround for matplotlib 2.0 issue with negative bounds
@@ -1322,8 +1316,15 @@ def setYAxisLogarithmic(self, flag):
             if redraw:
                 self.draw()
 
-        self.ax2.set_yscale("log" if flag else "linear")
-        self.ax.set_yscale("log" if flag else "linear")
+        if flag:
+            self.ax2.set_yscale("log")
+            self.ax.set_yscale("log")
+            return
+
+        self.ax2.set_yscale("linear")
+        self.ax2.yaxis.set_major_formatter(DefaultTickFormatter())
+        self.ax.set_yscale("linear")
+        self.ax.yaxis.set_major_formatter(DefaultTickFormatter())
 
     def setYAxisInverted(self, flag):
         if self.ax.yaxis_inverted() != bool(flag):

src/silx/gui/plot/backends/glutils/GLPlotFrame.py

@@ -46,6 +46,7 @@
 
 from .... import qt
 from ...._glutils import gl, Program
+from ....utils.matplotlib import DefaultTickFormatter
 from ..._utils import checkAxisLimits, FLOAT32_MINPOS
 from .GLSupport import mat4Ortho
 from .GLText import Text2D, CENTER, BOTTOM, TOP, LEFT, RIGHT, ROTATE_270
@@ -78,10 +79,14 @@ def __init__(
         labelVAlign=CENTER,
         titleAlign=CENTER,
         titleVAlign=CENTER,
+        orderOffsetAlign=CENTER,
+        orderOffsetVAlign=CENTER,
         titleRotate=0,
         titleOffset=(0.0, 0.0),
     ):
+        self._tickFormatter = DefaultTickFormatter()
         self._ticks = None
+        self._orderAndOffsetText = ""
 
         self._plotFrameRef = weakref.ref(plotFrame)
 
@@ -96,6 +101,9 @@ def __init__(
         self._foregroundColor = foregroundColor
         self._labelAlign = labelAlign
         self._labelVAlign = labelVAlign
+        self._orderOffetAnchor = (1.0, 0.0)
+        self._orderOffsetAlign = orderOffsetAlign
+        self._orderOffsetVAlign = orderOffsetVAlign
         self._titleAlign = titleAlign
         self._titleVAlign = titleVAlign
         self._titleRotate = titleRotate
@@ -193,6 +201,17 @@ def title(self, title):
             self._title = title
             self._dirtyPlotFrame()
 
+    @property
+    def orderOffetAnchor(self) -> tuple[float, float]:
+        """Anchor position for the tick order&offset text"""
+        return self._orderOffetAnchor
+
+    @orderOffetAnchor.setter
+    def orderOffetAnchor(self, position: tuple[float, float]):
+        if position != self._orderOffetAnchor:
+            self._orderOffetAnchor = position
+            self._dirtyTicks()
+
     @property
     def titleOffset(self):
         """Title offset in pixels (x: int, y: int)"""
@@ -296,6 +315,20 @@ def getVerticesAndLabels(self):
         )
         labels.append(axisTitle)
 
+        if self._orderAndOffsetText:
+            xOrderOffset, yOrderOffet = self.orderOffetAnchor
+            labels.append(
+                Text2D(
+                    text=self._orderAndOffsetText,
+                    font=font,
+                    color=self._foregroundColor,
+                    x=xOrderOffset,
+                    y=yOrderOffet,
+                    align=self._orderOffsetAlign,
+                    valign=self._orderOffsetVAlign,
+                    devicePixelRatio=self.devicePixelRatio,
+                )
+            )
         return vertices, labels
 
     def _dirtyPlotFrame(self):
@@ -320,6 +353,8 @@ def _ticksGenerator(self):
         """Generator of ticks as tuples:
         ((x, y) in display, dataPos, textLabel).
         """
+        self._orderAndOffsetText = ""
+
         dataMin, dataMax = self.dataRange
         if self.isLog and dataMin <= 0.0:
             _logger.warning("Getting ticks while isLog=True and dataRange[0]<=0.")
@@ -373,20 +408,25 @@ def _ticksGenerator(self):
                 tickDensity = 1.3 * self.devicePixelRatio / self.dotsPerInch
 
                 if not self.isTimeSeries:
-                    tickMin, tickMax, step, nbFrac = niceNumbersAdaptative(
+                    tickMin, tickMax, step, _ = niceNumbersAdaptative(
                         dataMin, dataMax, nbPixels, tickDensity
                     )
 
-                    for dataPos in self._frange(tickMin, tickMax, step):
-                        if dataMin <= dataPos <= dataMax:
-                            xPixel = x0 + (dataPos - dataMin) * xScale
-                            yPixel = y0 + (dataPos - dataMin) * yScale
+                    visibleTickPositions = [
+                        pos
+                        for pos in self._frange(tickMin, tickMax, step)
+                        if dataMin <= pos <= dataMax
+                    ]
+                    self._tickFormatter.axis.set_view_interval(dataMin, dataMax)
+                    self._tickFormatter.axis.set_data_interval(dataMin, dataMax)
+                    texts = self._tickFormatter.format_ticks(visibleTickPositions)
+                    self._orderAndOffsetText = self._tickFormatter.get_offset()
+
+                    for dataPos, text in zip(visibleTickPositions, texts):
+                        xPixel = x0 + (dataPos - dataMin) * xScale
+                        yPixel = y0 + (dataPos - dataMin) * yScale
+                        yield ((xPixel, yPixel), dataPos, text)
 
-                            if nbFrac == 0:
-                                text = "%g" % dataPos
-                            else:
-                                text = ("%." + str(nbFrac) + "f") % dataPos
-                            yield ((xPixel, yPixel), dataPos, text)
                 else:
                     # Time series
                     try:
@@ -795,6 +835,8 @@ def __init__(self, marginRatios, foregroundColor, gridColor):
                 foregroundColor=self._foregroundColor,
                 labelAlign=CENTER,
                 labelVAlign=TOP,
+                orderOffsetAlign=RIGHT,
+                orderOffsetVAlign=TOP,
                 titleAlign=CENTER,
                 titleVAlign=TOP,
                 titleRotate=0,
@@ -810,6 +852,8 @@ def __init__(self, marginRatios, foregroundColor, gridColor):
                 foregroundColor=self._foregroundColor,
                 labelAlign=RIGHT,
                 labelVAlign=CENTER,
+                orderOffsetAlign=LEFT,
+                orderOffsetVAlign=BOTTOM,
                 titleAlign=CENTER,
                 titleVAlign=BOTTOM,
                 titleRotate=ROTATE_270,
@@ -822,6 +866,8 @@ def __init__(self, marginRatios, foregroundColor, gridColor):
             foregroundColor=self._foregroundColor,
             labelAlign=LEFT,
             labelVAlign=CENTER,
+            orderOffsetAlign=RIGHT,
+            orderOffsetVAlign=BOTTOM,
             titleAlign=CENTER,
             titleVAlign=TOP,
             titleRotate=ROTATE_270,
@@ -1281,6 +1327,25 @@ def _buildVerticesAndLabels(self):
 
         self._x2AxisCoords = ((xCoords[0], yCoords[1]), (xCoords[1], yCoords[1]))
 
+        # Set order&offset anchor **before** handling Y axis inversion
+        font = qt.QApplication.instance().font()
+        fontPixelSize = font.pixelSize()
+        if fontPixelSize == -1:
+            fontPixelSize = font.pointSizeF() / 72.0 * self.dotsPerInch
+
+        self.axes[0].orderOffetAnchor = (
+            xCoords[1],
+            yCoords[0] + fontPixelSize * 1.2,
+        )
+        self.axes[1].orderOffetAnchor = (
+            xCoords[0],
+            yCoords[1] - 4 * self.devicePixelRatio,
+        )
+        self._y2Axis.orderOffetAnchor = (
+            xCoords[1],
+            yCoords[1] - 4 * self.devicePixelRatio,
+        )
+
         if self.isYAxisInverted:
             # Y axes are inverted, axes coordinates are inverted
             yCoords = yCoords[1], yCoords[0]

src/silx/gui/utils/matplotlib.py

@@ -54,7 +54,26 @@
 
 from matplotlib.font_manager import FontProperties
 from matplotlib.mathtext import MathTextParser
-from matplotlib import figure
+from matplotlib.ticker import ScalarFormatter as _ScalarFormatter
+from matplotlib import figure, font_manager
+from packaging.version import Version
+
+_MATPLOTLIB_VERSION = Version(matplotlib.__version__)
+
+
+class DefaultTickFormatter(_ScalarFormatter):
+    """Tick label formatter"""
+
+    def __init__(self):
+        super().__init__(useOffset=True, useMathText=True)
+        self.set_scientific(True)
+        self.create_dummy_axis()
+
+    if _MATPLOTLIB_VERSION < Version("3.1.0"):
+
+        def format_ticks(self, values):
+            self.set_locs(values)
+            return [self(value, i) for i, value in enumerate(values)]
 
 
 _FONT_STYLES = {
@@ -67,8 +86,15 @@
 def qFontToFontProperties(font: qt.QFont):
     """Convert a QFont to a matplotlib FontProperties"""
     weightFactor = 10 if qt.BINDING == "PyQt5" else 1
+    families = [font.family(), font.defaultFamily()]
+    if _MATPLOTLIB_VERSION >= Version("3.6.0"):
+        # Prevent 'Font family not found warnings'
+        availableNames = font_manager.get_font_names()
+        families = [f for f in families if f in availableNames]
+        families.append(font_manager.fontManager.defaultFamily["ttf"])
+
     return FontProperties(
-        family=[font.family(), font.defaultFamily()],
+        family=families,
         style=_FONT_STYLES[font.style()],
         weight=weightFactor * font.weight(),
         size=font.pointSizeF(),