widget_base.py

 
 
import os
import sys
import threading
import warnings
from typing import Any, Callable, Dict
 
import numpy as np
import pyqtgraph as pg
 
try:
    from PyQt5 import QtWidgets
    from PyQt5.QtCore import QThread, QTimer
    from PyQt5.uic import loadUiType
except ModuleNotFoundError as e:
    try:    
        from PySide2 import QtWidgets
        from PySide2.QtCore import  QThread, QTimer
        from PySide2.QtUiTools import loadUiType
    except ModuleNotFoundError as e:
        raise ModuleNotFoundError("No module named 'PyQt5' or PySide2', please install one of them\nException raised: "+e.msg)
 
from pyqtgraph.dockarea import Dock, DockArea
 
from shesha.util.matplotlibwidget import MatplotlibWidget
 
 
def uiLoader(moduleName):
    return loadUiType(os.environ["SHESHA_ROOT"] +
                      "/shesha/widgets/%s.ui" % moduleName)  # type: type, type
 
 
BaseWidgetTemplate, BaseClassTemplate = uiLoader('widget_base')
 
 
class PupilBoxes(QtWidgets.QGraphicsPathItem):
 
    def __init__(self, x, y):
        """x and y are 2D arrays of shape (Nplots, Nsamples)"""
        connect = np.ones(x.shape, dtype=bool)
        connect[:, -1] = 0  # don't draw the segment between each trace
        self.pathpath = pg.arrayToQPath(x.flatten(), y.flatten(), connect.flatten())
        pg.QtGui.QGraphicsPathItem.__init__(self, self.pathpath)
        self.setPen(pg.mkPen('r'))
 
    def shape(self):  # override because QGraphicsPathItem.shape is too expensive.
        return pg.QtGui.QGraphicsItem.shape(self)
 
    def boundingRect(self):
        return self.pathpath.boundingRect()
 
 
