main.py

# -*- coding: utf-8 -*-
"""
Created on Thu Aug  5 15:29:28 2021

@author: Zé Ricardo
UV spectrograph for interferometry

main
"""
import os, sys
import numpy as np



from PyQt5.QtWidgets import (QApplication, QDesktopWidget, QTabWidget, QFileDialog, QTableWidget, QTableWidgetItem,
                             QVBoxLayout,QDialog, QLineEdit, QMainWindow)


import files.Andor.Andor_Luca_XP as AC #API wrapper
import files.Andor.Spec as spec
from files.misc.calib.Calib import Calib
from files.misc.SaveSeriesPop.SaveSeriesPop import saveSeriesPop
from files.misc.CamSettings.camSettingsPop import camSetPop
# import files.Andor.Spec.thrnd as thrhnd
import files.misc.commSignals as cS
import files.misc.fakeCam as FC

from files.misc.calib.Calib import Calib

import pyqtgraph as pg

# import files.GUI.captureUI as capture
import files.GUI.captureUIv2 as capture

from PyQt5.QtCore import Qt
from PyQt5 import QtCore, QtGui
import time
import _thread





aC=True
pg.setConfigOption('imageAxisOrder', 'row-major')


os.system("pyuic5 files/GUI/captureUI.ui > files/GUI/captureUI.py")
os.system("pyuic5 files/GUI/captureUI_v2.ui > files/GUI/captureUIv2.py")
os.system("pyuic5 files/GUI/line_refD.ui > files/GUI/lineRefUI.py")
os.system("pyuic5 files/GUI/save_series.ui > files/GUI/saveSeriesUI.py")
os.system("pyuic5 files/GUI/cam_settings.ui > files/GUI/camSettingsUI.py")
# os.system("pyuic5 dialog_beam_block.ui > ui_BeamBlock.py")
# os.system("pyuic5 dialog_trunc.ui > ui_Truncate.py")









