Add QwtDateTimeScaleDraw and QwtDateTimeScaleEngine for datetime axis support

Author: PierreRaybaut

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Version 0.14.7
 
+- Added support for `QwtDateTimeScaleDraw` and `QwtDateTimeScaleEngine` for datetime axis support (see `QwtDateTimeScaleDraw` and `QwtDateTimeScaleEngine` classes in the `qwt` module)
 - Improved font rendering for rotated text in `QwtPlainTextEngine.draw` method: disabled font hinting to avoid character misalignment in rotated text
 
 ## Version 0.14.6

qwt/__init__.py

@@ -48,8 +48,16 @@
     QwtSeriesStore,
 )
 from qwt.scale_div import QwtScaleDiv  # noqa: F401
-from qwt.scale_draw import QwtAbstractScaleDraw, QwtScaleDraw  # noqa: F401
-from qwt.scale_engine import QwtLinearScaleEngine, QwtLogScaleEngine  # noqa: F401
+from qwt.scale_draw import (  # noqa: F401
+    QwtAbstractScaleDraw,
+    QwtDateTimeScaleDraw,
+    QwtScaleDraw,
+)
+from qwt.scale_engine import (  # noqa: F401
+    QwtDateTimeScaleEngine,
+    QwtLinearScaleEngine,
+    QwtLogScaleEngine,
+)
 from qwt.scale_map import QwtScaleMap  # noqa: F401
 from qwt.symbol import QwtSymbol as QSbl  # see deprecated section
 from qwt.text import QwtText  # noqa: F401

qwt/scale_draw.py

