Merge pull request #29 from PierreRaybaut/Inf_NaN

Better handling of infinite and NaN values

Author: PierreRaybaut

CHANGELOG.md

@@ -1,5 +1,11 @@
 # History of changes
 
+## Version 0.5.3
+
+Better handling of infinity and NaN values in scales (removed NumPy warnings)
+Now handling infinity and NaN values in series data: removing points that can't be drawn
+Fixed logarithmic scale engine: presence of values <= 0 was slowing down series data plotting
+
 ## Version 0.5.2
 
 Added CHM documentation to wheel package

qwt/plot_curve.py

@@ -813,51 +813,99 @@ def legendIcon(self, index, size):
                 self.__data.symbol.drawSymbol(painter, r)
         return graphic    
 
-    def setData(self, *args):
-        """Compatibility with Qwt5"""
-        if len(args) == 1:
+    def setData(self, *args, **kwargs):
+        """
+        Initialize data with a series data object or an array of points.
+        
+        .. py:method:: setData(data):
+        
+            :param data: Series data (e.g. `QwtPointArrayData` instance)
+            :type data: qwt.plot_series.QwtSeriesData
+
+        .. py:method:: setData(xData, yData, [size=None], [finite=True]):
+
+            Initialize data with `x` and `y` arrays.
+            
+            This signature was removed in Qwt6 and is temporarily maintained here to ensure compatibility with Qwt5.
+    
+            Same as `setSamples(x, y, [size=None], [finite=True])`
+        
+            :param x: List/array of x values
+            :param y: List/array of y values
+            :param size: size of xData and yData
+            :type size: int or None
+            :param bool finite: if True, keep only finite array elements (remove all infinity and not a number values), otherwise do not filter array elements
+        
+        .. seealso::
+        
+            :py:meth:`setSamples()`
+        """
+        if len(args) == 1 and not kwargs:
             super(QwtPlotCurve, self).setData(*args)
-        elif len(args) == 2:
-            self.setSamples(*args)
+        elif len(args) in (2, 3, 4):
+            self.setSamples(*args, **kwargs)
         else:
-            raise TypeError("%s().setData() takes 1 or 2 argument(s) (%s given)"\
+            raise TypeError("%s().setData() takes 1, 2, 3 or 4 argument(s) (%s given)"\
                             % (self.__class__.__name__, len(args)))
 
-    def setSamples(self, *args):
+    def setSamples(self, *args, **kwargs):
         """
         Initialize data with an array of points.
         
+        .. py:method:: setSamples(data):
+        
+            :param data: Series data (e.g. `QwtPointArrayData` instance)
+            :type data: qwt.plot_series.QwtSeriesData
+        
+        
         .. py:method:: setSamples(samples):
         
             Same as `setData(QwtPointArrayData(samples))`
         
             :param samples: List/array of points
         
-        .. py:method:: setSamples(xData, yData, [size=None]):
+        .. py:method:: setSamples(xData, yData, [size=None], [finite=True]):
 
             Same as `setData(QwtPointArrayData(xData, yData, [size=None]))`
         
             :param xData: List/array of x values
             :param yData: List/array of y values
             :param size: size of xData and yData
             :type size: int or None
+            :param bool finite: if True, keep only finite array elements (remove all infinity and not a number values), otherwise do not filter array elements
         
         .. seealso::
         
-            :py:class:`qwt.plot_series.QwtPointArrayData`,
+            :py:class:`qwt.plot_series.QwtPointArrayData`
         """
-        if len(args) == 1:
+        if len(args) == 1 and not kwargs:
             samples, = args
             if isinstance(samples, QwtSeriesData):
                 self.setData(samples)
             else:
                 self.setData(QwtPointArrayData(samples))
-        elif len(args) == 3:
-            xData, yData, size = args
-            self.setData(QwtPointArrayData(xData, yData, size))
-        elif len(args) == 2:
-            xData, yData = args
-            self.setData(QwtPointArrayData(xData, yData))
+        elif len(args) >= 2:
+            xData, yData = args[:2]
+            try:
+                size = kwargs.pop('size')
+            except KeyError:
+                size = None
+            try:
+                finite = kwargs.pop('finite')
+            except KeyError:
+                finite = None
+            if kwargs:
+                raise TypeError("%s().setSamples(): unknown %s keyword "\
+                                "argument(s)"\
+                                % (self.__class__.__name__,
+                                   ", ".join(list(kwargs.keys()))))
+            for arg in args[2:]:
+                if isinstance(arg, bool):
+                    finite = arg
+                elif isinstance(arg, int):
+                    size = arg
+            self.setData(QwtPointArrayData(xData, yData,
+                                           size=size, finite=finite))
         else:
             raise TypeError("%s().setSamples() takes 1, 2 or 3 argument(s) "\
                             "(%s given)" % (self.__class__.__name__, len(args)))

qwt/plot_series.py

@@ -185,15 +185,16 @@ class QwtPointArrayData(QwtSeriesData):
     """
     Interface for iterating over two array objects
     
-    .. py:class:: QwtCQwtPointArrayDataolorMap(x, y, [size=None])
+    .. 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):
+    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))
@@ -210,8 +211,13 @@ def __init__(self, x=None, y=None, size=None):
         if size is not None:
             x = np.resize(x, (size, ))
             y = np.resize(y, (size, ))
-        self.__x = x
-        self.__y = y
+        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):
         """
@@ -343,4 +349,4 @@ def swapData(self, series):
         """
         swappedSeries = self.__series
         self.__series = series
-        return swappedSeries
+        return swappedSeries

qwt/scale_draw.py

@@ -23,7 +23,6 @@
 from qwt.scale_map import QwtScaleMap
 from qwt.text import QwtText
 from qwt.math import qwtRadians
-from qwt.painter import QwtPainter
 
 from qwt.qt.QtGui import QPalette, QFontMetrics, QTransform
 from qwt.qt.QtCore import (Qt, qFuzzyCompare, QLocale, QRectF, QPointF, QRect,

qwt/scale_engine.py

@@ -652,6 +652,7 @@ def autoScale(self, maxNumSteps, x1, x2, stepSize):
         logBase = self.base()
         interval = QwtInterval(x1/np.power(logBase, self.lowerMargin()),
                                x2*np.power(logBase, self.upperMargin()))
+        interval = interval.limited(LOG_MIN, LOG_MAX)
         if interval.maxValue()/interval.minValue() < logBase:
             linearScaler = QwtLinearScaleEngine()
             linearScaler.setAttributes(self.attributes())
@@ -887,4 +888,4 @@ def align(self, interval, stepSize):
 
         return qwtPowInterval(self.base(), QwtInterval(x1, x2))
 
-        
+        

qwt/tests/CurveBenchmark.py

@@ -55,7 +55,7 @@ def __init__(self, title, xdata, ydata, style, symbol=None, *args):
             if symbol is not None:
                 curve.setSymbol(symbol)
             curve.attach(self)
-            curve.setData(xdata, ydata*idx)
+            curve.setData(xdata, ydata*idx, finite=False)
 #        self.setAxisScale(self.yLeft, -1.5, 1.5)
 #        self.setAxisScale(self.xBottom, 9.9, 10.)
         self.replot()

qwt/tests/LogCurveDemo.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the PyQwt License
+# Copyright (C) 2003-2009 Gerard Vermeulen, for the original PyQwt example
+# Copyright (c) 2015 Pierre Raybaut, for the PyQt5/PySide port and further 
+# developments (e.g. ported to PythonQwt API)
+# (see LICENSE file for more details)
+
+SHOW = True # Show test in GUI-based test launcher
+
+import numpy as np
+
+np.seterr(all='raise')
+
+from qwt.qt.QtGui import QApplication, QPen
+from qwt.qt.QtCore import Qt
+from qwt import QwtPlot, QwtPlotCurve, QwtLogScaleEngine
+
+
+def create_log_plot():
+    plot = QwtPlot('LogCurveDemo.py (or how to handle -inf values)')
+    plot.enableAxis(QwtPlot.xBottom)
+    plot.setAxisScaleEngine(QwtPlot.yLeft, QwtLogScaleEngine())
+    curve = QwtPlotCurve()
+    curve.setRenderHint(QwtPlotCurve.RenderAntialiased)
+    pen = QPen(Qt.magenta)
+    pen.setWidth(1.5)
+    curve.setPen(pen)
+    curve.attach(plot)
+    x = np.arange(0.0, 10.0, 0.1)
+    y = 10*np.cos(x)**2-.1
+    print("y<=0:", y<=0)
+    curve.setData(x, y)
+    plot.replot()
+    return plot
+
+
+if __name__ == '__main__':
+    app = QApplication([])
+    plot = create_log_plot()
+    plot.resize(800, 500)
+    plot.show()
+    app.exec_()

qwt/transform.py

@@ -166,7 +166,7 @@ def bounded(self, value):
         Modify value to be a valid value for the transformation.
         
         :param float value: Value to be bounded
-        :return: Value unmodified
+        :return: Value modified
         """
         return np.clip(value, self.LogMin, self.LogMax)
 
@@ -181,7 +181,7 @@ def transform(self, value):
         
             :py:meth:`invTransform()`
         """
-        return np.log(value)
+        return np.log(self.bounded(value))
 
     def invTransform(self, value):
         """