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