Fixed some examples (MapDemo, MultiDemo, ReallySimpleDemo, ...)

Author: Pierre Raybaut

examples/CurveDemo2.py

@@ -1,16 +1,14 @@
 #!/usr/bin/env python
 
-# The Python version of qwt-*/examples/curvdemo2
-
+#FIXME: scale issue!
 
 import sys
 from PyQt4 import Qt
-#import PyQt4.Qwt5 as Qwt
 import qwt as Qwt
-from PyQt4.Qwt5.anynumpy import *
+import numpy as np
 
-Size=15
-USize=13
+Size = 15
+USize = 13
 
 class CurveDemo(Qt.QFrame):
 
@@ -29,18 +27,14 @@ def __init__(self, *args):
         # curve 1
         curve = Qwt.QwtPlotCurve()
         curve.setPen(Qt.QPen(Qt.QColor(150, 150, 200), 2))
-        curve.setCurveType(Qwt.QwtPlotCurve.Xfy)
         curve.setStyle(Qwt.QwtPlotCurve.Lines)
-        curveFitter = Qwt.QwtSplineCurveFitter()
-        curveFitter.setSplineSize(150)
-        curve.setCurveFitter(curveFitter)
         curve.setSymbol(Qwt.QwtSymbol(Qwt.QwtSymbol.XCross,
                                       Qt.QBrush(),
                                       Qt.QPen(Qt.Qt.yellow, 2),
                                       Qt.QSize(7, 7)))
         self.tuples.append((curve,
                             Qwt.QwtScaleMap(0, 100, -1.5, 1.5),
-                            Qwt.QwtScaleMap(0, 100, 0.0, 2*pi)))
+                            Qwt.QwtScaleMap(0, 100, 0.0, 2*np.pi)))
         # curve 2
         curve = Qwt.QwtPlotCurve()
         curve.setPen(Qt.QPen(Qt.QColor(200, 150, 50),
@@ -52,75 +46,59 @@ def __init__(self, *args):
                                       Qt.QPen(Qt.Qt.yellow),
                                       Qt.QSize(5, 5)))
         self.tuples.append((curve,
-                            Qwt.QwtScaleMap(0, 100, 0.0, 2*pi),
+                            Qwt.QwtScaleMap(0, 100, 0.0, 2*np.pi),
                             Qwt.QwtScaleMap(0, 100, -3.0, 1.1)))
         # curve 3
         curve = Qwt.QwtPlotCurve()
         curve.setPen(Qt.QPen(Qt.QColor(100, 200, 150)))
         curve.setStyle(Qwt.QwtPlotCurve.Lines)
-        curve.setCurveAttribute(Qwt.QwtPlotCurve.Fitted)
-        curveFitter = Qwt.QwtSplineCurveFitter()
-        curveFitter.setFitMode(Qwt.QwtSplineCurveFitter.ParametricSpline)
-        curveFitter.setSplineSize(200)
-        curve.setCurveFitter(curveFitter)
         self.tuples.append((curve,
                             Qwt.QwtScaleMap(0, 100, -1.1, 3.0),
                             Qwt.QwtScaleMap(0, 100, -1.1, 3.0)))
         # curve 4
         curve = Qwt.QwtPlotCurve()
         curve.setPen(Qt.QPen(Qt.Qt.red))
         curve.setStyle(Qwt.QwtPlotCurve.Lines)
-        curve.setCurveAttribute(Qwt.QwtPlotCurve.Fitted)
-        curveFitter = Qwt.QwtSplineCurveFitter()
-        curveFitter.setSplineSize(200)
-        curve.setCurveFitter(curveFitter)
         self.tuples.append((curve,
                             Qwt.QwtScaleMap(0, 100, -5.0, 1.1),
                             Qwt.QwtScaleMap(0, 100, -1.1, 5.0)))
         # data
         self.phase = 0.0
-        self.base = arange(0.0, 2.01*pi, 2*pi/(USize-1))
-        self.uval = cos(self.base)
-        self.vval = sin(self.base)
+        self.base = np.arange(0.0, 2.01*np.pi, 2*np.pi/(USize-1))
+        self.uval = np.cos(self.base)
+        self.vval = np.sin(self.base)
         self.uval[1::2] *= 0.5
         self.vval[1::2] *= 0.5
         self.newValues()
         # start timer
         self.tid = self.startTimer(250)
 
-    # __init__()
-
     def paintEvent(self, event):
         Qt.QFrame.paintEvent(self,event)
         painter = Qt.QPainter(self)