class WidgetBase(BaseClassTemplate):
 
    def __init__(self, parent=None, hide_histograms=False) -> None:
        BaseClassTemplate.__init__(self, parent=parent)
 
        self.uiBaseuiBase = BaseWidgetTemplate()
        self.uiBaseuiBase.setupUi(self)
 
        
 
        self.gui_timergui_timer = QTimer()  # type: QTimer
        self.gui_timergui_timer.timeout.connect(self.updateDisplayupdateDisplay)
        if self.uiBaseuiBase.wao_Display.isChecked():
            self.gui_timergui_timer.start(1000. / self.uiBaseuiBase.wao_frameRate.value())
        self.loopLockloopLock = threading.Lock(
        )  # type: Threading.Lock # Asynchronous loop / display safe-threading
        self.hide_histogramshide_histograms = hide_histograms
        
 
        self.areaarea = DockArea()
        self.uiBaseuiBase.wao_DisplayDock.setWidget(self.areaarea)
        self.gridSHgridSH = []
 
        
        self.defaultParPathdefaultParPath = "."
        self.defaultAreaPathdefaultAreaPath = "."
        self.uiBaseuiBase.wao_load_config.clicked.connect(self.load_configload_config)
        self.uiBaseuiBase.wao_loadArea.clicked.connect(self.loadArealoadArea)
        self.uiBaseuiBase.wao_saveArea.clicked.connect(self.saveAreasaveArea)
        self.uiBaseuiBase.wao_init.clicked.connect(self.init_configinit_config)
        self.uiBaseuiBase.wao_configFromFile.clicked.connect(self.addConfigFromFileaddConfigFromFile)
 
        self.uiBaseuiBase.wao_Display.stateChanged.connect(self.gui_timer_configgui_timer_config)
        self.uiBaseuiBase.wao_frameRate.setValue(2)
 
        self.uiBaseuiBase.wao_load_config.setDisabled(False)
        self.uiBaseuiBase.wao_init.setDisabled(True)
 
        self.disp_checkboxesdisp_checkboxes = []
        self.docksdocks = {}  # type: Dict[str, pg.dockarea.Dock]
        self.viewboxesviewboxes = {}  # type: Dict[str, pg.ViewBox]
        self.imgsimgs = {}  # type: Dict[str, pg.ImageItem]
        self.histshists = {}  # type: Dict[str, pg.HistogramLUTItem]
 
        self.PupilLinesPupilLines = None
        self.adjustSize()
 
    def gui_timer_config(self, state) -> None:
        self.uiBaseuiBase.wao_frameRate.setDisabled(state)
        if state:
            self.gui_timergui_timer.start(1000. / self.uiBaseuiBase.wao_frameRate.value())
        else:
            self.gui_timergui_timer.stop()
 
    def closeEvent(self, event: Any) -> None:
        self.quitGUIquitGUI(event)
 
    def quitGUI(self, event: Any = None) -> None:
        reply = QtWidgets.QMessageBox.question(
                self, 'Message', "Are you sure to quit?", QtWidgets.QMessageBox.Yes |
                QtWidgets.QMessageBox.No, QtWidgets.QMessageBox.No)
 
        if reply == QtWidgets.QMessageBox.Yes:
            if event:
                event.accept()
            quit()
        else:
            if event:
                event.ignore()
 
    
 
    def saveArea(self, widget, filename=None):
        '''
            Callback when a area layout file is double clicked in the file browser
            Place the selected file name in the browsing drop-down menu,
            the call the self.load_config callback of the load button.
        '''
        if filename is None:
            filepath = QtWidgets.QFileDialog(
                    directory=self.defaultAreaPathdefaultAreaPath).getSaveFileName(
                            self, "Select area layout file", "",
                            "area layout file (*.area);;all files (*)")
            filename = filepath[0]
 
        try:
            with open(filename, "w+") as f:
                st = self.areaarea.saveState()
                f.write(str(st))
        except FileNotFoundError as err:
            warnings.warn(filename + " not loaded: " + err)
 
    def showDock(self, name):
        for disp_checkbox in self.disp_checkboxesdisp_checkboxes:
            if disp_checkbox.text() == name:
                disp_checkbox.setChecked(True)
                break
        if name in self.docksdocks.keys():
            self.areaarea.addDock(self.docksdocks[name])
 
    def restoreMyState(self, state):
        typ, contents, _ = state
 
        if typ == 'dock':
            self.showDockshowDock(contents)
        else:
            for o in contents:
                self.restoreMyStaterestoreMyState(o)
 
    def loadArea(self, widget=None, filename=None):
        # close all docks
        for disp_checkbox in self.disp_checkboxesdisp_checkboxes:
            disp_checkbox.setChecked(False)
        for dock in self.docksdocks.values():
            if dock.isVisible():
                dock.close()
 
        if filename is None:
            filepath = QtWidgets.QFileDialog(
                    directory=self.defaultAreaPathdefaultAreaPath).getOpenFileName(
                            self, "Select area layout file", "",
                            "area layout file (*.area);;all files (*)")
            filename = filepath[0]
 
        try:
            with open(filename, "r") as f:
                st = eval(f.readline())
 
                # restore docks from main area
                if st['main'] is not None:
                    self.restoreMyStaterestoreMyState(st["main"])
 
                # restore docks from floating area
                for win in st["float"]:
                    self.restoreMyStaterestoreMyState(win[0]['main'])
 
                # rearange dock s as in stored state
                self.areaarea.restoreState(st)
        except FileNotFoundError as err:
            warnings.warn(filename + "not loaded: " + err)
 
    def addConfigFromFile(self) -> None:
        '''
            Callback when a config file is double clicked in the file browser
            Place the selected file name in the browsing drop-down menu,
            the call the self.load_config callback of the load button.
        '''
        filepath = QtWidgets.QFileDialog(directory=self.defaultParPathdefaultParPath).getOpenFileName(
                self, "Select parameter file", "",
                "parameters file (*.py);;hdf5 file (*.h5);;all files (*)")
 
        self.uiBaseuiBase.wao_selectConfig.clear()
        self.uiBaseuiBase.wao_selectConfig.addItem(str(filepath[0]))
 
        self.load_configload_config(config_file=self.uiBaseuiBase.wao_selectConfig.currentText())
 
    def update_displayDock(self):
        guilty_guy = self.sender().text()
        state = self.sender().isChecked()
        if state:
            self.areaarea.addDock(self.docksdocks[guilty_guy])
        elif self.docksdocks[guilty_guy].isVisible():
            self.docksdocks[guilty_guy].close()
 
    def add_dispDock(self, name: str, parent, type: str = "pg_image") -> Dock:
        checkBox = QtWidgets.QCheckBox(name, parent)
        checkBox.clicked.connect(self.update_displayDockupdate_displayDock)
        checkableAction = QtWidgets.QWidgetAction(parent)
        checkableAction.setDefaultWidget(checkBox)
        parent.addAction(checkableAction)
        self.disp_checkboxesdisp_checkboxes.append(checkBox)
 
        d = Dock(name)  # , closable=True)
        self.docksdocks[name] = d
        if type == "pg_image":
            img = pg.ImageItem(border='w', image=np.zeros((2,2)))
            self.imgsimgs[name] = img
 
            viewbox = pg.ViewBox()
 
            viewbox.setAspectLocked(True)
            viewbox.addItem(img)  # Put image in plot area
            self.viewboxesviewboxes[name] = viewbox
            viewbox.invertY(False)
 
            iv = pg.ImageView(view=viewbox, imageItem=img)
            try:
                cmap = pg.colormap.get('viridis') # prepare a viridis color map
                iv.setColorMap(cmap)
            except:
                pass
            if (self.hide_histogramshide_histograms):
                iv.ui.histogram.hide()
            iv.ui.histogram.autoHistogramRange()  # init levels
            iv.ui.histogram.setMaximumWidth(100)
            iv.ui.menuBtn.hide()
            iv.ui.roiBtn.hide()
            d.addWidget(iv)
        elif type == "pg_plot":
            img = pg.PlotItem(border='w')
            self.imgsimgs[name] = img
            d.addWidget(img)
        elif type == "MPL":
            img = MatplotlibWidget()
            self.imgsimgs[name] = img
            d.addWidget(img)
        # elif type == "SR":
        #     d.addWidget(self.uiBase.wao_Strehl)
        return d
 
    def load_config(self, *args, **kwargs) -> None:
        '''
            Callback when 'LOAD' button is hit
        '''
        for groupbox in [
                self.uiBaseuiBase.wao_phasesgroup_tb, self.uiBaseuiBase.wao_imagesgroup_tb,
                self.uiBaseuiBase.wao_graphgroup_tb
        ]:
            layout = groupbox.menu()
            while layout and not layout.isEmpty():
                w = layout.children()[0]
                layout.removeAction(w)
                w.setParent(None)
        self.disp_checkboxesdisp_checkboxes.clear()
 
        # TODO: remove self.imgs, self.viewboxes and self.docks children
        for _, dock in self.docksdocks.items():
            if dock.isVisible():
                dock.close()
 
        self.docksdocks.clear()
        self.imgsimgs.clear()
        self.viewboxesviewboxes.clear()
 
        self.wao_phasesgroup_cbwao_phasesgroup_cb = QtWidgets.QMenu(self)
        self.uiBaseuiBase.wao_phasesgroup_tb.setMenu(self.wao_phasesgroup_cbwao_phasesgroup_cb)
        self.uiBaseuiBase.wao_phasesgroup_tb.setText('Select')
        self.uiBaseuiBase.wao_phasesgroup_tb.setPopupMode(QtWidgets.QToolButton.InstantPopup)
 
        self.wao_graphgroup_cbwao_graphgroup_cb = QtWidgets.QMenu(self)
        self.uiBaseuiBase.wao_graphgroup_tb.setMenu(self.wao_graphgroup_cbwao_graphgroup_cb)
        self.uiBaseuiBase.wao_graphgroup_tb.setText('Select')
        self.uiBaseuiBase.wao_graphgroup_tb.setPopupMode(QtWidgets.QToolButton.InstantPopup)
 
        self.uiBaseuiBase.wao_imagesgroup_tb.setText('Select')
        self.wao_imagesgroup_cbwao_imagesgroup_cb = QtWidgets.QMenu(self)
        self.uiBaseuiBase.wao_imagesgroup_tb.setMenu(self.wao_imagesgroup_cbwao_imagesgroup_cb)
        self.uiBaseuiBase.wao_imagesgroup_tb.setPopupMode(QtWidgets.QToolButton.InstantPopup)
 
        # self.uiBase.wao_init.setDisabled(False)
        #
        # if (hasattr(self.sim.config, "layout")):
        #     area_filename = self.defaultAreaPath + "/" + self.sim.config.layout + ".area"
        #     self.loadArea(filename=area_filename)
        #
        # self.adjustSize()
 
    def loadDefaultConfig(self) -> None:
        import glob
        parlist = sorted(glob.glob(self.defaultParPathdefaultParPath + "/*.py"))
        self.uiBaseuiBase.wao_selectConfig.clear()
        self.uiBaseuiBase.wao_selectConfig.addItems([
                parlist[i].split('/')[-1] for i in range(len(parlist))
        ])
 
    def init_config(self) -> None:
        self.loopLockloopLock.acquire(True)
        self.uiBaseuiBase.wao_load_config.setDisabled(True)
        self.uiBaseuiBase.wao_init.setDisabled(True)
        self.threadthread = WorkerThread(self.init_configThreadinit_configThread)
        self.threadthread.finished.connect(self.init_configFinishedinit_configFinished)
        self.threadthread.start()
 
    def init_configThread(self) -> None:
        pass
 
    def init_configFinished(self) -> None:
        self.uiBase.wao_load_config.setDisabled(False)
        self.uiBase.wao_init.setDisabled(False)
        self.loopLock.release()
 
    def updateDisplay(self) -> None:
        if not self.loopLockloopLock.acquire(False):
            return
        else:
            try:
                pass
            finally:
                self.loopLockloopLock.release()
 
    def addSHGrid(self, pg_image, valid_sub, sspsize, pitch):
        # First remove the old grid, if any
        if self.PupilLinesPupilLines is not None:
            pg_image.removeItem(self.PupilLinesPupilLines)
 
        nssp_tot = valid_sub[0].size
        connect = np.ones((nssp_tot, 5), dtype=bool)
        connect[:, -1] = 0  # don't draw the segment between each trace
        roi_x = np.ones((nssp_tot, 5), dtype=int)
        roi_y = np.ones((nssp_tot, 5), dtype=int)
        for idx_ssp in range(nssp_tot):
            (x, y) = (valid_sub[0][idx_ssp], valid_sub[1][idx_ssp])
            roi_x[idx_ssp, :] = [x, x, x + sspsize, x + sspsize, x]
            roi_y[idx_ssp, :] = [y, y + sspsize, y + sspsize, y, y]
        self.PupilLinesPupilLines = PupilBoxes(roi_x, roi_y)
        pg_image.addItem(self.PupilLinesPupilLines)
 
    def printInPlace(self, text: str) -> None:
        # This seems to trigger the GUI and keep it responsive
        print(text, end='\r', flush=True)
 
    def run(self):
        self.loop_once()
        if not self.stop:
            QTimer.singleShot(0, self.runrun)  # Update loop
 
 
class WorkerThread(QThread):
 
    def __init__(self, loopFunc: Callable) -> None:
        QThread.__init__(self)
        self.loopFuncloopFunc = loopFunc
 
    def run(self) -> None:
        self.loopFuncloopFunc()
 
    def stop(self) -> None:
        pass
 
    def cleanUp(self) -> None:
        pass