Initial commit (again)

GraphicsView.py

+# -*- coding: utf-8 -*-
+"""
+GraphicsView.py -   Extension of QGraphicsView
+Copyright 2010  Luke Campagnola
+Distributed under MIT/X11 license. See license.txt for more infomation.
+"""
+
+from PyQt4 import QtCore, QtGui, QtOpenGL, QtSvg
+#from numpy import vstack
+#import time
+from Point import *
+#from vector import *
+
+            
+        
+class GraphicsView(QtGui.QGraphicsView):
+    def __init__(self, *args):
+        """Re-implementation of QGraphicsView that removes scrollbars and allows unambiguous control of the 
+        viewed coordinate range. Also automatically creates a QGraphicsScene and a central QGraphicsWidget
+        that is automatically scaled to the full view geometry.
+        
+        By default, the view coordinate system matches the widget's pixel coordinates and 
+        automatically updates when the view is resized. This can be overridden by setting 
+        autoPixelRange=False. The exact visible range can be set with setRange().
+        
+        The view can be panned using the middle mouse button and scaled using the right mouse button if
+        enabled via enableMouse()."""
+        
+        QtGui.QGraphicsView.__init__(self, *args)
+        self.setViewport(QtOpenGL.QGLWidget())
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(0,0,0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active,QtGui.QPalette.Base,brush)
+        brush = QtGui.QBrush(QtGui.QColor(0,0,0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive,QtGui.QPalette.Base,brush)
+        brush = QtGui.QBrush(QtGui.QColor(244,244,244))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled,QtGui.QPalette.Base,brush)
+        self.setPalette(palette)
+        self.setProperty("cursor",QtCore.QVariant(QtCore.Qt.ArrowCursor))
+        self.setFocusPolicy(QtCore.Qt.StrongFocus)
+        self.setFrameShape(QtGui.QFrame.NoFrame)
+        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.setTransformationAnchor(QtGui.QGraphicsView.NoAnchor)
+        self.setResizeAnchor(QtGui.QGraphicsView.AnchorViewCenter)
+        #self.setResizeAnchor(QtGui.QGraphicsView.NoAnchor)
+        self.setViewportUpdateMode(QtGui.QGraphicsView.SmartViewportUpdate)
+        self.setSceneRect(QtCore.QRectF(-1e10, -1e10, 2e10, 2e10))
+        #self.setInteractive(False)
+        self.lockedViewports = []
+        self.lastMousePos = None
+        #self.setMouseTracking(False)
+        self.aspectLocked = False
+        self.yInverted = True
+        self.range = QtCore.QRectF(0, 0, 1, 1)
+        self.autoPixelRange = True
+        self.currentItem = None
+        self.clearMouse()
+        self.updateMatrix()
+        self.sceneObj = QtGui.QGraphicsScene()
+        self.setScene(self.sceneObj)
+        self.centralWidget = None
+        self.setCentralItem(QtGui.QGraphicsWidget())
+        self.mouseEnabled = False
+        self.scaleCenter = False  ## should scaling center around view center (True) or mouse click (False)
+        self.clickAccepted = False
+        
+    def setCentralItem(self, item):
+        if self.centralWidget is not None:
+            self.scene().removeItem(self.centralWidget)
+        self.centralWidget = item
+        self.sceneObj.addItem(item)
+        
+    def addItem(self, *args):
+        return self.scene().addItem(*args)
+        
+    def enableMouse(self, b=True):
+        self.mouseEnabled = b
+        self.autoPixelRange = (not b)
+        
+    def clearMouse(self):
+        self.mouseTrail = []
+        self.lastButtonReleased = None
+    
+    def resizeEvent(self, ev):
+        if self.autoPixelRange:
+            self.range = QtCore.QRectF(0, 0, self.size().width(), self.size().height())
+        self.setRange(self.range, padding=0, disableAutoPixel=False)
+        self.updateMatrix()
+    
+    def updateMatrix(self, propagate=True):
+        #print "udpateMatrix:"
+        translate = Point(self.range.center())
+        if self.range.width() == 0 or self.range.height() == 0:
+            return
+        scale = Point(self.size().width()/self.range.width(), self.size().height()/self.range.height())
+        
+        m = QtGui.QMatrix()
+        
+        ## First center the viewport at 0
+        self.resetMatrix()
+        center = self.viewportTransform().inverted()[0].map(Point(self.width()/2., self.height()/2.))
+        if self.yInverted:
+            m.translate(center.x(), center.y())
+            #print "  inverted; translate", center.x(), center.y()
+        else:
+            m.translate(center.x(), -center.y())
+            #print "  not inverted; translate", center.x(), -center.y()
+            
+        ## Now scale and translate properly
+        if self.aspectLocked:
+            scale = Point(scale.min())
+        if not self.yInverted:
+            scale = scale * Point(1, -1)
+        m.scale(scale[0], scale[1])
+        #print "  scale:", scale
+        st = translate
+        m.translate(-st[0], -st[1])
+        #print "  translate:", st
+        self.setMatrix(m)
+        self.currentScale = scale
+        
+        if propagate:
+            for v in self.lockedViewports:
+                v.setXRange(self.range, padding=0)
+        
+    def visibleRange(self):
+        r = QtCore.QRectF(self.rect())
+        return self.viewportTransform().inverted()[0].mapRect(r)
+
+    def translate(self, dx, dy):
+        self.range.adjust(dx, dy, dx, dy)
+        self.updateMatrix()
+    
+    def scale(self, sx, sy, center=None):
+        scale = [sx, sy]
+        if self.aspectLocked:
+            scale[0] = scale[1]
+        #adj = (self.range.width()*0.5*(1.0-(1.0/scale[0])), self.range.height()*0.5*(1.0-(1.0/scale[1])))
+        #print "======\n", scale, adj
+        #print self.range
+        #self.range.adjust(adj[0], adj[1], -adj[0], -adj[1])
+        #print self.range
+        
+        if self.scaleCenter:
+            center = None
+        if center is None:
+            center = self.range.center()
+            
+        w = self.range.width()  / scale[0]
+        h = self.range.height() / scale[1]
+        self.range = QtCore.QRectF(center.x() - (center.x()-self.range.left()) / scale[0], center.y() - (center.y()-self.range.top())  /scale[1], w, h)
+        
+        
+        self.updateMatrix()
+
+    def setRange(self, newRect=None, padding=0.05, lockAspect=None, propagate=True, disableAutoPixel=True):
+        if disableAutoPixel:
+            self.autoPixelRange=False
+        if newRect is None:
+            newRect = self.visibleRange()
+            padding = 0
+        padding = Point(padding)
+        newRect = QtCore.QRectF(newRect)
+        pw = newRect.width() * padding[0]
+        ph = newRect.height() * padding[1]
+        self.range = newRect.adjusted(-pw, -ph, pw, ph)
+        #print "New Range:", self.range
+        self.centralWidget.setGeometry(self.range)
+        self.updateMatrix(propagate)
+        self.emit(QtCore.SIGNAL('viewChanged'), self.range)
+        
+        
+    def lockXRange(self, v1):
+        if not v1 in self.lockedViewports:
+            self.lockedViewports.append(v1)
+        
+    def setXRange(self, r, padding=0.05):
+        r1 = QtCore.QRectF(self.range)
+        r1.setLeft(r.left())
+        r1.setRight(r.right())
+        self.setRange(r1, padding=[padding, 0], propagate=False)
+        
+    def setYRange(self, r, padding=0.05):
+        r1 = QtCore.QRectF(self.range)
+        r1.setTop(r.top())
+        r1.setBottom(r.bottom())
+        self.setRange(r1, padding=[0, padding], propagate=False)
+        
+    def invertY(self, invert=True):
+        #if self.yInverted != invert:
+            #self.scale[1] *= -1.
+        self.yInverted = invert
+        self.updateMatrix()
+    
+    
+    def wheelEvent(self, ev):
+        if not self.mouseEnabled:
+            return
+        QtGui.QGraphicsView.wheelEvent(self, ev)
+        sc = 1.001 ** ev.delta()
+        #self.scale *= sc
+        #self.updateMatrix()
+        self.scale(sc, sc)
+        
+        
+    def setAspectLocked(self, s):
+        self.aspectLocked = s
+        
+    #def mouseDoubleClickEvent(self, ev):
+        #QtGui.QGraphicsView.mouseDoubleClickEvent(self, ev)
+        #pass
+        
+    ### This function is here because interactive mode is disabled due to bugs.
+    #def graphicsSceneEvent(self, ev, pev=None, fev=None):
+        #ev1 = GraphicsSceneMouseEvent()
+        #ev1.setPos(QtCore.QPointF(ev.pos().x(), ev.pos().y()))
+        #ev1.setButtons(ev.buttons())
+        #ev1.setButton(ev.button())
+        #ev1.setModifiers(ev.modifiers())
+        #ev1.setScenePos(self.mapToScene(QtCore.QPoint(ev.pos())))
+        #if pev is not None:
+            #ev1.setLastPos(pev.pos())
+            #ev1.setLastScenePos(pev.scenePos())
+            #ev1.setLastScreenPos(pev.screenPos())
+        #if fev is not None:
+            #ev1.setButtonDownPos(fev.pos())
+            #ev1.setButtonDownScenePos(fev.scenePos())
+            #ev1.setButtonDownScreenPos(fev.screenPos())
+        #return ev1
+        
+    def mousePressEvent(self, ev):
+        QtGui.QGraphicsView.mousePressEvent(self, ev)
+        print "Press over:"
+        for i in self.items(ev.pos()):
+            print i.zValue(), int(i.acceptedMouseButtons()), i, i.scenePos()
+        print "Event accepted:", ev.isAccepted()
+        print "Grabber:", self.scene().mouseGrabberItem()
+        if not self.mouseEnabled:
+            return
+        self.lastMousePos = Point(ev.pos())
+        self.mousePressPos = ev.pos()
+        self.clickAccepted = ev.isAccepted()
+        if not self.clickAccepted:
+            self.scene().clearSelection()
+        return   ## Everything below disabled for now..
+        
+        #self.currentItem = None
+        #maxZ = None
+        #for i in self.items(ev.pos()):
+            #if maxZ is None or maxZ < i.zValue():
+                #self.currentItem = i
+                #maxZ = i.zValue()
+        #print "make event"
+        #self.pev = self.graphicsSceneEvent(ev)
+        #self.fev = self.pev
+        #if self.currentItem is not None:
+            #self.currentItem.mousePressEvent(self.pev)
+        ##self.clearMouse()
+        ##self.mouseTrail.append(Point(self.mapToScene(ev.pos())))
+        #self.emit(QtCore.SIGNAL("mousePressed(PyQt_PyObject)"), self.mouseTrail)
+                
+    def mouseReleaseEvent(self, ev):
+        QtGui.QGraphicsView.mouseReleaseEvent(self, ev)
+        if not self.mouseEnabled:
+            return 
+        #self.mouseTrail.append(Point(self.mapToScene(ev.pos())))
+        self.emit(QtCore.SIGNAL("mouseReleased"), ev)
+        self.lastButtonReleased = ev.button()
+        return   ## Everything below disabled for now..
+        
+        ##self.mouseTrail.append(Point(self.mapToScene(ev.pos())))
+        #self.emit(QtCore.SIGNAL("mouseReleased(PyQt_PyObject)"), self.mouseTrail)
+        #if self.currentItem is not None:
+            #pev = self.graphicsSceneEvent(ev, self.pev, self.fev)
+            #self.pev = pev
+            #self.currentItem.mouseReleaseEvent(pev)
+            #self.currentItem = None
+
+    def mouseMoveEvent(self, ev):
+        QtGui.QGraphicsView.mouseMoveEvent(self, ev)
+        if not self.mouseEnabled:
+            return
+        self.emit(QtCore.SIGNAL("sceneMouseMoved(PyQt_PyObject)"), self.mapToScene(ev.pos()))
+        #print "moved. Grabber:", self.scene().mouseGrabberItem()
+        
+        if self.lastMousePos is None:
+            self.lastMousePos = Point(ev.pos())
+            
+        if self.clickAccepted:  ## Ignore event if an item in the scene has already claimed it.
+            return
+            
+        delta = Point(ev.pos()) - self.lastMousePos
+        
+        self.lastMousePos = Point(ev.pos())
+        
+        if ev.buttons() == QtCore.Qt.RightButton:
+            delta = Point(clip(delta[0], -50, 50), clip(-delta[1], -50, 50))
+            scale = 1.01 ** delta
+            #if self.yInverted:
+                #scale[0] = 1. / scale[0]
+            self.scale(scale[0], scale[1], center=self.mapToScene(self.mousePressPos))
+            self.emit(QtCore.SIGNAL('regionChanged(QRectF)'), self.range)
+
+
+        elif ev.buttons() in [QtCore.Qt.MidButton, QtCore.Qt.LeftButton]:  ## Allow panning by left or mid button.
+            tr = -delta / self.currentScale
+            
+            self.translate(tr[0], tr[1])
+            self.emit(QtCore.SIGNAL('regionChanged(QRectF)'), self.range)
+        
+        #return   ## Everything below disabled for now..
+        
+        ##self.mouseTrail.append(Point(self.mapToScene(ev.pos())))
+        #if self.currentItem is not None:
+            #pev = self.graphicsSceneEvent(ev, self.pev, self.fev)
+            #self.pev = pev
+            #self.currentItem.mouseMoveEvent(pev)
+        
+        
+    
+        
+    def writeSvg(self, fileName=None):
+        if fileName is None:
+            fileName = str(QtGui.QFileDialog.getSaveFileName())
+        self.svg = QtSvg.QSvgGenerator()
+        self.svg.setFileName(fileName)
+        self.svg.setSize(self.size())
+        self.svg.setResolution(600)
+        painter = QtGui.QPainter(self.svg)
+        self.render(painter)
+        
+    def writeImage(self, fileName=None):
+        if fileName is None:
+            fileName = str(QtGui.QFileDialog.getSaveFileName())
+        self.png = QtGui.QImage(self.size(), QtGui.QImage.Format_ARGB32)
+        painter = QtGui.QPainter(self.png)
+        rh = self.renderHints()
+        self.setRenderHints(QtGui.QPainter.Antialiasing)
+        self.render(painter)
+        self.setRenderHints(rh)
+        self.png.save(fileName)
+        
+    #def getFreehandLine(self):
+        
+        ## Wait for click
+        #self.clearMouse()
+        #while self.lastButtonReleased != QtCore.Qt.LeftButton:
+            #QtGui.qApp.sendPostedEvents()
+            #QtGui.qApp.processEvents()
+            #time.sleep(0.01)
+        #fl = vstack(self.mouseTrail)
+        #return fl
+    
+    #def getClick(self):
+        #fl = self.getFreehandLine()
+        #return fl[-1]
+    
+
+#class GraphicsSceneMouseEvent(QtGui.QGraphicsSceneMouseEvent):
+    #"""Stand-in class for QGraphicsSceneMouseEvent"""
+    #def __init__(self):
+        #QtGui.QGraphicsSceneMouseEvent.__init__(self)
+            
+    #def setPos(self, p):
+        #self.vpos = p
+    #def setButtons(self, p):
+        #self.vbuttons = p
+    #def setButton(self, p):
+        #self.vbutton = p
+    #def setModifiers(self, p):
+        #self.vmodifiers = p
+    #def setScenePos(self, p):
+        #self.vscenePos = p
+    #def setLastPos(self, p):
+        #self.vlastPos = p
+    #def setLastScenePos(self, p):
+        #self.vlastScenePos = p
+    #def setLastScreenPos(self, p):
+        #self.vlastScreenPos = p
+    #def setButtonDownPos(self, p):
+        #self.vbuttonDownPos = p
+    #def setButtonDownScenePos(self, p):
+        #self.vbuttonDownScenePos = p
+    #def setButtonDownScreenPos(self, p):
+        #self.vbuttonDownScreenPos = p
+    
+    #def pos(self):
+        #return self.vpos
+    #def buttons(self):
+        #return self.vbuttons
+    #def button(self):
+        #return self.vbutton
+    #def modifiers(self):
+        #return self.vmodifiers
+    #def scenePos(self):
+        #return self.vscenePos
+    #def lastPos(self):
+        #return self.vlastPos
+    #def lastScenePos(self):
+        #return self.vlastScenePos
+    #def lastScreenPos(self):
+        #return self.vlastScreenPos
+    #def buttonDownPos(self):
+        #return self.vbuttonDownPos
+    #def buttonDownScenePos(self):
+        #return self.vbuttonDownScenePos
+    #def buttonDownScreenPos(self):
+        #return self.vbuttonDownScreenPos
+    

