Initial commit of the camera GUI and camera worker scripts

cameraGui.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Apr  4 10:35:32 2019
+
+@author: martindrech
+"""
+
+from PyQt5.QtWidgets import QMainWindow, QPushButton, QLabel
+
+from pyqtgraph.Qt import QtGui, QtCore
+from pyqtgraph import dockarea
+import pyqtgraph as pg
+from zylaCameraWorker import CameraWorker
+
+import sys
+import numpy as np
+
+
+class GuiMainWindow(QMainWindow):
+
+
+     def __init__(self):
+        super().__init__()
+        
+        self.initUI()
+        self.__init__
+        
+        self.some_time = pg.time()
+        
+        
+        
+        
+     def initUI(self):  
+        
+        self.win = QtGui.QMainWindow()
+        self.win.setWindowTitle('Toy GUI')
+        self.win.resize(1000,500)
+    
+        self.area = dockarea.DockArea()
+        self.win.setCentralWidget(self.area)
+        self.cw = QtGui.QWidget()
+        self.win.show()
+        
+
+           
+        self.d1 = dockarea.Dock("Zyla Camera Control")
+        self.d2 = dockarea.Dock("Zyla Camera Analysis")
+        
+        self.area.addDock(self.d1) 
+        self.area.addDock(self.d2, 'left', self.d1) 
+                
+        ## button spinbox and label
+        self.cameraButton = QPushButton('Acquisition')
+        self.d1.addWidget(self.cameraButton)
+        self.sb = pg.SpinBox(min = 0)
+        self.d1.addWidget(self.sb)
+        self.label = QLabel('nada')
+        self.d1.addWidget(self.label)
+        
+        #layouts and viewboxes
+        self.ImageLayout = pg.GraphicsLayoutWidget()
+        self.view = self.ImageLayout.addViewBox()
+        self.AnalysisLayout = pg.GraphicsLayoutWidget()
+        
+        #image layout
+        self.img = pg.ImageItem(border='w')
+        self.imv = pg.ImageView(imageItem = self.img, view = self.view)
+        self.d1.addWidget(self.imv)
+    
+        #analysis layout
+        self.d2.addWidget(self.AnalysisLayout)
+        self.p = self.AnalysisLayout.addPlot(row = 0, col = 0,  title="Time plot")
+        self.p.setRange(QtCore.QRectF(0, 0, 50, 255)) 
+        self.p.setAutoPan(y=True)
+        #self.p.setRange(xRange = (0, 10), yRange = (0, 255))
+        self.curve = self.p.plot(pen='y')
+               
+               
+        ## rOI
+        self.rois = []
+        self.rois.append(pg.TestROI([0,  0], [10, 10], pen=(0,9)))
+        for r in self.rois:
+            self.view.addItem(r)
+            #r.sigRegionChanged.connect(self.updateRoi)
+            
+        self.ROIdata = np.zeros(100)
+        self.iROIdata = 0
+        
+        self._initialize_image()
+       
+        
+        
+     def make_connections(self, backend):
+         backend.imageReadySignal.connect(self.updateImage)
+         
+         
+         
+     def _initialize_image(self):
+        ## lock the aspect ratio so pixels are always square
+        self.view.setAspectLocked(True)        
+        self.view.addItem(self.img)
+
+        self.i = 0
+    
+     def updateRois(self):
+        
+        for roi in self.rois:
+        
+            self.lastRoi = roi
+            roiSlice = roi.getArrayRegion(self.img.image, img=self.img)
+            self.newData = np.mean(roiSlice)
+            self.ROIdata[self.iROIdata] = self.newData
+            self.iROIdata = np.mod(self.i + 1, len(self.ROIdata))
+            self.curve.setData(self.ROIdata)
+            
+        
+     @QtCore.pyqtSlot(np.ndarray)     
+     def updateImage(self, image):
+         
+        n = 1024
+        self.img.setImage(image[:n, :n])
+        self.updateRois()
+        self.i = self.i + 1
+        if self.i%5 ==0:
+            self.label.setText(str(self.i) + '    time:' + str(pg.time()-self.some_time) )
+            self.some_time = pg.time()
+            
+     def __del__(self):
+         print('chau gui')
+         
+###############################################################################
+
+if __name__ == '__main__':
+    app = QtGui.QApplication([])
+    
+    myGuiMainWIndow = GuiMainWindow()
+    cameraWorker = CameraWorker()
+    
+    cameraWorker.make_connections(myGuiMainWIndow)
+    myGuiMainWIndow.make_connections(cameraWorker)
+    
+    cameraThread = QtCore.QThread() 
+    cameraWorker.moveToThread(cameraThread)
+    
+    cameraThread.start()
+
+    
+    
+    sys.exit(app.exec_())
\ No newline at end of file

dummyAndor.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Apr  6 22:17:00 2019
+
+@author: martindrech
+"""
+import numpy as np
+from PyQt5 import QtCore
+import time
+import threading
+
+class Helper_messager(QtCore.QObject):
+    imageAquiredSignal = QtCore.pyqtSignal()
+
+class AndorZyla():
+    
+    def __init__(self, num):
+        self.ExposureTime = AndorFeats()
+        self.FrameRate = AndorFeats()
+        self.CameraAcquiring = AndorFeats()
+        
+        self.helper = Helper_messager()
+        self.current_image = None
+        
+        self.CameraAcquiring.setValue(False)
+        
+        
+        
+    def Init(self):
+        print('Dummy camera initialized')
+        
+    def live_acquisition_loop(self):
+        t = threading.currentThread()
+        while getattr(t, "do_run", True):
+            time.sleep(self.ExposureTime.getValue())
+            self.current_image = self._twoD_gaussian()
+            self.helper.imageAquiredSignal.emit()            
+        print('stopping acq loop thread')
+        
+        
+    def live_acquisition_configure(self):
+        pass
+    
+    def AcquisitionStart(self):
+        self.CameraAcquiring.setValue(True)
+    def AcquisitionStop(self):
+        self.CameraAcquiring.setValue(False)
+    def _flush(self):
+        pass
+
+    
+    
+    def _twoD_gaussian(self, lim = 10, N = 100, sigma = 1, x0 = 0, y0 = 0):
+        x, y = np.meshgrid(np.linspace(-lim,lim,N), np.linspace(-lim,lim,N))
+        d = np.sqrt((x-x0)**2+(y-y0)**2)
+        g = np.exp(-( (d)**2 / ( 2.0 * sigma**2 ) ) )
+        noise = np.random.rand(N, N)
+        return(g+noise)
+
+
+
+
+class AndorFeats():
+    
+    def __init__(self):
+        self.value = None
+        
+    def getValue(self):
+        return self.value
+    def setValue(self, val):
+        self.value = val
+
+
+
+
+    def _twoD_gaussian(self, lim = 10, N = 100, sigma = 1, x0 = 0, y0 = 0):
+        x, y = np.meshgrid(np.linspace(-lim,lim,N), np.linspace(-lim,lim,N))
+        d = np.sqrt((x-x0)**2+(y-y0)**2)
+        g = np.exp(-( (d)**2 / ( 2.0 * sigma**2 ) ) )
+        noise = np.random.rand(N, N)
+        return(g+noise)
\ No newline at end of file