@@ -20,6 +20,7 @@
 """
 
 import math
+from datetime import datetime
 
 from qtpy.QtCore import (
     QLineF,
@@ -1218,3 +1219,62 @@ def updateMap(self):
             sm.setPaintInterval(pos.y() + len_, pos.y())
         else:
             sm.setPaintInterval(pos.x(), pos.x() + len_)
+
+
+class QwtDateTimeScaleDraw(QwtScaleDraw):
+    """Scale draw for datetime axis
+
+    This class formats axis labels as date/time strings from Unix timestamps.
+
+    Args:
+        format: Format string for datetime display (default: "%Y-%m-%d %H:%M:%S").
+                Uses Python datetime.strftime() format codes.
+        spacing: Spacing between labels (default: 4)
+
+    Examples:
+        >>> # Create a datetime scale with default format
+        >>> scale = QwtDateTimeScaleDraw()
+
+        >>> # Create a datetime scale with custom format (time only)
+        >>> scale = QwtDateTimeScaleDraw(format="%H:%M:%S")
+
+        >>> # Create a datetime scale with date only
+        >>> scale = QwtDateTimeScaleDraw(format="%Y-%m-%d", spacing=4)
+    """
+
+    def __init__(self, format: str = "%Y-%m-%d %H:%M:%S", spacing: int = 4) -> None:
+        super().__init__()
+        self._format = format
+        self.setSpacing(spacing)
+
+    def get_format(self) -> str:
+        """Get the current datetime format string
+
+        Returns:
+            str: Format string
+        """
+        return self._format
+
+    def set_format(self, format: str) -> None:
+        """Set the datetime format string
+
+        Args:
+            format: Format string for datetime display
+        """
+        self._format = format
+
+    def label(self, value: float) -> QwtText:
+        """Convert a timestamp value to a formatted date/time label
+
+        Args:
+            value: Unix timestamp (seconds since epoch)
+
+        Returns:
+            QwtText: Formatted label
+        """
+        try:
+            dt = datetime.fromtimestamp(value)
+            return QwtText(dt.strftime(self._format))
+        except (ValueError, OSError):
+            # Handle invalid timestamps
+            return QwtText("")

qwt/scale_engine.py

@@ -906,3 +906,175 @@ def align(self, interval, stepSize):
             x2 = interval.maxValue()
 
         return qwtPowInterval(self.base(), QwtInterval(x1, x2))
+
+
+class QwtDateTimeScaleEngine(QwtLinearScaleEngine):
+    """
+    A scale engine for datetime scales that creates intelligent time-based tick intervals.
+
+    This engine calculates tick intervals that correspond to meaningful time units
+    (seconds, minutes, hours, days, weeks, months, years) rather than arbitrary
+    numerical spacing.
+    """
+
+    # Time intervals in seconds
+    TIME_INTERVALS = [
+        1,  # 1 second
+        5,  # 5 seconds
+        10,  # 10 seconds
+        15,  # 15 seconds
+        30,  # 30 seconds
+        60,  # 1 minute
+        2 * 60,  # 2 minutes
+        5 * 60,  # 5 minutes
+        10 * 60,  # 10 minutes
+        15 * 60,  # 15 minutes
+        30 * 60,  # 30 minutes
+        60 * 60,  # 1 hour
+        2 * 60 * 60,  # 2 hours
+        3 * 60 * 60,  # 3 hours
+        6 * 60 * 60,  # 6 hours
+        12 * 60 * 60,  # 12 hours
+        24 * 60 * 60,  # 1 day
+        2 * 24 * 60 * 60,  # 2 days
+        7 * 24 * 60 * 60,  # 1 week
+        2 * 7 * 24 * 60 * 60,  # 2 weeks
+        30 * 24 * 60 * 60,  # 1 month (approx)
+        3 * 30 * 24 * 60 * 60,  # 3 months (approx)
+        6 * 30 * 24 * 60 * 60,  # 6 months (approx)
+        365 * 24 * 60 * 60,  # 1 year (approx)
+    ]
+
+    def __init__(self, base=10):
+        super(QwtDateTimeScaleEngine, self).__init__(base)
+
+    def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.0):
+        """
+        Calculate a scale division for a datetime interval
+
+        :param float x1: First interval limit (Unix timestamp)
+        :param float x2: Second interval limit (Unix timestamp)
+        :param int maxMajorSteps: Maximum for the number of major steps
+        :param int maxMinorSteps: Maximum number of minor steps
+        :param float stepSize: Step size. If stepSize == 0.0, calculates intelligent datetime step
+        :return: Calculated scale division
+        """
+        interval = QwtInterval(x1, x2).normalized()
+        if interval.width() <= 0:
+            return QwtScaleDiv()
+
+        # If stepSize is provided and > 0, use parent implementation
+        if stepSize > 0.0:
+            return super(QwtDateTimeScaleEngine, self).divideScale(
+                x1, x2, maxMajorSteps, maxMinorSteps, stepSize
+            )
+
+        # Calculate intelligent datetime step size
+        duration = interval.width()  # Duration in seconds
+
+        # Find the best time interval for the given duration and max steps
+        best_step = self._find_best_time_step(duration, maxMajorSteps)
+
+        # Use the calculated datetime step
+        scaleDiv = QwtScaleDiv()
+        if best_step > 0.0:
+            ticks = self.buildTicks(interval, best_step, maxMinorSteps)
+            scaleDiv = QwtScaleDiv(interval, ticks)
+
+        if x1 > x2:
+            scaleDiv.invert()
+
+        return scaleDiv
+
+    def _find_best_time_step(self, duration, max_steps):
+        """
+        Find the best time interval step for the given duration and maximum steps.
+
+        :param float duration: Total duration in seconds
+        :param int max_steps: Maximum number of major ticks
+        :return: Best step size in seconds
+        """
+        if max_steps < 1:
+            max_steps = 1
+
+        # Calculate the target step size
+        target_step = duration / max_steps
+
+        # Find the time interval that is closest to our target
+        best_step = self.TIME_INTERVALS[0]
+        min_error = abs(target_step - best_step)
+
+        for interval in self.TIME_INTERVALS:
+            error = abs(target_step - interval)
+            if error < min_error:
+                min_error = error
+                best_step = interval
+            # If the interval is getting much larger than target, stop
+            elif interval > target_step * 2:
+                break
+
+        return float(best_step)
+
+    def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
+        """
+        Calculate minor ticks for datetime intervals
+
+        :param list ticks: List of tick arrays
+        :param int maxMinorSteps: Maximum number of minor steps
+        :param float stepSize: Major tick step size
+        """
+        if maxMinorSteps < 1:
+            return
+
+        # For datetime, create intelligent minor tick intervals
+        minor_step = self._get_minor_step(stepSize, maxMinorSteps)
+
+        if minor_step <= 0:
+            return
+
+        major_ticks = ticks[QwtScaleDiv.MajorTick]
+        if len(major_ticks) < 2:
+            return
+
+        minor_ticks = []
+
+        # Generate minor ticks between each pair of major ticks
+        for i in range(len(major_ticks) - 1):
+            start = major_ticks[i]
+            end = major_ticks[i + 1]
+
+            # Add minor ticks between start and end
+            current = start + minor_step
+            while current < end:
+                minor_ticks.append(current)
+                current += minor_step
+
+        ticks[QwtScaleDiv.MinorTick] = minor_ticks
+
+    def _get_minor_step(self, major_step, max_minor_steps):
+        """
+        Calculate appropriate minor tick step size for datetime intervals
+
+        :param float major_step: Major tick step size in seconds
+        :param int max_minor_steps: Maximum number of minor steps
+        :return: Minor tick step size in seconds
+        """
+        # Define sensible minor tick divisions for different time scales
+        if major_step >= 365 * 24 * 60 * 60:  # 1 year or more
+            return 30 * 24 * 60 * 60  # 1 month
+        elif major_step >= 30 * 24 * 60 * 60:  # 1 month or more
+            return 7 * 24 * 60 * 60  # 1 week
+        elif major_step >= 7 * 24 * 60 * 60:  # 1 week or more
+            return 24 * 60 * 60  # 1 day
+        elif major_step >= 24 * 60 * 60:  # 1 day or more
+            return 6 * 60 * 60  # 6 hours
+        elif major_step >= 60 * 60:  # 1 hour or more
+            return 15 * 60  # 15 minutes
+        elif major_step >= 10 * 60:  # 10 minutes or more
+            return 2 * 60  # 2 minutes
+        elif major_step >= 60:  # 1 minute or more
+            return 15  # 15 seconds
+        elif major_step >= 10:  # 10 seconds or more
+            return 2  # 2 seconds
+        else:  # Less than 10 seconds
+            return major_step / max(max_minor_steps, 2)