ImageView.py

+# -*- coding: utf-8 -*-
+"""
+ImageView.py -  Widget for basic image dispay and analysis
+Copyright 2010  Luke Campagnola
+Distributed under MIT/X11 license. See license.txt for more infomation.
+
+Widget used for displaying 2D or 3D data. Features:
+  - float or int (including 16-bit int) image display via ImageItem
+  - zoom/pan via GraphicsView
+  - black/white level controls
+  - time slider for 3D data sets
+  - ROI plotting
+  - Image normalization through a variety of methods
+"""
+
+from ImageViewTemplate import *
+from graphicsItems import *
+from widgets import ROI
+from PyQt4 import QtCore, QtGui
+
+class PlotROI(ROI):
+    def __init__(self, size):
+        ROI.__init__(self, pos=[0,0], size=size, scaleSnap=True, translateSnap=True)
+        self.addScaleHandle([1, 1], [0, 0])
+
+
+class ImageView(QtGui.QWidget):
+    def __init__(self, parent=None, name="ImageView", *args):
+        QtGui.QWidget.__init__(self, parent, *args)
+        self.levelMax = 4096
+        self.levelMin = 0
+        self.name = name
+        self.image = None
+        self.imageDisp = None
+        self.ui = Ui_Form()
+        self.ui.setupUi(self)
+        self.scene = self.ui.graphicsView.sceneObj
+        self.ui.graphicsView.enableMouse(True)
+        self.ui.graphicsView.autoPixelRange = False
+        self.ui.graphicsView.setAspectLocked(True)
+        self.ui.graphicsView.invertY()
+        self.ui.graphicsView.enableMouse()
+        
+        self.imageItem = ImageItem()
+        self.scene.addItem(self.imageItem)
+        self.currentIndex = 0
+        
+        self.ui.normGroup.hide()
+
+        self.roi = PlotROI(10)
+        self.roi.setZValue(20)
+        self.scene.addItem(self.roi)
+        self.roi.hide()
+        self.ui.roiPlot.hide()
+        self.roiCurve = self.ui.roiPlot.plot()
+        self.roiTimeLine = InfiniteLine(self.ui.roiPlot, 0)
+        self.roiTimeLine.setPen(QtGui.QPen(QtGui.QColor(255, 255, 0, 200)))
+        self.ui.roiPlot.addItem(self.roiTimeLine)
+        
+        self.normLines = []
+        for i in [0,1]:
+            l = InfiniteLine(self.ui.roiPlot, 0)
+            l.setPen(QtGui.QPen(QtGui.QColor(0, 100, 200, 200)))
+            self.ui.roiPlot.addItem(l)
+            self.normLines.append(l)
+            l.hide()
+            
+        for fn in ['addItem']:
+            setattr(self, fn, getattr(self.ui.graphicsView, fn))
+
+        QtCore.QObject.connect(self.ui.timeSlider, QtCore.SIGNAL('valueChanged(int)'), self.timeChanged)
+        QtCore.QObject.connect(self.ui.whiteSlider, QtCore.SIGNAL('valueChanged(int)'), self.updateImage)
+        QtCore.QObject.connect(self.ui.blackSlider, QtCore.SIGNAL('valueChanged(int)'), self.updateImage)
+        QtCore.QObject.connect(self.ui.roiBtn, QtCore.SIGNAL('clicked()'), self.roiClicked)
+        self.roi.connect(QtCore.SIGNAL('regionChanged'), self.roiChanged)
+        QtCore.QObject.connect(self.ui.normBtn, QtCore.SIGNAL('toggled(bool)'), self.normToggled)
+        QtCore.QObject.connect(self.ui.normDivideRadio, QtCore.SIGNAL('clicked()'), self.updateNorm)
+        QtCore.QObject.connect(self.ui.normSubtractRadio, QtCore.SIGNAL('clicked()'), self.updateNorm)
+        QtCore.QObject.connect(self.ui.normOffRadio, QtCore.SIGNAL('clicked()'), self.updateNorm)
+        QtCore.QObject.connect(self.ui.normROICheck, QtCore.SIGNAL('clicked()'), self.updateNorm)
+        QtCore.QObject.connect(self.ui.normFrameCheck, QtCore.SIGNAL('clicked()'), self.updateNorm)
+        QtCore.QObject.connect(self.ui.normTimeRangeCheck, QtCore.SIGNAL('clicked()'), self.updateNorm)
+        QtCore.QObject.connect(self.ui.normStartSlider, QtCore.SIGNAL('valueChanged(int)'), self.updateNorm)
+        QtCore.QObject.connect(self.ui.normStopSlider, QtCore.SIGNAL('valueChanged(int)'), self.updateNorm)
+        
+        self.ui.roiPlot.registerPlot(self.name + '_ROI')
+
+    def updateNorm(self):
+        for l, sl in zip(self.normLines, [self.ui.normStartSlider, self.ui.normStopSlider]):
+            if self.ui.normTimeRangeCheck.isChecked():
+                l.show()
+            else:
+                l.hide()
+            
+            i, t = self.timeIndex(sl)
+            l.setPos(t)
+        
+        
+        self.imageDisp = None
+        self.updateImage()
+        self.roiChanged()
+
+    def normToggled(self, b):
+        self.ui.normGroup.setVisible(b)
+
+    def roiClicked(self):
+        if self.ui.roiBtn.isChecked():
+            self.roi.show()
+            self.ui.roiPlot.show()
+            self.roiChanged()
+        else:
+            self.roi.hide()
+            self.ui.roiPlot.hide()
+
+    def roiChanged(self):
+        if self.image is None:
+            return
+            
+        image = self.getProcessedImage()
+        if image.ndim == 2:
+            axes = (0, 1)
+        elif image.ndim == 3:
+            axes = (1, 2)
+        else:
+            return
+        data = self.roi.getArrayRegion(image.view(ndarray), self.imageItem, axes)
+        if data is not None:
+            while data.ndim > 1:
+                data = data.mean(axis=1)
+            self.roiCurve.setData(y=data, x=self.tVals)
+            #self.ui.roiPlot.replot()
+
+    def setImage(self, img, autoRange=True, autoLevels=True, levels=None):
+        self.image = img
+        if hasattr(img, 'xvals'):
+            self.tVals = img.xvals(0)
+        else:
+            self.tVals = arange(img.shape[0])
+        self.ui.timeSlider.setValue(0)
+        #self.ui.normStartSlider.setValue(0)
+        #self.ui.timeSlider.setMaximum(img.shape[0]-1)
+            
+        if img.ndim == 2:
+            self.axes = {'t': None, 'x': 0, 'y': 1, 'c': None}
+        elif img.ndim == 3:
+            if img.shape[2] <= 3:
+                self.axes = {'t': None, 'x': 0, 'y': 1, 'c': 2}
+            else:
+                self.axes = {'t': 0, 'x': 1, 'y': 2, 'c': None}
+        elif img.ndim == 4:
+            self.axes = {'t': 0, 'x': 1, 'y': 2, 'c': 3}
+
+            
+        self.imageDisp = None
+        if autoRange:
+            self.autoRange()
+        if autoLevels:
+            self.autoLevels()
+        if levels is not None:
+            self.levelMax = levels[1]
+            self.levelMin = levels[0]
+        self.updateImage()
+        if self.ui.roiBtn.isChecked():
+            self.roiChanged()
+            
+    def autoLevels(self):
+        image = self.getProcessedImage()
+        
+        self.ui.whiteSlider.setValue(self.ui.whiteSlider.maximum())
+        self.ui.blackSlider.setValue(0)
+        self.imageItem.setLevels(white=self.whiteLevel(), black=self.blackLevel())
+            
+    def autoRange(self):
+        image = self.getProcessedImage()
+        
+        self.ui.graphicsView.setRange(QtCore.QRectF(0, 0, image.shape[self.axes['x']], image.shape[self.axes['y']]), padding=0., lockAspect=True)        
+        
+    def getProcessedImage(self):
+        if self.imageDisp is None:
+            image = self.normalize(self.image)
+            self.imageDisp = image
+            self.levelMax = float(image.max())
+            self.levelMin = float(image.min())
+        return self.imageDisp
+        
+    def normalize(self, image):
+        
+        if self.ui.normOffRadio.isChecked():
+            return image
+            
+        div = self.ui.normDivideRadio.isChecked()
+        norm = image.copy()
+        #if div:
+            #norm = ones(image.shape)
+        #else: