# Source code for qwt.plot_series

    # -*- 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)

    """
    Plotting series item
    --------------------

    QwtPlotSeriesItem
    ~~~~~~~~~~~~~~~~~

    .. autoclass:: QwtPlotSeriesItem
       :members:

    QwtSeriesData
    ~~~~~~~~~~~~~

    .. autoclass:: QwtSeriesData
       :members:

    QwtPointArrayData
    ~~~~~~~~~~~~~~~~~

    .. autoclass:: QwtPointArrayData
       :members:

    QwtSeriesStore
    ~~~~~~~~~~~~~~

    .. autoclass:: QwtSeriesStore
       :members:
    """

    import numpy as np

    from qwt.plot import QwtPlotItem, QwtPlotItem_PrivateData
    from qwt.text import QwtText

    from qwt.qt.QtCore import Qt, QRectF, QPointF

    class QwtPlotSeriesItem_PrivateData(QwtPlotItem_PrivateData):
        def __init__(self):
            QwtPlotItem_PrivateData.__init__(self)
            self.orientation = Qt.Horizontal

    class QwtPlotSeriesItem(QwtPlotItem):
        """
        Base class for plot items representing a series of samples
        """
        def __init__(self, title):
            if not isinstance(title, QwtText):
                title = QwtText(title)
            QwtPlotItem.__init__(self, title)
            self.__data = QwtPlotSeriesItem_PrivateData()

        def setOrientation(self, orientation):
            """
            Set the orientation of the item. Default is `Qt.Horizontal`.

            The `orientation()` might be used in specific way by a plot item.
            F.e. a QwtPlotCurve uses it to identify how to display the curve
            int `QwtPlotCurve.Steps` or `QwtPlotCurve.Sticks` style.

            .. seealso::

                :py:meth`orientation()`
            """
            if self.__data.orientation != orientation:
                self.__data.orientation = orientation
                self.legendChanged()
                self.itemChanged()

        def orientation(self):
            """
            :return: Orientation of the plot item

            .. seealso::

                :py:meth`setOrientation()`
            """
            return self.__data.orientation

        def draw(self, painter, xMap, yMap, canvasRect):
            """
            Draw the complete series

            :param QPainter painter: Painter
            :param qwt.scale_map.QwtScaleMap xMap: Maps x-values into pixel coordinates.
            :param qwt.scale_map.QwtScaleMap yMap: Maps y-values into pixel coordinates.
            :param QRectF canvasRect: Contents rectangle of the canvas
            """
            self.drawSeries(painter, xMap, yMap, canvasRect, 0, -1)

        def boundingRect(self):
            return self.dataRect()

        def updateScaleDiv(self, xScaleDiv, yScaleDiv):
            rect = QRectF(xScaleDiv.lowerBound(), yScaleDiv.lowerBound(),
                          xScaleDiv.range(), yScaleDiv.range())
            self.setRectOfInterest(rect)

        def dataChanged(self):
            self.itemChanged()

    class QwtSeriesData(object):
        """
        Abstract interface for iterating over samples

        `PythonQwt` offers several implementations of the QwtSeriesData API,
        but in situations, where data of an application specific format
        needs to be displayed, without having to copy it, it is recommended
        to implement an individual data access.

        A subclass of `QwtSeriesData` must implement:

          - size():

            Should return number of data points.

         - sample()

            Should return values x and y values of the sample at specific position
            as QPointF object.

         - boundingRect()

            Should return the bounding rectangle of the data series.
            It is used for autoscaling and might help certain algorithms for
            displaying the data.
            The member `_boundingRect` is intended for caching the calculated
            rectangle.
        """
        def __init__(self):
            self._boundingRect = QRectF(0.0, 0.0, -1.0, -1.0)

        def setRectOfInterest(self, rect):
            """
            Set a the "rect of interest"

            QwtPlotSeriesItem defines the current area of the plot canvas
            as "rectangle of interest" ( QwtPlotSeriesItem::updateScaleDiv() ).
            It can be used to implement different levels of details.

            The default implementation does nothing.

            :param QRectF rect: Rectangle of interest
            """
            pass

        def size(self):
            """
            :return: Number of samples
            """
            pass

        def sample(self, i):
            """
            Return a sample

            :param int i: Index
            :return: Sample at position i
            """
            pass

        def boundingRect(self):
            """
            Calculate the bounding rect of all samples

            The bounding rect is necessary for autoscaling and can be used
            for a couple of painting optimizations.

            :return: Bounding rectangle
            """
            pass

    class QwtPointArrayData(QwtSeriesData):
        """
        Interface for iterating over two array objects

        .. py:class:: QwtPointArrayData(x, y, [size=None], [finite=True])

            :param x: Array of x values
            :type x: list or tuple or numpy.array
            :param y: Array of y values
            :type y: list or tuple or numpy.array
            :param int size: Size of the x and y arrays
            :param bool finite: if True, keep only finite array elements (remove all infinity and not a number values), otherwise do not filter array elements
        """
        def __init__(self, x=None, y=None, size=None, finite=None):
            QwtSeriesData.__init__(self)
            if x is None and y is not None:
                x = np.arange(len(y))
            elif y is None and x is not None:
                y = x
                x = np.arange(len(y))
            elif x is None and y is None:
                x = np.array([])
                y = np.array([])
            if isinstance(x, (tuple, list)):
                x = np.array(x)
            if isinstance(y, (tuple, list)):
                y = np.array(y)
            if size is not None:
                x = np.resize(x, (size, ))
                y = np.resize(y, (size, ))
            if finite if finite is not None else True:
                indexes = np.logical_and(np.isfinite(x), np.isfinite(y))
                self.__x = x[indexes]
                self.__y = y[indexes]
            else:
                self.__x = x
                self.__y = y

        def boundingRect(self):
            """
            Calculate the bounding rectangle

            The bounding rectangle is calculated once by iterating over all
            points and is stored for all following requests.

            :return: Bounding rectangle
            """
            xmin = self.__x.min()
            xmax = self.__x.max()
            ymin = self.__y.min()
            ymax = self.__y.max()
            return QRectF(xmin, ymin, xmax-xmin, ymax-ymin)

        def size(self):
            """
            :return: Size of the data set
            """
            return min([self.__x.size, self.__y.size])

        def sample(self, index):
            """
            :param int index: Index
            :return: Sample at position `index`
            """
            return QPointF(self.__x[index], self.__y[index])

        def xData(self):
            """
            :return: Array of the x-values
            """
            return self.__x

        def yData(self):
            """
            :return: Array of the y-values
            """
            return self.__y

    class QwtSeriesStore(object):
        """
        Class storing a `QwtSeriesData` object

        `QwtSeriesStore` and `QwtPlotSeriesItem` are intended as base classes for
        all plot items iterating over a series of samples.
        """
        def __init__(self):
            self.__series = None

        def setData(self, series):
            """
            Assign a series of samples

            :param qwt.plot_series.QwtSeriesData series: Data

            .. warning::

                The item takes ownership of the data object, deleting it
                when its not used anymore.
            """
            if self.__series != series:
                self.__series = series
                self.dataChanged()

        def data(self):
            """
            :return: the series data
            """
            return self.__series

        def sample(self, index):
            """
            :param int index: Index
            :return: Sample at position index
            """
            if self.__series:
                return self.__series.sample(index)
            else:
                return

        def dataSize(self):
            """
            :return: Number of samples of the series

            .. seealso::

                :py:meth:`setData()`,
                :py:meth:`qwt.plot_series.QwtSeriesData.size()`
            """
            if self.__series is None:
                return 0
            return self.__series.size()

        def dataRect(self):
            """
            :return: Bounding rectangle of the series or an invalid rectangle, when no series is stored

            .. seealso::

                :py:meth:`qwt.plot_series.QwtSeriesData.boundingRect()`
            """
            if self.__series is None or self.dataSize() == 0:
                return QRectF(1.0, 1.0, -2.0, -2.0)
            return self.__series.boundingRect()

        def setRectOfInterest(self, rect):
            """
            Set a the "rect of interest" for the series

            :param QRectF rect: Rectangle of interest

            .. seealso::

                :py:meth:`qwt.plot_series.QwtSeriesData.setRectOfInterest()`
            """
            if self.__series:
                self.__series.setRectOfInterest(rect)

        def swapData(self, series):
            """
            Replace a series without deleting the previous one

            :param qwt.plot_series.QwtSeriesData series: New series
            :return: Previously assigned series
            """
            swappedSeries = self.__series
            self.__series = series
            return swappedSeries