Added comparative benchmark: PyQwt5 vs. PythonQwt

Author: PierreRaybaut

qwt/tests/CurveBenchmark.py

@@ -10,13 +10,20 @@
 
 import time
 import numpy as np
+import sys
 
-from qwt.qt.QtGui import (QApplication, QPen, QBrush, QMainWindow, QGridLayout,
+from qwt.qt.QtGui import (QApplication, QPen, QMainWindow, QGridLayout,
                           QTabWidget, QWidget, QTextEdit, QLineEdit, QFont,
                           QFontDatabase)
-from qwt.qt.QtCore import QSize
 from qwt.qt.QtCore import Qt
-from qwt import QwtPlot, QwtSymbol, QwtPlotCurve
+
+import os
+if os.environ.get('USE_PYQWT5', False):
+    USE_PYQWT5 = True
+    from PyQt4.Qwt5 import QwtPlot, QwtPlotCurve
+else:
+    USE_PYQWT5 = False
+    from qwt import QwtPlot, QwtPlotCurve  # analysis:ignore
 
 
 COLOR_INDEX = None
@@ -38,34 +45,40 @@ def __init__(self, title, xdata, ydata, style, symbol=None, *args):
         self.setTitle(title)
         self.setAxisTitle(QwtPlot.xBottom, 'x')
         self.setAxisTitle(QwtPlot.yLeft, 'y')
-        curve = QwtPlotCurve()
-        curve.setPen(QPen(get_curve_color()))
-        curve.setStyle(style)
-        curve.setRenderHint(QwtPlotCurve.RenderAntialiased)
-        if symbol is not None:
-            curve.setSymbol(symbol)
-        curve.attach(self)
-        curve.setData(xdata, ydata)
+        for idx in range(1, 11):
+            curve = QwtPlotCurve()
+            curve.setPen(QPen(get_curve_color()))
+            curve.setStyle(style)
+            curve.setRenderHint(QwtPlotCurve.RenderAntialiased)
+            if symbol is not None:
+                curve.setSymbol(symbol)
+            curve.attach(self)
+            curve.setData(xdata, ydata*idx)
+#        self.setAxisScale(self.yLeft, -1.5, 1.5)
+#        self.setAxisScale(self.xBottom, 9.9, 10.)
         self.replot()
 
 
 class BMWidget(QWidget):
-    def __init__(self, points, *args):
+    def __init__(self, points, *args, **kwargs):
         super(BMWidget, self).__init__()
-        self.setup(points, *args)
+        self.setup(points, *args, **kwargs)
 
-    def params(self, *args):
-        return (
-                ('Lines', None),
-                ('Dots', None),
-                )
+    def params(self, *args, **kwargs):
+        if kwargs.get('only_lines', False):
+            return (('Lines', None),)
+        else:
+            return (
+                    ('Lines', None),
+                    ('Dots', None),
+                    )
 
-    def setup(self, points, *args):
+    def setup(self, points, *args, **kwargs):
         x = np.linspace(.001, 20., points)
         y = (np.sin(x)/x)*np.cos(20*x)
         layout = QGridLayout()
         nbcol, col, row = 2, 0, 0
-        for style, symbol in self.params(*args):
+        for style, symbol in self.params(*args, **kwargs):
            layout.addWidget(BMPlot(style, x, y, getattr(QwtPlotCurve, style),
                                    symbol=symbol), row, col)
            col += 1
@@ -81,50 +94,69 @@ def setup(self, points, *args):
 
 
 class BMText(QTextEdit):
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, title=None):
         super(BMText, self).__init__(parent)
         self.setReadOnly(True)
