merge from luke

SRTTransform3D.py

@@ -6,12 +6,12 @@ import pyqtgraph as pg
 import numpy as np
 import scipy.linalg
 
-class SRTTransform3D(QtGui.QMatrix4x4):
+class SRTTransform3D(pg.Transform3D):
     """4x4 Transform matrix that can always be represented as a combination of 3 matrices: scale * rotate * translate
     This transform has no shear; angles are always preserved.
     """
     def __init__(self, init=None):
-        QtGui.QMatrix4x4.__init__(self)
+        pg.Transform3D.__init__(self)
         self.reset()
         if init is None:
             return
@@ -190,11 +190,11 @@ class SRTTransform3D(QtGui.QMatrix4x4):
         self.update()
 
     def update(self):
-        QtGui.QMatrix4x4.setToIdentity(self)
+        pg.Transform3D.setToIdentity(self)
         ## modifications to the transform are multiplied on the right, so we need to reverse order here.
-        QtGui.QMatrix4x4.translate(self, *self._state['pos'])
-        QtGui.QMatrix4x4.rotate(self, self._state['angle'], *self._state['axis'])
-        QtGui.QMatrix4x4.scale(self, *self._state['scale'])
+        pg.Transform3D.translate(self, *self._state['pos'])
+        pg.Transform3D.rotate(self, self._state['angle'], *self._state['axis'])
+        pg.Transform3D.scale(self, *self._state['scale'])
 
     def __repr__(self):
         return str(self.saveState())

Transform3D.py

+# -*- coding: utf-8 -*-
+from .Qt import QtCore, QtGui
+import pyqtgraph as pg
+import numpy as np
+
+class Transform3D(QtGui.QMatrix4x4):
+    """
+    Extension of QMatrix4x4 with some helpful methods added.
+    """
+    def __init__(self, *args):
+        QtGui.QMatrix4x4.__init__(self, *args)
+        
+    def matrix(self, nd=3):
+        if nd == 3:
+            return np.array(self.copyDataTo()).reshape(4,4)
+        elif nd == 2:
+            m = np.array(self.copyDataTo()).reshape(4,4)
+            m[2] = m[3]
+            m[:,2] = m[:,3]
+            return m[:3,:3]
+        else:
+            raise Exception("Argument 'nd' must be 2 or 3")
+        
+    def map(self, obj):
+        """
+        Extends QMatrix4x4.map() to allow mapping (3, ...) arrays of coordinates
+        """
+        if isinstance(obj, np.ndarray) and obj.ndim >= 2 and obj.shape[0] in (2,3):
+            return pg.transformCoordinates(self, obj)
+        else:
+            return QtGui.QMatrix4x4.map(self, obj)
+            
+    def inverted(self):
+        inv, b = QtGui.QMatrix4x4.inverted(self)
+        return Transform3D(inv), b
\ No newline at end of file

Vector.py

-# -*- coding: utf-8 -*-
-"""
-Vector.py -  Extension of QVector3D which adds a few missing methods.
-Copyright 2010  Luke Campagnola
-Distributed under MIT/X11 license. See license.txt for more infomation.
-"""
-
-from .Qt import QtGui, QtCore
-import numpy as np
-
-class Vector(QtGui.QVector3D):
-    """Extension of QVector3D which adds a few helpful methods."""
-    
-    def __init__(self, *args):
-        if len(args) == 1:
-            if isinstance(args[0], QtCore.QSizeF):
-                QtGui.QVector3D.__init__(self, float(args[0].width()), float(args[0].height()), 0)
-                return
-            elif isinstance(args[0], QtCore.QPoint) or isinstance(args[0], QtCore.QPointF):
-                QtGui.QVector3D.__init__(self, float(args[0].x()), float(args[0].y()), 0)
-            elif hasattr(args[0], '__getitem__'):
-                vals = list(args[0])
-                if len(vals) == 2:
-                    vals.append(0)
-                if len(vals) != 3:
-                    raise Exception('Cannot init Vector with sequence of length %d' % len(args[0]))
-                QtGui.QVector3D.__init__(self, *vals)
-                return
-        elif len(args) == 2:
-            QtGui.QVector3D.__init__(self, args[0], args[1], 0)
-            return
-        QtGui.QVector3D.__init__(self, *args)
-
-    def __len__(self):
-        return 3
-        
-    #def __reduce__(self):
-        #return (Point, (self.x(), self.y()))
-        
-    def __getitem__(self, i):
-        if i == 0:
-            return self.x()
-        elif i == 1:
-            return self.y()
-        elif i == 2:
-            return self.z()
-        else:
-            raise IndexError("Point has no index %s" % str(i))
-        
-    def __setitem__(self, i, x):
-        if i == 0:
-            return self.setX(x)
-        elif i == 1:
-            return self.setY(x)
-        elif i == 2:
-            return self.setZ(x)
-        else:
-            raise IndexError("Point has no index %s" % str(i))
-        
+# -*- coding: utf-8 -*-
+"""
+Vector.py -  Extension of QVector3D which adds a few missing methods.
+Copyright 2010  Luke Campagnola
+Distributed under MIT/X11 license. See license.txt for more infomation.
+"""
+
+from .Qt import QtGui, QtCore
+import numpy as np
+
+class Vector(QtGui.QVector3D):
+    """Extension of QVector3D which adds a few helpful methods."""
+    
+    def __init__(self, *args):
+        if len(args) == 1:
+            if isinstance(args[0], QtCore.QSizeF):
+                QtGui.QVector3D.__init__(self, float(args[0].width()), float(args[0].height()), 0)
+                return
+            elif isinstance(args[0], QtCore.QPoint) or isinstance(args[0], QtCore.QPointF):
+                QtGui.QVector3D.__init__(self, float(args[0].x()), float(args[0].y()), 0)
+            elif hasattr(args[0], '__getitem__'):
+                vals = list(args[0])
+                if len(vals) == 2:
+                    vals.append(0)
+                if len(vals) != 3:
+                    raise Exception('Cannot init Vector with sequence of length %d' % len(args[0]))
+                QtGui.QVector3D.__init__(self, *vals)
+                return
+        elif len(args) == 2:
+            QtGui.QVector3D.__init__(self, args[0], args[1], 0)
+            return
+        QtGui.QVector3D.__init__(self, *args)
+
+    def __len__(self):
+        return 3
+        
+    #def __reduce__(self):
+        #return (Point, (self.x(), self.y()))
+        
+    def __getitem__(self, i):
+        if i == 0:
+            return self.x()
+        elif i == 1:
+            return self.y()
+        elif i == 2:
+            return self.z()
+        else:
+            raise IndexError("Point has no index %s" % str(i))
+        
+    def __setitem__(self, i, x):
+        if i == 0:
+            return self.setX(x)
+        elif i == 1:
+            return self.setY(x)
+        elif i == 2:
+            return self.setZ(x)
+        else:
+            raise IndexError("Point has no index %s" % str(i))
+        
+    def __iter__(self):
+        yield(self.x())
+        yield(self.y())
+        yield(self.z())
+        
\ No newline at end of file

__init__.py

@@ -165,6 +165,7 @@ from .WidgetGroup import *
 from .Point import Point
 from .Vector import Vector
 from .SRTTransform import SRTTransform
+from .Transform3D import Transform3D
 from .SRTTransform3D import SRTTransform3D
 from .functions import *
 from .graphicsWindows import *

dockarea/DockArea.py

@@ -208,6 +208,10 @@ class DockArea(Container, QtGui.QWidget, DockDrop):
     def restoreState(self, state):
         """
         Restore Dock configuration as generated by saveState.
+        
+        Note that this function does not create any Docks--it will only 
+        restore the arrangement of an existing set of Docks.
+        
         """
         
         ## 1) make dict of all docks and list of existing containers
@@ -240,8 +244,11 @@ class DockArea(Container, QtGui.QWidget, DockDrop):
         typ, contents, state = state
         pfx = "  " * depth
         if typ == 'dock':
-            obj = docks[contents]
-            del docks[contents]
+            try:
+                obj = docks[contents]
+                del docks[contents]
+            except KeyError:
+                raise Exception('Cannot restore dock state; no dock with name "%s"' % contents)
         else:
             obj = self.makeContainer(typ)
             