zylaCameraWorker.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Apr  4 11:10:20 2019
+
+@author: martindrech
+
+Por ahora, aca se va a crear una imagen cada cierto tiempo y eso se va a mandar a toy_gui para plotearse ahi
+"""
+
+import numpy as np
+from PyQt5 import QtCore
+#from drivers.andorzyla import AndorZyla
+from dummyAndor import AndorZyla
+import threading
+
+
+class CameraWorker(QtCore.QObject):
+    imageReadySignal = QtCore.pyqtSignal(np.ndarray)
+
+    
+
+    def __init__(self):     
+        super(CameraWorker, self).__init__()
+             
+        self.cam = AndorZyla(0)
+        self.cam.Init()
+        self.cam.ExposureTime.setValue(.01)
+        self.cam.FrameRate.setValue(20)
+
+        
+        
+        
+        print('camera worker initialized')
+        
+    def make_connections(self, frontend):
+        #frontend connections
+        frontend.cameraButton.clicked.connect(self.run)
+        frontend.sb.valueChanged.connect(lambda x = frontend.sb.value(): self.cam.ExposureTime.setValue(x))
+        
+        #internal connections
+        self.cam.helper.imageAquiredSignal.connect(self.acquire)
+
+        
+    def __del__(self):
+        print('adios camera worker')
+
+        
+    @QtCore.pyqtSlot()
+    def run(self):
+        if self.cam.CameraAcquiring.getValue():
+            self._stop_acquisition_loop()
+            print('acquisition now stopping')
+            
+        else:
+            self._start_acquisition_loop()
+            self.acq_thread = threading.Thread(target= self.cam.live_acquisition_loop)
+            self.acq_thread.start()
+            print('acquisiting now starting')
+
+
+    def _start_acquisition_loop(self):
+        self.cam.live_acquisition_configure()     
+        self.cam.AcquisitionStart()
+        print('frame rate: ', self.cam.FrameRate.getValue())
+        print('Exp time: ', self.cam.ExposureTime.getValue())
+
+  
+    def _stop_acquisition_loop(self):
+        self.acq_thread.do_run = False
+        self.acq_thread.join()
+        self.cam.AcquisitionStop()
+        self.cam._flush()
+
+
+        
+    @QtCore.pyqtSlot()
+    def acquire(self):
+        #print('acquiring')
+        self.imageReadySignal.emit(self.cam.current_image)
+