+        library = 'PyQwt5' if USE_PYQWT5 else 'PythonQwt'
+        wintitle = self.parent().windowTitle()
+        if not wintitle:
+            wintitle = "Benchmark"
+        if title is None:
+            title = '%s example' % wintitle
+        self.parent().setWindowTitle('%s [%s]' % (wintitle, library))
         self.setText("""\
-<b>Curve benchmark example:</b><br><br>
+<b>%s:</b><br>
+(base plotting library: %s)<br><br>
 Click on each tab to test if plotting performance is acceptable in terms of 
 GUI response time (switch between tabs, resize main windows, ...).<br>
 <br><br>
 <b>Benchmarks results:</b>
-""")
+""" % (title, library))
 
 
 class BMDemo(QMainWindow):
+    TITLE = 'Curve benchmark'
+    SIZE = (1000, 800)
     def __init__(self, max_n, parent=None, **kwargs):
         super(BMDemo, self).__init__(parent=parent)
-        self.setWindowTitle('Curve benchmark')
-        tabs = QTabWidget()
-        self.setCentralWidget(tabs)
-        contents = BMText()
-        tabs.addTab(contents, 'Contents')
-        self.resize(1000, 600)
+        title = self.TITLE
+        if kwargs.get('only_lines', False):
+            title = '%s (%s)' % (title, 'only lines')
+        self.setWindowTitle(title)
+        self.tabs = QTabWidget()
+        self.setCentralWidget(self.tabs)
+        self.text = BMText(self)
+        self.tabs.addTab(self.text, 'Contents')
+        self.resize(*self.SIZE)
 
         # Force window to show up and refresh (for test purpose only)
         self.show()
         QApplication.processEvents()
-
+        
         t0g = time.time()
+        self.run_benchmark(max_n, **kwargs)
+        dt = time.time()-t0g
+        self.text.append("<br><br><u>Total elapsed time</u>: %d ms" % (dt*1e3))
+        self.tabs.setCurrentIndex(0)
+        
+    def process_iteration(self, title, widget, t0):
+        self.tabs.addTab(widget, title)
+        self.tabs.setCurrentWidget(widget)
+
+        # Force widget to refresh (for test purpose only)
+        QApplication.processEvents()
+
+        time_str = "Elapsed time: %d ms" % ((time.time()-t0)*1000)
+        widget.text.setText(time_str)
+        self.text.append("<br><i>%s:</i><br>%s" % (title, time_str))
+
+    def run_benchmark(self, max_n, **kwargs):
         for idx in range(4, -1, -1):
             points = max_n/10**idx
-            t0 = time.time()
-            widget = BMWidget(points)
             title = '%d points' % points
-            tabs.addTab(widget, title)
-            tabs.setCurrentWidget(widget)
-
-            # Force widget to refresh (for test purpose only)
-            QApplication.processEvents()
-
-            time_str = "Elapsed time: %d ms" % ((time.time()-t0)*1000)
-            widget.text.setText(time_str)
-            contents.append("<br><i>%s:</i><br>%s" % (title, time_str))
-        dt = time.time()-t0g
-        contents.append("<br><br><u>Total elapsed time</u>: %d ms" % (dt*1000))
-        tabs.setCurrentIndex(0)
+            t0 = time.time()
+            widget = BMWidget(points, **kwargs)
+            self.process_iteration(title, widget, t0)
 
 
 if __name__ == '__main__':
@@ -133,5 +165,8 @@ def __init__(self, max_n, parent=None, **kwargs):
         if name in QFontDatabase().families():
             app.setFont(QFont(name))
             break
-    demo = BMDemo(1000000)
+    kwargs = {}
+    for arg in sys.argv[1:]:
+        kwargs[arg] = True
+    demo = BMDemo(1000000, **kwargs)
     app.exec_()

qwt/tests/CurveStyles.py

@@ -9,67 +9,55 @@
 SHOW = True # Show test in GUI-based test launcher
 
 import time
+import sys
 
-from qwt.qt.QtGui import (QApplication, QPen, QBrush, QMainWindow, QTabWidget,
-                          QFont, QFontDatabase)
+from qwt.qt.QtGui import QApplication, QPen, QBrush, QFont, QFontDatabase
 from qwt.qt.QtCore import QSize
 from qwt.qt.QtCore import Qt
 
 from qwt.tests import CurveBenchmark as cb
-from qwt import QwtSymbol
+
+if cb.USE_PYQWT5:
+    from PyQt4.Qwt5 import QwtSymbol
+else:
+    from qwt import QwtSymbol  # analysis:ignore
 
 
 class CSWidget(cb.BMWidget):
-    def params(self, *args):
+    def params(self, *args, **kwargs):
         symbols, = args
         symb1 = QwtSymbol(QwtSymbol.Ellipse, QBrush(Qt.yellow),
                           QPen(Qt.blue), QSize(5, 5))
         symb2 = QwtSymbol(QwtSymbol.XCross, QBrush(),
                           QPen(Qt.darkMagenta), QSize(5, 5))
         if symbols:
-            return (
-                    ('Sticks', symb1),
-                    ('Lines', symb1),
-                    ('Steps', symb2),
-                    ('Dots', symb2),
-                    )
+            if kwargs.get('only_lines', False):
+                return (('Lines', symb1), ('Lines', symb1), ('Lines', symb2),
+                        ('Lines', symb2),)
+            else:
+                return (('Sticks', symb1), ('Lines', symb1),
+                        ('Steps', symb2), ('Dots', symb2),)
         else:
-            return (
-                    ('Sticks', None),
-                    ('Lines', None),
-                    ('Steps', None),
-                    ('Dots', None),
-                    )
+            if kwargs.get('only_lines', False):
+                return (('Lines', None), ('Lines', None), ('Lines', None),
+                        ('Lines', None),)
+            else:
+                return (('Sticks', None), ('Lines', None), ('Steps', None),
+                        ('Dots', None),)
 
 
-class BMDemo(QMainWindow):
-    def __init__(self, max_n, parent=None, **kwargs):
-        super(BMDemo, self).__init__(parent=parent)
-        self.setWindowTitle('Curve styles')
-        tabs = QTabWidget()
-        self.resize(1000, 800)
-        
-        # Force window to show up and refresh (for test purpose only)
-        self.show()
-        QApplication.processEvents()
+class BMDemo(cb.BMDemo):
+    TITLE = 'Curve styles'
+    SIZE = (1000, 800)
 
-        self.setCentralWidget(tabs)
-        pts = 1000
-        for points, symbols in zip((pts/10, pts/10, pts, pts),
+    def run_benchmark(self, max_n, **kwargs):
+        for points, symbols in zip((max_n/10, max_n/10, max_n, max_n),
                                    (True, False)*2):
             t0 = time.time()
-            widget = CSWidget(points, symbols)
             symtext = "with%s symbols" % ("" if symbols else "out")
             title = '%d points, %s' % (points, symtext)
-            tabs.addTab(widget, title)
-            tabs.setCurrentWidget(widget)
-
-            # Force widget to refresh (for test purpose only)
-            QApplication.processEvents()
-
-            time_str = "Elapsed time: %d ms" % ((time.time()-t0)*1000)
-            widget.text.setText(time_str)
-        tabs.setCurrentIndex(0)
+            widget = CSWidget(points, symbols, **kwargs)
+            self.process_iteration(title, widget, t0)
 
 
 if __name__ == '__main__':
@@ -78,5 +66,8 @@ def __init__(self, max_n, parent=None, **kwargs):
         if name in QFontDatabase().families():
             app.setFont(QFont(name))
             break
-    demo = BMDemo(100000)
+    kwargs = {}
+    for arg in sys.argv[1:]:
+        kwargs[arg] = True
+    demo = BMDemo(1000, **kwargs)
     app.exec_()

qwt/tests/comparative_benchmarks.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the MIT License
+# Copyright (c) 2015 Pierre Raybaut
+# (see LICENSE file for more details)
+
+"""
+PyQwt5 vs. PythonQwt
+====================
+"""
+
+import os
+import os.path as osp
+import sys
+import subprocess
+import time
+
+
+def run_script(filename, args=None, wait=True):
+    """Run Python script"""
+    os.environ['PYTHONPATH'] = os.pathsep.join(sys.path)
+    
+    command = [sys.executable, '"'+filename+'"']
+    if args is not None:
+        command.append(args)
+    proc = subprocess.Popen(" ".join(command), shell=True)
+    if wait:
+        proc.wait()
+
+
+def main():
+    for name in ('CurveBenchmark.py', 'CurveStyles.py',):
+        for args in (None, 'only_lines'):
+            for value in ('', '1'):
+                os.environ['USE_PYQWT5'] = value
+                filename = osp.join(osp.dirname(osp.abspath(__file__)), name)
+                run_script(filename, wait=False, args=args)
+                time.sleep(4)
+
+
+if __name__ == '__main__':
+    main()
+