# -*- coding: utf-8 -*- """ widgets.py - Interactive graphics items for GraphicsView (ROI widgets) Copyright 2010 Luke Campagnola Distributed under MIT/X11 license. See license.txt for more infomation. Implements a series of graphics items which display movable/scalable/rotatable shapes for use as region-of-interest markers. ROI class automatically handles extraction of array data from ImageItems. """ from PyQt4 import QtCore, QtGui, QtOpenGL, QtSvg from numpy import array, arccos, dot, pi, zeros, vstack, ubyte, fromfunction, ceil, floor from numpy.linalg import norm import scipy.ndimage as ndimage from Point import * from math import cos, sin def rectStr(r): return "[%f, %f] + [%f, %f]" % (r.x(), r.y(), r.width(), r.height()) ## Multiple inheritance not allowed in PyQt. Retarded workaround: class QObjectWorkaround: def __init__(self): self._qObj_ = QtCore.QObject() def __getattr__(self, attr): if attr == '_qObj_': raise Exception("QObjectWorkaround not initialized!") return getattr(self._qObj_, attr) def connect(self, *args): return QtCore.QObject.connect(self._qObj_, *args) class ROI(QtGui.QGraphicsItem, QObjectWorkaround): def __init__(self, pos, size=Point(1, 1), angle=0.0, invertible=False, maxBounds=None, snapSize=1.0, scaleSnap=False, translateSnap=False, rotateSnap=False, parent=None): QObjectWorkaround.__init__(self) QtGui.QGraphicsItem.__init__(self, parent) pos = Point(pos) size = Point(size) self.aspectLocked = False self.translatable = True self.pen = QtGui.QPen(QtGui.QColor(255, 255, 255)) self.handlePen = QtGui.QPen(QtGui.QColor(150, 255, 255)) self.handles = [] self.state = {'pos': pos, 'size': size, 'angle': angle} self.lastState = None self.setPos(pos) self.rotate(-angle) self.setZValue(10) self.handleSize = 4 self.invertible = invertible self.maxBounds = maxBounds self.snapSize = snapSize self.translateSnap = translateSnap self.rotateSnap = rotateSnap self.scaleSnap = scaleSnap self.setFlag(self.ItemIsSelectable, True) def setZValue(self, z): QtGui.QGraphicsItem.setZValue(self, z) for h in self.handles: h['item'].setZValue(z+1) def sceneBounds(self): return self.sceneTransform().mapRect(self.boundingRect()) def parentBounds(self): return self.mapToParent(self.boundingRect()).boundingRect() def setPen(self, pen): self.pen = pen self.update() def setPos(self, pos, update=True): pos = Point(pos) self.state['pos'] = pos QtGui.QGraphicsItem.setPos(self, pos) if update: self.handleChange() def setSize(self, size, update=True): size = Point(size) self.prepareGeometryChange() self.state['size'] = size if update: self.updateHandles() self.handleChange() def addTranslateHandle(self, pos, axes=None, item=None): pos = Point(pos) return self.addHandle({'type': 't', 'pos': pos, 'item': item}) def addScaleHandle(self, pos, center, axes=None, item=None): pos = Point(pos) center = Point(center) info = {'type': 's', 'center': center, 'pos': pos, 'item': item} if pos.x() == center.x(): info['xoff'] = True if pos.y() == center.y(): info['yoff'] = True return self.addHandle(info) def addRotateHandle(self, pos, center, item=None): pos = Point(pos) center = Point(center) return self.addHandle({'type': 'r', 'center': center, 'pos': pos, 'item': item}) def addScaleRotateHandle(self, pos, center, item=None): pos = Point(pos) center = Point(center) if pos[0] != center[0] and pos[1] != center[1]: raise Exception("Scale/rotate handles must have either the same x or y coordinate as their center point.") return self.addHandle({'type': 'sr', 'center': center, 'pos': pos, 'item': item}) def addHandle(self, info): if not info.has_key('item') or info['item'] is None: #print "BEFORE ADD CHILD:", self.childItems() h = Handle(self.handleSize, typ=info['type'], pen=self.handlePen, parent=self) #print "AFTER ADD CHILD:", self.childItems() h.setPos(info['pos'] * self.state['size']) info['item'] = h else: h = info['item'] iid = len(self.handles) h.connectROI(self, iid) #h.mouseMoveEvent = lambda ev: self.pointMoveEvent(iid, ev) #h.mousePressEvent = lambda ev: self.pointPressEvent(iid, ev) #h.mouseReleaseEvent = lambda ev: self.pointReleaseEvent(iid, ev) self.handles.append(info) h.setZValue(self.zValue()+1) #if self.isSelected(): #h.show() #else: #h.hide() return h def mapSceneToParent(self, pt): return self.mapToParent(self.mapFromScene(pt)) def setSelected(self, s): QtGui.QGraphicsItem.setSelected(self, s) #print "select", self, s if s: for h in self.handles: h['item'].show() else: for h in self.handles: h['item'].hide() def mousePressEvent(self, ev): if ev.button() == QtCore.Qt.LeftButton: self.setSelected(True) if self.translatable: self.cursorOffset = self.scenePos() - ev.scenePos() self.emit(QtCore.SIGNAL('regionChangeStarted'), self) ev.accept() else: ev.ignore() def mouseMoveEvent(self, ev): #print "mouse move", ev.pos() if self.translatable: snap = None if self.translateSnap or (ev.modifiers() & QtCore.Qt.ControlModifier): snap = Point(self.snapSize, self.snapSize) newPos = ev.scenePos() + self.cursorOffset newPos = self.mapSceneToParent(newPos) self.translate(newPos - self.pos(), snap=snap) def mouseReleaseEvent(self, ev): if self.translatable: self.emit(QtCore.SIGNAL('regionChangeFinished'), self) def pointPressEvent(self, pt, ev): #print "press" self.emit(QtCore.SIGNAL('regionChangeStarted'), self) #self.pressPos = self.mapFromScene(ev.scenePos()) #self.pressHandlePos = self.handles[pt]['item'].pos() def pointReleaseEvent(self, pt, ev): #print "release" self.emit(QtCore.SIGNAL('regionChangeFinished'), self) def stateCopy(self): sc = {} sc['pos'] = Point(self.state['pos']) sc['size'] = Point(self.state['size']) sc['angle'] = self.state['angle'] return sc def updateHandles(self): #print "update", self.handles for h in self.handles: #print " try", h if h['item'] in self.childItems(): p = h['pos'] h['item'].setPos(h['pos'] * self.state['size']) #else: #print " Not child!", self.childItems() def checkPointMove(self, pt, pos, modifiers): return True def pointMoveEvent(self, pt, ev): self.movePoint(pt, ev.scenePos(), ev.modifiers()) def movePoint(self, pt, pos, modifiers=QtCore.Qt.KeyboardModifier()): #print "movePoint", pos newState = self.stateCopy() h = self.handles[pt] #p0 = self.mapToScene(h['item'].pos()) p0 = self.mapToScene(h['pos'] * self.state['size']) p1 = Point(pos) p0 = self.mapSceneToParent(p0) p1 = self.mapSceneToParent(p1) if h.has_key('center'): c = h['center'] cs = c * self.state['size'] #lpOrig = h['pos'] - #lp0 = self.mapFromScene(p0) - cs #lp1 = self.mapFromScene(p1) - cs lp0 = self.mapFromParent(p0) - cs lp1 = self.mapFromParent(p1) - cs if h['type'] == 't': #p0 = Point(self.mapToScene(h['item'].pos())) #p1 = Point(pos + self.mapToScene(self.pressHandlePos) - self.mapToScene(self.pressPos)) snap = None if self.translateSnap or (modifiers & QtCore.Qt.ControlModifier): snap = Point(self.snapSize, self.snapSize) self.translate(p1-p0, snap=snap, update=False) elif h['type'] == 's': #c = h['center'] #cs = c * self.state['size'] #p1 = (self.mapFromScene(ev.scenePos()) + self.pressHandlePos - self.pressPos) - cs if h['center'][0] == h['pos'][0]: lp1[0] = 0 if h['center'][1] == h['pos'][1]: lp1[1] = 0 if self.scaleSnap or (modifiers & QtCore.Qt.ControlModifier): lp1[0] = round(lp1[0] / self.snapSize) * self.snapSize lp1[1] = round(lp1[1] / self.snapSize) * self.snapSize hs = h['pos'] - c if hs[0] == 0: hs[0] = 1 if hs[1] == 0: hs[1] = 1 newSize = lp1 / hs if newSize[0] == 0: newSize[0] = newState['size'][0] if newSize[1] == 0: newSize[1] = newState['size'][1] if not self.invertible: if newSize[0] < 0: newSize[0] = newState['size'][0] if newSize[1] < 0: newSize[1] = newState['size'][1] if self.aspectLocked: newSize[0] = newSize[1] s0 = c * self.state['size'] s1 = c * newSize cc = self.mapToParent(s0 - s1) - self.mapToParent(Point(0, 0)) newState['size'] = newSize newState['pos'] = newState['pos'] + cc if self.maxBounds is not None: r = self.stateRect(newState) if not self.maxBounds.contains(r): return self.setPos(newState['pos'], update=False) self.prepareGeometryChange() self.state = newState self.updateHandles() elif h['type'] == 'r': #newState = self.stateCopy() #c = h['center'] #cs = c * self.state['size'] #p0 = Point(h['item'].pos()) - cs #p1 = (self.mapFromScene(ev.scenePos()) + self.pressHandlePos - self.pressPos) - cs if lp1.length() == 0 or lp0.length() == 0: return ang = newState['angle'] + lp0.angle(lp1) if ang is None: return if self.rotateSnap or (modifiers & QtCore.Qt.ControlModifier): ang = round(ang / (pi/12.)) * (pi/12.) tr = QtGui.QTransform() tr.rotate(-ang * 180. / pi) cc = self.mapToParent(cs) - (tr.map(cs) + self.state['pos']) newState['angle'] = ang newState['pos'] = newState['pos'] + cc if self.maxBounds is not None: r = self.stateRect(newState) if not self.maxBounds.contains(r): return self.setTransform(tr) self.setPos(newState['pos'], update=False) self.state = newState elif h['type'] == 'sr': #newState = self.stateCopy() if h['center'][0] == h['pos'][0]: scaleAxis = 1 else: scaleAxis = 0 #c = h['center'] #cs = c * self.state['size'] #p0 = Point(h['item'].pos()) - cs #p1 = (self.mapFromScene(ev.scenePos()) + self.pressHandlePos - self.pressPos) - cs if lp1.length() == 0 or lp0.length() == 0: return ang = newState['angle'] + lp0.angle(lp1) if ang is None: return if self.rotateSnap or (modifiers & QtCore.Qt.ControlModifier): ang = round(ang / (pi/12.)) * (pi/12.) hs = abs(h['pos'][scaleAxis] - c[scaleAxis]) newState['size'][scaleAxis] = lp1.length() / hs if self.scaleSnap or (modifiers & QtCore.Qt.ControlModifier): newState['size'][scaleAxis] = round(newState['size'][scaleAxis] / self.snapSize) * self.snapSize if newState['size'][scaleAxis] == 0: newState['size'][scaleAxis] = 1 c1 = c * newState['size'] tr = QtGui.QTransform() tr.rotate(-ang * 180. / pi) cc = self.mapToParent(cs) - (tr.map(c1) + self.state['pos']) newState['angle'] = ang newState['pos'] = newState['pos'] + cc if self.maxBounds is not None: r = self.stateRect(newState) if not self.maxBounds.contains(r): return self.setTransform(tr) self.setPos(newState['pos'], update=False) self.prepareGeometryChange() self.state = newState self.updateHandles() self.handleChange() def handleChange(self): changed = False if self.lastState is None: changed = True else: for k in self.state.keys(): if self.state[k] != self.lastState[k]: #print "state %s has changed; emit signal" % k changed = True self.lastState = self.stateCopy() if changed: self.update() self.emit(QtCore.SIGNAL('regionChanged'), self) def scale(self, s, center=[0,0]): c = self.mapToScene(Point(center) * self.state['size']) self.prepareGeometryChange() self.state['size'] = self.state['size'] * s c1 = self.mapToScene(Point(center) * self.state['size']) self.state['pos'] = self.state['pos'] + c - c1 self.setPos(self.state['pos']) self.updateHandles() def translate(self, *args, **kargs): """accepts either (x, y, snap) or ([x,y], snap) as arguments""" if 'snap' not in kargs: snap = None else: snap = kargs['snap'] if len(args) == 1: pt = args[0] else: pt = args newState = self.stateCopy() newState['pos'] = newState['pos'] + pt if snap != None: newState['pos'][0] = round(newState['pos'][0] / snap[0]) * snap[0] newState['pos'][1] = round(newState['pos'][1] / snap[1]) * snap[1] #d = ev.scenePos() - self.mapToScene(self.pressPos) if self.maxBounds is not None: r = self.stateRect(newState) #r0 = self.sceneTransform().mapRect(self.boundingRect()) d = Point(0,0) if self.maxBounds.left() > r.left(): d[0] = self.maxBounds.left() - r.left() elif self.maxBounds.right() < r.right(): d[0] = self.maxBounds.right() - r.right() if self.maxBounds.top() > r.top(): d[1] = self.maxBounds.top() - r.top() elif self.maxBounds.bottom() < r.bottom(): d[1] = self.maxBounds.bottom() - r.bottom() newState['pos'] += d self.state['pos'] = newState['pos'] self.setPos(self.state['pos']) #if 'update' not in kargs or kargs['update'] is True: self.handleChange() def stateRect(self, state): r = QtCore.QRectF(0, 0, state['size'][0], state['size'][1]) tr = QtGui.QTransform() tr.rotate(-state['angle'] * 180 / pi) r = tr.mapRect(r) return r.adjusted(state['pos'][0], state['pos'][1], state['pos'][0], state['pos'][1]) def boundingRect(self): return QtCore.QRectF(0, 0, self.state['size'][0], self.state['size'][1]) def paint(self, p, opt, widget): r = self.boundingRect() p.setRenderHint(QtGui.QPainter.Antialiasing) p.setPen(self.pen) p.drawRect(r) def getArraySlice(self, data, img, axes=(0,1), returnSlice=True): """Return a tuple of slice objects that can be used to slice the region from data covered by this ROI. Also returns the transform which maps the ROI into data coordinates. If returnSlice is set to False, the function returns a pair of tuples with the values that would have been used to generate the slice objects. ((ax0Start, ax0Stop), (ax1Start, ax1Stop))""" #print "getArraySlice" ## Determine shape of array along ROI axes dShape = (data.shape[axes[0]], data.shape[axes[1]]) #print " dshape", dShape ## Determine transform that maps ROI bounding box to image coordinates tr = self.sceneTransform() * img.sceneTransform().inverted()[0] ## Modify transform to scale from image coords to data coords #m = QtGui.QTransform() tr.scale(float(dShape[0]) / img.width(), float(dShape[1]) / img.height()) #tr = tr * m ## Transform ROI bounds into data bounds dataBounds = tr.mapRect(self.boundingRect()) #print " boundingRect:", self.boundingRect() #print " dataBounds:", dataBounds ## Intersect transformed ROI bounds with data bounds intBounds = dataBounds.intersect(QtCore.QRectF(0, 0, dShape[0], dShape[1])) #print " intBounds:", intBounds ## Determine index values to use when referencing the array. bounds = ( (int(min(intBounds.left(), intBounds.right())), int(1+max(intBounds.left(), intBounds.right()))), (int(min(intBounds.bottom(), intBounds.top())), int(1+max(intBounds.bottom(), intBounds.top()))) ) #print " bounds:", bounds if returnSlice: ## Create slice objects sl = [slice(None)] * data.ndim sl[axes[0]] = slice(*bounds[0]) sl[axes[1]] = slice(*bounds[1]) return tuple(sl), tr else: return bounds, tr def getArrayRegion(self, data, img, axes=(0,1)): ## transpose data so x and y are the first 2 axes trAx = range(0, data.ndim) trAx.remove(axes[0]) trAx.remove(axes[1]) tr1 = tuple(axes) + tuple(trAx) arr = data.transpose(tr1) ## Determine the minimal area of the data we will need (dataBounds, roiDataTransform) = self.getArraySlice(data, img, returnSlice=False, axes=axes) ## Pad data boundaries by 1px if possible dataBounds = ( (max(dataBounds[0][0]-1, 0), min(dataBounds[0][1]+1, arr.shape[0])), (max(dataBounds[1][0]-1, 0), min(dataBounds[1][1]+1, arr.shape[1])) ) ## Extract minimal data from array arr1 = arr[dataBounds[0][0]:dataBounds[0][1], dataBounds[1][0]:dataBounds[1][1]] ## Update roiDataTransform to reflect this extraction roiDataTransform *= QtGui.QTransform().translate(-dataBounds[0][0], -dataBounds[1][0]) ### (roiDataTransform now maps from ROI coords to extracted data coords) ## Rotate array if abs(self.state['angle']) > 1e-5: arr2 = ndimage.rotate(arr1, self.state['angle'] * 180 / pi, order=1) ## update data transforms to reflect this rotation rot = QtGui.QTransform().rotate(self.state['angle'] * 180 / pi) roiDataTransform *= rot ## The rotation also causes a shift which must be accounted for: dataBound = QtCore.QRectF(0, 0, arr1.shape[0], arr1.shape[1]) rotBound = rot.mapRect(dataBound) roiDataTransform *= QtGui.QTransform().translate(-rotBound.left(), -rotBound.top()) else: arr2 = arr1 ### Shift off partial pixels # 1. map ROI into current data space roiBounds = roiDataTransform.mapRect(self.boundingRect()) # 2. Determine amount to shift data shift = (int(roiBounds.left()) - roiBounds.left(), int(roiBounds.bottom()) - roiBounds.bottom()) if abs(shift[0]) > 1e-6 or abs(shift[1]) > 1e-6: # 3. pad array with 0s before shifting arr2a = zeros((arr2.shape[0]+2, arr2.shape[1]+2) + arr2.shape[2:], dtype=arr2.dtype) arr2a[1:-1, 1:-1] = arr2 # 4. shift array and udpate transforms arr3 = ndimage.shift(arr2a, shift + (0,)*(arr2.ndim-2), order=1) roiDataTransform *= QtGui.QTransform().translate(1+shift[0], 1+shift[1]) else: arr3 = arr2 ### Extract needed region from rotated/shifted array # 1. map ROI into current data space (round these values off--they should be exact integer values at this point) roiBounds = roiDataTransform.mapRect(self.boundingRect()) #print self, roiBounds.height() #import traceback #traceback.print_stack() roiBounds = QtCore.QRect(round(roiBounds.left()), round(roiBounds.top()), round(roiBounds.width()), round(roiBounds.height())) #2. intersect ROI with data bounds dataBounds = roiBounds.intersect(QtCore.QRect(0, 0, arr3.shape[0], arr3.shape[1])) #3. Extract data from array db = dataBounds bounds = ( (db.left(), db.right()+1), (db.top(), db.bottom()+1) ) arr4 = arr3[bounds[0][0]:bounds[0][1], bounds[1][0]:bounds[1][1]] ### Create zero array in size of ROI arr5 = zeros((roiBounds.width(), roiBounds.height()) + arr4.shape[2:], dtype=arr4.dtype) ## Fill array with ROI data orig = Point(dataBounds.topLeft() - roiBounds.topLeft()) subArr = arr5[orig[0]:orig[0]+arr4.shape[0], orig[1]:orig[1]+arr4.shape[1]] subArr[:] = arr4[:subArr.shape[0], :subArr.shape[1]] ## figure out the reverse transpose order tr2 = array(tr1) for i in range(0, len(tr2)): tr2[tr1[i]] = i tr2 = tuple(tr2) ## Untranspose array before returning return arr5.transpose(tr2) class Handle(QtGui.QGraphicsItem): def __init__(self, radius, typ=None, pen=QtGui.QPen(QtGui.QColor(200, 200, 220)), parent=None): #print " create item with parent", parent self.bounds = QtCore.QRectF(-1e-10, -1e-10, 2e-10, 2e-10) QtGui.QGraphicsItem.__init__(self, parent) self.setZValue(11) self.roi = [] self.radius = radius self.typ = typ self.prepareGeometryChange() self.pen = pen if typ == 't': self.sides = 4 self.startAng = pi/4 elif typ == 's': self.sides = 4 self.startAng = 0 elif typ == 'r': self.sides = 12 self.startAng = 0 elif typ == 'sr': self.sides = 12 self.startAng = 0 else: self.sides = 4 self.startAng = pi/4 def connectROI(self, roi, i): self.roi.append((roi, i)) def boundingRect(self): return self.bounds def mousePressEvent(self, ev): #print "handle press" if ev.button() != QtCore.Qt.LeftButton: ev.ignore() return self.cursorOffset = self.scenePos() - ev.scenePos() for r in self.roi: r[0].pointPressEvent(r[1], ev) #print " accepted." ev.accept() def mouseReleaseEvent(self, ev): #print "release" for r in self.roi: r[0].pointReleaseEvent(r[1], ev) def mouseMoveEvent(self, ev): #print "handle mouseMove", ev.pos() pos = ev.scenePos() + self.cursorOffset self.movePoint(pos, ev.modifiers()) def movePoint(self, pos, modifiers=QtCore.Qt.KeyboardModifier()): for r in self.roi: if not r[0].checkPointMove(r[1], pos, modifiers): return #print "point moved; inform %d ROIs" % len(self.roi) for r in self.roi: r[0].movePoint(r[1], pos, modifiers) def paint(self, p, opt, widget): m = p.transform() mi = m.inverted()[0] ## Determine length of unit vector in painter's coords size = mi.map(Point(self.radius, self.radius)) - mi.map(Point(0, 0)) size = (size.x()*size.x() + size.y() * size.y()) ** 0.5 bounds = QtCore.QRectF(-size, -size, size*2, size*2) if bounds != self.bounds: self.bounds = bounds self.prepareGeometryChange() p.setRenderHint(QtGui.QPainter.Antialiasing) p.setPen(self.pen) ang = self.startAng dt = 2*pi / self.sides for i in range(0, self.sides): x1 = size * cos(ang) y1 = size * sin(ang) x2 = size * cos(ang+dt) y2 = size * sin(ang+dt) ang += dt p.drawLine(Point(x1, y1), Point(x2, y2)) class TestROI(ROI): def __init__(self, pos, size, **args): #QtGui.QGraphicsRectItem.__init__(self, pos[0], pos[1], size[0], size[1]) ROI.__init__(self, pos, size, **args) #self.addTranslateHandle([0, 0]) self.addTranslateHandle([0.5, 0.5]) self.addScaleHandle([1, 1], [0, 0]) self.addScaleHandle([0, 0], [1, 1]) self.addScaleRotateHandle([1, 0.5], [0.5, 0.5]) self.addScaleHandle([0.5, 1], [0.5, 0.5]) self.addRotateHandle([1, 0], [0, 0]) self.addRotateHandle([0, 1], [1, 1]) class RectROI(ROI): def __init__(self, pos, size, centered=False, sideScalers=False, **args): #QtGui.QGraphicsRectItem.__init__(self, 0, 0, size[0], size[1]) ROI.__init__(self, pos, size, **args) if centered: center = [0.5, 0.5] else: center = [0, 0] #self.addTranslateHandle(center) self.addScaleHandle([1, 1], center) if sideScalers: self.addScaleHandle([1, 0.5], [center[0], 0.5]) self.addScaleHandle([0.5, 1], [0.5, center[1]]) class LineROI(ROI): def __init__(self, pos1, pos2, width, **args): pos1 = Point(pos1) pos2 = Point(pos2) d = pos2-pos1 l = d.length() ang = Point(1, 0).angle(d) c = Point(-width/2. * sin(ang), -width/2. * cos(ang)) pos1 = pos1 + c ROI.__init__(self, pos1, size=Point(l, width), angle=ang*180/pi, **args) self.addScaleRotateHandle([0, 0.5], [1, 0.5]) self.addScaleRotateHandle([1, 0.5], [0, 0.5]) self.addScaleHandle([0.5, 1], [0.5, 0.5]) class MultiLineROI(QtGui.QGraphicsItem, QObjectWorkaround): def __init__(self, points, width, **args): QObjectWorkaround.__init__(self) QtGui.QGraphicsItem.__init__(self) self.roiArgs = args if len(points) < 2: raise Exception("Must start with at least 2 points") self.lines = [] self.lines.append(ROI([0, 0], [1, 5], parent=self)) self.lines[-1].addScaleHandle([0.5, 1], [0.5, 0.5]) h = self.lines[-1].addScaleRotateHandle([0, 0.5], [1, 0.5]) h.movePoint(points[0]) h.movePoint(points[0]) for i in range(1, len(points)): h = self.lines[-1].addScaleRotateHandle([1, 0.5], [0, 0.5]) if i < len(points)-1: self.lines.append(ROI([0, 0], [1, 5], parent=self)) self.lines[-1].addScaleRotateHandle([0, 0.5], [1, 0.5], item=h) h.movePoint(points[i]) h.movePoint(points[i]) for l in self.lines: l.translatable = False #self.addToGroup(l) l.connect(QtCore.SIGNAL('regionChanged'), self.roiChangedEvent) l.connect(QtCore.SIGNAL('regionChangeStarted'), self.roiChangeStartedEvent) l.connect(QtCore.SIGNAL('regionChangeFinished'), self.roiChangeFinishedEvent) def paint(self, *args): pass def boundingRect(self): return QtCore.QRectF() def roiChangedEvent(self): w = self.lines[0].state['size'][1] for l in self.lines[1:]: w0 = l.state['size'][1] l.scale([1.0, w/w0], center=[0.5,0.5]) self.emit(QtCore.SIGNAL('regionChanged'), self) def roiChangeStartedEvent(self): self.emit(QtCore.SIGNAL('regionChangeStarted'), self) def roiChangeFinishedEvent(self): self.emit(QtCore.SIGNAL('regionChangeFinished'), self) def getArrayRegion(self, arr, img=None): rgns = [] for l in self.lines: rgn = l.getArrayRegion(arr, img) if rgn is None: continue #return None rgns.append(rgn) #print l.state['size'] #print [(r.shape) for r in rgns] return vstack(rgns) class EllipseROI(ROI): def __init__(self, pos, size, **args): #QtGui.QGraphicsRectItem.__init__(self, 0, 0, size[0], size[1]) ROI.__init__(self, pos, size, **args) self.addRotateHandle([1.0, 0.5], [0.5, 0.5]) self.addScaleHandle([0.5*2.**-0.5 + 0.5, 0.5*2.**-0.5 + 0.5], [0.5, 0.5]) def paint(self, p, opt, widget): r = self.boundingRect() p.setRenderHint(QtGui.QPainter.Antialiasing) p.setPen(self.pen) p.scale(r.width(), r.height())## workaround for GL bug r = QtCore.QRectF(r.x()/r.width(), r.y()/r.height(), 1,1) p.drawEllipse(r) def getArrayRegion(self, arr, img=None): arr = ROI.getArrayRegion(self, arr, img) if arr is None or arr.shape[0] == 0 or arr.shape[1] == 0: return None w = arr.shape[0] h = arr.shape[1] ## generate an ellipsoidal mask mask = fromfunction(lambda x,y: (((x+0.5)/(w/2.)-1)**2+ ((y+0.5)/(h/2.)-1)**2)**0.5 < 1, (w, h)) return arr * mask def shape(self): self.path = QtGui.QPainterPath() self.path.addEllipse(self.boundingRect()) return self.path class CircleROI(EllipseROI): def __init__(self, pos, size, **args): ROI.__init__(self, pos, size, **args) self.aspectLocked = True #self.addTranslateHandle([0.5, 0.5]) self.addScaleHandle([0.5*2.**-0.5 + 0.5, 0.5*2.**-0.5 + 0.5], [0.5, 0.5])