class MyApp(QMainWindow,capture.Ui_MainWindow):
    def __init__(self,andor):
        super(MyApp, self).__init__()
        # self.ui = trial.Ui_TabWidget()
        self.setupUi(self)
        #self.setScreenLocation()
        global initpath
        initpath = os.getcwd()
        self.dirpath=initpath
        self.andorcam=[]
        self.th=[]
        self.nRandomT=[]
        self.cSPop=[]
        
        self.sigs=cS.commSignals()
        self.spec=spec.Spec(andor)
        self.th=spec.thrnd(self.spec,self.sigs)
        self.andorcam=andor
        self.calib=Calib(self,self.spec)
        
        '''
        setting the box for video mode
        '''
        # self.vb=pg.ViewBox()
        # self.gV_cam.setCentralItem(self.vb)
        # self.vb.setAspectLocked()
        
        # self.camV=pg.ImageItem()
        # self.videoline=pg.InfiniteLine(movable=True,angle=0,label="Center",labelOpts={"movable":True,"position":0.9})
        # self.vidlinethick=[]
        # self.vidlinethick.append(pg.InfiniteLine(movable=False,angle=0))
        # self.vidlinethick.append(pg.InfiniteLine(movable=False,angle=0))
        
        # self.vb.addItem(self.camV)
        # for i in range(len(self.vidlinethick)):
        #     self.vb.addItem(self.vidlinethick[i])
            
        # self.vb.addItem(self.videoline)
        
        # self.imgAxis=pg.AxisItem(orientation="bottom")
        
        # self.gV_cam.addItem(self.imgAxis)
        # self.imgAxis.linkToView(self.vb)
        
        
        ###tests
        self.vb=pg.ViewBox()
        self.pIimg=pg.PlotItem(viewBox=self.vb)
        self.gV_cam.setCentralItem(self.pIimg)
        self.vb.setAspectLocked()
        
        # self.pIimg.addItem(self.vb)
        self.laxis=self.pIimg.getAxis("left")
        self.pIimg.removeItem(self.laxis)
        self.pIimg.hideAxis("left")
        
        self.pIimg.getAxis("bottom").linkToView(self.vb)
        self.pIimg.setClipToView(True)
        
        self.camV=pg.ImageItem()
        self.videoline=pg.InfiniteLine(movable=True,angle=0,label="Center",labelOpts={"movable":True,"position":0.9})
        self.vidlinethick=[]
        self.vidlinethick.append(pg.InfiniteLine(movable=False,angle=0))
        self.vidlinethick.append(pg.InfiniteLine(movable=False,angle=0))
        
        self.vb.addItem(self.camV)
        for i in range(len(self.vidlinethick)):
            self.vb.addItem(self.vidlinethick[i])
            
        self.vb.addItem(self.videoline)
        
        # self.imgAxis=pg.AxisItem(orientation="bottom")
        
        # self.gV_cam.addItem(self.imgAxis)
        
        
        
        '''
        setting the box for the plots
        '''
        self.plotI=pg.PlotItem()
        self.gV_plot.setCentralItem(self.plotI)
        
        self.plotArea=[]
        self.plotArea.append(pg.PlotDataItem())
        self.plotI.addItem(self.plotArea[0])
        
        self.plotArea[0].setData(np.linspace(0,2),np.sin(np.linspace(0,2)))
        
        
        
        
        '''
        Andor camera API class
        '''
        
            
        print("Pixels width: ",self.andorcam._width,"\tPixels height: ",self.andorcam._height)
        # # self.andorcam.CoolDown(1)
        self.popUI()#populate UI
        
        
        
        
        
       
        
        
        
        #signal handling
        self.pB_toggleCam.clicked.connect(self.toggleCam)
        self.pB_bckg_sub.clicked.connect(self.bckgSub)
        
        
        
        
        
        # self.RB_randomTrack.toggled.connect(self.updateRandomTracks)
        self.LE_nRandom.editingFinished.connect(self.updateRandomTracks)
        
        self.pB_setTrack.clicked.connect(self.setTrack)
        self.pB_delTrack.clicked.connect(self.delTrack)
        self.pB_finishTracks.clicked.connect(self.restartCam)
        self.CB_tracks.currentIndexChanged.connect(self.trackUIManager)
        
        self.LE_trackCenter.textChanged.connect(self.updateSelection)
        self.LE_trackThickness.textChanged.connect(self.updateSelection)
        
        
        self.LE_exposure.editingFinished.connect(self.updateExposure)
        
        self.LE_digAveraging.editingFinished.connect(self.setDigitalAverage)
        
        
        
        self.videoline.sigPositionChanged.connect(self.lineMove)
        # self.plotArea[0].scene().sigMouseMoved.connect(self.pltMouseHover)
        self.camV.scene().sigMouseMoved.connect(self.pltMouseHoverImg)
        self.plotArea[0].scene().sigMouseMoved.connect(self.pltMouseHoverPlt)
        
        self.RB_randomTrack.toggled.connect(self.uiRBupdate)
        
        self.cB_norm.toggled.connect(self.normdata)
        
        self.sigs.sensorDataAvailable.connect(self.th.graphUpdater)
        
        
        self.actionSeriesSetup.triggered.connect(self.sSPopUp)
        self.actionSaveCurrent.triggered.connect(self.saveCurrent)
        
        self.actionOther_Settings.triggered.connect(self.cSPopUp)
        
        
        
    #     self.plotArea[0].scene().sigMouseMoved.connect(self.mouseHover)
        
        
        
    # def mouseHover(self, pnt):
    #     mousePoint = self.plotI.vb.mapSceneToView(pnt)
    #     # print("bla")
    #     self.lbl_calib_pos.setText("{:.3f}".format(mousePoint.x())+"  :  "+"{:.3f}".format(mousePoint.y()))
        
        
        

        #methods
    def toggleCam(self):
        t={True:"Start",
           False:"Stop"
           }.get(self.th.plt)
        self.pB_toggleCam.setText(t)
       
        
        if self.th.plt:
            self.th.stopPlt()
            
        
        else:
            try:
                if self.RB_imageMode.isChecked():
                    self.spec.setMode("video")
                    self.spec.setImg(int(self.LE_hbin.text()),int(self.LE_vbin.text()),
                                           int(self.LE_hstart.text()),int(self.LE_hend.text()),
                                           int(self.LE_vstart.text()),int(self.LE_vend.text()))
                    # self.spec.exposure=(1e-3*float(self.LE_exposure.text()))
                    
                    self.th.currentGraphs(self.camV,self.plotI,self.lbl_fps)
                    _thread.start_new_thread(self.th.dataUpdater,())
                    
                elif self.RB_fvb.isChecked():
                    self.spec.setMode("fvb")
                    
                    self.th.currentGraphs(self.plotI,fpslabel=self.lbl_fps)
                    _thread.start_new_thread(self.th.dataUpdater,())
                    # _thread.start_new_thread(self.th.data_updater,(self.plotI,self.spec))
                    
                elif self.RB_singleTrack.isChecked():
                    self.spec.setMode("single track")
                    
                    self.th.currentGraphs(self.plotI,fpslabel=self.lbl_fps)
                    _thread.start_new_thread(self.th.dataUpdater,())
                    
                    
                elif self.RB_randomTrack.isChecked():
                    self.spec.setMode("user tracks",self.nRandomT)
                    self.th.currentGraphs(self.plotI,fpslabel=self.lbl_fps)
                    _thread.start_new_thread(self.th.dataUpdater,())
                    
                
                    
            except spec.SpecWarn:
                self.pB_toggleCam.setText("Start")
            except:
                raise
                
        if self.cSPop:
            self.cSPop.toggleUI()
                
    def bckgSub(self):
        
        if self.th.plt:
            self.toggleCam()
            
        self.pB_toggleCam.setDisabled(True)
        
        
        try:
            if self.RB_imageMode.isChecked():
                self.spec.setMode("video")
                self.spec.setImg(int(self.LE_hbin.text()),int(self.LE_vbin.text()),
                                       int(self.LE_hstart.text()),int(self.LE_hend.text()),
                                       int(self.LE_vstart.text()),int(self.LE_vend.text()))
                
                self.spec.bckgSub()
                
            elif self.RB_fvb.isChecked():
                self.spec.setMode("fvb")
                
                self.spec.bckgSub()
                
            elif self.RB_singleTrack.isChecked():
                self.spec.setMode("single track")
                
                self.spec.bckgSub()
                
                
            elif self.RB_randomTrack.isChecked():
                self.spec.setMode("user tracks",self.nRandomT)
                self.spec.bckgSub()
                
        except spec.SpecWarn:
            pass
        except:
            raise
            
        self.pB_toggleCam.setEnabled(True)
                
                
            # elif self.RB_randomTrack.isChecked():
            #     self.andorcam.SetReadMode(2)
            #     self.andorcam.SetRandomTracks(int(self.LE_nRandom.text()),self.tracks)
            #     self.andorcam.PrepareVideo(1e-3*float(self.LE_exposure.text()))
            #     _thread.start_new_thread(self.th.line_updater,(self.plotArea,self.andorcam))
        
    
    def restartCam(self):
        if self.th.plt:
            self.th.stopPlt()
            self.toggleCam()


    
    def popUI(self):
        self.LE_hend.setText(str(self.andorcam._width))
        self.LE_vend.setText(str(self.andorcam._height))
        self.LE_trackCenter.setText(str(1))
        self.LE_trackThickness.setText(str(1))
        self.LE_exposure.setText("{:.1f}".format(self.spec.exposure*1e3))
        self.andorcam.PrepareVideo(1e-3*float(self.LE_exposure.text()))
        
    def updateRandomTracks(self):
        if self.nRandomT!=int(self.LE_nRandom.text()):
            
            self.spec.clearTracks()
            tTracks=[]
            
            
            for i in range(int(self.LE_nRandom.text())):
                tTracks.append("Track "+str(i+1))
                
                
            self.CB_tracks.addItems(tTracks)
            self.nRandomT=int(self.LE_nRandom.text())
            
    def setTrack(self):
        self.spec.addTrack(self.CB_tracks.currentIndex(),int(self.LE_trackCenter.text()),int(self.LE_trackThickness.text()))
        
        Ans=self.spec.checkTracks(self.nRandomT)
        self.lbl_warn1.setText(Ans)
        
        if self.spec.allFine: self.pB_finishTracks.setEnabled(True)
            
        self.trackUIManager()  
        
    def delTrack(self):
        self.spec.removeTrack(self.CB_tracks.currentIndex())
        
        Ans=self.spec.checkTracks(self.nRandomT)
        self.lbl_warn1.setText(Ans)
        
        self.pB_finishTracks.setDisabled(True)
            
        self.trackUIManager()   
        
    def updateSelection(self):
        self.spec.setCurrentSelection(int(self.LE_trackCenter.text()),int(self.LE_trackThickness.text()))
        self.videoline.setValue(int(self.LE_trackCenter.text()))
        self.uiVidline()
        
    def updateExposure(self):
        self.spec.exposure=(1e-3*float(self.LE_exposure.text()))
        self.restartCam()
        
    def setDigitalAverage(self):
        # self.spec.averageFrames=int(self.LE_exposure.text())
        try:
            if bool(self.LE_digAveraging.text()):
                avgFrames=int(self.LE_digAveraging.text())
            else:
                avgFrames=1
                
            if not isinstance(avgFrames,int):
                avgFrames=1
                self.LE_digAveraging.setText(str(avgFrames))
                
        except ValueError:
            avgFrames=1
            self.LE_digAveraging.setText(str(avgFrames))
            
        except:
            raise
            
        if avgFrames<0:
            avgFrames=1
            self.LE_digAveraging.setText(str(avgFrames))
            
        self.spec.averageFrames=avgFrames
        # pass
        
    def normdata(self):
        self.spec.digitalnorm= self.cB_norm.isChecked()
            
            
    def trackUIManager(self):
        sender=self.sender()
        if bool(self.spec.trackTracker.count(self.CB_tracks.currentIndex())):
            self.LE_trackCenter.setText(str(self.spec.tracksthick[int(2*self.spec.trackTracker.index(self.CB_tracks.currentIndex()))]))
            self.LE_trackThickness.setText(str(self.spec.tracksthick[int(1+2*self.spec.trackTracker.index(self.CB_tracks.currentIndex()))]))
            self.pB_setTrack.setDisabled(True)
            self.pB_delTrack.setEnabled(True)
        elif sender.objectName()=="CB_tracks":
            self.LE_trackCenter.setText(str(1))
            self.LE_trackThickness.setText(str(1))
            # self.PB_setTrack.setDisabled(True)
            self.pB_delTrack.setDisabled(True)
            self.pB_setTrack.setEnabled(True)
            
        else:
            self.pB_delTrack.setDisabled(True)
            self.pB_setTrack.setEnabled(True)
            
        
    def saveCurrent(self):
        if self.th.plt:
            self.th.stopPlt()
        options = QFileDialog.Options()
        options |= QFileDialog.DontUseNativeDialog
        (file,typ) = QFileDialog.getSaveFileName(self,"Save Current Data", self.dirpath, "Data files (*.dat);;Header+binary (*.uvuh *.uvub)", options=options)
        typ=typ[-4:-1]
        # print(typ)
        self.setCurrDir(file)
        self.spec.saveSingle(file,typ)
        
        
    def setCurrDir(self,file):
        
        self.dirpath=file.rpartition("/")[0]+"/"
        

        
    def uiRBupdate(self):
        if self.RB_singleTrack.isChecked():
            self.LE_nRandom.setDisabled(True)
            self.CB_tracks.setDisabled(True)
        elif self.RB_randomTrack.isChecked():
            self.LE_nRandom.setEnabled(True)
            self.CB_tracks.setEnabled(True)
            
        
    def lineMove(self):
        pos=int(self.videoline.value())
        self.LE_trackCenter.setText("{:d}".format(pos))
        self.uiVidline()
        
    def uiVidline(self):
        self.vidlinethick[0].setValue(self.videoline.value()+int(self.LE_trackThickness.text())/2)
        self.vidlinethick[1].setValue(self.videoline.value()-int(self.LE_trackThickness.text())/2)
        
    def pltMouseHoverImg(self, pnt):
        mousePoint = self.vb.mapSceneToView(pnt)
        # sender=self.sender()
        # print(sender.objectName())
        self.lbl_pgPos.setText("{:.3f}".format(mousePoint.x())+"  :  "+"{:.3f}".format(mousePoint.y()))
        # self.lbl_pgPos.setText(str(self.sender().objectName()))
        
    def pltMouseHoverPlt(self, pnt):
        mousePoint = self.plotI.vb.mapSceneToView(pnt)
        # sender=self.sender()
        # print(sender.objectName())
        self.lbl_pgPos.setText("{:.3f}".format(mousePoint.x())+"  :  "+"{:.3f}".format(mousePoint.y()))
        
        
        
        
    def wheelEvent(self,event):
        # print(QApplication.focusWidget())
        focus=QApplication.focusWidget()
        if isinstance(focus,QLineEdit):
            if bool(focus.text()):
                if not focus.text().isalpha(): #still cases with non alpha-numeric characters like 'file.dat' or 'folder\' can pass and jam this thing
                    try:
                        prev=int(focus.text())
                        focus.setText(str(int(event.angleDelta().y()/120)+prev))
                    except ValueError: #if its not int, then it must be float. If by some chance a weird string got here, well, not good.
                        prev=float(focus.text())
                        focus.setText("{:.3f}".format(float(0.001*event.angleDelta().y()/120)+prev))
                    except:
                        raise
                        
                        
                        
    def sSPopUp(self):
        
        self.sSPop=saveSeriesPop(self.centralwidget,self,self.spec)
        # self.pop.show()
        self.sSPop.setWindowFlags(Qt.Tool)
        self.sSPop.setWindowModality(Qt.NonModal)
        # self.pop.exec_()
        self.sSPop.show()
        
    def cSPopUp(self):
        self.cSPop=camSetPop(self.centralwidget,self,self.andorcam)
        self.cSPop.setWindowFlags(Qt.Tool)
        self.cSPop.setWindowModality(Qt.NonModal)
        self.sigs.tempUpdate.connect(self.cSPop.setTempStatus)
        self.cSPop.show()
        
        
        
        
    def closeEvent(self, event): # override QMainWindow/QWidget/QTabWidget closeEvent method
        
        print('Exiting...')
        os.chdir(initpath)
        if self.th:
            self.th.stopPlt()
        # if self.andorcam:
        #     self.andorcam.ShutDown()
        
        
        
        self.close()
        QApplication.quit()
        
        
        
if __name__ == '__main__':
    def run_app(andor):
        app = QApplication(sys.argv)
        window = MyApp(andor)
        window.show()
        
        
        app.exec_()
        
    try:
        andor=AC.AndorLuca()
        run_app(andor)
    except AC.AndorNoCam:
        andor=FC.surrogateCam()
        run_app(andor)
    except:
        raise
        
    finally:
        # andor.AbortAcquisition()
        andor.ShutDown()