@@ -270,7 +277,7 @@ class DockArea(Container, QtGui.QWidget, DockDrop):
         
         if isinstance(obj, Dock):
             d[obj.name()] = obj
-        else:
+        elif obj is not None:
             c.append(obj)
             for i in range(obj.count()):
                 o2 = obj.widget(i)

examples/GLScatterPlotItem.py

@@ -15,48 +15,91 @@ w.show()
 g = gl.GLGridItem()
 w.addItem(g)
 
-#pos = np.empty((53, 3))
-#size = np.empty((53))
-#color = np.empty((53, 4))
-#pos[0] = (1,0,0); size[0] = 0.5;   color[0] = (1.0, 0.0, 0.0, 0.5)
-#pos[1] = (0,1,0); size[1] = 0.2;   color[1] = (0.0, 0.0, 1.0, 0.5)
-#pos[2] = (0,0,1); size[2] = 2./3.; color[2] = (0.0, 1.0, 0.0, 0.5)
-
-#z = 0.5
-#d = 6.0
-#for i in range(3,53):
-    #pos[i] = (0,0,z)
-    #size[i] = 2./d
-    #color[i] = (0.0, 1.0, 0.0, 0.5)
-    #z *= 0.5
-    #d *= 2.0
+
+##
+##  First example is a set of points with pxMode=False
+##  These demonstrate the ability to have points with real size down to a very small scale 
+## 
+pos = np.empty((53, 3))
+size = np.empty((53))
+color = np.empty((53, 4))
+pos[0] = (1,0,0); size[0] = 0.5;   color[0] = (1.0, 0.0, 0.0, 0.5)
+pos[1] = (0,1,0); size[1] = 0.2;   color[1] = (0.0, 0.0, 1.0, 0.5)
+pos[2] = (0,0,1); size[2] = 2./3.; color[2] = (0.0, 1.0, 0.0, 0.5)
+
+z = 0.5
+d = 6.0
+for i in range(3,53):
+    pos[i] = (0,0,z)
+    size[i] = 2./d
+    color[i] = (0.0, 1.0, 0.0, 0.5)
+    z *= 0.5
+    d *= 2.0
     
-#sp = gl.GLScatterPlotItem(pos=pos, sizes=size, colors=color, pxMode=False)
+sp1 = gl.GLScatterPlotItem(pos=pos, size=size, color=color, pxMode=False)
+sp1.translate(5,5,0)
+w.addItem(sp1)
+
 
+##
+##  Second example shows a volume of points with rapidly updating color
+##  and pxMode=True
+##
 
-pos = (np.random.random(size=(100000,3)) * 10) - 5
+pos = np.random.random(size=(100000,3))
+pos *= [10,-10,10]
+pos[0] = (0,0,0)
 color = np.ones((pos.shape[0], 4))
-d = (pos**2).sum(axis=1)**0.5
-color[:,3] = np.clip(-np.cos(d*2) * 0.2, 0, 1)
-sp = gl.GLScatterPlotItem(pos=pos, color=color, size=5)
+d2 = (pos**2).sum(axis=1)**0.5
+size = np.random.random(size=pos.shape[0])*10
+sp2 = gl.GLScatterPlotItem(pos=pos, color=(1,1,1,1), size=size)
 phase = 0.
 
+w.addItem(sp2)
+
+
+##
+##  Third example shows a grid of points with rapidly updating position
+##  and pxMode = False
+##
+
+pos3 = np.zeros((100,100,3))
+pos3[:,:,:2] = np.mgrid[:100, :100].transpose(1,2,0) * [-0.1,0.1]
+pos3 = pos3.reshape(10000,3)
+d3 = (pos3**2).sum(axis=1)**0.5
+
+sp3 = gl.GLScatterPlotItem(pos=pos3, color=(1,1,1,.3), size=0.1, pxMode=False)
+
+w.addItem(sp3)
+
+
 def update():
-    global phase, color, sp, d
-    s = -np.cos(d*2+phase)
-    color[:,3] = np.clip(s * 0.2, 0, 1)
+    ## update volume colors
+    global phase, sp2, d2
+    s = -np.cos(d2*2+phase)
+    color = np.empty((len(d2),4), dtype=np.float32)
+    color[:,3] = np.clip(s * 0.1, 0, 1)
     color[:,0] = np.clip(s * 3.0, 0, 1)
     color[:,1] = np.clip(s * 1.0, 0, 1)
     color[:,2] = np.clip(s ** 3, 0, 1)
-    
-    sp.setData(color=color)
+    sp2.setData(color=color)
     phase -= 0.1
     
+    ## update surface positions and colors
+    global sp3, d3, pos3
+    z = -np.cos(d3*2+phase)
+    pos3[:,2] = z
+    color = np.empty((len(d3),4), dtype=np.float32)
+    color[:,3] = 0.3
+    color[:,0] = np.clip(z * 3.0, 0, 1)
+    color[:,1] = np.clip(z * 1.0, 0, 1)
+    color[:,2] = np.clip(z ** 3, 0, 1)
+    sp3.setData(pos=pos3, color=color)
+    
 t = QtCore.QTimer()
 t.timeout.connect(update)
 t.start(50)
 
-w.addItem(sp)
 
 ## Start Qt event loop unless running in interactive mode.
 if sys.flags.interactive != 1:

examples/ROIExamples.py

@@ -36,12 +36,16 @@ img1a = pg.ImageItem(arr)
 v1a.addItem(img1a)
 img1b = pg.ImageItem()
 v1b.addItem(img1b)
+v1a.disableAutoRange('xy')
+v1b.disableAutoRange('xy')
+v1a.autoRange()
+v1b.autoRange()
 
 rois = []
 rois.append(pg.RectROI([20, 20], [20, 20], pen=(0,9)))
 rois[-1].addRotateHandle([1,0], [0.5, 0.5])
 rois.append(pg.LineROI([0, 60], [20, 80], width=5, pen=(1,9)))
-rois.append(pg.MultiLineROI([[20, 90], [50, 60], [60, 90]], width=5, pen=(2,9)))
+rois.append(pg.MultiRectROI([[20, 90], [50, 60], [60, 90]], width=5, pen=(2,9)))
 rois.append(pg.EllipseROI([60, 10], [30, 20], pen=(3,9)))
 rois.append(pg.CircleROI([80, 50], [20, 20], pen=(4,9)))
 #rois.append(pg.LineSegmentROI([[110, 50], [20, 20]], pen=(5,9)))
@@ -70,6 +74,10 @@ r2a = pg.PolyLineROI([[0,0], [10,10], [10,30], [30,10]], closed=True)
 v2a.addItem(r2a)
 r2b = pg.PolyLineROI([[0,-20], [10,-10], [10,-30]], closed=False)
 v2a.addItem(r2b)
+v2a.disableAutoRange('xy')
+#v2b.disableAutoRange('xy')
+v2a.autoRange()
+#v2b.autoRange()
 
 text = """Building custom ROI types<Br>
 ROIs can be built with a variety of different handle types<br>
@@ -107,6 +115,9 @@ r3b.addRotateHandle([0, 1], [1, 0])
 r3b.addScaleRotateHandle([0, 0.5], [0.5, 0.5])
 r3b.addScaleRotateHandle([1, 0.5], [0.5, 0.5])
 
+v3.disableAutoRange('xy')
+v3.autoRange()
+
 
 text = """Transforming objects with ROI"""
 w4 = w.addLayout(row=1, col=1)
@@ -121,6 +132,9 @@ img4 = pg.ImageItem(arr)
 v4.addItem(r4)
 img4.setParentItem(r4)
 
+v4.disableAutoRange('xy')
+v4.autoRange()
+
 
 
 

graphicsItems/GradientEditorItem.py

@@ -165,6 +165,9 @@ class TickSliderItem(GraphicsWidget):
         tick.setPos(pos)
         self.ticks[tick] = float(newX) / self.length
     
+    def tickMoveFinished(self, tick):
+        pass
+    
     def tickClicked(self, tick, ev):
         if ev.button() == QtCore.Qt.RightButton:
             self.removeTick(tick)
@@ -340,16 +343,18 @@ class GradientEditorItem(TickSliderItem):
     customizable by the user. :class: `GradientWidget <pyqtgraph.GradientWidget>` provides a widget
     with a GradientEditorItem that can be added to a GUI. 
     
-    ======================== ===========================================================
+    ================================ ===========================================================
     **Signals**
-    sigGradientChanged(self) Signal is emitted anytime the gradient changes. The signal 
-                             is emitted in real time while ticks are being dragged or 
-                             colors are being changed.
-    ======================== ===========================================================    
+    sigGradientChanged(self)         Signal is emitted anytime the gradient changes. The signal 
+                                     is emitted in real time while ticks are being dragged or 
+                                     colors are being changed.
+    sigGradientChangeFinished(self)  Signal is emitted when the gradient is finished changing.
+    ================================ ===========================================================    
  
     """
     
     sigGradientChanged = QtCore.Signal(object)
+    sigGradientChangeFinished = QtCore.Signal(object)
     
     def __init__(self, *args, **kargs):
         """
@@ -381,6 +386,7 @@ class GradientEditorItem(TickSliderItem):
         
         self.colorDialog.currentColorChanged.connect(self.currentColorChanged)
         self.colorDialog.rejected.connect(self.currentColorRejected)
+        self.colorDialog.accepted.connect(self.currentColorAccepted)
         
         self.backgroundRect.setParentItem(self)
         self.gradRect.setParentItem(self)
@@ -508,6 +514,9 @@ class GradientEditorItem(TickSliderItem):
         self.setTickColor(self.currentTick, self.currentTickColor)
         self.updateGradient()
         
+    def currentColorAccepted(self):
+        self.sigGradientChangeFinished.emit(self)
+        
     def tickClicked(self, tick, ev):
         #private
         if ev.button() == QtCore.Qt.LeftButton:
@@ -533,6 +542,9 @@ class GradientEditorItem(TickSliderItem):
         TickSliderItem.tickMoved(self, tick, pos)
         self.updateGradient()
 
+    def tickMoveFinished(self, tick):
+        self.sigGradientChangeFinished.emit(self)
+    
 
     def getGradient(self):
         """Return a QLinearGradient object."""
@@ -669,7 +681,7 @@ class GradientEditorItem(TickSliderItem):
         TickSliderItem.mouseReleaseEvent(self, ev)
         self.updateGradient()
         
-    def addTick(self, x, color=None, movable=True):
+    def addTick(self, x, color=None, movable=True, finish=True):
         """
         Add a tick to the gradient. Return the tick.
         
@@ -688,7 +700,17 @@ class GradientEditorItem(TickSliderItem):
         t = TickSliderItem.addTick(self, x, color=color, movable=movable)
         t.colorChangeAllowed = True
         t.removeAllowed = True
+        
+        if finish:
+            self.sigGradientChangeFinished.emit(self)
         return t