-        #painter.setRenderHint(Qt.QPainter.Antialiasing)
         painter.setClipRect(self.contentsRect())
         self.drawContents(painter)
 
-    # paintEvent()
-
     def drawContents(self, painter):
         r = self.contentsRect()
         for curve, xMap, yMap in self.tuples:
             xMap.setPaintInterval(r.left(), r.right())
             yMap.setPaintInterval(r.top(), r.bottom())
             curve.draw(painter, xMap, yMap, r)
 
-    # drawContents()
-
     def timerEvent(self, event):
         self.newValues()
         self.repaint()
 
     def newValues(self):
         phase = self.phase
 
-        self.xval = arange(0, 2.01*pi, 2*pi/(Size-1))
-        self.yval = sin(self.xval - phase)
-        self.zval = cos(3*(self.xval + phase))
+        self.xval = np.arange(0, 2.01*np.pi, 2*np.pi/(Size-1))
+        self.yval = np.sin(self.xval - phase)
+        self.zval = np.cos(3*(self.xval + phase))
 
-        s = 0.25 * sin(phase)
-        c = sqrt(1.0 - s*s)
+        s = 0.25 * np.sin(phase)
+        c = np.sqrt(1.0 - s*s)
         u = self.uval
         self.uval = c*self.uval-s*self.vval
         self.vval = c*self.vval+s*u
@@ -130,32 +108,19 @@ def newValues(self):
         self.tuples[2][0].setData(self.yval, self.zval)
         self.tuples[3][0].setData(self.uval, self.vval)
 
-        self.phase += 2*pi/100
-        if self.phase>2*pi:
+        self.phase += 2*np.pi/100
+        if self.phase>2*np.pi:
             self.phase = 0.0
 
 
 def make():
     demo = CurveDemo()
-    demo.resize(300, 300)
+    demo.resize(600, 600)
     demo.show()
     return demo
 
-# make()
-
 
-def main(args):
-    app = Qt.QApplication(args)
-    demo = make()
-    sys.exit(app.exec_())
-
-# main()
-
- 
-# Admire!         
 if __name__ == '__main__':
-    main(sys.argv)
-
-# Local Variables: ***
-# mode: python ***
-# End: ***
+    app = Qt.QApplication(sys.argv)
+    demo = make()
+    sys.exit(app.exec_())

examples/MapDemo.py

@@ -1,44 +1,30 @@
 #!/usr/bin/env python
 
-
 import random
 import sys
 import time
-try:
-    import resource
-    has_resource = 1
-except ImportError:
-    has_resource = 0
 
 from PyQt4 import Qt
-#import PyQt4.Qwt5 as Qwt
 import qwt as Qwt
