scale_map.py

# -*- coding: utf-8 -*-
#
# Licensed under the terms of the Qwt License
# Copyright (c) 2002 Uwe Rathmann, for the original C++ code
# Copyright (c) 2015 Pierre Raybaut, for the Python translation/optimization
# (see LICENSE file for more details)

"""
QwtScaleMap
-----------

.. autoclass:: QwtScaleMap
   :members:
"""

from qtpy.QtCore import QPointF, QRectF

from qwt._math import qwtFuzzyCompare


class QwtScaleMap(object):
    """
    A scale map

    `QwtScaleMap` offers transformations from the coordinate system
    of a scale into the linear coordinate system of a paint device
    and vice versa.

    The scale and paint device intervals are both set to [0,1].

    .. py:class:: QwtScaleMap([other=None])

        Constructor (eventually, copy constructor)

        :param qwt.scale_map.QwtScaleMap other: Other scale map

    .. py:class:: QwtScaleMap(p1, p2, s1, s2)
        :noindex:

        Constructor (was provided by `PyQwt` but not by `Qwt`)

        :param int p1: First border of the paint interval
        :param int p2: Second border of the paint interval
        :param float s1: First border of the scale interval
        :param float s2: Second border of the scale interval
    """

    def __init__(self, *args):
        self.__transform = None  # QwtTransform
        self.__s1 = 0.0
        self.__s2 = 1.0
        self.__p1 = 0.0
        self.__p2 = 1.0
        other = None
        if len(args) == 1:
            (other,) = args
        elif len(args) == 4:
            p1, p2, s1, s2 = args
            self.__s1 = s1
            self.__s2 = s2
            self.__p1 = p1
            self.__p2 = p2
        elif len(args) != 0:
            raise TypeError(
                "%s() takes 0, 1, or 4 argument(s) (%s given)"
                % (self.__class__.__name__, len(args))
            )
        if other is None:
            self.__cnv = 1.0
            self.__ts1 = 0.0
        else:
            self.__s1 = other.__s1
            self.__s2 = other.__s2
            self.__p1 = other.__p1
            self.__p2 = other.__p2
            self.__cnv = other.__cnv
            self.__ts1 = other.__ts1
            if other.__transform:
                self.__transform = other.__transform.copy()

    def __eq__(self, other):
        return (
            self.__s1 == other.__s1
            and self.__s2 == other.__s2
            and self.__p1 == other.__p1
            and self.__p2 == other.__p2
            and self.__cnv == other.__cnv
            and self.__ts1 == other.__ts1
        )

    def s1(self):
        """
        :return: First border of the scale interval
        """
        return self.__s1

    def s2(self):
        """
        :return: Second border of the scale interval
        """
        return self.__s2

    def p1(self):
        """
        :return: First border of the paint interval
        """
        return self.__p1

    def p2(self):
        """
        :return: Second border of the paint interval
        """
        return self.__p2

    def pDist(self):
        """
        :return: `abs(p2() - p1())`
        """
        return abs(self.__p2 - self.__p1)

    def sDist(self):
        """
        :return: `abs(s2() - s1())`
        """
        return abs(self.__s2 - self.__s1)

    def transform_scalar(self, s):
        """
        Transform a point related to the scale interval into an point
        related to the interval of the paint device

        :param float s: Value relative to the coordinates of the scale
        :return: Transformed value

        .. seealso::

            :py:meth:`invTransform_scalar()`
        """
        if self.__transform:
            s = self.__transform.transform(s)
        return self.__p1 + (s - self.__ts1) * self.__cnv

    def invTransform_scalar(self, p):
        """
        Transform an paint device value into a value in the
        interval of the scale.

        :param float p: Value relative to the coordinates of the paint device
        :return: Transformed value

        .. seealso::

            :py:meth:`transform_scalar()`
        """
        if self.__cnv == 0:
            s = self.__ts1  # avoid divide by zero
        else:
            s = self.__ts1 + (p - self.__p1) / self.__cnv
        if self.__transform:
            s = self.__transform.invTransform(s)
        return s

    def isInverting(self):
        """
        :return: True, when ( p1() < p2() ) != ( s1() < s2() )
        """
        return (self.__p1 < self.__p2) != (self.__s1 < self.__s2)

    def setTransformation(self, transform):
        """
        Initialize the map with a transformation

        :param qwt.transform.QwtTransform transform: Transformation
        """
        if self.__transform != transform:
            self.__transform = transform
        self.setScaleInterval(self.__s1, self.__s2)

    def transformation(self):
        """
        :return: the transformation
        """
        return self.__transform

    def setScaleInterval(self, s1, s2):
        """
        Specify the borders of the scale interval

        :param float s1: first border
        :param float s2: second border

        .. warning::

            Scales might be aligned to transformation depending boundaries
        """
        self.__s1 = s1
        self.__s2 = s2
        if self.__transform:
            self.__s1 = self.__transform.bounded(self.__s1)
            self.__s2 = self.__transform.bounded(self.__s2)
        self.updateFactor()

    def setPaintInterval(self, p1, p2):
        """
        Specify the borders of the paint device interval

        :param float p1: first border
        :param float p2: second border
        """
        self.__p1 = p1
        self.__p2 = p2
        self.updateFactor()

    def updateFactor(self):
        self.__ts1 = self.__s1
        ts2 = self.__s2
        if self.__transform:
            self.__ts1 = self.__transform.transform(self.__ts1)
            ts2 = self.__transform.transform(ts2)
        if self.__ts1 == ts2:
            # Degenerate scale: collapse every value to ``p1`` (matches the
            # symmetric guard in ``invTransform_scalar`` and the C++ Qwt
            # behaviour).
            self.__cnv = 0.0
        else:
            self.__cnv = (self.__p2 - self.__p1) / (ts2 - self.__ts1)

    def transform(self, *args):
        """
        Transform a rectangle from scale to paint coordinates.

        Transfom a scalar:

        :param float scalar: Scalar

        Transfom a rectangle:

        :param qwt.scale_map.QwtScaleMap xMap: X map
        :param qwt.scale_map.QwtScaleMap yMap: Y map
        :param QRectF rect: Rectangle in paint coordinates

        Transfom a point:

        :param qwt.scale_map.QwtScaleMap xMap: X map
        :param qwt.scale_map.QwtScaleMap yMap: Y map
        :param QPointF pos: Position in scale coordinates

        .. seealso::

            :py:meth:`invTransform()`
        """
        nargs = len(args)
        if nargs == 1:
            # Scalar transform: inline the fast path for the dominant case
            # (avoids one Python call frame per tick label).
            s = args[0]
            if self.__transform:
                s = self.__transform.transform(s)
            return self.__p1 + (s - self.__ts1) * self.__cnv
        elif nargs == 3 and isinstance(args[2], QPointF):
            xMap, yMap, pos = args
            return QPointF(xMap.transform(pos.x()), yMap.transform(pos.y()))
        elif nargs == 3 and isinstance(args[2], QRectF):
            xMap, yMap, rect = args
            x1 = xMap.transform(rect.left())
            x2 = xMap.transform(rect.right())
            y1 = yMap.transform(rect.top())
            y2 = yMap.transform(rect.bottom())
            if x2 < x1:
                x1, x2 = x2, x1
            if y2 < y1:
                y1, y2 = y2, y1
            if qwtFuzzyCompare(x1, 0.0, x2 - x1) == 0:
                x1 = 0.0
            if qwtFuzzyCompare(x2, 0.0, x2 - x1) == 0:
                x2 = 0.0
            if qwtFuzzyCompare(y1, 0.0, y2 - y1) == 0:
                y1 = 0.0
            if qwtFuzzyCompare(y2, 0.0, y2 - y1) == 0:
                y2 = 0.0
            return QRectF(x1, y1, x2 - x1, y2 - y1)
        else:
            raise TypeError(
                "%s().transform() takes 1 or 3 argument(s) (%s "
                "given)" % (self.__class__.__name__, len(args))
            )

    def invTransform(self, *args):
        """Transform from paint to scale coordinates

        Scalar: scalemap.invTransform(scalar)
        Point (QPointF): scalemap.invTransform(xMap, yMap, pos)
        Rectangle (QRectF): scalemap.invTransform(xMap, yMap, rect)
        """
        if len(args) == 1:
            # Scalar transform
            return self.invTransform_scalar(args[0])
        elif isinstance(args[2], QPointF):
            xMap, yMap, pos = args
            return QPointF(xMap.invTransform(pos.x()), yMap.invTransform(pos.y()))
        elif isinstance(args[2], QRectF):
            xMap, yMap, rect = args
            x1 = xMap.invTransform(rect.left())
            x2 = xMap.invTransform(rect.right())
            y1 = yMap.invTransform(rect.top())
            y2 = yMap.invTransform(rect.bottom())
            r = QRectF(x1, y1, x2 - x1, y2 - y1)
            return r.normalized()