def draw_average_line(self): """ method for drawing average lines on plot widget """ pen_1 = mkPen(color="#4c96d7", style=Qt.DotLine, width=2) average_line_1 = InfiniteLine(angle=90, movable=False, pen=pen_1) average_line_2 = InfiniteLine(angle=90, movable=False, pen=pen_1) pen_2 = mkPen(color="#4c96d7", style=Qt.SolidLine, width=2) average_line_3 = InfiniteLine(angle=90, movable=False, pen=pen_2) average_line_4 = InfiniteLine(angle=90, movable=False, pen=pen_2) brush = QBrush(QColor(0, 0, 255, 20)) if sum(self.y_1) != 0: average_1 = np.average(self.x_1, weights=self.y_1) linear_region_1 = LinearRegionItem([average_1, self.average], movable=False, brush=brush) self.graphics_view_1.addItem(linear_region_1) average_line_1.setPos(average_1) self.graphics_view_1.addItem(average_line_1) if sum(self.y_2) != 0: average_2 = np.average(self.x_2, weights=self.y_2) linear_region_2 = LinearRegionItem([average_2, self.average], movable=False, brush=brush) self.graphics_view_2.addItem(linear_region_2) average_line_2.setPos(average_2) self.graphics_view_2.addItem(average_line_2) average_line_3.setPos(self.average) average_line_4.setPos(self.average) self.graphics_view_1.addItem(average_line_3) self.graphics_view_2.addItem(average_line_4)
def setUI(self): self.vlayout = QtWidgets.QVBoxLayout() self.parent.setLayout(self.vlayout) form = QtWidgets.QWidget() self.viewer1D = Viewer1DBasic(form) self.vlayout.addWidget(form) self.fftbutton1D = QtWidgets.QPushButton() self.fftbutton1D.setText("") icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/FFT.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.fftbutton1D.setIcon(icon) self.fftbutton1D.setCheckable(True) self.fftbutton1D.clicked.connect(self.update_plot) vbox = self.viewer1D.parent.layout() widg = QtWidgets.QWidget() hbox = QtWidgets.QHBoxLayout() widg.setLayout(hbox) vbox.insertWidget(0, widg) hbox.addWidget(self.fftbutton1D) hbox.addStretch() self.viewer1D.ROI = LinearRegionItem(values=[0, 100]) self.viewer1D.plotwidget.plotItem.addItem(self.viewer1D.ROI) self.data_filtered_plot = self.viewer1D.plotwidget.plotItem.plot() self.data_filtered_plot.setPen('w') self.viewer1D.ROI.sigRegionChangeFinished.connect(self.set_data) self.viewer1D.ROIfft = LinearRegionItem() self.viewer1D.plotwidget.plotItem.addItem(self.viewer1D.ROIfft) self.viewer1D.ROIfft.sigRegionChangeFinished.connect(self.update_filter) self.parent.show()
def __init__(self, roi: Roi, enable_context: bool = True, **kwargs): AbstractRoiWidget.__init__(self, roi, enable_context=enable_context, **kwargs) LinearRegionItem.__init__(self) self.sigRegionChanged.connect(self.roi_is_moving) self.update_roi() if App().debug_tracker: App().debug_tracker.add_object(self, roi.name)
def initPlotView(self): self.plot = PlotWidget(enableAutoRange=True) self.plot.setXRange(self.lower - self.range * 0.05, self.upper + self.range * 0.05) self.plotLegand = self.plot.addLegend() self.graphicsView.addWidget(self.plot) self.plotRegion = LinearRegionItem() self.plotRegion.setZValue(10) self.peakPoint = ScatterPlotItem(size=8, pen=mkPen(color='0000FF', width=2), symbol="+", brush=mkBrush(255, 255, 255, 240)) self.plot.addItem(self.plotRegion, ignoreBounds=True) self.plot.addItem(self.peakPoint) self.setGraphViewStyle()
def visualize(self, canvas, **canvases): # TODO: callables? from pyqtgraph import LinearRegionItem canvas = canvases["imageview"] if callable(canvas): canvas = canvas() canvas.addItem(LinearRegionItem(*self.range.value, **self.kwargs))
def initUI(self): """ Initialize user interface. """ L = QGridLayout(self) self.resize(500, 300) widget_align = Qt.AlignLeft # Available columns for recondition: all numeric columns self.columns = list(filter( lambda c: self.locs[c].dtype in ['float64', 'float32', \ 'uint8', 'uint16', 'int64'], self.locs.columns)) # For the default, choose `I0` if available; otherwise # choose the first column init_col = 'I0' if ('I0' in self.columns) else self.columns[0] self.load_col(init_col) # Main plot self.PlotWidget = PlotWidget(name="Create Boolean attribute") L.addWidget(self.PlotWidget, 0, 0, alignment=widget_align) # Histogram self.curve = self.PlotWidget.plot(self.bin_c, self.H, clickable=True) # User threshold, as a LinearRegionItem from pyqtgraph self.LinearRegion = LinearRegionItem([self.hmin, (self.hmax-self.hmin)*0.25+self.hmin]) self.PlotWidget.addItem(self.LinearRegion) # Drop-down menu to select the column self.M_select_col = LabeledQComboBox(self.columns, "Attribute", init_value=init_col, parent=self) self.M_select_col.assign_callback(self.M_select_col_callback) L.addWidget(self.M_select_col, 1, 0, alignment=widget_align) # Accept the current threshold self.B_accept = QPushButton("Accept", parent=self) L.addWidget(self.B_accept, 2, 0, alignment=widget_align) self.B_accept.clicked.connect(self.B_accept_callback) self.update_histogram()
def initializeBinds(self): # añadir plots self.pushButtonPlay.clicked.connect(self.play) self.pushButton.clicked.connect(self.showFFT) setConfigOption('leftButtonPan', False) self.x = 0 self.y = 0 self.zoomedPlot = self.graphicsView.addPlot(row=1, col=0) self.fullPlot = self.graphicsView.addPlot(row=2, col=0) self.graphicsView.setBackground(background="w") # self.zoomedPlot.vb.setBackgroundColor("w") # self.fullPlot.vb.setBackgroundColor("w") self.penB = mkPen('b') self.penR = mkPen('r') self.region = LinearRegionItem() self.region.setZValue(10) self.vb = self.zoomedPlot.vb self.region.setRegion([1000, 2000]) self.fullPlot.addItem(self.region, ignoreBounds=True) # pg.dbg() self.zoomedPlot.setAutoVisible(y=True) self.vLine = InfiniteLine(angle=90, movable=False) self.hLine = InfiniteLine(angle=0, movable=False) self.zoomedPlot.addItem(self.vLine, ignoreBounds=True) self.zoomedPlot.addItem(self.hLine, ignoreBounds=True) # signal para capturar evento de raton # proxy = SignalProxy(self.zoomedPlot.scene().sigMouseMoved, rateLimit=60, slot=self.mouseMoved) self.zoomedPlot.scene().sigMouseMoved.connect(self.mouseMoved) self.region.sigRegionChanged.connect(self.update) self.zoomedPlot.sigRangeChanged.connect(self.updateRegion)
def __init__(self, image=None, fillHistogram=True, bounds: tuple = None): GraphicsWidget.__init__(self) self.imageItem = lambda: None # fake a dead weakref self.layout = QGraphicsGridLayout() self.setLayout(self.layout) self.layout.setContentsMargins(1, 1, 1, 1) self.layout.setSpacing(0) self.vb = ViewBox(parent=self) # self.vb.setMaximumHeight(152) # self.vb.setMinimumWidth(45) self.vb.setMouseEnabled(x=True, y=False) self.region = LinearRegionItem([0, 1], 'vertical', swapMode='block', bounds=bounds) self.region.setZValue(1000) self.vb.addItem(self.region) self.region.lines[0].addMarker('<|', 0.5) self.region.lines[1].addMarker('|>', 0.5) self.region.sigRegionChanged.connect(self.regionChanging) self.region.sigRegionChangeFinished.connect(self.regionChanged) self.axis = AxisItem('bottom', linkView=self.vb, maxTickLength=-10, parent=self) self.layout.addItem(self.axis, 1, 0) self.layout.addItem(self.vb, 0, 0) self.range = None self.vb.sigRangeChanged.connect(self.viewRangeChanged) self.plot = PlotCurveItem(pen=(200, 200, 200, 100)) # self.plot.rotate(90) self.vb.addItem(self.plot) self.fillHistogram(fillHistogram) self._showRegions() self.autoHistogramRange() if image is not None: self.setImageItem(image)
def set_experiment_view(self): self.ui.graphicsView.clear() plot = PlotDataItem(pen="k") duration = (self.ui.spinBoxExperimentDurationMinutes.value() * 60) + self.ui.spinBoxExperimentDurationSeconds.value() xs = np.linspace(0, duration, 2) ys = [1, 1] plot.setData(xs, ys) self.ui.graphicsView.addItem(plot) for ii in range(len(self.Stims.df)): start = self.Stims.df.time_on.iloc[ii] stop = self.Stims.df.time_off.iloc[ii] if self.Stims.df.message_on.iloc[ii].startswith("w"): box = LinearRegionItem(values=(start, stop), brush=(255, 255, 250, 230), movable=False) self.ui.graphicsView.addItem(box) elif self.Stims.df.message_on.iloc[ii].startswith("n"): on = self.Stims.df.message_on.iloc[ii][1:] r = int(on[:3]) g = int(on[3:6]) b = int(on[6:]) box = LinearRegionItem(values=(start, stop), brush=(r, g, b, 50), movable=False) self.ui.graphicsView.addItem(box) elif self.Stims.df.message_on.iloc[ii].startswith("v"): box = LinearRegionItem(values=(start, stop), brush="k", movable=False) self.ui.graphicsView.addItem(box) self.ui.comboBoxSelectStimId.clear() for stim_id in set(self.Stims.df.id): self.ui.comboBoxSelectStimId.addItem(stim_id)
def __init__(self, name): Node.__init__(self, name, terminals={ 'dataIn': { 'io': 'in' }, 'dataOut': { 'io': 'out' }, 'plotItems': { 'io': 'out' } }) color = (220, 220, 25, 255) self.plotDataItem = PlotDataItem(stepMode=True, fillLevel=0, pen={ 'color': color, 'width': 2 }) self.plotRegion = LinearRegionItem([0, 1], movable=True) self.plotRegion.sigRegionChangeFinished.connect(self.regionChanged) self.sigUpdatePlot.connect(self.updatePlot)
class ConditionDialog(QDialog): """ Create a new binary column on a set of localizations by drawing a threshold on a 1D histogram of some attribute for those localizations. For example, threshold only spots with low intensity (I0) or something. init ---- locs : pandas.DataFrame parent : root QWidget """ def __init__(self, locs, parent=None): super(ConditionDialog, self).__init__(parent=parent) self.locs = locs self.initUI() def initUI(self): """ Initialize user interface. """ L = QGridLayout(self) self.resize(500, 300) widget_align = Qt.AlignLeft # Available columns for recondition: all numeric columns self.columns = list(filter( lambda c: self.locs[c].dtype in ['float64', 'float32', \ 'uint8', 'uint16', 'int64'], self.locs.columns)) # For the default, choose `I0` if available; otherwise # choose the first column init_col = 'I0' if ('I0' in self.columns) else self.columns[0] self.load_col(init_col) # Main plot self.PlotWidget = PlotWidget(name="Create Boolean attribute") L.addWidget(self.PlotWidget, 0, 0, alignment=widget_align) # Histogram self.curve = self.PlotWidget.plot(self.bin_c, self.H, clickable=True) # User threshold, as a LinearRegionItem from pyqtgraph self.LinearRegion = LinearRegionItem([self.hmin, (self.hmax-self.hmin)*0.25+self.hmin]) self.PlotWidget.addItem(self.LinearRegion) # Drop-down menu to select the column self.M_select_col = LabeledQComboBox(self.columns, "Attribute", init_value=init_col, parent=self) self.M_select_col.assign_callback(self.M_select_col_callback) L.addWidget(self.M_select_col, 1, 0, alignment=widget_align) # Accept the current threshold self.B_accept = QPushButton("Accept", parent=self) L.addWidget(self.B_accept, 2, 0, alignment=widget_align) self.B_accept.clicked.connect(self.B_accept_callback) self.update_histogram() def load_col(self, col): """ Get data from a specific column in the locs dataframe. args ---- col : str """ self.data = np.asarray(self.locs[col]) # Histogram limits self.hmin = self.data.min() self.hmax = np.percentile(self.data, 99.9) # Binning scheme n_bins = 5000 bin_size = (self.hmax - self.hmin) / n_bins self.bin_edges = np.arange(self.hmin, self.hmax, bin_size) # Bin the data according to the binning scheme self.H, _edges = np.histogram(self.data, bins=self.bin_edges) self.bin_c = self.bin_edges[:-1] + (self.bin_edges[1]-self.bin_edges[0])/2.0 def update_histogram(self): """ Update the main histogram with data from a new column """ self.PlotWidget.clear() self.curve = self.PlotWidget.plot(self.bin_c, self.H) self.curve.setPen('w') # Set default values for linear rect region self.LinearRegion.setRegion((self.hmin, np.percentile(self.data, 50))) self.PlotWidget.addItem(self.LinearRegion) self.curve.updateItems() def M_select_col_callback(self): """ Select the current attribute to filter on. """ col = self.M_select_col.currentText() self.load_col(col) self.update_histogram() def B_accept_callback(self): """ Set the return value and exit from the dialog. """ self.return_val = ( self.LinearRegion.getRegion(), self.M_select_col.currentText(), ) self.accept()
class HistogramItem(GraphicsWidget): """ This is a graphicsWidget which provides controls for adjusting the display of an image. Includes: - Image histogram - Movable region over histogram to select black/white levels Parameters ---------- image : ImageItem or None If *image* is provided, then the control will be automatically linked to the image and changes to the control will be immediately reflected in the image's appearance. fillHistogram : bool By default, the histogram is rendered with a fill. For performance, set *fillHistogram* = False. """ sigLevelsChanged = pyqtSignal(object) sigLevelChangeFinished = pyqtSignal(object) def __init__(self, image=None, fillHistogram=True, bounds: tuple = None): GraphicsWidget.__init__(self) self.imageItem = lambda: None # fake a dead weakref self.layout = QGraphicsGridLayout() self.setLayout(self.layout) self.layout.setContentsMargins(1, 1, 1, 1) self.layout.setSpacing(0) self.vb = ViewBox(parent=self) # self.vb.setMaximumHeight(152) # self.vb.setMinimumWidth(45) self.vb.setMouseEnabled(x=True, y=False) self.region = LinearRegionItem([0, 1], 'vertical', swapMode='block', bounds=bounds) self.region.setZValue(1000) self.vb.addItem(self.region) self.region.lines[0].addMarker('<|', 0.5) self.region.lines[1].addMarker('|>', 0.5) self.region.sigRegionChanged.connect(self.regionChanging) self.region.sigRegionChangeFinished.connect(self.regionChanged) self.axis = AxisItem('bottom', linkView=self.vb, maxTickLength=-10, parent=self) self.layout.addItem(self.axis, 1, 0) self.layout.addItem(self.vb, 0, 0) self.range = None self.vb.sigRangeChanged.connect(self.viewRangeChanged) self.plot = PlotCurveItem(pen=(200, 200, 200, 100)) # self.plot.rotate(90) self.vb.addItem(self.plot) self.fillHistogram(fillHistogram) self._showRegions() self.autoHistogramRange() if image is not None: self.setImageItem(image) def fillHistogram(self, fill=True, level=0.0, color=(100, 100, 200)): if fill: self.plot.setFillLevel(level) self.plot.setBrush(color) else: self.plot.setFillLevel(None) def paint(self, p, *args): rgn = self.getLevels() self.vb.mapFromViewToItem(self, Point(self.vb.viewRect().center().x(), rgn[0])) self.vb.mapFromViewToItem(self, Point(self.vb.viewRect().center().x(), rgn[1])) def setHistogramRange(self, mn, mx, padding=0.1): """Set the Y range on the histogram plot. This disables auto-scaling.""" self.vb.enableAutoRange(self.vb.XAxis, False) self.vb.setYRange(mn, mx, padding) def autoHistogramRange(self): """Enable auto-scaling on the histogram plot.""" self.vb.enableAutoRange(self.vb.XYAxes) def setImageItem(self, img): """Set an ImageItem to have its levels and LUT automatically controlled by this HistogramLUTItem. """ self.imageItem = weakref.ref(img) img.sigImageChanged.connect(self.imageChanged) self.regionChanged() self.imageChanged(autoLevel=True) def viewRangeChanged(self): self.update() def regionChanged(self): if self.imageItem() is not None: self.imageItem().setLevels(self.getLevels()) self.sigLevelChangeFinished.emit(self) def regionChanging(self): if self.imageItem() is not None: self.imageItem().setLevels(self.getLevels()) self.sigLevelsChanged.emit(self) self.update() def imageChanged(self, autoLevel=False): if self.imageItem() is None: return self.plot.setVisible(True) # plot one histogram for all image data h = self.imageItem().getHistogram() if h[0] is None: return self.plot.setData(*h) if autoLevel: mn = h[0][0] mx = h[0][-1] self.region.setRegion([mn, mx]) else: mn, mx = self.imageItem().levels self.region.setRegion([mn, mx]) def getLevels(self): """ Return the min and max levels. """ return self.region.getRegion() def setLevels(self, min=None, max=None): """ Set the min/max (bright and dark) levels. """ assert None not in (min, max) self.region.setRegion((min, max)) def _showRegions(self): self.region.setVisible(True) def saveState(self): return { 'levels': self.getLevels(), } def restoreState(self, state): self.setLevels(*state['levels'])
class FindPeak(QWidget): def __init__(self, parent, x_data, y_data): super(FindPeak, self).__init__() self.parent = parent self.x = x_data self.y = y_data self.lower = np.min(x_data) self.upper = np.max(x_data) self.range = self.upper - self.lower self.renderWindow() self.initPlotView() self.drawCurve() self.setUpProcessUI() self.bindEvents() self.integral(x_data, y_data, self.lower, self.upper) def bindEvents(self): self.bindBoundEvent() self.bindAlgorithmEvent() self.bindFindEvent() def bindBoundEvent(self): def leftBoundEvent(x): self.lower = x upper = self.upper self.plotRegion.setRegion([x, upper]) self.rightBound.setMinimum(x) self.peakCenter.setMinimum(x) self.peakCenter.setValue((x + upper) / 2) self.integral(self.x, self.y, x, upper) def rightBoundEvent(x): self.upper = x lower = self.lower self.plotRegion.setRegion([lower, x]) self.leftBound.setMaximum(x) self.peakCenter.setMaximum(x) self.peakCenter.setValue((x + lower) / 2) self.integral(self.x, self.y, lower, x) def regionChangeEvent(): lower, upper = self.plotRegion.getRegion() self.lower = lower self.upper = upper self.leftBound.setValue(lower) self.leftBound.setMaximum(upper) self.rightBound.setValue(upper) self.rightBound.setMinimum(lower) self.peakCenter.setMinimum(lower) self.peakCenter.setMaximum(upper) self.peakCenter.setValue((lower + upper) / 2) self.integral(self.x, self.y, lower, upper) self.leftBound.valueChanged.connect(leftBoundEvent) self.rightBound.valueChanged.connect(rightBoundEvent) self.plotRegion.sigRegionChanged.connect(regionChangeEvent) def bindAlgorithmEvent(self): def updateInput(a, b, c, d, e, f): self.peakWidth.setEnabled(a) self.detectDis.setEnabled(b) self.noisePrt.setEnabled(c) self.amplitude.setEnabled(d) self.threshold.setEnabled(e) self.findBtn.setEnabled(f) def changeAlgorithm(algorithm): if algorithm == "Extremum": updateInput(False, False, False, False, False, True) pass elif algorithm == "Matlab Like": updateInput(True, True, False, True, True, True) pass elif algorithm == "Gaussian": updateInput(False, False, False, False, False, False) pass elif algorithm == "Lorentzian": updateInput(False, False, False, False, False, False) pass elif algorithm == "Pseudo-Voigt": updateInput(False, False, False, False, False, False) pass elif algorithm == "Wavelet Transform": updateInput(True, True, True, False, False, False) pass self.algorithm.currentTextChanged.connect(changeAlgorithm) updateInput(False, False, False, False, False, True) def integral(self, x_data, y_data, lower, upper): idx = np.where((x_data >= lower) & (x_data <= upper)) x = x_data[idx] y = y_data[idx] self.integralArea.setValue(simps(y, x)) def bindFindEvent(self): x_data = self.x y_data = self.y def findPeak(): region = np.where((x_data >= self.lower) & (x_data <= self.upper)) sub_data = y_data[region] sub_region = x_data[region] algorithm = self.algorithm.currentText() shape = self.shape.currentText() if shape == "Peak": const = 1 else: const = -1 sub_data = sub_data * const if algorithm == "Extremum": peak = np.max(sub_data) idx = np.where(sub_data == peak) x = sub_region[idx][0] y = sub_data[idx][0] * const self.peakCenter.setValue(x) return self.renderPeakPoint([x, y]) elif algorithm == "Matlab Like": indexes = find_peaks( sub_data, height=self.amplitude.value(), #低于指定高度忽略 threshold=self.threshold.value(), #相邻两点高度差 distance=self.detectDis.value(), #两峰间距 width=self.peakWidth.value() #峰宽 )[0] if np.size(indexes) == 0: return idx = np.where(sub_data == np.max(sub_data[indexes])) x = sub_region[idx][0] y = sub_data[idx][0] * const self.peakCenter.setValue(x) return self.renderPeakPoint([x, y]) elif algorithm == "Wavelet Transform": indexes = find_peaks_cwt( sub_data, widths=self.peakWidth.value(), #峰宽 max_distances=self.detectDis.value(), #两峰间距 noise_perc=self.noisePrt.value())[0] if np.size(indexes) == 0: return idx = np.where(sub_data == np.max(sub_data[indexes])) x = sub_region[idx][0] y = sub_data[idx][0] * const self.peakCenter.setValue(x) return self.renderPeakPoint([x, y]) self.noisePrt pass self.findBtn.clicked.connect(findPeak) def renderPeakPoint(self, pos): self.peakPoint.clear() self.peakPoint.addPoints([{'pos': pos, 'data': 1}]) def renderWindow(self): #边框结构 self.setGeometry(80, 80, 800, 420) size = self.geometry() screen = QDesktopWidget().screenGeometry() posX = (screen.width() - size.width()) / 2 posY = (screen.height() - size.height()) / 2 self.move(posX, posY) #标题 self.setWindowTitle('Find Peak') self.setWindowIcon(QIcon('resource/curve.ico')) #布局 layout = QGridLayout() self.graphicsView = QGridLayout() layout.addLayout(self.graphicsView, 0, 0, 1, 1) self.Process_Box = QGroupBox() self.Process_Box.setMinimumSize(200, 420) self.Process_Box.setFlat(True) layout.addWidget(self.Process_Box, 0, 1, 1, 1) self.setLayout(layout) def setUpProcessUI(self): layout = QGridLayout() layout.setContentsMargins(10, 10, 10, 10) layout.setSpacing(10) self.Process_Box.setLayout(layout) layout.addWidget(QLabel(self.translate('Left Boundary')), 0, 0, 1, 1) layout.addWidget(QLabel(self.translate('Right Boundary')), 1, 0, 1, 1) layout.addWidget(QLabel(self.translate("Integral Area")), 2, 0, 1, 1) layout.addWidget(QLabel(self.translate('Peak Center')), 3, 0, 1, 1) layout.addWidget(QLabel(self.translate('Peak Shape')), 4, 0, 1, 1) layout.addWidget(QLabel(self.translate('Find Peak Algorithm')), 5, 0, 1, 1) layout.addWidget(QLabel(self.translate('Minimum Peak Width')), 6, 0, 1, 1) layout.addWidget(QLabel(self.translate('Minimum Detect Distance')), 7, 0, 1, 1) layout.addWidget(QLabel(self.translate('Noise Percent')), 8, 0, 1, 1) layout.addWidget(QLabel(self.translate("Minimum Amplitude")), 9, 0, 1, 1) layout.addWidget(QLabel(self.translate("Relative Threshold")), 10, 0, 1, 1) self.leftBound = SpinBox(lower=self.lower, dec=4, val=self.lower) self.rightBound = SpinBox(upper=self.upper, dec=4, val=self.upper) self.peakCenter = SpinBox(lower=self.lower, upper=self.upper, dec=4) self.peakWidth = SpinBox(lower=1, upper=10000, val=5) self.noisePrt = SpinBox(lower=0, upper=100, step=1, val=10) self.detectDis = SpinBox(lower=1, val=3) self.amplitude = SpinBox(lower=-1E5, upper=1E5, dec=4, val=-1) self.threshold = SpinBox(lower=0, upper=100, dec=4, val=0.001) self.integralArea = SpinBox(upper=1E8, dec=4) self.integralArea.setReadOnly(True) self.integralArea.setButtonSymbols(QAbstractSpinBox.NoButtons) self.shape = QComboBox() self.shape.addItems(["Peak", "Valley"]) #self.shape.currentTextChanged.connect() self.algorithm = QComboBox() self.algorithm.addItems([ 'Extremum', 'Matlab Like', 'Wavelet Transform', 'Gaussian', 'Lorentzian', 'Pseudo-Voigt' ]) #self.algorithm.currentTextChanged.connect() #https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.find_peaks_cwt.html layout.addWidget(self.leftBound, 0, 1, 1, 1) layout.addWidget(self.rightBound, 1, 1, 1, 1) layout.addWidget(self.integralArea, 2, 1, 1, 1) layout.addWidget(self.peakCenter, 3, 1, 1, 1) layout.addWidget(self.shape, 4, 1, 1, 1) layout.addWidget(self.algorithm, 5, 1, 1, 1) layout.addWidget(self.peakWidth, 6, 1, 1, 1) layout.addWidget(self.detectDis, 7, 1, 1, 1) layout.addWidget(self.noisePrt, 8, 1, 1, 1) layout.addWidget(self.amplitude, 9, 1, 1, 1) layout.addWidget(self.threshold, 10, 1, 1, 1) self.findBtn = QPushButton(self.translate('Find Peak')) layout.addWidget(self.findBtn, 11, 0, 1, 2) pass def initPlotView(self): self.plot = PlotWidget(enableAutoRange=True) self.plot.setXRange(self.lower - self.range * 0.05, self.upper + self.range * 0.05) self.plotLegand = self.plot.addLegend() self.graphicsView.addWidget(self.plot) self.plotRegion = LinearRegionItem() self.plotRegion.setZValue(10) self.peakPoint = ScatterPlotItem(size=8, pen=mkPen(color='0000FF', width=2), symbol="+", brush=mkBrush(255, 255, 255, 240)) self.plot.addItem(self.plotRegion, ignoreBounds=True) self.plot.addItem(self.peakPoint) self.setGraphViewStyle() def setGraphViewStyle(self): self.plot.setAutoVisible(y=True) self.plot.setBackground('#ffffff') self.plot.showGrid(x=True, y=True, alpha=0.25) self.plot.getAxis('bottom').setPen(color='#000000', width=1.5) self.plot.getAxis('left').setPen(color='#000000', width=1.5) self.plotRegion.setRegion([self.lower, self.upper]) self.plotRegion.setBounds([self.lower, self.upper]) def drawCurve(self): pen = mkPen(color='FF0000', width=2) self.plot.plot(self.x, self.y, pen=pen) self.plot.show() def translate(self, text): if self.parent: self.langText = self.parent.langText else: self.langText = load(open('SCN.translation', encoding='utf-8')) if text in self.langText: return self.langText[text] return text
class arrayNormaliserNode(Node): nodeName = 'arrayNormaliser' sigUpdatePlot = QtCore.Signal(object) def __init__(self, name): Node.__init__(self, name, terminals={ 'dataIn': { 'io': 'in' }, 'dataOut': { 'io': 'out' }, 'plotItems': { 'io': 'out' } }) color = (220, 220, 25, 255) self.plotDataItem = PlotDataItem(stepMode=True, fillLevel=0, pen={ 'color': color, 'width': 2 }) self.plotRegion = LinearRegionItem([0, 1], movable=True) self.plotRegion.sigRegionChangeFinished.connect(self.regionChanged) self.sigUpdatePlot.connect(self.updatePlot) def updatePlot(self, xy): self.plotDataItem.setData(*xy) def regionChanged(self): self.regionLimits = self.plotRegion.getRegion() self.update() def process(self, dataIn, display=True): if len(dataIn.shape) != 1: data = dataIn[:, -1] else: data = dataIn self.extremeLimits = np.nanmin(data), np.nanmax(data) # if not self.plotWidget.closed: # the plotWidget attribute is never removed but it is invalidated when the widget is closed y, x = np.histogram(data, bins=100) # self.plotWidget.clear() self.sigUpdatePlot.emit((x, y)) # self.plotWidget.addItem(self.plotRegion) if hasattr(self, 'regionLimits'): mi, ma = self.regionLimits else: mi, ma = self.extremeLimits # if hasattr(self, 'plotRegion'): # self.plotRegion.setRegion((mi, ma)) dataOut = (data - mi) / (ma - mi) # print (dataOut) return { 'dataOut': dataOut, 'plotItems': [self.plotRegion, self.plotDataItem] }
def __init__(self, value: RoiParameters, *args, **kwargs): AbstractROI.__init__(self, value) LinearRegionItem.__init__(self, *args, **kwargs) self.sigRegionChanged.connect(self.roi_is_moving) self.init_roi()
def visualize(self, canvas): # TODO: callables? from pyqtgraph import LinearRegionItem self.canvas = canvas self.canvas.addItem(LinearRegionItem(*self.range.value, **self.kwargs))
class GraphicWidgetLogic(Ui_GraphicWindow): def __init__(self, GraphicWidgetLogic): Ui_GraphicWindow.__init__(self) self.FS = 48000 self.x = 0 self.y = 0 self.freq = 0 self.amp = 0 self.flag = "PURE" # se inicializa el sistema de visualizado avanzado def initializeBinds(self): # añadir plots self.pushButtonPlay.clicked.connect(self.play) self.pushButton.clicked.connect(self.showFFT) setConfigOption('leftButtonPan', False) self.x = 0 self.y = 0 self.zoomedPlot = self.graphicsView.addPlot(row=1, col=0) self.fullPlot = self.graphicsView.addPlot(row=2, col=0) self.graphicsView.setBackground(background="w") # self.zoomedPlot.vb.setBackgroundColor("w") # self.fullPlot.vb.setBackgroundColor("w") self.penB = mkPen('b') self.penR = mkPen('r') self.region = LinearRegionItem() self.region.setZValue(10) self.vb = self.zoomedPlot.vb self.region.setRegion([1000, 2000]) self.fullPlot.addItem(self.region, ignoreBounds=True) # pg.dbg() self.zoomedPlot.setAutoVisible(y=True) self.vLine = InfiniteLine(angle=90, movable=False) self.hLine = InfiniteLine(angle=0, movable=False) self.zoomedPlot.addItem(self.vLine, ignoreBounds=True) self.zoomedPlot.addItem(self.hLine, ignoreBounds=True) # signal para capturar evento de raton # proxy = SignalProxy(self.zoomedPlot.scene().sigMouseMoved, rateLimit=60, slot=self.mouseMoved) self.zoomedPlot.scene().sigMouseMoved.connect(self.mouseMoved) self.region.sigRegionChanged.connect(self.update) self.zoomedPlot.sigRangeChanged.connect(self.updateRegion) def play(self): sd.play(self.y, self.FS, blocking=True) def showFFT(self): self.FFTwindow = QtWidgets.QWidget() self.ui = GraphicWidgetLogicSpectrumLogic(self) self.ui.setupUi(self.FFTwindow) self.ui.initializeBinds() self.ui.PlotFFT(self.x, self.y, self.flag, self.amp) self.FFTwindow.activateWindow() self.FFTwindow.show() self.FFTwindow.raise_() def updateRegion(self, window, viewRange): rgn = viewRange[0] self.region.setRegion(rgn) def update(self): self.region.setZValue(10) minX, maxX = self.region.getRegion() self.zoomedPlot.setXRange(minX, maxX, padding=0) def mouseMoved(self, evt): pos = Point(evt.x(), evt.y()) if self.zoomedPlot.sceneBoundingRect().contains(pos): mousePoint = self.vb.mapSceneToView(pos) index = float(evt.x()) # if index > 0 : # self.dataLabel.setText("<span style='font-size: 12pt'>x=%0.1f, <span style='color: red'>y1=%0.1f</span>, <span style='color: green'>y2=%0.1f</span>" % int(index), self.x[index], self.y[index]) self.vLine.setPos(mousePoint.x()) self.hLine.setPos(mousePoint.y()) def PlotSin(self, amp, freq, phase, flag="PURE"): print(self.flag) self.flag = flag self.amp = amp self.freq = freq self.x = arange(0, 1, 1 / self.FS) self.y = (amp / 10) * sin(2 * pi * freq * self.x + (phase * pi)) self.fullPlot.plot(self.x, self.y, pen=self.penR) self.zoomedPlot.plot(self.x, self.y, pen=self.penB) def plotSawtooth(self, amp, freq): self.amp = amp self.freq = freq self.Fs: int = 44100 self.x = arange(0, 1, 1 / self.Fs) self.y = (amp / 10) * sawtooth(2 * pi * freq * self.x) self.fullPlot.plot(self.x, self.y, pen=self.penR) self.zoomedPlot.plot(self.x, self.y, pen=self.penB) def plotSquare(self, amp, freq): self.amp = amp self.freq = freq self.Fs: int = 44100 self.x = arange(0, 1, 1 / self.Fs) self.y = (amp / 10) * square(2 * pi * freq * self.x) self.fullPlot.plot(self.x, self.y, pen=self.penR) self.zoomedPlot.plot(self.x, self.y, pen=self.penB) def plotGpulse(self, amp, freq): self.amp = amp self.freq = freq self.Fs: int = 44100 self.x = arange(0, 1, 1 / self.Fs) self.y = (amp / 10) * gausspulse((self.x, freq)) self.fullPlot.plot(self.x, self.y, pen=self.penR) self.zoomedPlot.plot(self.x, self.y, pen=self.penB) def plotHarmonic(self, x_array, y_array): self.x = x_array self.y = y_array self.fullPlot.plot(x_array, y_array, pen=self.penR) self.zoomedPlot.plot(x_array, y_array, pen=self.penB)
def mouseDragEvent(self, ev): if not ev.modifiers() == Qt.ShiftModifier: LinearRegionItem.mouseDragEvent(self, ev) else: self.mouseClickEvent(ev)
class PlotBC(Smooth1DPlot): sigBackgroundChanged = pyqtSignal() def __init__(self, profile: BasicProfile, parent=None): super().__init__(profile, parent) self._status = BaseLineStatus.no_baseline self.baseline_plot = self.image_view.plot_item.plot() self._init_roi() self._baseline_setup_widget = BaseLineSetup( self, self._status, **self.profile.get_parameters()) self.profile.sigDataUpdated.connect(self.update_plot) @property def y(self): if self._status == BaseLineStatus.baseline_subtracted and self.profile.baseline is not None: return self.profile.y - self.profile.baseline else: return self.profile.y def update_data(self, *args, **kwargs): self.profile.update_data(*args, **kwargs) def is_shown(self, shown: bool): self.profile.is_shown = shown def _init_toolbars(self): super()._init_toolbars() baseline_toolbar = BlackToolBar('Baseline Correction') self.addToolBar(baseline_toolbar) baseline_button = RoundedPushButton(parent=baseline_toolbar, icon=Icon('baseline'), radius=30) baseline_button.clicked.connect(self.open_baseline_setup) baseline_toolbar.addWidget(baseline_button) def _init_roi(self): self._roi = LinearRegionItem() self._roi.hide() self._roi.setBrush(QColor(255, 255, 255, 50)) self.image_view.plot_item.addItem(self._roi) def open_baseline_setup(self): if self.y is None: return setup = self._baseline_setup_widget if self.profile.x_range is None: self._set_default_bounds() self._roi.setRegion(self.profile.x_range) if self.profile.baseline is None: self._set_status(BaseLineStatus.no_baseline) # elif self._status == BaseLineStatus.no_baseline: # self._set_status(BaseLineStatus.baseline_subtracted) # else: # self._set_status(self._status) # self.plot() setup.set_parameters(self.profile.get_parameters()) setup.calculate_signal.connect(self._on_calculate_baseline) setup.subtract_signal.connect(self._on_subtracting_baseline) setup.restore_signal.connect(self._on_restoring_data) setup.close_signal.connect(self._on_closing_setup) setup.show() self._roi.show() # def show_baseline(self): # if (self.profile.baseline is None or self._status == BaseLineStatus.baseline_calculated or # self._status == BaseLineStatus.baseline_restored): # return # self._on_restoring_data() def update_plot(self): self.sigma_slider.set_value(self.profile.sigma, True) if self.profile.baseline is None: self.clear_baseline() else: self._set_status(BaseLineStatus.baseline_subtracted) self.plot() def plot_baseline(self): if self.profile.baseline is not None: self.baseline_plot.setData(self.profile.x, self.profile.baseline, pen=get_pen(width=4, color='red', style=Qt.DashDotLine)) def _set_default_bounds(self): if self.x is None: self.profile.x_range = (0, 1) else: self.profile.x_range = (self.x.min(), self.x.max()) def _update_bounds(self): self.profile.x_range = self._roi.getRegion() def _set_status(self, status: 'BaseLineStatus'): self._status = status self._baseline_setup_widget.set_status(status) def _on_calculate_baseline(self, params: dict): self.profile.set_parameters(**params) self._update_bounds() try: self.profile.update_baseline() except Exception as err: logger.exception(err) show_error( 'Failed calculating baseline. Change roi region or parameters and try again.', error_title='Baseline calculation error') return self._set_status(BaseLineStatus.baseline_calculated) self.plot_baseline() def _on_subtracting_baseline(self): self.baseline_plot.clear() self._set_status(BaseLineStatus.baseline_subtracted) self.plot() def _on_restoring_data(self): self._set_status(BaseLineStatus.baseline_restored) self.plot_baseline() self.plot() def _on_closing_setup(self): self._baseline_setup_widget.hide() self._roi.hide() self.clear_baseline() if self._status != BaseLineStatus.baseline_subtracted: self._set_status(BaseLineStatus.no_baseline) self.profile.clear_baseline(clear_range=False) self.sigBackgroundChanged.emit() def clear_baseline(self): self.baseline_plot.clear()
class BaseLine(object): @property def status(self): return self._status @property def roi(self): return self._roi @property def baseline(self): if self._status == BaseLineStatus.baseline_subtracted: return self._baseline else: return @property def parent(self): return self._parent() def __init__(self, parent: PlotWithBaseLineCorrection): self._parent = weakref.ref(parent) self._baseline = None self._x_axis = None self._x1 = None self._x2 = None self._smoothness_param = None self._asymmetry_param = None self._baseline_setup_widget = None self.baseline_plot = None self._status = BaseLineStatus.no_baseline self.__init_parameters__() self.__init_roi__() def clear(self): self._baseline = None self._set_status(BaseLineStatus.no_baseline) self._remove_baseline_from_plot() def open_setup(self): self.set_axis(self.parent.x) self._baseline_setup_widget = setup = BaseLineSetup( self._status, **self.get_parameters()) if None in (self._x1, self._x2): self.set_default_bounds() self.roi.show() setup.calculate_signal.connect(self._on_calculate_baseline) setup.subtract_signal.connect(self._on_subtracting_baseline) setup.restore_signal.connect(self._on_restoring_data) setup.close_signal.connect(self._on_closing_setup) setup.show() def _set_status(self, status: 'BaseLineStatus'): self._status = status if self._baseline_setup_widget: self._baseline_setup_widget.set_status(status) def _on_calculate_baseline(self, params: dict): self.set_parameters(**params) self.update_bounds() try: self.get_baseline_correction(self.parent.smoothed_y) except Exception as err: logger.exception(err) show_error( 'Failed calculating baseline. Change roi region or parameters and try again.', 'Baseline calculation error') self._plot_baseline() self._set_status(BaseLineStatus.baseline_calculated) def _on_subtracting_baseline(self): self._remove_baseline_from_plot() self._set_status(BaseLineStatus.baseline_subtracted) self.parent.update_smoothed_y() self.parent.plot() def _on_restoring_data(self): self._set_status(BaseLineStatus.baseline_restored) self._plot_baseline() self.parent.update_smoothed_y() self.parent.plot() def _on_closing_setup(self): self._baseline_setup_widget = None self.roi.hide() if (self.status == BaseLineStatus.baseline_calculated or self.status == BaseLineStatus.baseline_restored): self._remove_baseline_from_plot() self.clear() def _plot_baseline(self): if not self.baseline_plot: self.baseline_plot = self.parent.image_view.plot_item.plot() pen = QPen(QColor('red')) pen.setStyle(Qt.DashDotLine) pen.setWidth(4) pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) pen.setCosmetic(True) self.baseline_plot.setData(self._x_axis, self._baseline, pen=pen) def _remove_baseline_from_plot(self): if self.baseline_plot: self.parent.image_view.plot_item.removeItem(self.baseline_plot) self.baseline_plot = None def __init_parameters__(self): # not necessary params = read_config('Baseline correction') self.set_parameters(**params) def __init_roi__(self): self._roi = LinearRegionItem() self._roi.hide() self._roi.setBrush(QColor(255, 255, 255, 50)) self.parent.image_view.plot_item.addItem(self.roi) def update_bounds(self): self._x1, self._x2 = self.roi.getRegion() def set_parameters(self, **kwargs): if 'smoothness_param' in kwargs: self._smoothness_param = kwargs['smoothness_param'] if 'asymmetry_param' in kwargs: self._asymmetry_param = kwargs['asymmetry_param'] def get_parameters(self): params = dict() if self._asymmetry_param is not None: params['asymmetry_param'] = self._asymmetry_param if self._smoothness_param is not None: params['smoothness_param'] = self._smoothness_param return params def set_axis(self, x: np.ndarray): self._x_axis = x self.set_default_bounds() def set_bounds(self, x1: float, x2: float): self._x1, self._x2 = x1, x2 self.roi.setRegion((x1, x2)) def set_default_bounds(self): if self._x_axis is None: self.set_bounds(0, 1) else: self.set_bounds(self._x_axis.min(), self._x_axis.max()) def get_baseline_correction(self, y: np.ndarray): if (self._x_axis is None or y.size != self._x_axis.size or None in (self._x1, self._x2, self._smoothness_param, self._asymmetry_param)): return x1, x2 = self._get_coords() baseline = baseline_correction(y[x1:x2], self._smoothness_param, self._asymmetry_param) self._baseline = np.zeros_like(y) self._baseline[x1:x2] = baseline return self.baseline def _get_coords(self): scale_factor = self._x_axis.size / (self._x_axis.max() - self._x_axis.min()) x_min = self._x_axis.min() min_ind, max_ind = 0, self._x_axis.size x1 = int((self._x1 - x_min) * scale_factor) x2 = int((self._x2 - x_min) * scale_factor) x1 = min((max((x1, min_ind)), max_ind)) x2 = min((max((x2, min_ind)), max_ind)) xs = (x1, x2) return min(xs), max(xs)
def __init_roi__(self): self._roi = LinearRegionItem() self._roi.hide() self._roi.setBrush(QColor(255, 255, 255, 50)) self.parent.image_view.plot_item.addItem(self.roi)
def set_GUI(self): """ """ #%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% #main_layout = QtWidgets.QGridLayout() #self.area.setLayout(main_layout) #vsplitter = QtWidgets.QSplitter(Qt.Vertical) # Hsplitter=QtWidgets.QSplitter(Qt.Horizontal) params = [ {'title': 'set data:', 'name': 'set_data_4D', 'type': 'action', 'visible': False}, {'title': 'set data:', 'name': 'set_data_3D', 'type': 'action', 'visible': False}, {'title': 'set data:', 'name': 'set_data_2D', 'type': 'action', 'visible': False}, {'title': 'set data:', 'name': 'set_data_1D', 'type': 'action', 'visible': False}, {'title': 'Signal shape', 'name': 'data_shape_settings', 'type': 'group', 'children': [ {'title': 'Initial Data shape:', 'name': 'data_shape_init', 'type': 'str', 'value': "", 'readonly': True}, {'title': 'Axes shape:', 'name': 'nav_axes_shapes', 'type': 'group', 'children': [], 'readonly': True}, {'title': 'Data shape:', 'name': 'data_shape', 'type': 'str', 'value': "", 'readonly': True}, {'title': 'Navigator axes:', 'name': 'navigator_axes', 'type': 'itemselect'}, {'title': 'Set Nav axes:', 'name': 'set_nav_axes', 'type': 'action', 'visible': True}, ]}, ] self.settings = Parameter.create(name='Param', type='group', children=params) ##self.signal_axes_selection() # connecting from tree self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed) # any changes on the settings self.settings.child(('set_data_1D')).sigActivated.connect(lambda: self.set_data_test('1D')) self.settings.child(('set_data_2D')).sigActivated.connect(lambda: self.set_data_test('2D')) self.settings.child(('set_data_3D')).sigActivated.connect(lambda: self.set_data_test('3D')) self.settings.child(('set_data_4D')).sigActivated.connect(lambda: self.set_data_test('4D')) self.settings.child('data_shape_settings', 'set_nav_axes').sigActivated.connect(self.update_data) ##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ##% 1D signalviewer viewer1D_widget = QtWidgets.QWidget() self.ui.viewer1D = Viewer1D(viewer1D_widget) self.ROI1D = LinearRegionItem() self.ui.viewer1D.viewer.plotwidget.plotItem.addItem(self.ROI1D) self.ui.combomath = QtWidgets.QComboBox() self.ui.combomath.addItems(['Sum', 'Mean', 'Half-life']) self.ui.viewer1D.ui.button_widget.layout().insertWidget(4, self.ui.combomath) self.ui.combomath.currentIndexChanged.connect(self.update_Navigator) self.ROI1D.sigRegionChangeFinished.connect(self.update_Navigator) # % 2D viewer Dock viewer2D_widget = QtWidgets.QWidget() self.ui.viewer2D = Viewer2D(viewer2D_widget) self.ui.viewer2D.ui.Ini_plot_pb.setVisible(False) self.ui.viewer2D.ui.FlipUD_pb.setVisible(False) self.ui.viewer2D.ui.FlipLR_pb.setVisible(False) self.ui.viewer2D.ui.rotate_pb.setVisible(False) self.ui.viewer2D.ui.auto_levels_pb.click() self.ui.viewer2D.ui.ROIselect_pb.click() self.ROI2D = self.ui.viewer2D.ui.ROIselect self.ui.viewer2D.ROI_select_signal.connect(self.update_Navigator) dock_signal = Dock('Signal') dock_signal.addWidget(viewer1D_widget) dock_signal.addWidget(viewer2D_widget) ##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ##% Navigator viewer Dock navigator1D_widget = QtWidgets.QWidget() self.ui.navigator1D = Viewer1D(navigator1D_widget) self.ui.navigator1D.ui.crosshair.crosshair_dragged.connect(self.update_viewer_data) self.ui.navigator1D.ui.crosshair_pb.click() self.ui.navigator1D.data_to_export_signal.connect(self.export_data) navigator2D_widget = QtWidgets.QWidget() self.ui.navigator2D = Viewer2D(navigator2D_widget) self.ui.navigator2D.ui.auto_levels_pb.click() self.ui.navigator2D.crosshair_dragged.connect( self.update_viewer_data) # export scaled position in conjonction with 2D scaled axes self.ui.navigator2D.ui.crosshair_pb.click() self.ui.navigator2D.data_to_export_signal.connect(self.export_data) self.ui.navigation_widget = QtWidgets.QWidget() # vlayout_navigation = QtWidgets.QVBoxLayout() # self.navigator_label = QtWidgets.QLabel('Navigation View') # self.navigator_label.setMaximumHeight(15) #layout_navigation.addWidget(self.navigator_label) self.ui.nav_axes_widget = QtWidgets.QWidget() self.ui.nav_axes_widget.setLayout(QtWidgets.QVBoxLayout()) #vlayout_navigation.addWidget(navigator2D_widget) #vlayout_navigation.addWidget(self.ui.nav_axes_widget) self.ui.nav_axes_widget.setVisible(False) #vlayout_navigation.addWidget(navigator1D_widget) #self.ui.navigation_widget.setLayout(vlayout_navigation) #vsplitter.insertWidget(0, self.ui.navigation_widget) dock_navigation = Dock('Navigation') dock_navigation.addWidget(navigator1D_widget) dock_navigation.addWidget(navigator2D_widget) self.area.addDock(dock_navigation) self.area.addDock(dock_signal, 'right', dock_navigation) # self.ui.signal_widget = QtWidgets.QWidget() # VLayout1 = QtWidgets.QVBoxLayout() # self.viewer_label = QtWidgets.QLabel('Data View') # self.viewer_label.setMaximumHeight(15) # VLayout1.addWidget(self.viewer_label) # VLayout1.addWidget(viewer1D_widget) # VLayout1.addWidget(viewer2D_widget) # self.ui.signal_widget.setLayout(VLayout1) #vsplitter.insertWidget(1, self.ui.signal_widget) icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/cartesian.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.ui.set_signals_pb_1D = QtWidgets.QPushButton('') self.ui.set_signals_pb_1D.setToolTip('Change navigation/signal axes') self.ui.set_signals_pb_1D_bis = QtWidgets.QPushButton('') self.ui.set_signals_pb_1D_bis.setToolTip('Change navigation/signal axes') self.ui.set_signals_pb_1D.setIcon(icon) self.ui.set_signals_pb_1D_bis.setIcon(icon) self.ui.set_signals_pb_2D = QtWidgets.QPushButton('') self.ui.set_signals_pb_2D.setToolTip('Change navigation/signal axes') self.ui.set_signals_pb_2D.setIcon(icon) self.ui.set_signals_pb_2D_bis = QtWidgets.QPushButton('') self.ui.set_signals_pb_2D_bis.setToolTip('Change navigation/signal axes') self.ui.set_signals_pb_2D_bis.setIcon(icon) self.ui.navigator1D.ui.button_widget.layout().insertWidget(0, self.ui.set_signals_pb_1D) self.ui.navigator2D.ui.buttons_layout.insertWidget(0, self.ui.set_signals_pb_2D) self.ui.viewer1D.ui.button_widget.layout().insertWidget(0, self.ui.set_signals_pb_1D_bis) self.ui.viewer2D.ui.buttons_layout.insertWidget(0, self.ui.set_signals_pb_2D_bis) #main_layout.addWidget(vsplitter) self.ui.set_signals_pb_1D.clicked.connect(self.signal_axes_selection) self.ui.set_signals_pb_2D.clicked.connect(self.signal_axes_selection) self.ui.set_signals_pb_1D_bis.clicked.connect(self.signal_axes_selection) self.ui.set_signals_pb_2D_bis.clicked.connect(self.signal_axes_selection) #to start: display as default a 2D navigator and a 1D viewer self.ui.navigator1D.parent.setVisible(False) self.ui.viewer2D.parent.setVisible(True)
def __init__(self, image=None, fillHistogram=True, rgbHistogram=False, levelMode='mono'): GraphicsWidget.__init__(self) self.overlay = False self.lut = None self.imageItem = lambda: None # fake a dead weakref self.levelMode = levelMode self.rgbHistogram = rgbHistogram self.layout = QtGui.QGraphicsGridLayout() self.setLayout(self.layout) self.layout.setContentsMargins(1,1,1,1) self.layout.setSpacing(0) self.vb = ViewBox(parent=self) self.vb.setMaximumWidth(152) self.vb.setMinimumWidth(45) self.vb.setMouseEnabled(x=False, y=True) self.gradient = GradientEditorItem() self.gradient.setOrientation('right') self.gradient.loadPreset('grey') self.regions = [ LinearRegionItem([0, 1], 'horizontal', swapMode='block'), LinearRegionItem([0, 1], 'horizontal', swapMode='block', pen='r', brush=fn.mkBrush((255, 50, 50, 50)), span=(0., 1/3.)), LinearRegionItem([0, 1], 'horizontal', swapMode='block', pen='g', brush=fn.mkBrush((50, 255, 50, 50)), span=(1/3., 2/3.)), LinearRegionItem([0, 1], 'horizontal', swapMode='block', pen='b', brush=fn.mkBrush((50, 50, 255, 80)), span=(2/3., 1.)), LinearRegionItem([0, 1], 'horizontal', swapMode='block', pen='w', brush=fn.mkBrush((255, 255, 255, 50)), span=(2/3., 1.))] for region in self.regions: region.setZValue(1000) self.vb.addItem(region) region.lines[0].addMarker('<|', 0.5) region.lines[1].addMarker('|>', 0.5) region.sigRegionChanged.connect(self.regionChanging) region.sigRegionChangeFinished.connect(self.regionChanged) self.region = self.regions[0] # for backward compatibility. self.axis = AxisItem('left', linkView=self.vb, maxTickLength=-10, parent=self) self.layout.addItem(self.axis, 0, 0) self.layout.addItem(self.vb, 0, 1) self.layout.addItem(self.gradient, 0, 2) self.range = None self.gradient.setFlag(self.gradient.ItemStacksBehindParent) self.vb.setFlag(self.gradient.ItemStacksBehindParent) self.gradient.sigGradientChanged.connect(self.gradientChanged) self.vb.sigRangeChanged.connect(self.viewRangeChanged) add = QtGui.QPainter.CompositionMode_Plus self.plots = [ PlotCurveItem(pen=(200, 200, 200, 100)), # mono PlotCurveItem(pen=(255, 0, 0, 100), compositionMode=add), # r PlotCurveItem(pen=(0, 255, 0, 100), compositionMode=add), # g PlotCurveItem(pen=(0, 0, 255, 100), compositionMode=add), # b PlotCurveItem(pen=(200, 200, 200, 100), compositionMode=add), # a ] self.plot = self.plots[0] # for backward compatibility. for plot in self.plots: plot.rotate(90) self.vb.addItem(plot) self.fillHistogram(fillHistogram) self._showRegions() self.vb.addItem(self.plot) self.autoHistogramRange() if image is not None: self.setImageItem(image)