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)
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 __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 __init__(self, item, parent_layout): super(TabGroupWidget, self).__init__(item, parent_layout) self.tabs = QTabWidget() items = item.item.group self.widgets = [] for item in items: if item.get_prop_value("display", parent_layout.instance, "hide", False): continue item.set_prop("display", embedded=True) widget = parent_layout.build_widget(item) frame = QFrame() label = widget.item.get_prop_value("display", "label") icon = widget.item.get_prop_value("display", "icon", None) if icon is not None: self.tabs.addTab(frame, get_icon(icon), label) else: self.tabs.addTab(frame, label) layout = QGridLayout() layout.setAlignment(Qt.AlignTop) frame.setLayout(layout) widget.place_on_grid(layout, 0, 0, 1) try: widget.get() except Exception: print("Error building item :", item.item._name) raise self.widgets.append(widget)
def __init__(self, item, parent_layout): super(FloatArrayWidget, self).__init__(item, parent_layout) _label = item.get_prop_value("display", "label") self.groupbox = self.group = QGroupBox(_label) self.layout = QGridLayout() self.layout.setAlignment(Qt.AlignLeft) self.groupbox.setLayout(self.layout) self.first_line, self.dim_label = get_image_layout("shape.png", _("Number of rows x Number of columns")) edit_button = QPushButton(get_icon("arredit.png"), "") edit_button.setToolTip(_("Edit array contents")) edit_button.setMaximumWidth(32) self.first_line.addWidget(edit_button) self.layout.addLayout(self.first_line, 0, 0) self.min_line, self.min_label = get_image_layout("min.png", _("Smallest element in array")) self.layout.addLayout(self.min_line, 1, 0) self.max_line, self.max_label = get_image_layout("max.png", _("Largest element in array")) self.layout.addLayout(self.max_line, 2, 0) edit_button.clicked.connect(self.edit_array) self.arr = None # le tableau si il a été modifié self.instance = None
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)
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 __init__(self, manager, parent=None): QSplitter.__init__(self, Qt.Horizontal, parent) 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 __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 __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
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
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)
def setup_widget_layout(self): self.fit_layout = QHBoxLayout() self.params_layout = QGridLayout() params_group = create_groupbox(self, _("Fit parameters"), layout=self.params_layout) if self.auto_fit_enabled: auto_group = self.create_autofit_group() self.fit_layout.addWidget(auto_group) self.fit_layout.addWidget(params_group) self.plot_layout.addLayout(self.fit_layout, 1, 0) vlayout = QVBoxLayout(self) vlayout.addWidget(self.toolbar) vlayout.addLayout(self.plot_layout) self.setLayout(vlayout)
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)
def __init__(self, item, parent_layout): super(GroupWidget, self).__init__(item, parent_layout) embedded = item.get_prop_value("display", "embedded", False) if not embedded: self.group = QGroupBox(item.get_prop_value("display", "label")) else: self.group = QFrame() self.layout = QGridLayout() EditLayoutClass = parent_layout.__class__ self.edit = EditLayoutClass(self.group, item.instance, self.layout, item.item.group) self.group.setLayout(self.layout)
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)
def __init__(self, item, parent_layout): super(DataSetWidget, self).__init__(item, parent_layout) self.dataset = self.klass() # Création du layout contenant les champs d'édition du signal embedded = item.get_prop_value("display", "embedded", False) if not embedded: self.group = QGroupBox(item.get_prop_value("display", "label")) else: self.group = QFrame() self.layout = QGridLayout() self.group.setLayout(self.layout) EditLayoutClass = parent_layout.__class__ self.edit = EditLayoutClass(self.parent_layout.parent, self.dataset, self.layout)
def __init__(self, label, klass, wordwrap=False, **kwargs): QGroupBox.__init__(self, label) self.klass = klass self.dataset = klass(**kwargs) self.layout = QVBoxLayout() if self.dataset.get_comment(): label = QLabel(self.dataset.get_comment()) label.setWordWrap(wordwrap) self.layout.addWidget(label) self.grid_layout = QGridLayout() self.layout.addLayout(self.grid_layout) self.setLayout(self.layout) self.edit = self.get_edit_layout()
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)
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 setup_instance(self, instance): """Override DataSetEditDialog method""" from guidata.dataset.datatypes import DataSetGroup assert isinstance(instance, DataSetGroup) tabs = QTabWidget() # tabs.setUsesScrollButtons(False) self.layout.addWidget(tabs) for dataset in instance.datasets: layout = QVBoxLayout() layout.setAlignment(Qt.AlignTop) if dataset.get_comment(): label = QLabel(dataset.get_comment()) label.setWordWrap(self.wordwrap) layout.addWidget(label) grid = QGridLayout() self.edit_layout.append( self.layout_factory(dataset, grid) ) layout.addLayout(grid) page = QWidget() page.setLayout(layout) if dataset.get_icon(): tabs.addTab( page, get_icon(dataset.get_icon()), dataset.get_title() ) else: tabs.addTab( page, dataset.get_title() )
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)
class FloatArrayWidget(AbstractDataSetWidget): """ FloatArrayItem widget """ def __init__(self, item, parent_layout): super(FloatArrayWidget, self).__init__(item, parent_layout) _label = item.get_prop_value("display", "label") self.groupbox = self.group = QGroupBox(_label) self.layout = QGridLayout() self.layout.setAlignment(Qt.AlignLeft) self.groupbox.setLayout(self.layout) self.first_line, self.dim_label = get_image_layout("shape.png", _("Number of rows x Number of columns")) edit_button = QPushButton(get_icon("arredit.png"), "") edit_button.setToolTip(_("Edit array contents")) edit_button.setMaximumWidth(32) self.first_line.addWidget(edit_button) self.layout.addLayout(self.first_line, 0, 0) self.min_line, self.min_label = get_image_layout("min.png", _("Smallest element in array")) self.layout.addLayout(self.min_line, 1, 0) self.max_line, self.max_label = get_image_layout("max.png", _("Largest element in array")) self.layout.addLayout(self.max_line, 2, 0) edit_button.clicked.connect(self.edit_array) self.arr = None # le tableau si il a été modifié self.instance = None def edit_array(self): """Open an array editor dialog""" parent = self.parent_layout.parent label = self.item.get_prop_value("display", "label") try: # Spyder 3 from spyderlib.widgets.variableexplorer import arrayeditor except ImportError: # Spyder 2 from spyderlib.widgets import arrayeditor editor = arrayeditor.ArrayEditor(parent) if editor.setup_and_check(self.arr, title=label): if editor.exec_(): self.update(self.arr) def get(self): """Override AbstractDataSetWidget method""" self.arr = numpy.array(self.item.get(), copy=False) if self.item.get_prop_value("display", "transpose"): self.arr = self.arr.T self.update(self.arr) def update(self, arr): """Override AbstractDataSetWidget method""" shape = arr.shape if len(shape) == 1: shape = (1,) + shape dim = " x ".join( [ str(d) for d in shape ]) self.dim_label.setText(dim) format = self.item.get_prop_value("display", "format") minmax = self.item.get_prop_value("display", "minmax") try: if minmax == "all": mint = format % arr.min() maxt = format % arr.max() elif minmax == "columns": mint = ", ".join([format % arr[r,:].min() for r in range(arr.shape[0])]) maxt = ", ".join([format % arr[r,:].max() for r in range(arr.shape[0])]) else: mint = ", ".join([format % arr[:, r].min() for r in range(arr.shape[1])]) maxt = ", ".join([format % arr[:, r].max() for r in range(arr.shape[1])]) except (TypeError, IndexError): mint, maxt = "-", "-" self.min_label.setText(mint) self.max_label.setText(maxt) def set(self): """Override AbstractDataSetWidget method""" if self.item.get_prop_value("display", "transpose"): value = self.value().T else: value = self.value() self.item.set(value) def value(self): return self.arr def place_on_grid(self, layout, row, label_column, widget_column, row_span=1, column_span=1): """Override AbstractDataSetWidget method""" layout.addWidget(self.group, row, label_column, row_span, column_span+1)
def setup_instance(self, instance): """Construct main layout""" grid = QGridLayout() grid.setAlignment(Qt.AlignTop) self.layout.addLayout(grid) self.edit_layout.append( self.layout_factory( instance, grid) )
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()
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)
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()
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)
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()
class FitWidgetMixin(CurveWidgetMixin): def __init__(self, wintitle="guiqwt plot", icon="guiqwt.svg", toolbar=False, options=None, panels=None, param_cols=1, legend_anchor='TR', auto_fit=True): if wintitle is None: wintitle = _('Curve fitting') self.x = None self.y = None self.fitfunc = None self.fitargs = None self.fitkwargs = None self.fitparams = None self.autofit_prm = None self.data_curve = None self.fit_curve = None self.legend = None self.legend_anchor = legend_anchor self.xrange = None self.show_xrange = False self.param_cols = param_cols self.auto_fit_enabled = auto_fit self.button_list = [] # list of buttons to be disabled at startup self.fit_layout = None self.params_layout = None CurveWidgetMixin.__init__(self, wintitle=wintitle, icon=icon, toolbar=toolbar, options=options, panels=panels) self.refresh() # QWidget API -------------------------------------------------------------- def resizeEvent(self, event): QWidget.resizeEvent(self, event) self.get_plot().replot() # CurveWidgetMixin API ----------------------------------------------------- def setup_widget_layout(self): self.fit_layout = QHBoxLayout() self.params_layout = QGridLayout() params_group = create_groupbox(self, _("Fit parameters"), layout=self.params_layout) if self.auto_fit_enabled: auto_group = self.create_autofit_group() self.fit_layout.addWidget(auto_group) self.fit_layout.addWidget(params_group) self.plot_layout.addLayout(self.fit_layout, 1, 0) vlayout = QVBoxLayout(self) vlayout.addWidget(self.toolbar) vlayout.addLayout(self.plot_layout) self.setLayout(vlayout) def create_plot(self, options): CurveWidgetMixin.create_plot(self, options) for plot in self.get_plots(): plot.SIG_RANGE_CHANGED.connect(self.range_changed) # Public API --------------------------------------------------------------- def set_data(self, x, y, fitfunc=None, fitparams=None, fitargs=None, fitkwargs=None): if self.fitparams is not None and fitparams is not None: self.clear_params_layout() self.x = x self.y = y if fitfunc is not None: self.fitfunc = fitfunc if fitparams is not None: self.fitparams = fitparams if fitargs is not None: self.fitargs = fitargs if fitkwargs is not None: self.fitkwargs = fitkwargs self.autofit_prm = AutoFitParam(title=_("Automatic fitting options")) self.autofit_prm.xmin = x.min() self.autofit_prm.xmax = x.max() self.compute_imin_imax() if self.fitparams is not None and fitparams is not None: self.populate_params_layout() self.refresh() def set_fit_data(self, fitfunc, fitparams, fitargs=None, fitkwargs=None): if self.fitparams is not None: self.clear_params_layout() self.fitfunc = fitfunc self.fitparams = fitparams self.fitargs = fitargs self.fitkwargs = fitkwargs self.populate_params_layout() self.refresh() def clear_params_layout(self): for i, param in enumerate(self.fitparams): for widget in param.get_widgets(): if widget is not None: self.params_layout.removeWidget(widget) widget.hide() def populate_params_layout(self): add_fitparam_widgets_to(self.params_layout, self.fitparams, self.refresh, param_cols=self.param_cols) def create_autofit_group(self): auto_button = QPushButton(get_icon('apply.png'), _("Run"), self) auto_button.clicked.connect(self.autofit) autoprm_button = QPushButton(get_icon('settings.png'), _("Settings"), self) autoprm_button.clicked.connect(self.edit_parameters) xrange_button = QPushButton(get_icon('xrange.png'), _("Bounds"), self) xrange_button.setCheckable(True) xrange_button.toggled.connect(self.toggle_xrange) auto_layout = QVBoxLayout() auto_layout.addWidget(auto_button) auto_layout.addWidget(autoprm_button) auto_layout.addWidget(xrange_button) self.button_list += [auto_button, autoprm_button, xrange_button] return create_groupbox(self, _("Automatic fit"), layout=auto_layout) def get_fitfunc_arguments(self): """Return fitargs and fitkwargs""" fitargs = self.fitargs if self.fitargs is None: fitargs = [] fitkwargs = self.fitkwargs if self.fitkwargs is None: fitkwargs = {} return fitargs, fitkwargs def refresh(self, slider_value=None): """Refresh Fit Tool dialog box""" # Update button states enable = self.x is not None and self.y is not None \ and self.x.size > 0 and self.y.size > 0 \ and self.fitfunc is not None and self.fitparams is not None \ and len(self.fitparams) > 0 for btn in self.button_list: btn.setEnabled(enable) if not enable: # Fit widget is not yet configured return fitargs, fitkwargs = self.get_fitfunc_arguments() yfit = self.fitfunc(self.x, [p.value for p in self.fitparams], *fitargs, **fitkwargs) plot = self.get_plot() if self.legend is None: self.legend = make.legend(anchor=self.legend_anchor) plot.add_item(self.legend) if self.xrange is None: self.xrange = make.range(0., 1.) plot.add_item(self.xrange) self.xrange.set_range(self.autofit_prm.xmin, self.autofit_prm.xmax) self.xrange.setVisible(self.show_xrange) if self.data_curve is None: self.data_curve = make.curve([], [], _("Data"), color="b", linewidth=2) plot.add_item(self.data_curve) self.data_curve.set_data(self.x, self.y) if self.fit_curve is None: self.fit_curve = make.curve([], [], _("Fit"), color="r", linewidth=2) plot.add_item(self.fit_curve) self.fit_curve.set_data(self.x, yfit) plot.replot() plot.disable_autoscale() def range_changed(self, xrange_obj, xmin, xmax): self.autofit_prm.xmin, self.autofit_prm.xmax = xmin, xmax self.compute_imin_imax() def toggle_xrange(self, state): self.xrange.setVisible(state) plot = self.get_plot() plot.replot() if state: plot.set_active_item(self.xrange) self.show_xrange = state def edit_parameters(self): if self.autofit_prm.edit(parent=self): self.xrange.set_range(self.autofit_prm.xmin, self.autofit_prm.xmax) plot = self.get_plot() plot.replot() self.compute_imin_imax() def compute_imin_imax(self): self.i_min = self.x.searchsorted(self.autofit_prm.xmin) self.i_max = self.x.searchsorted(self.autofit_prm.xmax, side='right') def errorfunc(self, params): x = self.x[self.i_min:self.i_max] y = self.y[self.i_min:self.i_max] fitargs, fitkwargs = self.get_fitfunc_arguments() return y - self.fitfunc(x, params, *fitargs, **fitkwargs) def autofit(self): meth = self.autofit_prm.method x0 = np.array([p.value for p in self.fitparams]) if meth == "lq": x = self.autofit_lq(x0) elif meth=="simplex": x = self.autofit_simplex(x0) elif meth=="powel": x = self.autofit_powel(x0) elif meth=="bfgs": x = self.autofit_bfgs(x0) elif meth=="l_bfgs_b": x = self.autofit_l_bfgs(x0) elif meth=="cg": x = self.autofit_cg(x0) else: return for v, p in zip(x, self.fitparams): p.value = v self.refresh() for prm in self.fitparams: prm.update() def get_norm_func(self): prm = self.autofit_prm err_norm = eval(prm.err_norm) def func(params): err = np.linalg.norm(self.errorfunc(params), err_norm) return err return func def autofit_simplex(self, x0): prm = self.autofit_prm from scipy.optimize import fmin x = fmin(self.get_norm_func(), x0, xtol=prm.xtol, ftol=prm.ftol) return x def autofit_powel(self, x0): prm = self.autofit_prm from scipy.optimize import fmin_powell x = fmin_powell(self.get_norm_func(), x0, xtol=prm.xtol, ftol=prm.ftol) return x def autofit_bfgs(self, x0): prm = self.autofit_prm from scipy.optimize import fmin_bfgs x = fmin_bfgs(self.get_norm_func(), x0, gtol=prm.gtol, norm=eval(prm.norm)) return x def autofit_l_bfgs(self, x0): prm = self.autofit_prm bounds = [(p.min, p.max) for p in self.fitparams] from scipy.optimize import fmin_l_bfgs_b x, _f, _d = fmin_l_bfgs_b(self.get_norm_func(), x0, pgtol=prm.gtol, approx_grad=1, bounds=bounds) return x def autofit_cg(self, x0): prm = self.autofit_prm from scipy.optimize import fmin_cg x = fmin_cg(self.get_norm_func(), x0, gtol=prm.gtol, norm=eval(prm.norm)) return x def autofit_lq(self, x0): prm = self.autofit_prm def func(params): err = self.errorfunc(params) return err from scipy.optimize import leastsq x, _ier = leastsq(func, x0, xtol=prm.xtol, ftol=prm.ftol) return x def get_values(self): """Convenience method to get fit parameter values""" return [param.value for param in self.fitparams]
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)
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)
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()
class FitWidgetMixin(CurveWidgetMixin): def __init__(self, wintitle="guiqwt plot", icon="guiqwt.svg", toolbar=False, options=None, panels=None, param_cols=1, legend_anchor='TR', auto_fit=True): if wintitle is None: wintitle = _('Curve fitting') self.x = None self.y = None self.fitfunc = None self.fitargs = None self.fitkwargs = None self.fitparams = None self.autofit_prm = None self.data_curve = None self.fit_curve = None self.legend = None self.legend_anchor = legend_anchor self.xrange = None self.show_xrange = False self.param_cols = param_cols self.auto_fit_enabled = auto_fit self.button_list = [] # list of buttons to be disabled at startup self.fit_layout = None self.params_layout = None CurveWidgetMixin.__init__(self, wintitle=wintitle, icon=icon, toolbar=toolbar, options=options, panels=panels) self.refresh() # QWidget API -------------------------------------------------------------- def resizeEvent(self, event): QWidget.resizeEvent(self, event) self.get_plot().replot() # CurveWidgetMixin API ----------------------------------------------------- def setup_widget_layout(self): self.fit_layout = QHBoxLayout() self.params_layout = QGridLayout() params_group = create_groupbox(self, _("Fit parameters"), layout=self.params_layout) if self.auto_fit_enabled: auto_group = self.create_autofit_group() self.fit_layout.addWidget(auto_group) self.fit_layout.addWidget(params_group) self.plot_layout.addLayout(self.fit_layout, 1, 0) vlayout = QVBoxLayout(self) vlayout.addWidget(self.toolbar) vlayout.addLayout(self.plot_layout) self.setLayout(vlayout) def create_plot(self, options): CurveWidgetMixin.create_plot(self, options) for plot in self.get_plots(): plot.SIG_RANGE_CHANGED.connect(self.range_changed) # Public API --------------------------------------------------------------- def set_data(self, x, y, fitfunc=None, fitparams=None, fitargs=None, fitkwargs=None): if self.fitparams is not None and fitparams is not None: self.clear_params_layout() self.x = x self.y = y if fitfunc is not None: self.fitfunc = fitfunc if fitparams is not None: self.fitparams = fitparams if fitargs is not None: self.fitargs = fitargs if fitkwargs is not None: self.fitkwargs = fitkwargs self.autofit_prm = AutoFitParam(title=_("Automatic fitting options")) self.autofit_prm.xmin = x.min() self.autofit_prm.xmax = x.max() self.compute_imin_imax() if self.fitparams is not None and fitparams is not None: self.populate_params_layout() self.refresh() def set_fit_data(self, fitfunc, fitparams, fitargs=None, fitkwargs=None): if self.fitparams is not None: self.clear_params_layout() self.fitfunc = fitfunc self.fitparams = fitparams self.fitargs = fitargs self.fitkwargs = fitkwargs self.populate_params_layout() self.refresh() def clear_params_layout(self): for i, param in enumerate(self.fitparams): for widget in param.get_widgets(): if widget is not None: self.params_layout.removeWidget(widget) widget.hide() def populate_params_layout(self): add_fitparam_widgets_to(self.params_layout, self.fitparams, self.refresh, param_cols=self.param_cols) def create_autofit_group(self): auto_button = QPushButton(get_icon('apply.png'), _("Run"), self) auto_button.clicked.connect(self.autofit) autoprm_button = QPushButton(get_icon('settings.png'), _("Settings"), self) autoprm_button.clicked.connect(self.edit_parameters) xrange_button = QPushButton(get_icon('xrange.png'), _("Bounds"), self) xrange_button.setCheckable(True) xrange_button.toggled.connect(self.toggle_xrange) auto_layout = QVBoxLayout() auto_layout.addWidget(auto_button) auto_layout.addWidget(autoprm_button) auto_layout.addWidget(xrange_button) self.button_list += [auto_button, autoprm_button, xrange_button] return create_groupbox(self, _("Automatic fit"), layout=auto_layout) def get_fitfunc_arguments(self): """Return fitargs and fitkwargs""" fitargs = self.fitargs if self.fitargs is None: fitargs = [] fitkwargs = self.fitkwargs if self.fitkwargs is None: fitkwargs = {} return fitargs, fitkwargs def refresh(self, slider_value=None): """Refresh Fit Tool dialog box""" # Update button states enable = self.x is not None and self.y is not None \ and self.x.size > 0 and self.y.size > 0 \ and self.fitfunc is not None and self.fitparams is not None \ and len(self.fitparams) > 0 for btn in self.button_list: btn.setEnabled(enable) if not enable: # Fit widget is not yet configured return fitargs, fitkwargs = self.get_fitfunc_arguments() yfit = self.fitfunc(self.x, [p.value for p in self.fitparams], *fitargs, **fitkwargs) plot = self.get_plot() if self.legend is None: self.legend = make.legend(anchor=self.legend_anchor) plot.add_item(self.legend) if self.xrange is None: self.xrange = make.range(0., 1.) plot.add_item(self.xrange) self.xrange.set_range(self.autofit_prm.xmin, self.autofit_prm.xmax) self.xrange.setVisible(self.show_xrange) if self.data_curve is None: self.data_curve = make.curve([], [], _("Data"), color="b", linewidth=2) plot.add_item(self.data_curve) self.data_curve.set_data(self.x, self.y) if self.fit_curve is None: self.fit_curve = make.curve([], [], _("Fit"), color="r", linewidth=2) plot.add_item(self.fit_curve) self.fit_curve.set_data(self.x, yfit) plot.replot() plot.disable_autoscale() def range_changed(self, xrange_obj, xmin, xmax): self.autofit_prm.xmin, self.autofit_prm.xmax = xmin, xmax self.compute_imin_imax() def toggle_xrange(self, state): self.xrange.setVisible(state) plot = self.get_plot() plot.replot() if state: plot.set_active_item(self.xrange) self.show_xrange = state def edit_parameters(self): if self.autofit_prm.edit(parent=self): self.xrange.set_range(self.autofit_prm.xmin, self.autofit_prm.xmax) plot = self.get_plot() plot.replot() self.compute_imin_imax() def compute_imin_imax(self): self.i_min = self.x.searchsorted(self.autofit_prm.xmin) self.i_max = self.x.searchsorted(self.autofit_prm.xmax, side='right') def errorfunc(self, params): x = self.x[self.i_min:self.i_max] y = self.y[self.i_min:self.i_max] fitargs, fitkwargs = self.get_fitfunc_arguments() return y - self.fitfunc(x, params, *fitargs, **fitkwargs) def autofit(self): meth = self.autofit_prm.method x0 = np.array([p.value for p in self.fitparams]) if meth == "lq": x = self.autofit_lq(x0) elif meth == "simplex": x = self.autofit_simplex(x0) elif meth == "powel": x = self.autofit_powel(x0) elif meth == "bfgs": x = self.autofit_bfgs(x0) elif meth == "l_bfgs_b": x = self.autofit_l_bfgs(x0) elif meth == "cg": x = self.autofit_cg(x0) else: return for v, p in zip(x, self.fitparams): p.value = v self.refresh() for prm in self.fitparams: prm.update() def get_norm_func(self): prm = self.autofit_prm err_norm = eval(prm.err_norm) def func(params): err = np.linalg.norm(self.errorfunc(params), err_norm) return err return func def autofit_simplex(self, x0): prm = self.autofit_prm from scipy.optimize import fmin x = fmin(self.get_norm_func(), x0, xtol=prm.xtol, ftol=prm.ftol) return x def autofit_powel(self, x0): prm = self.autofit_prm from scipy.optimize import fmin_powell x = fmin_powell(self.get_norm_func(), x0, xtol=prm.xtol, ftol=prm.ftol) return x def autofit_bfgs(self, x0): prm = self.autofit_prm from scipy.optimize import fmin_bfgs x = fmin_bfgs(self.get_norm_func(), x0, gtol=prm.gtol, norm=eval(prm.norm)) return x def autofit_l_bfgs(self, x0): prm = self.autofit_prm bounds = [(p.min, p.max) for p in self.fitparams] from scipy.optimize import fmin_l_bfgs_b x, _f, _d = fmin_l_bfgs_b(self.get_norm_func(), x0, pgtol=prm.gtol, approx_grad=1, bounds=bounds) return x def autofit_cg(self, x0): prm = self.autofit_prm from scipy.optimize import fmin_cg x = fmin_cg(self.get_norm_func(), x0, gtol=prm.gtol, norm=eval(prm.norm)) return x def autofit_lq(self, x0): prm = self.autofit_prm def func(params): err = self.errorfunc(params) return err from scipy.optimize import leastsq x, _ier = leastsq(func, x0, xtol=prm.xtol, ftol=prm.ftol) return x def get_values(self): """Convenience method to get fit parameter values""" return [param.value for param in self.fitparams]