Example #1
0
    def create_slice_dock(self):
        widget = QWidget()
        dock = QDockWidget("Slice", self)
        dock.setAllowedAreas(Qt.TopDockWidgetArea | Qt.BottomDockWidgetArea
                             | Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
        self.addDockWidget(Qt.BottomDockWidgetArea, dock)
        layout = QGridLayout(widget)
        self.slice_index_spin_box = QSpinBox()
        index_max = self.map_.measurement.param.axis3.get_length()
        self.slice_index_spin_box.setRange(0, index_max - 1)

        slice_slider = QSlider(Qt.Horizontal)
        slice_slider.setRange(0, index_max - 1)
        self.connect(self.slice_index_spin_box, SIGNAL("valueChanged(int)"),
                     self.set_slice_index)
        self.connect(slice_slider, SIGNAL("valueChanged(int)"),
                     self.slice_index_spin_box.setValue)
        self.connect(self.slice_index_spin_box, SIGNAL("valueChanged(int)"),
                     slice_slider.setValue)
        self.slice_value_spin_box = QDoubleSpinBox()
        scale = self.map_.measurement.param.axis3.get_scale()
        self.slice_value_spin_box.setRange(scale.min(), scale.max())
        self.slice_value_spin_box.setValue(scale[0])
        self.connect(self.slice_value_spin_box, SIGNAL("valueChanged(double)"),
                     self.set_slice_value)
        unit = self.map_.measurement.param.axis3.unit
        self.slice_value_spin_box.setSuffix(unit)
        layout.addWidget(slice_slider, 0, 0)
        layout.addWidget(self.slice_index_spin_box, 0, 1)
        layout.addWidget(self.slice_value_spin_box, 0, 2)
        dock.setWidget(widget)
Example #2
0
class SubplotWidget(QSplitter):
    """Construct a Widget that helps managing several plots
    together handled by the same manager

    Since the plots must be added to the manager before the panels
    the add_itemlist method can be called after having declared
    all the subplots
    """
    def __init__(self, manager, parent=None, **kwargs):
        super(SubplotWidget, self).__init__(parent, **kwargs)
        self.setOrientation(Qt.Horizontal)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.manager = manager
        self.plots = []
        self.itemlist = None
        main = QWidget()
        self.plotlayout = QGridLayout()
        main.setLayout(self.plotlayout)
        self.addWidget(main)

    def add_itemlist(self, show_itemlist=False):
        self.itemlist = PlotItemList(self)
        self.itemlist.setVisible(show_itemlist)
        self.addWidget(self.itemlist)
        configure_plot_splitter(self)
        self.manager.add_panel(self.itemlist)

    def add_subplot(self, plot, i=0, j=0, plot_id=None):
        """Add a plot to the grid of plots"""
        self.plotlayout.addWidget(plot, i, j)
        self.plots.append(plot)
        if plot_id is None:
            plot_id = id(plot)
        self.manager.add_plot(plot, plot_id)
Example #3
0
    def create_slice_dock(self):
        widget = QWidget()
        dock = QDockWidget("Slice", self)
        dock.setAllowedAreas(Qt.TopDockWidgetArea | Qt.BottomDockWidgetArea |
                             Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
        self.addDockWidget(Qt.BottomDockWidgetArea, dock)
        layout = QGridLayout(widget)
        self.slice_index_spin_box = QSpinBox()
        index_max = self.map_.measurement.param.axis3.get_length()
        self.slice_index_spin_box.setRange(0, index_max-1 )

        slice_slider = QSlider(Qt.Horizontal)
        slice_slider.setRange(0, index_max-1)
        self.connect(self.slice_index_spin_box, SIGNAL("valueChanged(int)"),
                     self.set_slice_index)
        self.connect(slice_slider, SIGNAL("valueChanged(int)"),
                     self.slice_index_spin_box.setValue)
        self.connect(self.slice_index_spin_box, SIGNAL("valueChanged(int)"),
                     slice_slider.setValue)
        self.slice_value_spin_box = QDoubleSpinBox()
        scale = self.map_.measurement.param.axis3.get_scale()
        self.slice_value_spin_box.setRange(scale.min(),scale.max())
        self.slice_value_spin_box.setValue(scale[0])
        self.connect(self.slice_value_spin_box, SIGNAL("valueChanged(double)"),
                     self.set_slice_value)
        unit = self.map_.measurement.param.axis3.unit
        self.slice_value_spin_box.setSuffix(unit)
        layout.addWidget(slice_slider, 0, 0)
        layout.addWidget(self.slice_index_spin_box, 0, 1)
        layout.addWidget(self.slice_value_spin_box, 0, 2)
        dock.setWidget(widget)
Example #4
0
class SubplotWidget(QSplitter):
    """Construct a Widget that helps managing several plots
    together handled by the same manager

    Since the plots must be added to the manager before the panels
    the add_itemlist method can be called after having declared
    all the subplots
    """
    def __init__(self, manager, parent=None, **kwargs):
        super(SubplotWidget, self).__init__(parent, **kwargs)
        self.setOrientation(Qt.Horizontal)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.manager = manager
        self.plots = []
        self.itemlist = None
        main = QWidget()
        self.plotlayout = QGridLayout()
        main.setLayout(self.plotlayout)
        self.addWidget(main)

    def add_itemlist(self, show_itemlist=False):
        self.itemlist = PlotItemList(self)
        self.itemlist.setVisible(show_itemlist)
        self.addWidget(self.itemlist)
        configure_plot_splitter(self)
        self.manager.add_panel(self.itemlist)

    def add_subplot(self, plot, i=0, j=0, plot_id=None):
        """Add a plot to the grid of plots"""
        self.plotlayout.addWidget(plot, i, j)
        self.plots.append(plot)
        if plot_id is None:
            plot_id = id(plot)
        self.manager.add_plot(plot, plot_id)
Example #5
0
 def __init__(self, parent=None):
     QFrame.__init__(self, parent)
     layout = QGridLayout()
     self.setLayout(layout)
     angle = 0
     for row in range(7):
         for column in range(7):
             layout.addWidget(RotatedLabel("Label %03d°" % angle,
                                           angle=angle, color=Qt.blue,
                                           bold=True),
                              row, column, Qt.AlignCenter)
             angle += 10
Example #6
0
 def __init__(self, parent=None):
     QFrame.__init__(self, parent)
     layout = QGridLayout()
     self.setLayout(layout)
     angle = 0
     for row in range(7):
         for column in range(7):
             layout.addWidget(
                 RotatedLabel("Label %03d°" % angle,
                              angle=angle,
                              color=Qt.blue,
                              bold=True), row, column, Qt.AlignCenter)
             angle += 10
Example #7
0
    def __init__(self, parent):
        super(MakeNicerWidget, self).__init__(parent)

        self.data = np.array([])  # array which holds data

        # Time domain plot
        self.tdWidget = DockablePlotWidget(self, CurveWidget)
        self.tdWidget.calcFun.addFun('fs', lambda x: x, lambda x: x)
        self.tdWidget.calcFun.addFun('µm', lambda x: x * fsDelay * 1e3,
                                     lambda x: x / fsDelay * 1e-3)
        self.tdWidget.calcFun.addFun('mm', lambda x: x * fsDelay,
                                     lambda x: x / fsDelay)
        tdPlot = self.tdWidget.get_plot()
        self.tdSignal = SignalFT(self, plot=tdPlot)
        self.tdFit = SignalFT(self, plot=tdPlot, col='r')

        # Frequency domain plot
        self.fdWidget = DockablePlotWidget(self, CurveWidget)
        self.fdWidget.calcFun.addFun('PHz', lambda x: x, lambda x: x)
        self.fdWidget.calcFun.addFun('THz', lambda x: x * 1e3,
                                     lambda x: x * 1e-3)
        self.fdWidget.calcFun.addFun('µm', lambda x: c0 / x * 1e-9,
                                     lambda x: c0 / x * 1e-9)
        self.fdWidget.calcFun.addFun('eV', lambda x: x, lambda x: x)
        fdplot = self.fdWidget.get_plot()
        self.fdSignal = SignalFT(self, plot=fdplot)
        self.fdFit = SignalFT(self, plot=fdplot, col='r')

        self.smoothNum = QSpinBox()  # gives number of smoothin points
        self.smoothNum.setMinimum(1)
        self.smoothNum.setSingleStep(2)

        # Put things together in layouts
        buttonLayout = QGridLayout()
        plotLayout = QVBoxLayout()
        layout = QHBoxLayout()
        plotLayout.addWidget(self.tdWidget)
        plotLayout.addWidget(self.fdWidget)

        buttonLayout.addWidget(QLabel('Fitting function'), 0, 0)
        buttonLayout.addWidget(
            QLineEdit("lambda x,A,f,phi: np.sin(2*np.pi*f*x+phi)"), 1, 0, 1, 2)
        buttonLayout.addWidget(QLabel('Smooth'), 2, 0)
        buttonLayout.addWidget(self.smoothNum, 2, 1)
        buttonLayout.setRowStretch(3, 20)

        layout.addLayout(buttonLayout)
        layout.addLayout(plotLayout)
        self.setLayout(layout)

        # connect signals
        self.updateTdPlot.connect(self.tdSignal.updatePlot)
        self.updateTdFitPlot.connect(self.tdFit.updatePlot)
        self.updateFdPlot.connect(lambda data: self.fdSignal.updatePlot(
            self.fdSignal.computeFFT(data)))
        self.updateFdFitPlot.connect(
            lambda data: self.fdFit.updatePlot(self.fdFit.computeFFT(data)))
        self.smoothNum.valueChanged.connect(self.smoothData)

        self.setData()
Example #8
0
    def __init__(self, parent=None, x=[], y=[], data=[]):
        QWidget.__init__(self, parent)

        if len(x) < 2:
            x = np.linspace(0, 1392, 1392)
            y = np.linspace(0, 1040, 1040)
            data = np.zeros((1040, 1392))

        self.x = x
        self.y = y
        self.data = data

        sx = 600
        sy = int(sx / 1.338)
        stretch_x = 3
        stretch_y = 3

        #self.setGeometry(QRect(0,0,sx,sy))
        layout = QGridLayout(self)
        layout.setMargin(0)

        self.screen = ImageScreen(self, x, y, data)
        self.cutX = CutScreen(self)
        self.cutY = CutScreen(self)

        layout.addWidget(self.screen, 1, 0)
        layout.addWidget(self.cutX, 0, 0)
        layout.addWidget(self.cutY, 1, 1)

        layout.setColumnStretch(0, stretch_x)
        layout.setColumnStretch(1, 1)
        layout.setRowStretch(0, 1)
        layout.setRowStretch(1, stretch_y)

        self.setLayout(layout)

        self.updateGeometry()

        self.manager = PlotManager(self)
        self.manager.add_plot(self.screen.plot)
        self.manager.add_plot(self.cutX.plot)
        self.manager.add_plot(self.cutY.plot)

        #roi = ROISelectTool
        #bkgnd = BKGNDSelectTool

        self.tools = [tools.SelectTool, tools.RectZoomTool, tools.ColormapTool]

        self.manager.register_all_curve_tools()
Example #9
0
    def __init__(self, parent=None, x=[], y=[], data=[]):
        QWidget.__init__(self, parent)

        if len(x) < 2:
            x = np.linspace(0, 1392, 1392)
            y = np.linspace(0, 1040, 1040)
            data = np.zeros((1040, 1392))

        self.x = x
        self.y = y
        self.data = data

        layout = QGridLayout(self)
        '''
        self.screen = ImageScreen(self,x,y,data,int(self.sizex*5.0/6.0),int(self.sizey*5.0/6.0))       
        self.cutX = CutScreen(self,sizex=int(self.sizex*5.0/6.0),sizey=int(self.sizey*1.0/6.0))       
        self.cutY = CutScreen(self,sizex=int(self.sizex*1.0/6.0),sizey=int(self.sizey*5.0/6.0))
        '''

        sx = 500
        sy = int(sx / 1.338)
        a = 0.2

        self.screen = ImageScreen(self, x, y, data, sizex=sx, sizey=sy)
        self.cutX = CutScreen(self, sizex=sx, sizey=int(a * sy))
        self.cutY = CutScreen(self, sizex=int(a * sx), sizey=sy)

        layout.addWidget(self.screen, 1, 0)
        layout.addWidget(self.cutX, 0, 0)
        layout.addWidget(self.cutY, 1, 1)

        self.setLayout(layout)

        self.updateGeometry()

        self.manager = PlotManager(self)
        self.manager.add_plot(self.screen.plot)
        self.manager.add_plot(self.cutX.plot)
        self.manager.add_plot(self.cutY.plot)

        roi = RegionSelectTool
        self.tools = [
            tools.SelectTool, tools.RectZoomTool, roi, tools.ColormapTool
        ]
        self.manager.register_all_curve_tools()
    def __init__(self,
                 name,
                 instanceId,
                 widgetList,
                 dataFunc,
                 inactivityTimeout=True):
        dspWidget.__init__(self,
                           name,
                           instanceId,
                           widgetList,
                           inactivityTimeout=inactivityTimeout)

        self.dataFunc = dataFunc

        self.Fs = 2000

        layout = QGridLayout()
        self.setLayout(layout)

        self.resize(1024, 800)

        self.refPlotW = dspCurveWidget(mode="PCM",
                                       title="Reference PCM",
                                       show_itemlist=False)
        layout.addWidget(self.refPlotW, 1, 0, 1, 1)

        self.errPlotW = dspCurveWidget(mode="PCM",
                                       title="Error Mic PCM",
                                       show_itemlist=False)
        layout.addWidget(self.errPlotW, 2, 0, 1, 1)

        self.mscohPlotW = dspCurveWidget(mode="MSCoh",
                                         title="Magnitude Squared Coherence",
                                         show_itemlist=False)
        layout.addWidget(self.mscohPlotW, 3, 0, 1, 2)
Example #11
0
 def __init__(self, item, parent_layout):
     super(MultipleChoiceWidget, self).__init__(item, parent_layout)
     self.groupbox = self.group = QGroupBox(item.get_prop_value("display", "label"))
     layout = QGridLayout()
     self.boxes = []
     nx, ny = item.get_prop_value("display", "shape")
     cx, cy = 0, 0
     _choices = item.get_prop_value("data", "choices")
     for _, choice, _img in _choices:
         checkbox = QCheckBox(choice)
         layout.addWidget(checkbox, cx, cy)
         if nx < 0:
             cy += 1
             if cy >= ny:
                 cy = 0
                 cx += 1
         else:
             cx += 1
             if cx >= nx:
                 cx = 0
                 cy += 1
         self.boxes.append(checkbox)
     self.groupbox.setLayout(layout)
Example #12
0
 def __init__(self, item, parent_layout):
     super(MultipleChoiceWidget, self).__init__(item, parent_layout)
     self.groupbox = self.group = QGroupBox(item.get_prop_value("display",
                                                                "label"))
     layout = QGridLayout()
     self.boxes = []
     nx, ny = item.get_prop_value("display", "shape")
     cx, cy = 0, 0
     _choices = item.get_prop_value("data", "choices")
     for _, choice, _img in _choices:
         checkbox = QCheckBox(choice)
         layout.addWidget(checkbox, cx, cy)
         if nx < 0:
             cy += 1
             if cy >= ny:
                 cy = 0
                 cx += 1
         else:
             cx += 1
             if cx >= nx:
                 cx = 0
                 cy += 1
         self.boxes.append(checkbox)
     self.groupbox.setLayout(layout)
Example #13
0
 def __init__(self, parent):
     QWidget.__init__(self, parent)
 
     layout = QGridLayout()
     self.setLayout(layout)
     
     self.plot1 = ImagePlot(self)
     layout.addWidget(self.plot1, 0, 0, 1, 1)
     self.plot2 = ImagePlot(self)
     layout.addWidget(self.plot2, 1, 0, 1, 1)
     
     self.contrast = ContrastAdjustment(self)
     layout.addWidget(self.contrast, 2, 0, 1, 2)
     self.itemlist = PlotItemList(self)
     layout.addWidget(self.itemlist, 0, 1, 2, 1)
     
     self.manager = PlotManager(self)
     for plot in (self.plot1, self.plot2):
         self.manager.add_plot(plot)
     for panel in (self.itemlist, self.contrast):
         self.manager.add_panel(panel)
Example #14
0
    def __init__(self, parent):
        QWidget.__init__(self, parent)

        layout = QGridLayout()
        self.setLayout(layout)

        self.plot1 = ImagePlot(self)
        layout.addWidget(self.plot1, 0, 0, 1, 1)
        self.plot2 = ImagePlot(self)
        layout.addWidget(self.plot2, 1, 0, 1, 1)

        self.contrast = ContrastAdjustment(self)
        layout.addWidget(self.contrast, 2, 0, 1, 2)
        self.itemlist = PlotItemList(self)
        layout.addWidget(self.itemlist, 0, 1, 2, 1)

        self.manager = PlotManager(self)
        for plot in (self.plot1, self.plot2):
            self.manager.add_plot(plot)
        for panel in (self.itemlist, self.contrast):
            self.manager.add_panel(panel)
Example #15
0
    def __init__(self,
                 name,
                 instanceId,
                 widgetList,
                 dataFunc,
                 inactivityTimeout=True):
        dspWidget.__init__(self,
                           name,
                           instanceId,
                           widgetList,
                           inactivityTimeout=inactivityTimeout)

        self.dataFunc = dataFunc

        self.Fs = 2000

        layout = QGridLayout()
        self.setLayout(layout)

        self.refPlotW = dspCurveWidget(title="Reference PCM",
                                       color=1,
                                       show_itemlist=False)
        layout.addWidget(self.refPlotW, 0, 0, 1, 1)

        self.micPlotW = dspCurveWidget(title="MIC PCM",
                                       color=2,
                                       show_itemlist=False)
        layout.addWidget(self.micPlotW, 0, 1, 1, 1)

        self.coefPlotW = dspCurveWidget(title="Secondary Path Response",
                                        mode="Freq",
                                        show_buttons=True,
                                        show_itemlist=False)
        self.coefPlotW.customCurve = self.updateFilterCurve
        self.coefPlotW.plotPoints = 512
        layout.addWidget(self.coefPlotW, 1, 0, 1, 2)

        self.numberofsamples = QLabel("samples")
        layout.addWidget(self.numberofsamples, 2, 2, 1, 1)
        self.samples = QLabel("samples")
        layout.addWidget(self.samples, 2, 3, 1, 1)

        self.Button = QPushButton("Phase (degrees)")
        layout.addWidget(self.Button, 1, 2, 1, 1)
        self.connect(self.Button, SIGNAL('clicked()'), self.ButtonPressed)
        self.flag = False

        self.refPlotW.BriefAnalysis.hide()
        self.micPlotW.BriefAnalysis.hide()
        self.coefPlotW.BriefAnalysis.hide()
        self.refPlotW.update_box.hide()
        self.micPlotW.update_box.hide()
        self.coefPlotW.update_box.hide()
        self.refPlotW.update_box1.hide()
        self.micPlotW.update_box1.hide()
        self.coefPlotW.update_box1.hide()
        self.refPlotW.Performance_config.hide()
        self.micPlotW.Performance_config.hide()
        self.coefPlotW.Performance_config.hide()
        self.refPlotW.Performance_off.hide()
        self.micPlotW.Performance_off.hide()
        self.coefPlotW.Performance_off.hide()
        self.refPlotW.samples_label.hide()
        self.micPlotW.samples_label.hide()
        self.coefPlotW.samples_label.hide()
Example #16
0
class Window(QMainWindow):
    def __init__(self, wintitle):
        super(Window, self).__init__()
        self.default_tool = None
        self.plots = []
        self.itemlist = PlotItemList(None)
        self.contrast = ContrastAdjustment(None)
        self.xcsw = XCrossSection(None)
        self.ycsw = YCrossSection(None)

        self.manager = PlotManager(self)
        self.toolbar = QToolBar(_("Tools"), self)
        self.manager.add_toolbar(self.toolbar, "default")
        self.toolbar.setMovable(True)
        self.toolbar.setFloatable(True)
        self.addToolBar(Qt.TopToolBarArea, self.toolbar)

        frame = QFrame(self)
        self.setCentralWidget(frame)
        self.layout = QGridLayout()
        layout = QVBoxLayout(frame)
        frame.setLayout(layout)
        layout.addLayout(self.layout)
        self.frame = frame

        self.setWindowTitle(wintitle)
        self.setWindowIcon(get_icon('guiqwt.svg'))

    def closeEvent(self, event):
        global _figures, _current_fig, _current_axes
        figure_title = to_text_string(self.windowTitle())
        if _figures.pop(figure_title) == _current_fig:
            _current_fig = None
            _current_axes = None
        self.itemlist.close()
        self.contrast.close()
        self.xcsw.close()
        self.ycsw.close()
        event.accept()

    def add_plot(self, i, j, plot):
        self.layout.addWidget(plot, i, j)
        self.manager.add_plot(plot)
        self.plots.append(plot)

    def replot(self):
        for plot in self.plots:
            plot.replot()
            item = plot.get_default_item()
            if item is not None:
                plot.set_active_item(item)
                item.unselect()

    def add_panels(self, images=False):
        self.manager.add_panel(self.itemlist)
        if images:
            for panel in (self.ycsw, self.xcsw, self.contrast):
                panel.hide()
                self.manager.add_panel(panel)

    def register_tools(self, images=False):
        if images:
            self.manager.register_all_image_tools()
        else:
            self.manager.register_all_curve_tools()

    def display(self):
        self.show()
        self.replot()
        self.manager.get_default_tool().activate()
        self.manager.update_tools_status()
Example #17
0
    def __init__(self, parent):
        #super(ObjectFT, self).__init__(Qt.Vertical, parent)
        super().__init__(parent)

        self.scp = None  # variable to hold oscilloscope object
        self.mutex = QMutex()

        layoutWidget = QWidget()
        layout = QGridLayout()
        layoutWidget.setLayout(layout)

        self.openDevBtn = QPushButton('Open Osci')
        # channel stuff
        self.measCh = QComboBox()
        self.chSens = QComboBox()
        self.triggCh = QComboBox()
        self.frequency = QLineEdit()
        self.frequency.setValidator(QIntValidator())
        self.recordLen = QLineEdit()
        self.recordLen.setValidator(QIntValidator())
        self.delay = QLineEdit()
        self.delay.setValidator(QDoubleValidator())
        # trigger stuff
        self.triggLevel = QLineEdit()
        self.triggLevel.setToolTip(
            'http://api.tiepie.com/libtiepie/0.5/triggering_scpch.html#triggering_scpch_level'
        )
        self.triggLevel.setText(
            '0.5'
        )  # init value otherwise there's trouble with signal changing index of sensitivity
        self.triggLevel.setValidator(QDoubleValidator(0., 1., 3))
        self.hystereses = QLineEdit()
        self.hystereses.setText('0.05')
        self.hystereses.setToolTip(
            'http://api.tiepie.com/libtiepie/0.5/triggering_scpch.html#triggering_scpch_hysteresis'
        )
        self.hystereses.setValidator(QDoubleValidator(0., 1., 3))
        self.triggKind = QComboBox()
        # do averages
        self.averages = QSpinBox()
        self.averages.setValue(1)
        self.averages.setRange(1, 10000)

        # put layout together
        layout.addWidget(self.openDevBtn, 0, 0)
        layout.addWidget(QLabel('Measuring Ch'), 1, 0)
        layout.addWidget(self.measCh, 1, 1)
        layout.addWidget(QLabel('Ch sensitivity'), 2, 0)
        layout.addWidget(self.chSens, 2, 1)
        layout.addWidget(QLabel('Sample freq. (kHz)'), 3, 0)
        layout.addWidget(self.frequency, 3, 1)
        layout.addWidget(QLabel('Record length'), 4, 0)
        layout.addWidget(self.recordLen, 4, 1)
        layout.addWidget(QLabel('Delay'), 5, 0)
        layout.addWidget(self.delay, 5, 1)
        layout.addWidget(QLabel('Trigger Ch'), 6, 0)
        layout.addWidget(self.triggCh, 6, 1)
        layout.addWidget(QLabel('Trigger Level (%)'), 7, 0)
        layout.addWidget(self.triggLevel, 7, 1)
        layout.addWidget(QLabel('Hystereses'), 8, 0)
        layout.addWidget(self.hystereses, 8, 1)
        layout.addWidget(QLabel('Trigger kind'), 9, 0)
        layout.addWidget(self.triggKind, 9, 1)
        layout.addWidget(QLabel('Averages'), 10, 0)
        layout.addWidget(self.averages, 10, 1)
        layout.setRowStretch(11, 10)
        layout.setColumnStretch(2, 10)

        self.addWidget(layoutWidget)

        # connect UI to get things working
        self.openDevBtn.released.connect(self.openDev)
        self.chSens.currentIndexChanged.connect(self._changeSens)
        self.frequency.returnPressed.connect(self._changeFreq)
        self.recordLen.returnPressed.connect(self._changeRecordLength)
        self.triggCh.currentIndexChanged.connect(self._changeTrigCh)
        self.triggLevel.returnPressed.connect(self._triggLevelChanged)
        self.triggLevel.textChanged.connect(self._check_state)
        self.hystereses.returnPressed.connect(self._setHystereses)
        self.hystereses.textChanged.connect(self._check_state)
Example #18
0
class CurveWidgetMixin(PlotManager):
    def __init__(self,
                 wintitle="guiqwt plot",
                 icon="guiqwt.svg",
                 toolbar=False,
                 options=None,
                 panels=None):
        PlotManager.__init__(self, main=self)

        self.plot_layout = QGridLayout()

        if options is None:
            options = {}
        self.plot_widget = None
        self.create_plot(options)

        if panels is not None:
            for panel in panels:
                self.add_panel(panel)

        self.toolbar = QToolBar(_("Tools"))
        if not toolbar:
            self.toolbar.hide()

        # Configuring widget layout
        self.setup_widget_properties(wintitle=wintitle, icon=icon)
        self.setup_widget_layout()

        # Configuring plot manager
        self.add_toolbar(self.toolbar, "default")
        self.register_tools()

    def setup_widget_layout(self):
        raise NotImplementedError

    def setup_widget_properties(self, wintitle, icon):
        self.setWindowTitle(wintitle)
        if is_text_string(icon):
            icon = get_icon(icon)
        if icon is not None:
            self.setWindowIcon(icon)
        self.setMinimumSize(320, 240)
        self.resize(640, 480)

    def register_tools(self):
        """
        Register the plotting dialog box tools: the base implementation 
        provides standard, curve-related and other tools - i.e. calling 
        this method is exactly the same as calling 
        :py:meth:`guiqwt.plot.CurveDialog.register_all_curve_tools`
        
        This method may be overriden to provide a fully customized set of tools
        """
        self.register_all_curve_tools()

    def create_plot(self, options):
        """
        Create the plotting widget (which is an instance of class 
        :py:class:`guiqwt.plot.BaseCurveWidget`), add it to the dialog box 
        main layout (:py:attr:`guiqwt.plot.CurveDialog.plot_layout`) and 
        then add the `item list` panel

        May be overriden to customize the plot layout 
        (:py:attr:`guiqwt.plot.CurveDialog.plot_layout`)
        """
        self.plot_widget = BaseCurveWidget(self, **options)
        self.plot_layout.addWidget(self.plot_widget, 0, 0)

        # Configuring plot manager
        self.add_plot(self.plot_widget.plot)
        self.add_panel(self.plot_widget.itemlist)
Example #19
0
    def __init__(self, parent):
        #super(ObjectFT, self).__init__(Qt.Vertical, parent)
        super().__init__(parent)

        self.meter = None
        self.collectData = True # bool for data collection thread
        self.avgData = Queue() # need data for averaging and set for holding all
        self.measure = False
        self.runDataThr = True
        self.measureData = []
        self.startTime = None


        layoutWidget = QWidget()
        layout = QGridLayout()
        layoutWidget.setLayout(layout)

        ##############
        # gui elements
        self.ipEdit = QLineEdit()
        rx = QRegExp("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$")
        self.ipEdit.setValidator(QRegExpValidator(rx))
        self.ipEdit.setText('127.0.0.1')
        self.portEdit = QLineEdit()
        self.portEdit.setValidator(QIntValidator(1, 65535, self))
        self.portEdit.setText('5000')
        self.connectBtn = QPushButton('Connect')
        self.avgSpin = QSpinBox()
        self.avgSpin.setValue(1)
        self.avgSpin.setRange(1, 10000)
        self.currValDisp = QLabel('0.0')
        self.startMeasBtn = QPushButton('Start aq')
        self.stopMeasBtn  = QPushButton('Stop aq')

        ##############
        # put layout together
        layout.addWidget(QLabel('IP Address:'), 0, 0)
        layout.addWidget(self.ipEdit, 1, 0)
        layout.addWidget(QLabel('Port:'), 0, 1)
        layout.addWidget(self.portEdit, 1, 1)
        layout.addWidget(self.connectBtn, 2, 1)
        layout.addWidget(QLabel('Averages'), 4, 0)
        layout.addWidget(self.avgSpin, 5, 0)
        layout.addWidget(self.currValDisp, 5, 1)
        layout.addWidget(self.startMeasBtn, 6, 0)
        layout.addWidget(self.stopMeasBtn, 6, 1)
        layout.setRowStretch(7, 10)
        self.addWidget(layoutWidget)

        ##############
        # Network stuff
        self.tcpClient = QtNetwork.QTcpSocket()
        self.tcpClient.readyRead.connect(self.__getSocketData)
        self.tcpClient.error.connect(lambda x: print(x))

        ##############
        # make button and stuff functional
        self.connectBtn.released.connect(self.connectMeter)
        self.avgSpin.valueChanged.connect(self.changeAverage)
        self.startMeasBtn.released.connect(self._startMeasure)
        self.stopMeasBtn.released.connect(self._stopMeasure)

        ##############
        # thread for getting data from socket
        self.updateAvgTxt.connect(self.__updateAvgTxt)
        self.dataAq_Thr = QThread()
        self.dataAq_Thr.start()
        self.dataAq_worker = GenericWorker(self.__getData)
        self.dataAq_worker.moveToThread(self.dataAq_Thr)
Example #20
0
   def __init__(self, name, instanceId, widgetList, dataFunc, inactivityTimeout = True):
      dspWidget.__init__(self, name, instanceId, widgetList, inactivityTimeout = inactivityTimeout)

      self.dataFunc = dataFunc

      self.Fs = 2000

      layout = QGridLayout()
      self.setLayout(layout)

      self.resize(1024, 800)

      self.refPlotW = dspCurveWidget(mode="Freq",title="Reference PCM", show_itemlist=False)
      layout.addWidget(self.refPlotW, 1, 1, 1, 1)
      self.refExitButton = QPushButton("Hide")
      layout.addWidget(self.refExitButton, 1,0,1,1)
      self.connect(self.refExitButton, SIGNAL('clicked()'), self.refExitButtonPressed)

      self.errPlotW = dspCurveWidget(mode="Freq",title="Error Mic PCM", show_itemlist=False)
      layout.addWidget(self.errPlotW, 2, 1, 1, 1)
      self.errExitButton = QPushButton("Hide")
      layout.addWidget(self.errExitButton, 2,0,1,1)
      self.connect(self.errExitButton, SIGNAL('clicked()'), self.errExitButtonPressed)

      self.outPlotW = dspCurveWidget(mode="Freq",title="ANC Output", show_itemlist=False)
      layout.addWidget(self.outPlotW, 3, 1, 1, 1)
      self.outExitButton = QPushButton("Hide")
      layout.addWidget(self.outExitButton, 3,0,1,1)
      self.connect(self.outExitButton, SIGNAL('clicked()'), self.outExitButtonPressed)

      self.coefPlotW = dspCurveWidget(title="ANC Filter", mode="Freq", show_buttons=False, show_itemlist=True)
      self.coefPlotW.customCurve = self.updateFilterCurve
      self.coefPlotW.plotPoints = 1024
      layout.addWidget(self.coefPlotW, 4, 1, 1, 1)
      self.coefExitButton = QPushButton("Hide")
      layout.addWidget(self.coefExitButton, 4,0,1,1)
      self.connect(self.coefExitButton, SIGNAL('clicked()'), self.coefExitButtonPressed)
Example #21
0
class CurveWidgetMixin(PlotManager):
    def __init__(self, wintitle="guiqwt plot", icon="guiqwt.svg",
                 toolbar=False, options=None, panels=None):
        PlotManager.__init__(self, main=self)

        self.plot_layout = QGridLayout()
        
        if options is None:
            options = {}
        self.plot_widget = None
        self.create_plot(options)
        
        if panels is not None:
            for panel in panels:
                self.add_panel(panel)
        
        self.toolbar = QToolBar(_("Tools"))
        if not toolbar:
            self.toolbar.hide()

        # Configuring widget layout
        self.setup_widget_properties(wintitle=wintitle, icon=icon)
        self.setup_widget_layout()
        
        # Configuring plot manager
        self.add_toolbar(self.toolbar, "default")
        self.register_tools()
        
    def setup_widget_layout(self):
        raise NotImplementedError
        
    def setup_widget_properties(self, wintitle, icon):
        self.setWindowTitle(wintitle)
        if is_text_string(icon):
            icon = get_icon(icon)
        if icon is not None:
            self.setWindowIcon(icon)
        self.setMinimumSize(320, 240)
        self.resize(640, 480)

    def register_tools(self):
        """
        Register the plotting dialog box tools: the base implementation 
        provides standard, curve-related and other tools - i.e. calling 
        this method is exactly the same as calling 
        :py:meth:`guiqwt.plot.CurveDialog.register_all_curve_tools`
        
        This method may be overriden to provide a fully customized set of tools
        """
        self.register_all_curve_tools()

    def create_plot(self, options, row=0, column=0, rowspan=1, columnspan=1):
        """
        Create the plotting widget (which is an instance of class 
        :py:class:`guiqwt.plot.BaseCurveWidget`), add it to the dialog box 
        main layout (:py:attr:`guiqwt.plot.CurveDialog.plot_layout`) and 
        then add the `item list` panel

        May be overriden to customize the plot layout 
        (:py:attr:`guiqwt.plot.CurveDialog.plot_layout`)
        """
        self.plot_widget = BaseCurveWidget(self, **options)
        self.plot_layout.addWidget(self.plot_widget,
                                   row, column, rowspan, columnspan)
        
        # Configuring plot manager
        self.add_plot(self.plot_widget.plot)
        self.add_panel(self.plot_widget.itemlist)
Example #22
0
    def __init__(self, parent):
        #super(ObjectFT, self).__init__(Qt.Vertical, parent)
        super().__init__(parent)

        self.stage = None
        self.offset = 0.  # offset from 0 where t0 is (mm)
        self.newOff = 0.
        self.stageRange = (0, 0)

        layoutWidget = QWidget()
        layout = QGridLayout()
        layoutWidget.setLayout(layout)

        # put layout together
        self.openStageBtn = QPushButton("Open stage")
        self.initStageBtn = QPushButton("Init stage")

        #absolute move
        #current position
        self.currentPos = QLabel('')
        #self.currentPos.setValidator(QDoubleValidator())
        #relative move (mm)
        self.deltaMove_mm = QLineEdit()
        self.deltaMove_mm.setText('0')
        self.deltaMove_mm.setValidator(QDoubleValidator())
        self.deltaMovePlus_mm = QPushButton('+')
        self.deltaMoveMinus_mm = QPushButton('-')
        #relative move (fs)
        self.deltaMove_fs = QLineEdit()
        self.deltaMovePlus_fs = QPushButton('+')
        self.deltaMoveMinus_fs = QPushButton('-')
        #velocity
        self.velocityLabel = QLabel('Velocity:')
        self.velocity = QSlider(Qt.Horizontal)
        self.velocity.setMinimum(0)
        self.velocity.setMaximum(
            2000)  # unit in µm; TODO: try to get max vel. from controller

        # scan from (fs)
        self.scanFrom = QLineEdit()
        self.scanFrom.setText('-100')
        self.scanFrom.setValidator(QIntValidator())
        # scan to (fs)
        self.scanTo = QLineEdit()
        self.scanTo.setText('100')
        self.scanTo.setValidator(QIntValidator())
        # scan stepsize (fs)
        self.scanStep = QLineEdit()
        self.scanStep.setText('10')
        self.scanStep.setValidator(QDoubleValidator())
        # center here button
        self.centerBtn = QPushButton('Center here')
        self.centerBtn.setToolTip('Center scan at current stage position')
        self.startScanBtn = QPushButton("Start scan")
        self.stopScanBtn = QPushButton("Stop scan")
        self.niceBtn = QPushButton('Make it nice')
        # spacer line
        hLine = QFrame()
        hLine.setFrameStyle(QFrame.HLine)
        hLine.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)

        # put layout together
        layout.addWidget(self.openStageBtn, 0, 0)
        layout.addWidget(self.initStageBtn, 0, 1)
        layout.addWidget(QLabel("Current pos (mm):"), 1, 0)
        layout.addWidget(self.currentPos, 1, 1)
        layout.addWidget(self.velocityLabel, 2, 0)
        layout.addWidget(self.velocity, 3, 0, 1, 2)
        layout.addWidget(QLabel('Move relative (mm)'), 4, 0)
        layout.addWidget(self.deltaMove_mm, 5, 0, 1, 2)
        layout.addWidget(self.deltaMoveMinus_mm, 6, 0)
        layout.addWidget(self.deltaMovePlus_mm, 6, 1)
        layout.addWidget(QLabel('Move relative (fs)'), 7, 0)
        layout.addWidget(self.deltaMove_fs, 8, 0, 1, 2)
        layout.addWidget(self.deltaMoveMinus_fs, 9, 0)
        layout.addWidget(self.deltaMovePlus_fs, 9, 1)

        layout.addWidget(hLine, 10, 0, 1, 2)
        layout.addWidget(QLabel('Scan from (fs)'), 11, 0)
        layout.addWidget(self.scanFrom, 11, 1)
        layout.addWidget(QLabel('Scan to (fs)'), 12, 0)
        layout.addWidget(self.scanTo, 12, 1)
        layout.addWidget(QLabel('Stepsize (fs)'), 13, 0)
        layout.addWidget(self.scanStep, 13, 1)
        layout.addWidget(self.startScanBtn, 14, 0)
        layout.addWidget(self.stopScanBtn, 14, 1)
        layout.addWidget(self.centerBtn, 15, 1)
        layout.addWidget(self.niceBtn, 16, 1)
        layout.setRowStretch(17, 10)
        layout.setColumnStretch(2, 10)

        self.addWidget(layoutWidget)

        # make button and stuff functional
        self.openStageBtn.released.connect(self.connectStage)
        self.initStageBtn.released.connect(self.initStage)
        self.scanFrom.returnPressed.connect(self._xAxeChanged)
        self.scanTo.returnPressed.connect(self._xAxeChanged)
        self.centerBtn.released.connect(self._centerHere)
        self.deltaMovePlus_mm.released.connect(
            lambda x=1: self.moveRel_mm(float(self.deltaMove_mm.text())))
        self.deltaMoveMinus_mm.released.connect(
            lambda x=-1: self.moveRel_mm(float(self.deltaMove_mm.text()), x))

        ################
        # thread for updating position
        #self.currPosThr = GenericThread(self.__getCurrPos)
        self.updateCurrPos.connect(self.__updateCurrPos)
        self.currPos_thread = QThread()  # create the QThread
        self.currPos_thread.start()

        # This causes my_worker.run() to eventually execute in my_thread:
        self.currPos_worker = GenericWorker(self.__getCurrPos)
        self.currPos_worker.moveToThread(self.currPos_thread)
class dspPcmWidget(dspWidget):
   def __init__(self, name, instanceId, widgetList, dataFunc, inactivityTimeout = True):
      dspWidget.__init__(self, name, instanceId, widgetList, inactivityTimeout = inactivityTimeout)

      self.dataFunc = dataFunc
      self.Fs = 2000
      self.sample_rate = 5333
      self.pascal_constant=2*10**-5

      self.pcm =[]

      self.layout = QGridLayout()
      self.setLayout(self.layout) 
      
      self.pcmPlotW = dspCurveWidget(title="Monitor Mic Data", show_itemlist=False)
      self.layout.addWidget(self.pcmPlotW, 1, 0, 1, 1)

      self.resize(1000, 300)



      self.Button1 = QPushButton("Level")

      self.layout.addWidget(self.Button1, 1,1,1,1)

      self.connect(self.Button1, SIGNAL('clicked()'), self.Button1Pressed)



    

 
   def A_weighting(self, fs):

       f1 = 20.598997
       f2 = 107.65265
       f3 = 737.86223
       f4 = 12194.217
       A1000 = 1.9997

       NUMs = [(2*pi * f4)**2 * (10**(A1000/20)), 0, 0, 0, 0]
       DENs = polymul([1, 4*pi * f4, (2*pi * f4)**2],
                   [1, 4*pi * f1, (2*pi * f1)**2])
       DENs = polymul(polymul(DENs, [1, 2*pi * f3]),
                                 [1, 2*pi * f2])

       return bilinear(NUMs, DENs, fs)

   def C_weighting(self, fs):
      f1 = 20.598997 
      f4 = 12194.217
      C1000 = 0.0619

      NUMs = [(2*pi*f4)**2*(10**(C1000/20.0)),0,0]
      DENs = polymul([1,4*pi*f4,(2*pi*f4)**2.0],[1,4*pi*f1,(2*pi*f1)**2]) 

 
      return bilinear(NUMs,DENs,fs)
   
   def properties(self, signal, samplerate):
      signal_level = self.ac_rms(signal)
      weighted = self.A_weight(signal, samplerate)
      weighted1= self.C_weight(signal, samplerate)
      weighted_level = self.ac_rms(weighted)
      weighted_level1= self.ac_rms(weighted1)
    
      return [
    'RMS level: %.3f (%.3f dB SPL)' % (signal_level, self.dB(signal_level)+10),
    'A-weighted: %.3f (%.3f dB(A))' % (weighted_level, self.dB(weighted_level)+10),
    'C-weighted: %.3f (%.3f dB(C))' % (weighted_level1, self.dB(weighted_level1)+10)
    #'A-difference: %.3f dB' % self.dB(weighted_level/signal_level),
    #'-----------------',
]

   def ac_rms(self, signal):

       return self.rms_flat(signal - mean(signal))

   def rms_flat(self, a):

       return np.sqrt(np.mean(np.absolute(a)**2))

   def dB(self, level):

       return 20 * log10(self.rms_flat(level)/self.pascal_constant)

   def A_weight(self, signal, samplerate):
       B, A = self.A_weighting(samplerate)
       return lfilter(B, A, signal)

   def C_weight(self, signal, samplerate):
       B, A = self.C_weighting(samplerate)
       return lfilter(B, A, signal)

   def Button1Pressed(self):
       
       elements = np.asarray(self.pcm)
       rms_pcm = np.sqrt(np.mean(elements**2))
       dB = 20*scipy.log10(np.abs(rms_pcm/self.pascal_constant))
       #print (str(dB)+" "+'dB SPL')
       Sound_properties = self.properties(elements, self.sample_rate)
       print colored("Sound Properties:", 'yellow')
       print colored(Sound_properties[0], 'yellow')
       print colored(Sound_properties[1], 'yellow')
       print colored(Sound_properties[2], 'yellow')
       #print colored(Sound_properties[3], 'blue')
      

   def update(self):
      try:
         data = self.dataFunc(self.instanceId, self.preferredSamples)
      except RuntimeError:
         return
      
      channels = data.get('chn')
      blockSize = data.get('frm')
      self.pcm = data.get('pcm')
      #elements = np.asarray(pcm)


         
         #this will calculate the signal to noise ratio of monitor microphone placed in the point of interest(in between two micrphones)
         #snr = scipy.stats.signaltonoise(elements)


      #extracting list of pcm data into another list with two elements for taking first element and use for that finding rms value 
      #two_elements=[pcm[2*i:2*i+2] for i in range(int(0),int(math.ceil(len(pcm)/2.0)))]

      # Conditional to keep backwards compatibility with old SPI logs. 
      Fs = data.get('Fs') if (data.get('Fs') != 0) else self.Fs
      if Fs == 96:
          Fs = 96000
      self.sample_rate= Fs
      samples = len(self.pcm) / channels
      self.pcmPlotW.update(Fs, channels, blockSize, samples, self.pcm) 
      #self.updatesamples(str(samples))


   def rescale(self):
      self.pcmPlotW.rescale()
Example #24
0
class Window(QMainWindow):
    def __init__(self, wintitle):
        super(Window, self).__init__()
        self.default_tool = None
        self.plots = []
        self.itemlist = PlotItemList(None)
        self.contrast = ContrastAdjustment(None)
        self.xcsw = XCrossSection(None)
        self.ycsw = YCrossSection(None)
        
        self.manager = PlotManager(self)
        self.toolbar = QToolBar(_("Tools"), self)
        self.manager.add_toolbar(self.toolbar, "default")
        self.toolbar.setMovable(True)
        self.toolbar.setFloatable(True)
        self.addToolBar(Qt.TopToolBarArea, self.toolbar)

        frame = QFrame(self)
        self.setCentralWidget(frame)
        self.layout = QGridLayout()
        layout = QVBoxLayout(frame)
        frame.setLayout(layout)
        layout.addLayout(self.layout)
        self.frame = frame

        self.setWindowTitle(wintitle)
        self.setWindowIcon(get_icon('guiqwt.svg'))

    def closeEvent(self, event):
        global _figures, _current_fig, _current_axes
        figure_title = to_text_string(self.windowTitle())
        if _figures.pop(figure_title) == _current_fig:
            _current_fig = None
            _current_axes = None
        self.itemlist.close()
        self.contrast.close()
        self.xcsw.close()
        self.ycsw.close()
        event.accept()
        
    def add_plot(self, i, j, plot):
        self.layout.addWidget(plot, i, j)
        self.manager.add_plot(plot)
        self.plots.append(plot)

    def replot(self):
        for plot in self.plots:
            plot.replot()
            item = plot.get_default_item()
            if item is not None:
                plot.set_active_item(item)
                item.unselect()
            
    def add_panels(self, images=False):
        self.manager.add_panel(self.itemlist)
        if images:
            for panel in (self.ycsw, self.xcsw, self.contrast):
                panel.hide()
                self.manager.add_panel(panel)
            
    def register_tools(self, images=False):
        if images:
            self.manager.register_all_image_tools()
        else:
            self.manager.register_all_curve_tools()
    
    def display(self):
        self.show()
        self.replot()
        self.manager.get_default_tool().activate()
        self.manager.update_tools_status()
Example #25
0
    def __init__(self, parent):
        super().__init__(parent)

        self.camera = None
        self.cameraSettings = None
        self.aquireData = False
        self.directory = 'N:/4all/mpsd_drive/xtsfasta/Data'

        layoutWidget = QWidget()
        layout = QGridLayout()
        layoutWidget.setLayout(layout)

        ###############
        # GUI elements
        self.openCamBtn = QPushButton('Connect camera')
        self.startAquBtn = QPushButton('Start aquisiton')
        self.readoutSpeedCombo = QComboBox()
        # this really should not be hard coded but received from dll
        self.readoutSpeedCombo.addItems(["1 MHz", 
            "1.8 MHz",
            "2.3 MHz",
            "2.8 MHz",
            "250 kHz",
            "500 kHz"])
        self.exposureTimeSpin = QSpinBox()
        self.exposureTimeSpin.setRange(1, 1e6)
        self.exposureTimeSpin.setValue(1e3) # default exposure 1s
        self.exposureTimeSpin.setSingleStep(100)
        self.exposureTimeSpin.setSuffix(' ms')
        #self.exposureTimeSpin.setValidator(QIntValidator(1, 2**31)) # ms
        self.binningXCombo = QComboBox()
        self.binningXCombo.addItems(["No binning",
                  "Binning of 2 columns",
                  "Binning of 4 columns",
                  "Binning of 8 columns",
                  "Binning of 16 columns",
                  "Binning of 32 columns",
                  "Binning of 64 columns",
                  "Binning of 128 columns",
                  "Full horizontal binning"])
        self.binningYCombo = QComboBox()
        self.binningYCombo.addItems(["No binning",
                  "Binning of 2 lines",
                  "Binning of 4 lines",
                  "Binning of 8 lines",
                  "Binning of 16 lines",
                  "Binning of 32 lines",
                  "Binning of 64 lines",
                  "Binning of 128 lines",
                  "Binning of 256 lines"])
        self.temperatureSpin = QSpinBox()
        self.temperatureSpin.setRange(-100, 20)
        self.temperatureSpin.setValue(-10)
        self.temperatureSpin.setSuffix('°C')
        self.updateInterSpin = QSpinBox()
        self.updateInterSpin.setRange(1, 3600)
        self.updateInterSpin.setValue(5)
        self.updateInterSpin.setSuffix(' s')
        #self.updateInterSpin.setText("2")
        #self.updateInterEdit.setValidator(QIntValidator(1, 3600))
        self.loi = QSpinBox()
        self.loi.setRange(1, 511) # one pixel less as the camera has
        self.deltaPixels = QSpinBox()
        self.deltaPixels.setRange(0, 256)
        self.autoSave = QCheckBox("Auto save")
        self.getDirectory = QPushButton('Choose Dir')
        self.dirPath = QLineEdit(self.directory)
        self.comment = QPlainTextEdit()

        ##############
        # put elements in layout
        layout.addWidget(self.openCamBtn, 0, 0)
        layout.addWidget(self.startAquBtn, 0, 1)
        layout.addWidget(QLabel('readout speed'), 1, 0)
        layout.addWidget(self.readoutSpeedCombo, 1, 1)
        layout.addWidget(QLabel('exposure time'), 2, 0)
        layout.addWidget(self.exposureTimeSpin, 2, 1)
        layout.addWidget(QLabel('binning X'), 3, 0)
        layout.addWidget(self.binningXCombo, 3, 1)
        layout.addWidget(QLabel('binning Y'), 4, 0)
        layout.addWidget(self.binningYCombo, 4, 1)
        layout.addWidget(QLabel('temperature'), 5, 0)
        layout.addWidget(self.temperatureSpin, 5, 1)
        layout.addWidget(QLabel('update every n-seconds'), 6, 0)
        layout.addWidget(self.updateInterSpin, 6, 1)
        layout.addWidget(QLabel('Pixel of interest'), 7, 0)
        layout.addWidget(self.loi, 7, 1)
        layout.addWidget(QLabel('Δ pixels'), 8, 0)
        layout.addWidget(self.deltaPixels, 8, 1)
        layout.addWidget(self.autoSave, 9, 1)
        layout.addWidget(self.getDirectory, 10, 0)
        layout.addWidget(self.dirPath, 10, 1)
        layout.addWidget(QLabel('Comment:'), 11, 0)
        layout.addWidget(self.comment, 12, 0, 1, 2)
        layout.setRowStretch(13, 10)

        self.addWidget(layoutWidget)


        #################
        # connect elements for functionality
        self.openCamBtn.released.connect(self.__openCam)
        self.getDirectory.released.connect(self.__chooseDir)
        self.temperatureSpin.valueChanged.connect(self.__setTemperature)
        self.exposureTimeSpin.valueChanged.connect(self.__setCamParameter)
        self.readoutSpeedCombo.currentIndexChanged.connect(self.__setCamParameter)
        self.startAquBtn.released.connect(self.__startCurrImageThr)
        
        ################
        # thread for updating position
        self.currImage_thread = QThread() # create the QThread
        self.currImage_thread.start()

        # This causes my_worker.run() to eventually execute in my_thread:
        self.currImage_worker = GenericWorker(self.__getCurrImage)
        self.currImage_worker.moveToThread(self.currImage_thread)
 
        self.startAquBtn.setEnabled(False) 
        self.readoutSpeedCombo.setEnabled(False)
        self.exposureTimeSpin.setEnabled(False)
        self.binningXCombo.setEnabled(False)
        self.binningYCombo.setEnabled(False)
        self.temperatureSpin.setEnabled(False)
        self.updateInterSpin.setEnabled(False)