+
+
+    def removeTick(self, tick, finish=True):
+        TickSliderItem.removeTick(self, tick)
+        if finish:
+            self.sigGradientChangeFinished.emit(self)
+        
         
     def saveState(self):
         """
@@ -723,13 +745,14 @@ class GradientEditorItem(TickSliderItem):
         ## public
         self.setColorMode(state['mode'])
         for t in list(self.ticks.keys()):
-            self.removeTick(t)
+            self.removeTick(t, finish=False)
         for t in state['ticks']:
             c = QtGui.QColor(*t[1])
-            self.addTick(t[0], c)
+            self.addTick(t[0], c, finish=False)
         self.updateGradient()
+        self.sigGradientChangeFinished.emit(self)
 
-
+        
 class Tick(GraphicsObject):
     ## private class
     
@@ -791,6 +814,7 @@ class Tick(GraphicsObject):
             if ev.isFinish():
                 self.moving = False
                 self.sigMoved.emit(self)
+                self.view().tickMoveFinished(self)
 
     def mouseClickEvent(self, ev):
         if  ev.button() == QtCore.Qt.RightButton and self.moving:

graphicsItems/GraphicsItem.py

@@ -433,4 +433,18 @@ class GraphicsItem(object):
         """
         Called whenever the transformation matrix of the view has changed.
         """
-        pass
\ No newline at end of file
+        pass
+    
+    #def prepareGeometryChange(self):
+        #self._qtBaseClass.prepareGeometryChange(self)
+        #self.informViewBoundsChanged()
+        
+    def informViewBoundsChanged(self):
+        """
+        Inform this item's container ViewBox that the bounds of this item have changed.
+        This is used by ViewBox to react if auto-range is enabled.
+        """
+        view = self.getViewBox()
+        if view is not None and hasattr(view, 'implements') and view.implements('ViewBox'):
+            view.itemBoundsChanged(self)  ## inform view so it can update its range if it wants
+        
\ No newline at end of file

graphicsItems/GraphicsObject.py

@@ -11,10 +11,13 @@ class GraphicsObject(GraphicsItem, QtGui.QGraphicsObject):
     _qtBaseClass = QtGui.QGraphicsObject
     def __init__(self, *args):
         QtGui.QGraphicsObject.__init__(self, *args)
+        self.setFlag(self.ItemSendsGeometryChanges)
         GraphicsItem.__init__(self)
         
     def itemChange(self, change, value):
         ret = QtGui.QGraphicsObject.itemChange(self, change, value)
         if change in [self.ItemParentHasChanged, self.ItemSceneHasChanged]:
             self._updateView()
+        if change in [self.ItemPositionHasChanged, self.ItemTransformHasChanged]:
+            self.informViewBoundsChanged()
         return ret

graphicsItems/PlotDataItem.py

@@ -361,9 +361,11 @@ class PlotDataItem(GraphicsObject):
         
         self.updateItems()
         prof.mark('update items')
+        
         view = self.getViewBox()
         if view is not None:
             view.itemBoundsChanged(self)  ## inform view so it can update its range if it wants
+        
         self.sigPlotChanged.emit(self)
         prof.mark('emit')
         prof.finish()

graphicsItems/PlotItem/PlotItem.py

@@ -506,12 +506,14 @@ class PlotItem(GraphicsWidget):
             self.curves.append(item)
             #self.addItem(c)
             
+        if hasattr(item, 'setLogMode'):
+            item.setLogMode(self.ctrl.logXCheck.isChecked(), self.ctrl.logYCheck.isChecked())
+            
         if isinstance(item, PlotDataItem):
             ## configure curve for this plot
             (alpha, auto) = self.alphaState()
             item.setAlpha(alpha, auto)
             item.setFftMode(self.ctrl.fftCheck.isChecked())
-            item.setLogMode(self.ctrl.logXCheck.isChecked(), self.ctrl.logYCheck.isChecked())
             item.setDownsampling(self.downsampleMode())
             item.setPointMode(self.pointMode())
             
@@ -526,6 +528,7 @@ class PlotItem(GraphicsWidget):
             #c.connect(c, QtCore.SIGNAL('plotChanged'), self.plotChanged)
             #item.sigPlotChanged.connect(self.plotChanged)
             #self.plotChanged()
+            
 
     def addDataItem(self, item, *args):
         print("PlotItem.addDataItem is deprecated. Use addItem instead.")
@@ -878,8 +881,9 @@ class PlotItem(GraphicsWidget):
     def updateLogMode(self):
         x = self.ctrl.logXCheck.isChecked()
         y = self.ctrl.logYCheck.isChecked()
-        for c in self.curves:
-            c.setLogMode(x,y)
+        for i in self.items:
+            if hasattr(i, 'setLogMode'):
+                i.setLogMode(x,y)
         self.getAxis('bottom').setLogMode(x)
         self.getAxis('top').setLogMode(x)
         self.getAxis('left').setLogMode(y)

graphicsItems/ROI.py

@@ -28,7 +28,7 @@ from .UIGraphicsItem import UIGraphicsItem
 __all__ = [
     'ROI', 
     'TestROI', 'RectROI', 'EllipseROI', 'CircleROI', 'PolygonROI', 
-    'LineROI', 'MultiLineROI', 'LineSegmentROI', 'PolyLineROI', 'SpiralROI',