-from PyQt4.Qwt5.anynumpy import *
+import numpy as np
 
 
 def standard_map(x, y, kappa):
     """provide one interate of the inital conditions (x, y)
-       for the standard map with parameter kappa.
-    """
-    y_new = y-kappa*sin(2.0*pi*x)
+       for the standard map with parameter kappa."""
+    y_new = y-kappa*np.sin(2.0*np.pi*x)
     x_new = x+y_new
-
     # bring back to [0,1.0]^2
     if( (x_new>1.0) or (x_new<0.0) ):
-         x_new = x_new - floor(x_new)
+         x_new = x_new - np.floor(x_new)
     if( (y_new>1.0) or (y_new<0.0) ):
-         y_new = y_new - floor(y_new)
-
+         y_new = y_new - np.floor(y_new)
     return x_new, y_new
 
-# standard_map
-
 
 class MapDemo(Qt.QMainWindow):
-
     def __init__(self, *args):
         Qt.QMainWindow.__init__(self, *args)
-
         self.plot = Qwt.QwtPlot(self)
         self.plot.setTitle("A Simple Map Demonstration")
         self.plot.setCanvasBackground(Qt.Qt.white)
@@ -47,82 +33,38 @@ def __init__(self, *args):
         self.plot.setAxisScale(Qwt.QwtPlot.xBottom, 0.0, 1.0)
         self.plot.setAxisScale(Qwt.QwtPlot.yLeft, 0.0, 1.0)
         self.setCentralWidget(self.plot)
-
         # Initialize map data
         self.count = self.i = 1000
-        self.xs = zeros(self.count, Float)
-        self.ys = zeros(self.count, Float)
-
+        self.xs = np.zeros(self.count, np.float)
+        self.ys = np.zeros(self.count, np.float)
         self.kappa = 0.2
-
         self.curve = Qwt.QwtPlotCurve("Map")
         self.curve.attach(self.plot)
-
         self.curve.setSymbol(Qwt.QwtSymbol(Qwt.QwtSymbol.Ellipse,
                                            Qt.QBrush(Qt.Qt.red),
                                            Qt.QPen(Qt.Qt.blue),
                                            Qt.QSize(5, 5)))
-
         self.curve.setPen(Qt.QPen(Qt.Qt.cyan))
-
         toolBar = Qt.QToolBar(self)
         self.addToolBar(toolBar)
-
-        toolBar.addWidget(Qt.QLabel("Count:", toolBar))
-        sizeCounter = Qwt.QwtCounter(toolBar)
-        toolBar.addWidget(sizeCounter)
-        toolBar.addSeparator()
-        sizeCounter.setRange(0, 1000000, 100)
-        sizeCounter.setValue(self.count)
-        sizeCounter.setNumButtons(3)
-        self.connect(
-            sizeCounter, Qt.SIGNAL('valueChanged(double)'), self.setCount)
-
-        toolBar.addWidget(Qt.QLabel("Ticks (ms):", toolBar))
-        tickCounter = Qwt.QwtCounter(toolBar)
-        toolBar.addWidget(tickCounter)
-        toolBar.addSeparator()
         # 1 tick = 1 ms, 10 ticks = 10 ms (Linux clock is 100 Hz)
         self.ticks = 10
-        tickCounter.setRange(0, 1000, 1)
-        tickCounter.setValue(self.ticks)
-        tickCounter.setNumButtons(3)
-        self.connect(
-            tickCounter, Qt.SIGNAL('valueChanged(double)'), self.setTicks)
         self.tid = self.startTimer(self.ticks)
-
         self.timer_tic = None
         self.user_tic = None
-        self.system_tic = None
-        
+        self.system_tic = None    
         self.plot.replot()
 
-    # __init__()
-        
-    def setCount(self, count):
-        self.count = self.i = count
-        self.xs = zeros(self.count, Float)
-        self.ys = zeros(self.count, Float)
-        self.i = self.count
-        self.killTimer(self.tid)
-        self.tid = self.startTimer(self.ticks)
-
-    # setCount()
-
     def setTicks(self, ticks):
         self.i = self.count
         self.ticks = int(ticks)
         self.killTimer(self.tid)
         self.tid = self.startTimer(ticks)
-
-    # setTicks()
 
     def resizeEvent(self, event):
         self.plot.resize(event.size())
         self.plot.move(0, 0)
 
-    # resizeEvent()
-
     def moreData(self):
         if self.i == self.count:
             self.i = 0
@@ -132,17 +74,6 @@ def moreData(self):
             self.ys[self.i] = self.y
             self.i += 1
             chunks = []
-            if has_resource:
-                self.user_toc, self.system_toc = resource.getrusage(
-                    resource.RUSAGE_SELF)[:2]
-                if self.user_tic:
-                    chunks.append("user: %s s;"
-                                  % (self.user_toc-self.user_tic))
-                self.user_tic = self.user_toc
-                if self.system_tic:
-                    chunks.append("system: %s s;"
-                                  % (self.system_toc-self.system_tic))
-                self.system_tic = self.system_toc
             self.timer_toc = time.time()
             if self.timer_tic:
                 chunks.append("wall: %s s." % (self.timer_toc-self.timer_tic))
@@ -153,45 +84,21 @@ def moreData(self):
             self.xs[self.i] = self.x
             self.ys[self.i] = self.y
             self.i += 1
-
-    # moreData()
 
     def timerEvent(self, e):
         self.moreData()
         self.curve.setData(self.xs[:self.i], self.ys[:self.i])
         self.plot.replot()
 
-    # timerEvent()
-
-# class MapDemo
-
 
 def make():
     demo = MapDemo()
     demo.resize(600, 600)
     demo.show()
     return demo
 
-# make()
 
-
-def main(args):
-    app = Qt.QApplication(args)
+if __name__ == '__main__':
+    app = Qt.QApplication(sys.argv)
     demo = make()
     sys.exit(app.exec_())
-
-# main()
-
-
-# Admire! 
-if __name__ == '__main__':
-    if 'settracemask' in sys.argv:
-        # for debugging, requires: python configure.py --trace ...
-        import sip
-        sip.settracemask(0x3f)
-
-    main(sys.argv)
-
-# Local Variables: ***
-# mode: python ***
-# End: ***