def __init__(self,map='map'): prefileMeas = sorted([x for x in [y for y in os.listdir("./")] if re.search("axion.m.[0-9]{5}$", x)]) fileMeas = [] for maes in prefileMeas: try: with h5py.File(maes, 'r') as f: if (map in f) : fileMeas.append(maes) except: print('Error opening file: %s'%maes) fileHdf5 = h5py.File(fileMeas[0], "r") self.Lx = fileHdf5["/"].attrs.get("Size") self.Ly = fileHdf5["/"].attrs.get("Size") self.Lz = fileHdf5["/"].attrs.get("Depth") self.z = fileHdf5["/"].attrs.get("z") self.R = self.z fileHdf5.close() self.allData = [] self.step = 1 self.tStep = 100 self.pause = False self.timer = pg.QtCore.QTimer() # Read all data self.i = 0 self.size = 0 # if os.path.exists("./Strings.PyDat"): # fp = gzip.open("./Strings.PyDat", "rb") # self.allData = pickle.load(fp) # fp.close() # self.size = len(self.allData) # else: for meas in fileMeas: # print(meas) fileHdf5 = h5py.File(meas, "r") Lx = fileHdf5["/"].attrs.get("Size") Ly = fileHdf5["/"].attrs.get("Size") Lz = fileHdf5["/"].attrs.get("Depth") zR = fileHdf5["/"].attrs.get("z") R = zR if 'R' in fileHdf5: R = fileHdf5["/"].attrs.get("R") fl = fileHdf5["/"].attrs.get("Field type").decode() if self.Lx != Lx or self.Ly != Ly or self.Lz != Lz: print("Error: Size mismatch (%d %d %d) vs (%d %d %d)\nAre you mixing files?\n" % (Lx, Ly, Lz, self.Lx, self.Ly, self.Lz)) exit() if fl == "Saxion": mTmp = fileHdf5[map]['m'].value.reshape(Ly,Lx,2) rData = np.sqrt(mTmp[:,:,0]**2 + mTmp[:,:,1]**2) rMax = np.amax(rData) rData = rData/R aData = (np.arctan2(mTmp[:,:,1], mTmp[:,:,0]) + 2*np.pi)/(4.*np.pi) elif fl == "Axion": aData = fileHdf5[map]['m'].value.reshape(Ly,Lx) # pm = np.amax(aData) # print ("BMax %f" % pm) aData = aData/R rData = np.ones(aData.shape) pData = np.ones(aData.shape)*(2*np.pi) aData = (aData + pData)/(4.*np.pi) # iData = np.trunc(aData/(2*np.pi)) # aData = aData - iData*(2*np.pi) # aData = aData - pData # pm = np.amax(aData) # print ("AMax %f" % pm) rMax = R else: print("Unrecognized field type %s" % fl) exit() self.allData.append([rData, aData, zR, rMax]) fileHdf5.close() self.size = self.size + 1 # fp = gzip.open("Strings.PyDat", "wb") # pickle.dump(self.allData, fp, protocol=2) # fp.close() self.app = QtGui.QApplication([]) self.pWin = pg.GraphicsLayoutWidget() self.pWin.setWindowTitle('Axion / Saxion evolution') self.pWin.resize(1600,1600) pg.setConfigOptions(antialias=True) self.aPlot = self.pWin.addPlot(row=0, col=0) self.sPlot = self.pWin.addPlot(row=0, col=1) self.aPlot.setXRange(0,Lx*1.2) self.aPlot.setYRange(0,Lx*1.2) self.sPlot.setXRange(0,Lx*1.2) self.sPlot.setYRange(0,Lx*1.2) self.zAtxt = pg.TextItem("z=0.000000") self.zStxt = pg.TextItem("z=0.000000") data = self.allData[0] aPos = np.array([0.00, 0.10, 0.25, 0.4, 0.5, 0.6, 0.75, 0.9, 1.0 ]) aCol = ['#006600', 'b', 'w', 'r', 'k', 'b', 'w', 'r', '#006600'] vb = self.aPlot.getViewBox() aSzeX = vb.size().width()*0.96 aSzeY = vb.size().height()*0.8 self.aMap = pg.ColorMap(aPos, np.array([pg.colorTuple(pg.Color(c)) for c in aCol])) self.aLut = self.aMap.getLookupTable() self.aLeg = pg.GradientLegend((aSzeX/20, aSzeY), (aSzeX, aSzeY/12.)) self.aLeg.setLabels({ "-pi": 0.0, "-pi/2": 0.25, "0.0": 0.50, "+pi/2": 0.75, "+pi": 1.00 }) self.aLeg.setParentItem(self.aPlot) self.aLeg.gradient.setColorAt(0.00, QtGui.QColor(255,255,255)) self.aLeg.gradient.setColorAt(0.25, QtGui.QColor(255, 0, 0)) self.aLeg.gradient.setColorAt(0.50, QtGui.QColor( 0, 0, 0)) self.aLeg.gradient.setColorAt(0.75, QtGui.QColor( 0, 0,255)) self.aLeg.gradient.setColorAt(1.00, QtGui.QColor(255,255,255)) self.aImg = pg.ImageItem(lut=self.aLut) self.aPlot.addItem(self.aImg) self.aPlot.addItem(self.zAtxt) # sPos = np.linspace(0.0, data[3], 5) sPos = np.array([0.00, 0.25, 0.50, 0.75, 1.00]) sLab = ["%.2f" % mod for mod in sPos] sCol = ['w', 'r', 'y', 'c', 'k'] vs = self.sPlot.getViewBox() sSzeX = vs.size().width()*0.96 sSzeY = vs.size().height()*0.8 self.sMap = pg.ColorMap(sPos, np.array([pg.colorTuple(pg.Color(c)) for c in sCol])) self.s**t = self.sMap.getLookupTable() self.sLeg = pg.GradientLegend((sSzeX/20, sSzeY), (aSzeX/0.96 + sSzeX, sSzeY/12.)) self.sLeg.setLabels({ sLab[0]: 0.0, sLab[1]: 0.25, sLab[2]: 0.50, sLab[3]: 0.75, sLab[4]: 1.00 }) self.sLeg.setParentItem(self.sPlot) self.sLeg.gradient.setColorAt(0.00, QtGui.QColor(255,255,255)) self.sLeg.gradient.setColorAt(0.25, QtGui.QColor(255, 0, 0)) self.sLeg.gradient.setColorAt(0.50, QtGui.QColor(255,255, 0)) self.sLeg.gradient.setColorAt(0.75, QtGui.QColor( 0,255,255)) self.sLeg.gradient.setColorAt(1.00, QtGui.QColor( 0, 0, 0)) self.sImg = pg.ImageItem(lut=self.s**t) self.sPlot.addItem(self.sImg) self.sPlot.addItem(self.zStxt) self.sImg.setImage(data[0], levels=(0.,1.)) self.aImg.setImage(data[1], levels=(0.,1.)) self.pWin.show() self.baseKeyPress = self.pWin.keyPressEvent
args = parser.parse_args() try: args.specimen = int(args.specimen) except ValueError: pass # look up image file names jp2_files = sorted(lims.specimen_images(args.specimen)[0]['file'], key=lambda f: os.path.split(f)[-1]) if sys.platform == 'win32': jp2_files = ['\\' + '\\'.join(f.split('/')) for f in jp2_files] aff_files = [os.path.splitext(f)[0] + '.aff' for f in jp2_files] # make a window with zoomable view box app = pg.mkQApp() window = pg.GraphicsLayoutWidget() window.show() view = window.addViewBox() # view should have square pixels and y-axis pointig downward view.setAspectLocked(True) view.invertY() # for displaying a particular z slice aff_image_item = None z_index = None def set_z_index(zi): global aff_image_item, z_index zi = np.clip(zi, 0, len(aff_files) - 1)
def __init__(self, device, *args, **kwargs): # agregue device super().__init__(*args, **kwargs) self.nidaq = device # esto tiene que ir imageWidget = pg.GraphicsLayoutWidget() self.vb = imageWidget.addViewBox(row=1, col=1) # imageWidget2 = pg.GraphicsLayoutWidget() # self.vb2 = imageWidget2.addViewBox(row=1, col=1) # Parameters for smooth moving (to no shake hard the piezo) self.moveTime = 0.1 # total time to move(s) self.moveSamples = 1000 # samples to move self.moveRate = self.moveSamples / self.moveTime self.activeChannels = ["x", "y", "z"] self.AOchans = [0, 1, 2] # LiveView Button self.liveviewButton = QtGui.QPushButton('confocal LIVEVIEW') self.liveviewButton.setCheckable(True) self.liveviewButton.clicked.connect(self.liveview) # self.liveviewButton.clicked.connect(self.channelsOpen) # save image Button self.saveimageButton = QtGui.QPushButton('Scan and Save') self.saveimageButton.setCheckable(True) self.saveimageButton.clicked.connect(self.saveimage) self.saveimageButton.setStyleSheet( "QPushButton { background-color: gray; }" "QPushButton:pressed { background-color: blue; }") # Defino el tipo de Scan que quiero self.scanMode = QtGui.QComboBox() self.scanModes = ['step scan', 'otro scan', 'tempesta scan'] self.scanMode.addItems(self.scanModes) # self.scanMode.currentIndexChanged.connect( # lambda: self.setScanMode(self.scanMode.currentText())) # def setScanMode(self, mode): ## self.stageScan.setScanMode(mode) # self.scanParameterChanged('scanMode') self.stepcheck = QtGui.QCheckBox('Scan Barckward') self.stepcheck.clicked.connect(self.steptype) self.step = False self.canales = False # Scanning parameters self.initialPositionLabel = QtGui.QLabel('Initial Pos [x0 y0 z0] (µm)') self.initialPositionEdit = QtGui.QLineEdit('0 0 1') self.scanRangeLabel = QtGui.QLabel('Scan range (µm)') self.scanRangeEdit = QtGui.QLineEdit('10') self.pixelTimeLabel = QtGui.QLabel('Pixel time (ms)') self.pixelTimeEdit = QtGui.QLineEdit('1') self.numberofPixelsLabel = QtGui.QLabel('Number of pixels') self.numberofPixelsEdit = QtGui.QLineEdit('100') self.pixelSizeLabel = QtGui.QLabel('Pixel size (nm)') self.pixelSizeValue = QtGui.QLabel('') self.timeTotalLabel = QtGui.QLabel('tiempo total del escaneo (s)') self.timeTotalValue = QtGui.QLabel('') self.numberofPixelsEdit.textChanged.connect(self.paramChanged) self.scanRangeEdit.textChanged.connect(self.paramChanged) self.pixelTimeEdit.textChanged.connect(self.paramChanged) self.initialPositionEdit.textChanged.connect(self.paramChanged) self.paramChanged() self.paramWidget = QtGui.QWidget() grid = QtGui.QGridLayout() self.setLayout(grid) grid.addWidget(imageWidget, 0, 0) grid.addWidget(self.paramWidget, 0, 1) # grid.addWidget(imageWidget2, 0, 2) subgrid = QtGui.QGridLayout() self.paramWidget.setLayout(subgrid) subgrid.addWidget(self.liveviewButton, 10, 1) subgrid.addWidget(self.initialPositionLabel, 0, 1) subgrid.addWidget(self.initialPositionEdit, 1, 1) subgrid.addWidget(self.scanRangeLabel, 2, 1) subgrid.addWidget(self.scanRangeEdit, 3, 1) subgrid.addWidget(self.pixelTimeLabel, 4, 1) subgrid.addWidget(self.pixelTimeEdit, 5, 1) subgrid.addWidget(self.numberofPixelsLabel, 6, 1) subgrid.addWidget(self.numberofPixelsEdit, 7, 1) subgrid.addWidget(self.pixelSizeLabel, 8, 1) subgrid.addWidget(self.pixelSizeValue, 9, 1) subgrid.addWidget(self.timeTotalLabel, 13, 1) subgrid.addWidget(self.timeTotalValue, 14, 1) subgrid.addWidget(self.stepcheck, 11, 2) # subgrid.addWidget(self.scanMode, 12, 1) subgrid.addWidget(self.saveimageButton, 15, 1) # self.paramWidget.setFixedHeight(400) self.vb.setMouseMode(pg.ViewBox.RectMode) # self.vb2.setMouseMode(pg.ViewBox.RectMode) self.img = pg.ImageItem() self.img.translate(-0.5, -0.5) self.vb.addItem(self.img) self.vb.setAspectLocked(True) # self.vb2.addItem(self.img) # self.vb2.setAspectLocked(True) imageWidget.setAspectLocked(True) # imageWidget2.setAspectLocked(True) self.hist = pg.HistogramLUTItem(image=self.img) self.hist.gradient.loadPreset('thermal') self.hist.vb.setLimits(yMin=0, yMax=66000) # self.hist.vb2.setLimits(yMin=0, yMax=66000) # self.cubehelixCM = pg.ColorMap(np.arange(0, 1, 1/256), # guitools.cubehelix().astype(int)) # self.hist.gradient.setColorMap(self.cubehelixCM) for tick in self.hist.gradient.ticks: tick.hide() imageWidget.addItem(self.hist, row=1, col=2) # imageWidget2.addItem(self.hist, row=1, col=2) # self.ROI = guitools.ROI((0, 0), self.vb, (0, 0), handlePos=(1, 0), # handleCenter=(0, 1), color='y', scaleSnap=True, # translateSnap=True) self.viewtimer = QtCore.QTimer() self.viewtimer.timeout.connect(self.updateView)
def __init__(self, parent: QtCore.QObject = None, colormap: ColormapType = HOT_COLORMAP): super().__init__(parent) self._colormap = colormap self._lower_threshold_spinbox = QtWidgets.QDoubleSpinBox(self) self._upper_threshold_spinbox = QtWidgets.QDoubleSpinBox(self) self._colorbar_imageitem = pg.ImageItem() self._colorbar_viewbox = pgext.ViewBoxWithoutPadding( lockAspect=False, enableMouse=False, enableMenu=False, ) self._colorbar_viewbox.addItem(self._colorbar_imageitem) self._colorbar_layout = pg.GraphicsLayoutWidget(self) size_policy = self._colorbar_layout.sizePolicy() size_policy.setVerticalPolicy(QtWidgets.QSizePolicy.Fixed) size_policy.setHorizontalPolicy(QtWidgets.QSizePolicy.Ignored) self._colorbar_layout.setSizePolicy(size_policy) self._colorbar_layout.ci.layout.setContentsMargins(0, 0, 0, 0) self._colorbar_layout.addItem(self._colorbar_viewbox) layout = QtWidgets.QHBoxLayout(self) layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(self._lower_threshold_spinbox) layout.addWidget(self._colorbar_layout) layout.addWidget(self._upper_threshold_spinbox) layout.setStretch(1, 1) self.setLayout(layout) self.setMaximumWidth(400) self._lower_threshold_spinbox.setMinimum(self.MIN_THRESHOLD) self._lower_threshold_spinbox.setMaximum(self.MAX_THRESHOLD) self._lower_threshold_spinbox.setSingleStep(self.STEP) self._lower_threshold_spinbox.setValue(self.MIN_THRESHOLD) self._upper_threshold_spinbox.setMinimum(self.MIN_THRESHOLD) self._upper_threshold_spinbox.setMaximum(self.MAX_THRESHOLD) self._upper_threshold_spinbox.setSingleStep(self.STEP) self._upper_threshold_spinbox.setValue(self.MAX_THRESHOLD) self._map_no_value = 0.0 self._auto_thresholds = True self._thr_calculator = MapImageThresholdsCalculator( no_value=self._map_no_value) self._make_colorbar() self._lower_threshold_spinbox.valueChanged.connect( self._thresholds_changed) self._upper_threshold_spinbox.valueChanged.connect( self._thresholds_changed)
# Convert the RGB float values to RGBA integer values return list([(pos, (int(r), int(g), int(b), 255)) for pos, (r, g, b) in rgb_list]) # Start Qt event loop unless running in interactive mode. if __name__ == '__main__': import sys import matplotlib.cm if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'): app = QtGui.QApplication([]) # Create window with ImageView widget win = pyqtgraph.GraphicsLayoutWidget() win.resize(800, 800) win.show() imv = pyqtgraph.ImageItem() view = win.addViewBox() view.addItem(imv) win.setCentralWidget(view) win.show() win.setWindowTitle( 'Example: Matplotlib colormaps in pyqtgraph ImageView') # Create random data set with noisy signals data = np.random.normal(size=(200, 200)) gradient = np.linspace(0., 10., 200)
def __init__(self, rag, ndim=3, axis=2): self.rag = rag self.labels = rag.labels self.featureExtractor = graphs.gridRagFeatureExtractor( self.rag, self.labels) self.featureExtractor.labels = self.labels self.featureExtractor.graph = self.rag self.shape = self.labels.shape self.blocking2d = Blocking2d(self.shape[0:2], (40, 40)) self.ndim = ndim self.axis = axis assert len(self.shape) == ndim self.nSlices = 1 if ndim == 3: self.nSlices = self.shape[axis] self.sliceDict = None # qt gui self.win = QtGui.QMainWindow() self.win.setWindowTitle('pyqtgraph example: ImageItem') self.win.show() self.win.resize(800, 600) self.cw = QtGui.QWidget() self.cw.setMouseTracking(True) self.win.setCentralWidget(self.cw) self.layout = QtGui.QHBoxLayout() self.layout2 = QtGui.QVBoxLayout() self.cw.setLayout(self.layout) self.gv = pg.GraphicsLayoutWidget() self.gv.scene() self.gv.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding) self.gv.setMouseTracking(True) self.layerCtrl = BvLayerCtrl() self.layout.addLayout(self.layout2) self.layout.addWidget(self.layerCtrl) self.layout2.addWidget(self.gv, 3) self.viewBox = BvGridViewBox(blocking2d=self.blocking2d) #self.viewBox.setMouseTracking(True) self.gv.addItem(self.viewBox) self.viewBox.setAspectLocked(True) self.edgeClickLabels = dict() def scrolled(d): if d > 0: d = 5 else: d = -5 if self.ndim == 3: newSlice = min(self.nSlices - 1, self.currentSlice - d) newSlice = max(0, newSlice) self.currentSlice = newSlice with vigra.Timer("scroll"): self.setZ(self.currentSlice) self.viewBox.sigScrolled.connect(scrolled) self.ctrlWidget = DownCtrl() self.ctrlWidget.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Minimum) self.layout2.insertStretch(1, 0) self.layout2.addWidget(self.ctrlWidget) self.ctrlWidget.modeSelectorComboBox.currentIndexChanged.connect( self.updatePens) self.ctrlWidget.brushSizeSlider.sliderMoved.connect( self.changeLineSize) self.ctrlWidget.saveLabelsButton.clicked.connect( self.onClickedSaveLabels) self.ctrlWidget.loadLabelsButton.clicked.connect( self.onClickedLoadLabels) self.ctrlWidget.computeFeaturesButton.clicked.connect( self.onClickedComputeFeatures) self.ctrlWidget.saveFeaturesButton.clicked.connect( self.onClickedSaveFeatures) self.ctrlWidget.loadFeaturesButton.clicked.connect( self.onClickedLoadFeatures) self.ctrlWidget.featureGradientWidget.sigGradientChanged.connect( self.onGradientChanged) self.ctrlWidget.trainRfButton.clicked.connect(self.onClickedTrainRf) self.ctrlWidget.predictProbsButton.clicked.connect( self.onClickedPredictProbs) self.ctrlWidget.predictMcButton.clicked.connect(self.onClickedMulticut) self.ctrlWidget.saveRfButton.clicked.connect(self.onClickedSaveRf) self.ctrlWidget.loadRfButton.clicked.connect(self.onClickedLoadRf) self.layerCtrl.sigFeatureSelected.connect(self.onFeatureSelected) self.imgItem = pg.ImageItem(border='w') self.viewBox.addItem(self.imgItem) self.dataDict = dict() self.curves = [] self.allCurves = None self.currentSlice = 0 self.pathHint = None self.currentFeatures = None self.featureMinMax = None self.currentFi = 0 self.rf = None self.probs = None self.nCurves = 0 self.ScrollLock = threading.Lock() self.scrollingIsLocked = False
def init_ui(self): self.process = KMeansProcess(self.ivm) layout = QtGui.QVBoxLayout() self.setLayout(layout) title = TitleWidget(self, help="cluster") layout.addWidget(title) DESC = """ <i>Performs clustering of 3D or 4D data using the K-means algorithm. PCA reduction is used on 4D data to extract representative curves """ desc = QtGui.QLabel(DESC) desc.setWordWrap(True) layout.addWidget(desc) gbox = QtGui.QGroupBox() gbox.setTitle('Clustering options') grid = QtGui.QGridLayout() gbox.setLayout(grid) # Data to cluster grid.addWidget(QtGui.QLabel("Data"), 0, 0) self.data_combo = OverlayCombo(self.ivm) self.data_combo.currentIndexChanged.connect(self._data_changed) grid.addWidget(self.data_combo, 0, 1) grid.addWidget(QtGui.QLabel("ROI"), 1, 0) self.roi_combo = RoiCombo(self.ivm, none_option=True) grid.addWidget(self.roi_combo, 1, 1) # Number of clusters inside the ROI self.n_clusters = NumericOption("Number of clusters", grid, xpos=2, ypos=0, minval=2, maxval=20, default=4, intonly=True) self.n_clusters.spin.setToolTip("") # Number of PCA modes self.n_pca = NumericOption("Number of PCA modes", grid, xpos=2, ypos=1, minval=1, maxval=10, default=3, intonly=True) self.n_pca.spin.setToolTip("") # Output ROI name grid.addWidget(QtGui.QLabel("Output name"), 2, 0) self.output_name = QtGui.QLineEdit("clusters") grid.addWidget(self.output_name, 2, 1) layout.addWidget(gbox) # Run clustering button hbox = QtGui.QHBoxLayout() self.run_btn = QtGui.QPushButton('Run', self) self.run_btn.clicked.connect(self.run_clustering) hbox.addWidget(self.run_btn) hbox.addStretch(1) layout.addLayout(hbox) # Plot window, showing representative curves for 4D data self.show_curves_btn = QtGui.QPushButton('Show representative curves', self) self.show_curves_btn.clicked.connect(self._show_curves) layout.addWidget(self.show_curves_btn) self.plotwin = pg.GraphicsLayoutWidget() self.plotwin.setBackground(background=None) self.plot = self.plotwin.addPlot(title="Cluster representative curves") self.plot.setLabel('left', "Signal Enhancement") self.plotwin.setVisible(False) layout.addWidget(self.plotwin) # Statistics self.show_count_btn = QtGui.QPushButton('Show voxel counts', self) self.show_count_btn.clicked.connect(self._show_counts) layout.addWidget(self.show_count_btn) self.stats_gbox = QtGui.QGroupBox() self.stats_gbox.setTitle('Voxel count') self.count_table = QtGui.QStandardItemModel() self.count_view = QtGui.QTableView() self.count_view.resizeColumnsToContents() self.count_view.setModel(self.count_table) hbox = QtGui.QHBoxLayout() hbox.addWidget(self.count_view) self.stats_gbox.setLayout(hbox) self.stats_gbox.setVisible(False) layout.addWidget(self.stats_gbox) # Merge regions self.show_merge_btn = QtGui.QPushButton('Show merge options', self) self.show_merge_btn.clicked.connect(self._show_merge) layout.addWidget(self.show_merge_btn) self.merge_gbox = QtGui.QGroupBox() self.merge_gbox.setTitle('Merge regions') vbox = QtGui.QVBoxLayout() self.merge_gbox.setLayout(vbox) hbox = QtGui.QHBoxLayout() self.merge_btn = QtGui.QPushButton('Merge', self) self.merge_btn.clicked.connect(self._run_merge) hbox.addWidget(self.merge_btn) hbox.addWidget(QtGui.QLabel('Merge region ')) self.merge_region1 = QtGui.QLineEdit('1', self) hbox.addWidget(self.merge_region1) hbox.addWidget(QtGui.QLabel(' with ')) self.merge_region2 = QtGui.QLineEdit('2', self) hbox.addWidget(self.merge_region2) vbox.addLayout(hbox) hbox = QtGui.QHBoxLayout() self.auto_merge_btn = QtGui.QPushButton('AutoMerge', self) self.auto_merge_btn.clicked.connect(self._run_automerge) hbox.addWidget(self.auto_merge_btn) hbox.addStretch(1) vbox.addLayout(hbox) self.merge_gbox.setVisible(False) layout.addWidget(self.merge_gbox) layout.addStretch(1)
def setup(self): # definition of all button TogOff = self.icon + 'Toggle_Off.png' TogOn = self.icon + 'Toggle_On.png' TogOff = pathlib.Path(TogOff) TogOff = pathlib.PurePosixPath(TogOff) TogOn = pathlib.Path(TogOn) TogOn = pathlib.PurePosixPath(TogOn) self.setStyleSheet("QCheckBox::indicator{width: 30px;height: 30px;}" "QCheckBox::indicator:unchecked { image : url(%s);}" "QCheckBox::indicator:checked { image: url(%s);}" "QCheckBox{font :10pt;}" % (TogOff, TogOn)) vbox1 = QVBoxLayout() self.hbox0 = QHBoxLayout() vbox1.addLayout(self.hbox0) hbox1 = QHBoxLayout() self.checkBoxPlot = QCheckBox('CROSS', self) self.checkBoxPlot.setChecked(False) self.label_CrossValue = QLabel() self.label_CrossValue.setStyleSheet("font:13pt") hbox1.addWidget(self.checkBoxPlot) hbox1.addWidget(self.label_CrossValue) hbox2 = QHBoxLayout() self.label_Cross = QLabel() #self.label_Cross.setMaximumHeight(20) self.label_Cross.setMaximumWidth(170) self.label_Cross.setStyleSheet("font:12pt") hbox2.addWidget(self.label_Cross) vbox1.addLayout(hbox1) vbox1.addLayout(hbox2) self.ZoomLabel = QLabel('Zoom') vbox1.addWidget(self.ZoomLabel) self.checkBoxZoom = QSlider(Qt.Horizontal) self.checkBoxZoom.setMaximumWidth(250) self.checkBoxZoom.setMinimum(0) self.checkBoxZoom.setMaximum(200) self.checkBoxZoom.setValue(0) vbox1.addWidget(self.checkBoxZoom) self.checkBoxScale = QCheckBox('Auto Scale', self) self.checkBoxScale.setChecked(True) self.checkBoxScale.setMaximumWidth(100) self.checkBoxColor = QCheckBox('Color', self) self.checkBoxColor.setChecked(True) self.checkBoxHist = QCheckBox('Hist', self) self.checkBoxHist.setChecked(False) self.maxGraphBox = QCheckBox('Max', self) hbox3 = QHBoxLayout() grid_layout = QGridLayout() grid_layout.setVerticalSpacing(0) grid_layout.setHorizontalSpacing(10) grid_layout.addWidget(self.checkBoxScale, 0, 0) grid_layout.addWidget(self.checkBoxColor, 1, 0) grid_layout.addWidget(self.checkBoxHist, 0, 1) #grid_layout.addWidget(self.checkBoxZoom, 1, 0) grid_layout.addWidget(self.maxGraphBox, 1, 1) hbox3.addLayout(grid_layout) vbox1.addLayout(hbox3) hbox4 = QHBoxLayout() if self.meas == 'on': self.MeasButton = QPushButton('Meas.') hbox4.addWidget(self.MeasButton) vbox1.addLayout(hbox4) vbox1.addStretch(1) self.winImage = pg.GraphicsLayoutWidget() #self.winImage.setContentsMargins(1,1,1,1) self.winImage.setAspectLocked(True) self.winImage.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) #self.winImage.ci.setContentsMargins(1,1,1,1) vbox2 = QVBoxLayout() # self.dockImage=QDockWidget(self) # self.dockImage.setWidget(self.winImage) # self.dockImage.setFeatures(QDockWidget.DockWidgetFloatable) #vbox2.addWidget(self.dockImage) vbox2.addWidget(self.winImage) vbox2.setContentsMargins(0, 0, 0, 0) self.p1 = self.winImage.addPlot() self.imh = pg.ImageItem() self.axeX = self.p1.getAxis('bottom') self.axeY = self.p1.getAxis('left') self.p1.addItem(self.imh) self.p1.setMouseEnabled(x=False, y=False) self.p1.setContentsMargins(0, 0, 0, 0) self.p1.setAspectLocked(True, ratio=1) self.p1.showAxis('right', show=False) self.p1.showAxis('top', show=False) self.p1.showAxis('left', show=True) self.p1.showAxis('bottom', show=True) if self.bloqKeyboard == True: self.vLine = pg.InfiniteLine(angle=90, movable=False, pen='r') self.hLine = pg.InfiniteLine(angle=0, movable=False, pen='r') else: self.vLine = pg.InfiniteLine(angle=90, movable=False, pen='y') self.hLine = pg.InfiniteLine(angle=0, movable=False, pen='y') self.xc = int(self.conf.value(self.name + "/xc")) self.yc = int(self.conf.value(self.name + "/yc")) self.rx = int(self.conf.value(self.name + "/rx")) self.ry = int(self.conf.value(self.name + "/ry")) self.vLine.setPos(self.xc) self.hLine.setPos(self.yc) self.ro1 = pg.EllipseROI([self.xc, self.yc], [self.rx, self.ry], pen='y', movable=False, maxBounds=QtCore.QRectF( 0, 0, self.rx, self.ry)) self.ro1.setPos([self.xc - (self.rx / 2), self.yc - (self.ry / 2)]) # text for fwhm on p1 self.textX = pg.TextItem(angle=-90) self.textY = pg.TextItem() #histogram self.hist = pg.HistogramLUTItem() self.hist.setImageItem(self.imh) self.hist.autoHistogramRange() self.hist.gradient.loadPreset('flame') ## XY graph self.curve2 = pg.PlotCurveItem() self.curve3 = pg.PlotCurveItem() ## main layout hMainLayout = QHBoxLayout() if self.aff == 'right': hMainLayout.addLayout(vbox2) hMainLayout.addLayout(vbox1) else: hMainLayout.addLayout(vbox1) hMainLayout.addLayout(vbox2) hMainLayout.setContentsMargins(1, 1, 1, 1) hMainLayout.setSpacing(1) hMainLayout.setStretch(10, 1) self.setLayout(hMainLayout) self.setContentsMargins(1, 1, 1, 1)
def initUI(self): #qbtn = QtGui.QPushButton('Quit', self) #qbtn.clicked.connect(QtCore.QCoreApplication.instance().quit) #qbtn.resize(qbtn.sizeHint()) #qbtn.move(50, 50) self.receivedDataLabel = QtGui.QLabel('Received Data') self.logButton = QtGui.QPushButton('Log Data', self) self.uppesthbox = QtGui.QHBoxLayout() self.uppesthbox.addStretch(1) self.uppesthbox.addWidget(self.receivedDataLabel) self.uppesthbox.addStretch(1) self.uppesthbox.addWidget(self.logButton) #add labels self.UART_TX_Mode_hbox = QtGui.QHBoxLayout() self.UART_TX_Mode_label = QtGui.QLabel('0') self.UART_TX_Mode_hbox.addWidget(self.UART_TX_Mode_label) self.UART_TX_Mode_Gbox = QtGui.QGroupBox("UART TX Mode") self.UART_TX_Mode_Gbox.setLayout(self.UART_TX_Mode_hbox) self.BootState_hbox = QtGui.QHBoxLayout() self.BootState_label = QtGui.QLabel('0') self.BootState_hbox.addWidget(self.BootState_label) self.BootState_Gbox = QtGui.QGroupBox("Boot State") self.BootState_Gbox.setLayout(self.BootState_hbox) self.Ticks_hbox = QtGui.QHBoxLayout() self.Ticks_label = QtGui.QLabel('0') self.Ticks_hbox.addWidget(self.Ticks_label) self.Ticks_Gbox = QtGui.QGroupBox("Ticks") self.Ticks_Gbox.setLayout(self.Ticks_hbox) self.Change_status_hbox = QtGui.QHBoxLayout() self.Change_status_label = QtGui.QLabel('0') self.Change_status_hbox.addWidget(self.Change_status_label) self.Change_status_Gbox = QtGui.QGroupBox("Change status") self.Change_status_Gbox.setLayout(self.Change_status_hbox) self.State_counter_hbox = QtGui.QHBoxLayout() self.State_counter_label = QtGui.QLabel('0') self.State_counter_hbox.addWidget(self.State_counter_label) self.State_counter_Gbox = QtGui.QGroupBox("State counter value") self.State_counter_Gbox.setLayout(self.State_counter_hbox) self.Ref_transferred_hbox = QtGui.QHBoxLayout() self.Ref_transferred_label = QtGui.QLabel('0') self.Ref_transferred_hbox.addWidget(self.Ref_transferred_label) self.Ref_transferred_Gbox = QtGui.QGroupBox( "Reference fr. transferred") self.Ref_transferred_Gbox.setLayout(self.Ref_transferred_hbox) self.Flash_errors_hbox = QtGui.QHBoxLayout() self.Flash_errors_label = QtGui.QLabel('0') self.Flash_errors_hbox.addWidget(self.Flash_errors_label) self.Flash_errors_Gbox = QtGui.QGroupBox("Flash errors") self.Flash_errors_Gbox.setLayout(self.Flash_errors_hbox) self.Reg_errors_hbox = QtGui.QHBoxLayout() self.Reg_errors_label = QtGui.QLabel('0') self.Reg_errors_hbox.addWidget(self.Reg_errors_label) self.Reg_errors_Gbox = QtGui.QGroupBox("Register errors") self.Reg_errors_Gbox.setLayout(self.Reg_errors_hbox) self.datavbox = QtGui.QVBoxLayout() self.datavbox.addWidget(self.UART_TX_Mode_Gbox) self.datavbox.addWidget(self.BootState_Gbox) self.datavbox.addWidget(self.Ticks_Gbox) self.datavbox.addWidget(self.Change_status_Gbox) self.datavbox.addWidget(self.State_counter_Gbox) self.datavbox.addWidget(self.Ref_transferred_Gbox) self.datavbox.addWidget(self.State_counter_Gbox) self.datavbox.addWidget(self.Ref_transferred_Gbox) self.datavbox.addWidget(self.Flash_errors_Gbox) self.datavbox.addWidget(self.Reg_errors_Gbox) self.datavbox.addStretch(1) self.stateView = StateView(self) self.statevbox = QtGui.QVBoxLayout() self.stateView.setFixedWidth(242) #self.stateView.setFixedHeight(502) self.statevbox.addWidget(self.stateView) self.unitView = UnitView(self) self.unitvbox = QtGui.QVBoxLayout() self.unitView.setFixedWidth(512) #self.unitView.setFixedHeight(502) self.unitvbox.addWidget(self.unitView) #x = np.arange(1000) #y = np.random.normal(size=(3, 1000)) self.glw = pg.GraphicsLayoutWidget() self.glw.setFixedWidth(512) self.time_np = [] self.plotCP = self.glw.addPlot(title="ColdPlate regulation") self.plotCP.enableAutoRange() #self.plotCP.addLegend() self.PID_CP_Zpoint_np = [] self.PID_CP_Zpoint_curve = self.plotCP.plot(self.time_np, self.PID_CP_Zpoint_np, pen=(0, 0, 255), name='Desire value') self.PID_CP_Output_np = [] self.PID_CP_Output_curve = self.plotCP.plot(self.time_np, self.PID_CP_Output_np, pen=(0, 255, 0), name='Output to CP') self.PID_CP_Error_np = [] self.PID_CP_Error_curve = self.plotCP.plot(self.time_np, self.PID_CP_Error_np, pen=(255, 0, 0), name='Error') self.glw.nextRow() self.plotLaser = self.glw.addPlot(title="Laser ADC regulation") self.plotLaser.enableAutoRange() #self.plotLaser.addLegend() self.PID_Laser_Zpoint_np = [] self.PID_Laser_Zpoint_curve = self.plotLaser.plot( self.time_np, self.PID_Laser_Zpoint_np, pen=(0, 0, 255), name='Desire value') self.PID_Laser_Output_np = [] self.PID_Laser_Output_curve = self.plotLaser.plot( self.time_np, self.PID_Laser_Output_np, pen=(0, 255, 0), name='Output to Laser') self.PID_Laser_Error_np = [] self.PID_Laser_Error_curve = self.plotLaser.plot( self.time_np, self.PID_Laser_Error_np, pen=(255, 0, 0), name='Error') self.glw.nextRow() self.plotAMP = self.glw.addPlot(title="Laser AMP regulation") self.plotAMP.enableAutoRange() #self.plotAMP.addLegend() self.PID_AMP_Zpoint_np = [] self.PID_AMP_Zpoint_curve = self.plotAMP.plot(self.time_np, self.PID_AMP_Zpoint_np, pen=(0, 0, 255), name='Desire value') self.PID_AMP_Output_np = [] self.PID_AMP_Output_curve = self.plotAMP.plot(self.time_np, self.PID_AMP_Output_np, pen=(0, 255, 0), name='Output to AMP') self.PID_AMP_Error_np = [] self.PID_AMP_Error_curve = self.plotAMP.plot(self.time_np, self.PID_AMP_Error_np, pen=(255, 0, 0), name='Error') self.PID_OSC_Output_np = [] self.PID_OSC_Output_curve = self.plotAMP.plot(self.time_np, self.PID_OSC_Output_np, pen=(200, 200, 200), name='Output to OSC') #legend = pg.LegendItem() #legend.addItem(self.PID_CP_Zpoint_curve, name=self.PID_CP_Zpoint_curve.opts['name']) #legend.setParentItem(self.plotCP) #legend.anchor((0,0),(0,0)) self.graphsvbox = QtGui.QVBoxLayout() self.graphsvbox.addWidget(self.glw) self.upperhbox = QtGui.QHBoxLayout() self.upperhbox.addLayout(self.statevbox) self.upperhbox.addStretch(1) self.upperhbox.addLayout(self.unitvbox) self.upperhbox.addStretch(1) self.upperhbox.addLayout(self.graphsvbox) self.upperhbox.addStretch(1) self.upperhbox.addLayout(self.datavbox) self.connectStatLabel = QtGui.QLabel('Disconnected') self.comPortComboBox = QtGui.QComboBox() self.comPortComboBox.addItem("Search") #self.connect(self.comPortComboBox, QtCore.SIGNAL("highlighted(int)"), self.updtPortsList) #self.comPortComboBox.activated.connect(self.updtPortsList) self.baudRateComboBox = QtGui.QComboBox() self.connectButtonState = False self.connectButton = QtGui.QPushButton('Connect', self) #self.connect(self.connectButton, QtCore.SIGNAL("highlighted(int)"), self.updtPortsList) self.lowerhbox = QtGui.QHBoxLayout() self.lowerhbox.addStretch(1) self.lowerhbox.addWidget(self.connectStatLabel) self.lowerhbox.addStretch(1) self.lowerhbox.addWidget(self.comPortComboBox) self.lowerhbox.addWidget(self.baudRateComboBox) self.lowerhbox.addWidget(self.connectButton) self.vbox = QtGui.QVBoxLayout() # MAIN Box self.vbox.addLayout(self.uppesthbox) self.vbox.addLayout(self.upperhbox) self.vbox.addLayout(self.lowerhbox) self.vbox.addStretch(1) self.setLayout(self.vbox) self.connect(self.connectButton, QtCore.SIGNAL("clicked()"), self.OnPressConnect) self.connect(self.logButton, QtCore.SIGNAL("clicked()"), self.OnPressLog) self.connect(self.comPortComboBox, QtCore.SIGNAL("activated(int)"), self.updtPortsList) #self.connect(self, QtCore.SIGNAL("unitSignal(int)"), self.unitChanged) #self.connect(self.comPortComboBox, QtCore.SIGNAL("currentIndexChanged(int)"), self.comPortComboBox, QtCore.SLOT("blockSignals(False)")) #self.connect(self.comPortComboBox, QtCore.SIGNAL("currentIndexChanged(int)"), self.comPortComboBox.blockSignals(False)) #self.resize(250, 150) #self.center_window() self.setWindowTitle('MCU Telemetry') self.setWindowIcon(QtGui.QIcon('web.png')) self.show() self.UART_TX_Mode = 0 self.BootState = 0 self.Ticks = 0 self.ADC_I2C1_Enable = 0 # in binary self.ADC_I2C2_Enable = 0 # in binary self.PORTD = 0 # in binary self.PID_CP_Enabled = 0 self.PID_Laser_Enabled = 0 self.PID_AMP_Enabled = 0 self.WindEyeState = 0 self.desState = 0 self.oldState = 0 self.Change_status = 0 self.Ref_transferred = 0 self.Flash_errors = 0 self.Reg_errors = 0
def plotClusters(self): '''3D scatter plots of data points with cluster labels - using pyqtgraph''' #self.app = QtGui.QApplication([]) try: self.mw = QtGui.QMainWindow() except: self.mw = QtWidgets.QMainWindow() self.mw.resize(800,800) view = pg.GraphicsLayoutWidget() ## GraphicsView with GraphicsLayout inserted by default self.mw.setCentralWidget(view) self.mw.show() self.mw.setWindowTitle('all points and cluster centeroids') #create plot window w1 = view.addPlot() #make point data point_n1 = len(self.ch1Points_3D[::,0]) point_n2 = len(self.ch2Points_3D[::,0]) point_s1 = pg.ScatterPlotItem(size=3, pen=pg.mkPen(None), brush=pg.mkBrush(255, 0, 0, 120)) point_s2 = pg.ScatterPlotItem(size=3, pen=pg.mkPen(None), brush=pg.mkBrush(0, 0, 255, 120)) point_pos1 = np.array([self.ch1Points_3D[::,0],self.ch1Points_3D[::,1]]) point_pos2 = np.array([self.ch2Points_3D[::,0],self.ch2Points_3D[::,1]]) point_spots1 = [{'pos': point_pos1[:,i], 'data': 1} for i in range(point_n1)] point_spots2 = [{'pos': point_pos2[:,i], 'data': 1} for i in range(point_n2)] point_s1.addPoints(point_spots1) point_s2.addPoints(point_spots2) w1.addItem(point_s1) w1.addItem(point_s2) #make centeroid data centeroid_s1 = pg.ScatterPlotItem(size=10, pen=pg.mkPen(None), brush=pg.mkBrush(255, 255, 255, 120)) centeroid_s2 = pg.ScatterPlotItem(size=10, pen=pg.mkPen(None), brush=pg.mkBrush(255, 255, 255, 120)) #combined clusters centeroid_n1 = len(self.combined_ch1_Centeroids[::,0]) centeroid_n2 = len(self.combined_ch2_Centeroids[::,0]) centeroid_pos1 = np.array([self.combined_ch1_Centeroids[::,0],self.combined_ch1_Centeroids[::,1]]) centeroid_pos2 = np.array([self.combined_ch2_Centeroids[::,0],self.combined_ch2_Centeroids[::,1]]) #all clusters #centeroid_n1 = len(self.ch1_centeroids_3D[::,0]) #centeroid_n2 = len(self.ch2_centeroids_3D[::,0]) #centeroid_pos1 = np.array([self.ch1_centeroids_3D[::,0],self.ch1_centeroids_3D[::,1]]) #centeroid_pos2 = np.array([self.ch2_centeroids_3D[::,0],self.ch2_centeroids_3D[::,1]]) self.centeroid_spots1 = [{'pos': centeroid_pos1[:,i], 'data': 1} for i in range(centeroid_n1)] self.centeroid_spots2 = [{'pos': centeroid_pos2[:,i], 'data': 1} for i in range(centeroid_n2)] centeroid_s1.addPoints(self.centeroid_spots1) centeroid_s2.addPoints(self.centeroid_spots2) w1.addItem(centeroid_s1) w1.addItem(centeroid_s2) #add text labels ## Create text object, use HTML tags to specify color/size for i in range(len(self.centeroid_spots1)): text = pg.TextItem(str(i), anchor=(0,0))#, angle=45, border='w', fill=(0, 0, 255, 100)) text.setPos(self.centeroid_spots1[i]['pos'][0],self.centeroid_spots1[i]['pos'][1]) w1.addItem(text) #add roi points ch1_pts = np.vstack(self.AllPoints_ch1) ch2_pts = np.vstack(self.AllPoints_ch2) roi_point_n1 = len(ch1_pts[::,0]) roi_point_n2 = len(ch2_pts[::,0]) roi_point_s1 = pg.ScatterPlotItem(size=5, pen=pg.mkPen(None), brush=pg.mkBrush(255, 0, 0, 120)) roi_point_s2 = pg.ScatterPlotItem(size=5, pen=pg.mkPen(None), brush=pg.mkBrush(0, 0, 255, 120)) roi_point_pos1 = np.array([ch1_pts[::,0],ch1_pts[::,1]]) roi_point_pos2 = np.array([ch2_pts[::,0],ch2_pts[::,1]]) roi_point_spots1 = [{'pos': roi_point_pos1[:,i], 'data': 1} for i in range(roi_point_n1)] roi_point_spots2 = [{'pos': roi_point_pos2[:,i], 'data': 1} for i in range(roi_point_n2)] roi_point_s1.addPoints(roi_point_spots1) roi_point_s2.addPoints(roi_point_spots2) w1.addItem(roi_point_s1) w1.addItem(roi_point_s2) return
def setup_figure(self): self.compute_scan_params() self.clear_qt_attr('graph_layout') self.graph_layout = pg.GraphicsLayoutWidget(border=(100, 100, 100)) self.ui.plot_groupBox.layout().addWidget(self.graph_layout) self.clear_qt_attr('img_plot') self.img_plot = self.graph_layout.addPlot() self.img_items = [] self.img_item = pg.ImageItem() self.img_items.append(self.img_item) self.img_plot.addItem(self.img_item) self.img_plot.showGrid(x=True, y=True) self.img_plot.setAspectLocked(lock=True, ratio=1) self.hist_lut = pg.HistogramLUTItem() self.graph_layout.addItem(self.hist_lut) #self.clear_qt_attr('current_stage_pos_arrow') self.current_stage_pos_arrow = pg.ArrowItem() self.current_stage_pos_arrow.setZValue(100) self.img_plot.addItem(self.current_stage_pos_arrow) #self.stage = self.app.hardware_components['dummy_xy_stage'] if hasattr(self, 'stage'): self.stage.settings.x_position.updated_value.connect( self.update_arrow_pos, QtCore.Qt.UniqueConnection) self.stage.settings.y_position.updated_value.connect( self.update_arrow_pos, QtCore.Qt.UniqueConnection) self.stage.settings.x_position.connect_to_widget( self.ui.x_doubleSpinBox) self.stage.settings.y_position.connect_to_widget( self.ui.y_doubleSpinBox) self.graph_layout.nextRow() self.pos_label = pg.LabelItem(justify='right') self.pos_label.setText("=====") self.graph_layout.addItem(self.pos_label) self.scan_roi = pg.ROI([0, 0], [1, 1], movable=True) self.scan_roi.addScaleHandle([1, 1], [0, 0]) self.scan_roi.addScaleHandle([0, 0], [1, 1]) self.update_scan_roi() self.scan_roi.sigRegionChangeFinished.connect( self.mouse_update_scan_roi) self.img_plot.addItem(self.scan_roi) for lqname in 'h0 h1 v0 v1 dh dv'.split(): self.settings.as_dict()[lqname].updated_value.connect( self.update_scan_roi) self.img_plot.scene().sigMouseMoved.connect(self.mouseMoved) # GoTo position context menu #self.goto_cmenu_action = QtWidgets.QAction("GoTo Position", self.img_plot.scene()) #self.img_plot.scene().contextMenu.append(self.goto_cmenu_action) #self.goto_cmenu_action.triggered.connect(self.on_goto_position) # Point ROI self.pt_roi = pg.CircleROI((0, 0), (self.circ_roi_size, self.circ_roi_size), movable=True, pen=(0, 9)) #self.pt_roi.removeHandle(self.pt_roi.getHandles()[0]) h = self.pt_roi.addTranslateHandle((0.5, 0.5)) h.pen = pg.mkPen('r') h.update() self.img_plot.addItem(self.pt_roi) self.pt_roi.removeHandle(0) #self.pt_roi_plotline = pg.PlotCurveItem([0], pen=(0,9)) #self.imview.getView().addItem(self.pt_roi_plotline) self.pt_roi.sigRegionChangeFinished[object].connect( self.on_update_pt_roi)
def __init__(self, *args, **kwargs): super(MainWindow, self).__init__(*args, **kwargs) pg.setConfigOption('background', 'w') pg.setConfigOption('foreground', 'k') pg.setConfigOptions(antialias=True) uic.loadUi(pkg_resources.resource_filename(__name__, "sysmonitor.ui"), self) self.len_data = 60 self.cpu_curve = [] self.mem_curve = [] self.gpu_curve = [] self.net_curve = [] self.disk_curve = [] self.ti = [] self.ti_net = [] self.ti_disk = [] self.wait_time_ms = 1000 self.s = sysinfo() self.meminfo = np.zeros([self.len_data, 2]) self.netinfo = np.zeros([self.len_data, 2, self.s.amount_net_adater]) self.diskinfo = np.zeros([self.len_data, 2, self.s.amount_disks]) self.cpuinfo = np.zeros([self.len_data, self.s.cpu_core_count + 1]) self.x = np.linspace(-self.len_data * self.wait_time_ms / 1000, 0, num=self.len_data, endpoint=True) self.label_8.setText(self.s.cpu_model_name) self.plot_meminfo() self.plot_cpuinfo() self.plot_netinfo() self.plot_diskinfo() self.headertitle = ('USER', 'PID', 'CPU [%]', 'MEM [%]', 'START', 'TIME', 'COMMAND') self.tableWidget.verticalHeader().setVisible(False) self.tableWidget.horizontalHeader().setHighlightSections(False) header = self.tableWidget.horizontalHeader() header.setResizeMode(QtGui.QHeaderView.ResizeToContents) header.setStretchLastSection(True) header.setResizeMode(False) self.tableWidget.setSelectionBehavior( QtGui.QAbstractItemView.SelectRows) self.tableWidget.setShowGrid(False) self.update_running_processes() self.timer_4 = QtCore.QTimer() self.timer_4.timeout.connect(self.update_running_processes) self.timer_4.start(self.wait_time_ms) if self.s.nvidia_installed == 1: self.gpu_widgets = [] self.gpuinfo = np.zeros([self.len_data, 4, self.s.gpu_num]) for gpu_ind in range(self.s.gpu_num): tab_widgets = [] # first set vertical alignment of tab tab = QtWidgets.QWidget() self.tabWidget.addTab(tab, self.s.gpu_name[gpu_ind]) vbox = QtGui.QVBoxLayout(tab) # then add widgets in horizontal layout widget_1 = QtWidgets.QWidget() widget_2 = QtWidgets.QWidget() widget_3 = QtWidgets.QWidget() widget_4 = QtWidgets.QWidget() widget_5 = QtWidgets.QWidget() vbox.addWidget(widget_1) vbox.addWidget(widget_2) vbox.addWidget(widget_3) vbox.addWidget(widget_4) vbox.addWidget(widget_5) hbox_1 = QtGui.QGridLayout(widget_1) hbox_2 = QtGui.QGridLayout(widget_2) hbox_3 = QtGui.QGridLayout(widget_3) hbox_4 = QtGui.QGridLayout(widget_4) hbox_5 = QtGui.QGridLayout(widget_5) label_1 = QtGui.QLabel("Gpu:") label_1_sub = QtGui.QLabel("% over 60 seconds") label_1_sub.setFont(QtGui.QFont('Ubuntu', 7)) label_2 = QtGui.QLabel("Memory:") label_2_sub = QtGui.QLabel("% over 60 seconds") label_2_sub.setFont(QtGui.QFont('Ubuntu', 7)) label_3 = QtGui.QLabel("Encoder:") label_3_sub = QtGui.QLabel("% over 60 seconds") label_3_sub.setFont(QtGui.QFont('Ubuntu', 7)) label_4 = QtGui.QLabel("Decoder:") label_4_sub = QtGui.QLabel("% over 60 seconds") label_4_sub.setFont(QtGui.QFont('Ubuntu', 7)) label_5 = QtGui.QLabel("Gpu clock:") label_6 = QtGui.QLabel("Memory clock:") hbox_1.addWidget(label_1, 1, 1) hbox_1.addWidget(label_2, 1, 2) hbox_1.addWidget(label_1_sub, 2, 1) hbox_1.addWidget(label_2_sub, 2, 2) hbox_3.addWidget(label_3, 1, 1) hbox_3.addWidget(label_4, 1, 2) hbox_3.addWidget(label_3_sub, 2, 1) hbox_3.addWidget(label_4_sub, 2, 2) hbox_5.addWidget(label_5, 1, 1) hbox_5.addWidget(label_6, 1, 2) graph_w_1 = pg.GraphicsLayoutWidget() graph_w_2 = pg.GraphicsLayoutWidget() graph_w_3 = pg.GraphicsLayoutWidget() graph_w_4 = pg.GraphicsLayoutWidget() hbox_2.addWidget(graph_w_1, 1, 1) hbox_2.addWidget(graph_w_2, 1, 2) hbox_4.addWidget(graph_w_3, 1, 1) hbox_4.addWidget(graph_w_4, 1, 2) # Append for later access tab_widgets.append(tab) tab_widgets.append(vbox) tab_widgets.append(widget_1) tab_widgets.append(widget_2) tab_widgets.append(widget_3) tab_widgets.append(widget_4) tab_widgets.append(widget_5) tab_widgets.append(hbox_1) tab_widgets.append(hbox_2) tab_widgets.append(hbox_3) tab_widgets.append(hbox_4) tab_widgets.append(hbox_5) tab_widgets.append(label_1) tab_widgets.append(label_2) tab_widgets.append(label_3) tab_widgets.append(label_4) tab_widgets.append(label_5) tab_widgets.append(label_6) tab_widgets.append(graph_w_1) tab_widgets.append(graph_w_2) tab_widgets.append(graph_w_3) tab_widgets.append(graph_w_4) self.gpu_widgets.append(tab_widgets) self.plot_gpuinfo() self.update_gpuinfo() self.timer_3 = QtCore.QTimer() self.timer_3.timeout.connect(self.update_gpuinfo) self.timer_3.start(self.wait_time_ms)
import sys from pyqtgraph.Qt import QtGui, QtCore import pyqtgraph as pg import numpy as np app = QtGui.QApplication(sys.argv) mw = QtGui.QMainWindow() mw.resize(800, 800) view = pg.GraphicsLayoutWidget() mw.setCentralWidget(view) mw.setWindowTitle('pyqtgraph example: ScatterPlot') w1 = view.addPlot() x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] y = [10, 8, 6, 4, 2, 20, 18, 16, 14, 12] # Create seed for the random time = QtCore.QTime.currentTime() QtCore.qsrand(time.msec()) for i in range(len(x)): s = pg.ScatterPlotItem( [x[i]], [y[i]], size=10, pen=pg.mkPen(None)) # brush=pg.mkBrush(255, 255, 255, 120)) s.setBrush( QtGui.QBrush( QtGui.QColor(QtCore.qrand() % 256, QtCore.qrand() % 256, QtCore.qrand() % 256))) w1.addItem(s) mw.show()
def getPlot(self): if self._plotView is not None: self._layout.removeWidget(self._plotView) self._plotView = None self._plotView = pg.GraphicsLayoutWidget() # Set titles plot = self._plotView.addPlot(title="SiPM Signals") plot.setLabel("bottom", "SiPM") plot.setLabel("left", "p.e.") # Create a random distribution vals = [] for count in range(1, 100): val = numpy.random.randint(1, 10) vals.append(val - 1) # Fill y, x = numpy.histogram(vals, bins=8) # Set colors pg.setConfigOption('background', 'w') hist_pen = pg.mkPen(color=[0, 0, 100, 255], width=4) hist_brush = pg.mkBrush(color=[0, 0, 255, 255]) point_pen = pg.mkPen(color=[0, 0, 0, 255], width=2) point_brush = pg.mkBrush(color=[0, 0, 0, 255]) # Add the histogram and legend #plot.addLegend() hist = pg.PlotCurveItem(x, y, stepMode=True, pen=hist_pen, fillLevel=0, brush=hist_brush) plot.addItem(hist) # Add points #getPoints() xtemp = [] ytemp = [] for i in range(0, 8): xtemp.append(i + 0.5) for i in range(0, 8): error = numpy.random.randint(1, 5) ytemp.append(y[i] + error) x_points = numpy.array(xtemp) y_points = numpy.array(ytemp) points = pg.ScatterPlotItem(name="Data") points.setData(x_points, y_points, symbol='o', pen=None) points.setSize(20) points.setPen(point_pen) points.setBrush(point_brush) plot.addItem(points) #plot.addItem(self._legend) # Add error bars top_error_temp = [] bottom_error_temp = [] for i in range(0, 8): top_error_temp.append(2) bottom_error_temp.append(2) error_bars = pg.ErrorBarItem(beam=0.25, pen=point_pen) top_error = numpy.array(top_error_temp) bottom_error = numpy.array(bottom_error_temp) error_bars.setData(x=x_points, y=y_points, top=top_error, bottom=bottom_error) plot.addItem(error_bars) self._layout.addWidget(self._plotView) self._plotView.show()
def __init__(self, root = '/Volumes/Data/Vasiliki/'): super().__init__() # Read color map from here : http://www.kennethmoreland.com/color-advice/ self.cl = np.loadtxt('../modified_intrinsic/extended-black-body-table-byte-0256.csv', delimiter=',', skiprows=1) self.cmap = [QtGui.qRgb(*x[1:]) for x in self.cl] self.cl = np.vstack((np.ones(self.cl.shape[0]), self.cl[:, 1:].transpose())).transpose() self.c_data = np.array([]) self._c_slice = 0 self.S: Optional[Session] = None # File model self.file_model = QtWidgets.QFileSystemModel() self.file_model.setFilter(QtCore.QDir.AllDirs | QtCore.QDir.Files | QtCore.QDir.NoDotAndDotDot ) self.file_model.setNameFilters(["*.h5"]) self.file_model.setRootPath(root) self.main_widget = QtWidgets.QWidget(self) # Layouts self.h_layout = QtWidgets.QHBoxLayout(self.main_widget) self.h_layout_cble = QtWidgets.QHBoxLayout() self.h_layout_btn = QtWidgets.QHBoxLayout() self.v_layout_left = QtWidgets.QVBoxLayout() self.v_layout_right = QtWidgets.QVBoxLayout() self.f_layout_trial = QtWidgets.QFormLayout() self.h_layout_analysis = QtWidgets.QGridLayout() left_scroll = QtWidgets.QScrollArea() left_scroll.setWidgetResizable(True) left_wdg = QtWidgets.QWidget() left_wdg.setLayout(self.v_layout_left) left_scroll.setWidget(left_wdg) # Widgets self.tree = QtWidgets.QTreeView(self) self.tree.setModel(self.file_model) self.tree.setRootIndex(self.file_model.index(root)) self.tree.hideColumn(1) self.tree.hideColumn(2) self.tree.hideColumn(3) self.tree.expanded.connect(self.expanded) self.tree.selectionModel().currentChanged.connect(self.select_file) # Trial structure fields self.baseline_sb = QtWidgets.QSpinBox(self) self.stim_sb = QtWidgets.QSpinBox(self) self.recovery_sb = QtWidgets.QSpinBox(self) self.frame_dur = QtWidgets.QSpinBox(self) self.frame_dur.setRange(1, 1000) self.baseline_sb.setValue(30) self.stim_sb.setValue(30) self.recovery_sb.setValue(20) self.frame_dur.setValue(100) self.baseline_sb.setMaximumWidth(50) self.stim_sb.setMaximumWidth(50) self.recovery_sb.setMaximumWidth(50) self.frame_dur.setMaximumWidth(50) self.analysis_btn = QtWidgets.QPushButton('&Analysis') self.analysis_btn.clicked.connect(self.analyze) self.movie_btn = QtWidgets.QPushButton('&Movie') self.movie_btn.clicked.connect(self.export_movie) self.resp_btn = QtWidgets.QPushButton('&Save response') self.resp_btn.clicked.connect(self.export_resp) self.tc_btn = QtWidgets.QPushButton('Save &time course') self.tc_btn.clicked.connect(self.export_tc) self.excel_btn = QtWidgets.QPushButton('Excel export') self.excel_btn.clicked.connect(self.excel_export) self.max_slider = LabeledSlider('Maximum value') self.max_slider.setEnabled(False) self.max_slider.setSingleStep(1) self.max_slider.valueChanged.connect(self.max_df_changed) self.slice_slider = LabeledSlider('Current frame') self.slice_slider.setEnabled(False) self.slice_slider.setSingleStep(1) self.slice_slider.valueChanged.connect(self.slice_changed) self.data_cb = QtWidgets.QComboBox(self) self.data_cb.currentIndexChanged.connect(self.data_changed) self.data_cb.setSizeAdjustPolicy(QtWidgets.QComboBox.AdjustToContents) self.comment_le = QtWidgets.QLineEdit() self.comment_le.setEnabled(False) self.comment_le.editingFinished.connect(self.commenting) # PyQtGraph self.win = pg.GraphicsLayoutWidget(self) self.plot_anat = self.win.addPlot(row=0, col=0) self.plot_resp = self.win.addPlot(row=1, col=0) self.resp_item = pg.ImageItem() self.anat_item = pg.ImageItem() self.plot_resp.addItem(self.resp_item) self.plot_anat.addItem(self.anat_item) roi_pen = pg.mkPen(color='y', width=2) self.roi = pg.ROI([0, 0], [100, 100], pen=roi_pen) self.roi_anat = pg.ROI([0, 0], [100, 100], movable=False, pen=roi_pen) self.roi.addScaleHandle([0.5, 1], [0.5, 0.5]) self.roi.addScaleHandle([0, 0.5], [0.5, 0.5]) self.roi.sigRegionChanged.connect(self.roi_moved) self.plot_resp.addItem(self.roi) self.plot_anat.addItem(self.roi_anat) self.roi.setZValue(10) self.plot_widget = self.win.addPlot(row=2, col=0) self.roi_plot = pg.PlotDataItem() self.plot_widget.addItem(self.roi_plot) # Adding widgets to layouts self.v_layout_right.addWidget(self.win) self.v_layout_left.addWidget(self.tree) # self.h_layout_analysis.addSpacerItem(QtWidgets.QSpacerItem(300, 1, QtWidgets.QSizePolicy.Expanding)) self.f_layout_trial.addRow('Number of baseline frames', self.baseline_sb) self.f_layout_trial.addRow('Number of stimulation frames', self.stim_sb) self.f_layout_trial.addRow('Number of recovery frames', self.recovery_sb) self.f_layout_trial.addRow('Exposure time', self.frame_dur) self.f_layout_trial.addRow("", self.analysis_btn) self.h_layout_analysis.addLayout(self.f_layout_trial, 0, 0) # self.h_layout_analysis.addItem(QtWidgets.QSpacerItem(1, 1, QtWidgets.QSizePolicy.Fixed, # QtWidgets.QSizePolicy.Expanding), 0, 1) self.v_layout_left.addLayout(self.h_layout_analysis) self.v_layout_left.addWidget(self.max_slider) self.h_layout_btn.addWidget(self.movie_btn) self.h_layout_btn.addWidget(self.resp_btn) self.h_layout_btn.addWidget(self.tc_btn) self.h_layout_btn.addWidget(self.excel_btn) self.h_layout_cble.addWidget(self.data_cb) self.h_layout_cble.addWidget(self.comment_le) self.v_layout_left.addLayout(self.h_layout_cble) self.v_layout_left.addWidget(self.slice_slider) self.v_layout_left.addLayout(self.h_layout_btn) # self.h_layout.addLayout(self.v_layout_left) self.h_layout.addWidget(left_scroll) self.h_layout.addLayout(self.v_layout_right) # Sizing self.setMinimumSize(600, 800) self.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) # self.tree.setMinimumSize(400, 800) self.setCentralWidget(self.main_widget) self.setWindowTitle('Flavo imaging explorer') self.c_path = None self.an_th = None self.resp_btn.setEnabled(False) self.tc_btn.setEnabled(False) self.movie_btn.setEnabled(False) self.excel_btn.setEnabled(False) # Logging self._logger = logging.getLogger('Intrinsiclog') self._logger.setLevel(logging.DEBUG) self._log_handler = RotatingFileHandler('Intrinsic.log', maxBytes=int(1e6), backupCount=1) formatter = logging.Formatter( '%(asctime)s :: %(filename)s :: %(funcName)s :: line %(lineno)d :: %(levelname)s :: %(message)s', datefmt='%Y-%m-%d:%H:%M:%S') self._log_handler.setFormatter(formatter) self._logger.addHandler(self._log_handler) sys.excepthook = handle_exception self.statusBar().showMessage('Ready!', 1500)
def __init__(self, parent=None): super(BinaryPlayer, self).__init__(parent) pg.setConfigOptions(imageAxisOrder='row-major') self.setGeometry(70,70,1070,1070) self.setWindowTitle('View registered binary') self.cwidget = QtGui.QWidget(self) self.setCentralWidget(self.cwidget) self.l0 = QtGui.QGridLayout() #layout = QtGui.QFormLayout() self.cwidget.setLayout(self.l0) #self.p0 = pg.ViewBox(lockAspect=False,name='plot1',border=[100,100,100],invertY=True) self.win = pg.GraphicsLayoutWidget() # --- cells image self.win = pg.GraphicsLayoutWidget() self.win.move(600,0) self.win.resize(1000,500) self.l0.addWidget(self.win,1,1,13,14) layout = self.win.ci.layout # A plot area (ViewBox + axes) for displaying the image self.p0 = self.win.addViewBox(lockAspect=True,row=0,col=0,invertY=True) #self.p0.setMouseEnabled(x=False,y=False) self.p0.setMenuEnabled(False) self.pimg = pg.ImageItem() self.p0.addItem(self.pimg) self.p1 = self.win.addPlot(name='plot1',row=1,col=0) self.p1.setMouseEnabled(x=True,y=False) self.p1.setMenuEnabled(False) #self.p1.autoRange(padding=0.01) self.p2 = self.win.addPlot(name='plot2',row=2,col=0) self.p2.setMouseEnabled(x=True,y=False) self.p2.setMenuEnabled(False) #self.p2.autoRange(padding=0.01) self.win.ci.layout.setRowStretchFactor(0,5) self.movieLabel = QtGui.QLabel("No ops chosen") self.movieLabel.setStyleSheet("color: white;") self.movieLabel.setAlignment(QtCore.Qt.AlignCenter) self.nframes = 0 self.cframe = 0 self.createButtons() # create ROI chooser self.l0.addWidget(QtGui.QLabel(''),2,0,1,2) qlabel = QtGui.QLabel(self) qlabel.setText("<font color='white'>Selected ROI:</font>") self.l0.addWidget(qlabel,3,0,1,2) self.ROIedit = QtGui.QLineEdit(self) self.ROIedit.setValidator(QtGui.QIntValidator(0,10000)) self.ROIedit.setText('0') self.ROIedit.setFixedWidth(45) self.ROIedit.setAlignment(QtCore.Qt.AlignRight) self.ROIedit.returnPressed.connect(self.number_chosen) self.l0.addWidget(self.ROIedit, 4,0,1,1) # create frame slider self.frameLabel = QtGui.QLabel("Current frame:") self.frameLabel.setStyleSheet("color: white;") self.frameNumber = QtGui.QLabel("0") self.frameNumber.setStyleSheet("color: white;") self.frameSlider = QtGui.QSlider(QtCore.Qt.Horizontal) #self.frameSlider.setTickPosition(QtGui.QSlider.TicksBelow) self.frameSlider.setTickInterval(5) self.frameSlider.setTracking(False) self.frameDelta = 10 self.l0.addWidget(QtGui.QLabel(''),12,0,1,1) self.l0.setRowStretch(12,1) self.l0.addWidget(self.frameLabel, 13,0,1,2) self.l0.addWidget(self.frameNumber, 14,0,1,2) self.l0.addWidget(self.frameSlider, 13,2,14,13) self.l0.addWidget(QtGui.QLabel(''),14,1,1,1) ll = QtGui.QLabel('(when paused, left/right arrow keys can move slider)') ll.setStyleSheet("color: white;") self.l0.addWidget(ll,16,0,1,3) #speedLabel = QtGui.QLabel("Speed:") #self.speedSpinBox = QtGui.QSpinBox() #self.speedSpinBox.setRange(1, 9999) #self.speedSpinBox.setValue(100) #self.speedSpinBox.setSuffix("%") self.frameSlider.valueChanged.connect(self.go_to_frame) self.l0.addWidget(self.movieLabel,0,0,1,5) self.updateFrameSlider() self.updateButtons() self.updateTimer = QtCore.QTimer() self.updateTimer.timeout.connect(self.next_frame) self.cframe = 0 self.loaded = False self.Floaded = False self.wraw = False self.wred = False self.wraw_wred = False self.win.scene().sigMouseClicked.connect(self.plot_clicked) # if not a combined recording, automatically open binary if hasattr(parent, 'ops'): if parent.ops['save_path'][-8:]!='combined': fileName = os.path.join(parent.basename, 'ops.npy') print(fileName) self.Fcell = parent.Fcell self.stat = parent.stat self.Floaded = True self.openFile(fileName, True)
def cluster_ruru(sampRate): import pyqtgraph as pg from pyqtgraph.Qt import QtCore, QtGui import SignalProc import wavio d = pd.read_csv( 'D:\AviaNZ\Sound_Files\Denoising_paper_data\Primary_dataset\\ruru\we2.tsv', sep="\t", header=None) data = d.values target = data[:, -1] fnames = data[:, 0] data = data[:, 1:-1] # dim reduction before clustering # pca = PCA(n_components=0.9) # data = pca.fit_transform(data) data = TSNE().fit_transform(data) learners = Clustering.Clustering(data, target) print('\n**************Ruru dataset******************') # Only choose algorithms that does not require n_clusters m = [] print('\nDBSCAN--------------------------------------') model_dbscan = learners.DBscan(eps=0.5, min_samples=5) # print(model_dbscan.labels_) print('# clusters', len(set(model_dbscan.labels_))) m.append(learners.clusteringScore1(learners.targets, model_dbscan.labels_)) print('\nBirch----------------------------------------') model_birch = learners.birch(threshold=0.88, n_clusters=None) # print(model_birch.labels_) print('# clusters', len(set(model_birch.labels_))) m.append(learners.clusteringScore1(learners.targets, model_birch.labels_)) print('\nAgglomerative Clustering----------------------') model_agg = learners.agglomerativeClustering( n_clusters=None, compute_full_tree=True, distance_threshold=4.4, linkage='complete' ) # Either set n_clusters=None and compute_full_tree=T # or distance_threshold=None model_agg.fit_predict(learners.features) # print(model_agg.labels_) print('# clusters', len(set(model_agg.labels_))) m.append(learners.clusteringScore1(learners.targets, model_agg.labels_)) print('\nAffinity Propagation--------------------------') model_aff = learners.affinityPropagation(damping=0.8, max_iter=400, convergence_iter=50) # print(model_aff.labels_) print('# clusters', len(set(model_aff.labels_))) m.append(learners.clusteringScore1(learners.targets, model_aff.labels_)) best_m = np.argmax(m, axis=0).tolist( ) # Get algorithm with the best performance on each index best_alg = max(set(best_m), key=best_m.count) # Get the overall best alg # Analysis if best_alg == 0: model_best = model_dbscan print('\n***best clustering by: DBSCAN') print('predicted:\n', model_dbscan.labels_) print('actual:\n', learners.targets) elif best_alg == 1: model_best = model_birch print('\n***best clustering by: Birch') print('predicted:\n', model_birch.labels_) print('actual:\n', learners.targets) elif best_alg == 2: model_best = model_agg print('\n***best clustering by: Agglomerative') print('predicted:\n', model_agg.labels_) print('actual:\n', learners.targets) elif best_alg == 3: model_best = model_aff print('\n***best clustering by: Affinity') print('predicted:\n', model_aff.labels_) print('actual:\n', learners.targets) # plot the examples using the best clustering model # n_clusters = len(set(model_best.labels_)) # get indices and plot them labels = list(set(model_best.labels_)) app = QtGui.QApplication([]) for label in labels: inds = np.where(model_best.labels_ == label)[0].tolist() mw = QtGui.QMainWindow() mw.show() mw.resize(1200, 800) win = pg.GraphicsLayoutWidget() mw.setCentralWidget(win) row = 0 col = 0 for i in inds: wavobj = wavio.read(fnames[i]) fs = wavobj.rate audiodata = wavobj.data if audiodata.dtype is not 'float': audiodata = audiodata.astype('float') if np.shape(np.shape(audiodata))[0] > 1: audiodata = audiodata[:, 0] if fs != sampRate: audiodata = librosa.core.audio.resample( audiodata, fs, sampRate) fs = sampRate sp = SignalProc.SignalProc(audiodata, fs, 128, 128) sg = sp.spectrogram(audiodata, multitaper=False) vb = win.addViewBox(enableMouse=False, enableMenu=False, row=row, col=col, invertX=True) vb2 = win.addViewBox(enableMouse=False, enableMenu=False, row=row + 1, col=col) im = pg.ImageItem(enableMouse=False) txt = fnames[i].split("/")[-1][:-4] lbl = pg.LabelItem(txt, rotateAxis=(1, 0), angle=179) vb.addItem(lbl) vb2.addItem(im) im.setImage(sg) im.setBorder('w') mw.setWindowTitle("Class " + str(label) + ' - ' + str(np.shape(inds)[0]) + ' calls') if row == 8: row = 0 col += 1 else: row += 2 QtGui.QApplication.instance().exec_()
def __init__(self): super(realtime_Plot, self).__init__() self.setWindowTitle('Real Time Input Plot') self.resize(800, 500) # self.setWindowModality(Qt.ApplicationModal) self.traces = dict() self.color = (224, 223, 227) self.win_1 = pg.GraphicsLayoutWidget() self.win_1.setBackground(self.color) self.win_2 = pg.GraphicsLayoutWidget() self.win_2.setBackground(self.color) self.wf_xlabels = [(0, '0'), (2048, '2048'), (4096, '4096')] self.wf_xaxis = pg.AxisItem(orientation='bottom') self.wf_xaxis.setTicks([self.wf_xlabels]) self.wf_ylabels = [(0, '0'), (-1, '-1'), (1, '1')] self.wf_yaxis = pg.AxisItem(orientation='left') self.wf_yaxis.setTicks([self.wf_ylabels]) self.sp_xlabels = [(np.log10(20), '20'), (np.log10(50), '50'), (np.log10(100), '100'), (np.log10(250), '250'), (np.log10(500), '500'), (np.log10(1000), '1k'), (np.log10(4000), '4k'), (np.log10(8000), '8k'), (np.log10(20000), '20k')] self.sp_xaxis = pg.AxisItem(orientation='bottom') self.sp_xaxis.setTicks([self.sp_xlabels]) self.sp_ylabels = [(0, '0'), (-1, '-12'), (-2, '-24'), (-3, '-48')] self.sp_yaxis = pg.AxisItem(orientation='left') self.sp_yaxis.setTicks([self.sp_ylabels]) self.waveform = self.win_1.addPlot( title='Waveform', row=1, col=1, axisItems={ 'bottom': self.wf_xaxis, 'left': self.wf_yaxis }, ) self.spectrum = self.win_2.addPlot( title='Spectrum', row=2, col=1, axisItems={ 'bottom': self.sp_xaxis, 'left': self.sp_yaxis }, ) self.waveform.showGrid(x=True, y=True, alpha=0.3) self.waveform.setMouseEnabled(x=False, y=False) self.spectrum.showGrid(x=True, y=True, alpha=0.3) self.spectrum.setMouseEnabled(x=False, y=False) layout = QHBoxLayout() layout.addWidget(self.win_1) layout.addWidget(self.win_2) self.setLayout(layout) # ------------------------------- just for test ------------------------ # pyaudio should be deleted self.FORMAT = pyaudio.paInt16 self.CHANNELS = 1 self.RATE = 44100 self.CHUNK = 1024 * 2 self.p = pyaudio.PyAudio() self.stream = self.p.open( format=self.FORMAT, channels=self.CHANNELS, rate=self.RATE, input=True, output=True, frames_per_buffer=self.CHUNK, ) # waveform and spectrum x points self.x = np.arange(0, 2 * self.CHUNK, 2) self.f = np.linspace(0, 20000, 1024)
def cosmic_ray_removal(self, offset=0, medianRatio=1, noiseCoeff=5): """ Remove cosmic rays from the raw_array when it is a sequence of consecutive exposures. :param offset: baseline to add to raw_array. Not used, but here if it's needed in the future :param medianRatio: Multiplier to the median when deciding a cutoff :param noiseCoeff: Multiplier to the noise on the median May need changing for noisy data :return: """ # log.warn("Warning: HSG FVB Cosmic removal not implemented") # self.clean_array = self.raw_array d = np.array(self.raw_array) print d.shape med = ndimage.filters.median_filter(d, size=(d.shape[0], 1), mode='wrap') print med.shape meanMedian = med.mean(axis=0) print meanMedian.shape # Construct a cutoff for each pixel. It was kind of guess and # check cutoff = meanMedian * medianRatio + noiseCoeff * np.std( meanMedian[:100]) print cutoff.shape winlist = [] win = pg.GraphicsLayoutWidget() win.setWindowTitle("Raw Image") p1 = win.addPlot() img = pg.ImageItem() img.setImage(d.copy().T) p1.addItem(img) hist = pg.HistogramLUTItem() hist.setImageItem(img) win.addItem(hist) win.nextRow() p2 = win.addPlot(colspan=2) p2.plot(np.sum(d, axis=1)) win.show() winlist.append(win) win2 = pg.GraphicsLayoutWidget() win2.setWindowTitle("Median Image") p1 = win2.addPlot() img = pg.ImageItem() img.setImage(med.T) p1.addItem(img) hist = pg.HistogramLUTItem() hist.setImageItem(img) win2.addItem(hist) win2.nextRow() p2 = win2.addPlot(colspan=2) p2.plot(np.sum(med, axis=1) / 4) win2.show() winlist.append(win2) win2 = pg.GraphicsLayoutWidget() win2.setWindowTitle("d-m") p1 = win2.addPlot() img = pg.ImageItem() img.setImage((d - med).T) p1.addItem(img) hist = pg.HistogramLUTItem() hist.setImageItem(img) win2.addItem(hist) win2.nextRow() p2 = win2.addPlot(colspan=2) p2.plot((d - med)[0, :], pen='w') p2.plot((d - med)[1, :], pen='g') p2.plot((d - med)[2, :], pen='r') p2.plot((d - med)[3, :], pen='y') p2.plot(cutoff, pen='c') win2.show() winlist.append(win2) self.winlist = winlist # Find the bad pixel positions # Note the [:, None] - needed to cast the correct shapes badPixs = np.argwhere((d - med) > (cutoff)) for pix in badPixs: # get the other pixels in the row which aren't the cosmic p = d[pix[0], [i for i in range(d.shape[1]) if not i == pix[1]]] # Replace the cosmic by the average of the others # Could get hairy if more than one cosmic per row. # Maybe when doing many exposures? d[pix[0], pix[1]] = np.mean(p) self.clean_array = np.array(d)
if args.debug: try: ump.set_debug_mode(True) except Exception as e: print(f"Could not enable Sensapex debug mode: {e}") time.sleep(2) devids = ump.list_devices() devs = {i: ump.get_device(i) for i in devids} print("SDK version:", ump.sdk_version()) print("Found device IDs:", devids) dev = devs[args.device] app = pg.mkQApp() win = pg.GraphicsLayoutWidget() win.show() plots = [ win.addPlot(labels={ "left": ("x position", "m"), "bottom": ("time", "s") }), win.addPlot(labels={ "left": ("y position", "m"), "bottom": ("time", "s") }), win.addPlot(labels={ "left": ("z position", "m"), "bottom": ("time", "s") }), ]
""" Demonstrates adding a custom context menu to a GraphicsItem and extending the context menu of a ViewBox. PyQtGraph implements a system that allows each item in a scene to implement its own context menu, and for the menus of its parent items to be automatically displayed as well. """ import initExample ## Add path to library (just for examples; you do not need this) import pyqtgraph as pg from pyqtgraph.Qt import QtCore, QtGui import numpy as np win = pg.GraphicsLayoutWidget(show=True) win.setWindowTitle('pyqtgraph example: context menu') view = win.addViewBox() # add two new actions to the ViewBox context menu: zoom1 = view.menu.addAction('Zoom to box 1') zoom2 = view.menu.addAction('Zoom to box 2') # define callbacks for these actions def zoomTo1(): # note that box1 is defined below view.autoRange(items=[box1])
arr[75, :] = 5 arr[:, 75] = 5 arr[50, :] = 10 arr[:, 50] = 10 arr += np.sin(np.linspace(0, 20, 100)).reshape(1, 100) arr += np.random.normal(size=(100,100)) # add an arrow for asymmetry arr[10, :50] = 10 arr[9:12, 44:48] = 10 arr[8:13, 44:46] = 10 ## create GUI app = pg.mkQApp("ROI Examples") w = pg.GraphicsLayoutWidget(show=True, size=(1000,800), border=True) w.setWindowTitle('pyqtgraph example: ROI Examples') text = """Data Selection From Image.<br>\n Drag an ROI or its handles to update the selected image.<br> Hold CTRL while dragging to snap to pixel boundaries<br> and 15-degree rotation angles. """ w1 = w.addLayout(row=0, col=0) label1 = w1.addLabel(text, row=0, col=0) v1a = w1.addViewBox(row=1, col=0, lockAspect=True) v1b = w1.addViewBox(row=2, col=0, lockAspect=True) img1a = pg.ImageItem(arr) v1a.addItem(img1a) img1b = pg.ImageItem() v1b.addItem(img1b)
def add_orbit_plot(self): win = pg.GraphicsLayoutWidget() self.plot_x = win.addPlot(row=0, col=0) axis = self.plot_x.getAxis("bottom") axis.setStyle(showValues=False) # win.ci.layout.setRowMaximumHeight(0, 200) self.plot_x.showGrid(1, 1, 1) self.plot_y = win.addPlot(row=1, col=0) axis = self.plot_y.getAxis("bottom") axis.setStyle(showValues=False) self.plot_x.setXLink(self.plot_y) #self.plot_x.hideAxis("bottom") self.plot_x.setLabel('left', 'X Orbit', 'mm') self.plot_y.showGrid(1, 1, 1) self.plot_y.setLabel('left', 'Y Orbit', 'mm') self.plot_y.getAxis('left').enableAutoSIPrefix( enable=False) # stop the auto unit scaling on y axes layout = QtGui.QGridLayout() self.ui.w_disp.setLayout(layout) layout.addWidget(win, 0, 0) self.plot_y.setAutoVisible(y=True) #legend for plot_x and plot_y self.leg_x = customLegend(offset=(75, 20)) self.leg_x.setParentItem(self.plot_x.graphicsItem()) self.leg_y = customLegend(offset=(75, 20)) self.leg_y.setParentItem(self.plot_y.graphicsItem()) self.plot_Dx = win.addPlot(row=2, col=0) self.plot_Dx.setLabel('left', 'Dx', 'm') axis = self.plot_Dx.getAxis("bottom") axis.setStyle(showValues=False) self.plot_Dy = win.addPlot(row=3, col=0) self.plot_Dy.setLabel('left', 'Dy', 'm') self.plot_Dy.showGrid(1, 1, 1) self.plot_Dy.setXLink(self.plot_y) #win.ci.layout.setRowMaximumHeight(2, 150) self.plot_Dx.setXLink(self.plot_y) self.plot_Dx.showGrid(1, 1, 1) color = QtGui.QColor(0, 255, 255) pen = pg.mkPen(color, width=3) self.Dx_curve = pg.PlotCurveItem(x=[], y=[], pen=pen, name='Dx', antialias=True) self.plot_Dx.addItem(self.Dx_curve) self.plot_Dx.addLegend() color = QtGui.QColor(0, 255, 255) pen = pg.mkPen(color, width=1) self.Dx_des_curve = pg.PlotCurveItem(x=[], y=[], pen=pen, name='Dx des', antialias=True) self.plot_Dx.addItem(self.Dx_des_curve) self.plot_Dx.addLegend() color = QtGui.QColor(0, 255, 255) pen = pg.mkPen(color, width=3, symbolPen='o') self.Dy_curve = pg.PlotDataItem(x=[], y=[], pen=pen, name='Dy', antialias=True) self.plot_Dy.addItem(self.Dy_curve) self.plot_Dy.addLegend() color = QtGui.QColor(0, 255, 255) pen = pg.mkPen(color, width=1, symbolPen='o') self.Dy_des_curve = pg.PlotDataItem(x=[], y=[], pen=pen, name='Dy des', antialias=True) self.plot_Dy.addItem(self.Dy_des_curve) self.plot_Dy.addLegend()
def buildGUI(self): self.setWindowTitle('Bandpass Optimizer') app_icon = QtGui.QIcon() app_icon.addFile( os.path.join('supra', 'GUI', 'Images', 'BAM_no_wave.png'), QtCore.QSize(16, 16)) self.setWindowIcon(app_icon) p = self.palette() p.setColor(self.backgroundRole(), Qt.black) self.setPalette(p) theme(self) layout = QGridLayout() self.setLayout(layout) self.bandpass_view = pg.GraphicsLayoutWidget() self.bandpass_canvas = self.bandpass_view.addPlot() self.bp_button = createButton('Bandpass', layout, 4, 2, self.bandpass) self.save_button = createButton('Save', layout, 4, 3, self.bandpassSave) layout.addWidget(self.bandpass_view, 1, 1, 1, 2) _, self.low_bandpass_edits = createLabelEditObj('Low Bandpass', layout, 2, width=1, h_shift=0, tool_tip='', validate='float', default_txt='2') _, self.high_bandpass_edits = createLabelEditObj('High Bandpass', layout, 3, width=1, h_shift=0, tool_tip='', validate='float', default_txt='8') self.stream = self.stn.stream.select( channel="{:}".format(self.channel)) st = self.stn.stream.select(channel="{:}".format(self.channel))[0] self.orig_trace = st.copy() stn = self.stn delta = self.orig_trace.stats.delta start_datetime = self.orig_trace.stats.starttime.datetime end_datetime = self.orig_trace.stats.endtime.datetime stn.offset = (start_datetime - self.bam.setup.fireball_datetime).total_seconds() self.current_waveform_delta = delta self.current_waveform_time = np.arange(0, self.orig_trace.stats.npts / self.orig_trace.stats.sampling_rate, \ delta) time_data = np.copy(self.current_waveform_time) self.orig_trace.detrend() resp = stn.response if resp is not None: self.orig_trace = self.orig_trace.remove_response(inventory=resp, output="DISP") # st.remove_sensitivity(resp) waveform_data = self.orig_trace.data self.orig_data = np.copy(waveform_data) waveform_data = waveform_data[:len(time_data)] time_data = time_data[:len(waveform_data)] + stn.offset self.current_waveform_processed = waveform_data # Init the butterworth bandpass filter butter_b, butter_a = butterworthBandpassFilter(2, 8, \ 1.0/self.current_waveform_delta, order=6) # Filter the data waveform_data = scipy.signal.filtfilt(butter_b, butter_a, np.copy(waveform_data)) self.current_station_waveform = pg.PlotDataItem(x=time_data, y=waveform_data, pen='w') self.bandpass_canvas.addItem(self.current_station_waveform) self.bandpass_canvas.setXRange(self.t_arrival - 100, self.t_arrival + 100, padding=1) self.bandpass_canvas.setLabel( 'bottom', "Time after {:} s".format(self.bam.setup.fireball_datetime)) self.bandpass_canvas.setLabel('left', "Signal Response") self.bandpass_canvas.plot(x=[-10000, 10000], y=[0, 0], pen=pg.mkPen(color=(100, 100, 100))) self.noise_selector = pg.LinearRegionItem(values=[0, 10], brush=(255, 0, 0, 100)) self.signal_selector = pg.LinearRegionItem(values=[200, 210], brush=(0, 255, 0, 100)) self.bandpass_canvas.addItem(self.noise_selector) self.bandpass_canvas.addItem(self.signal_selector) self.bandpass_graph = MatplotlibPyQT() self.bandpass_graph.ax1 = self.bandpass_graph.figure.add_subplot(211) self.bandpass_graph.ax2 = self.bandpass_graph.figure.add_subplot(212) layout.addWidget(self.bandpass_graph, 1, 4, 1, 2)
""" ## Add path to library (just for examples; you do not need this) #import initExample from pyqtgraph.Qt import QtGui, QtCore import pyqtgraph as pg import numpy as np from collections import namedtuple app = QtGui.QApplication([]) mw = QtGui.QMainWindow() mw.resize(800,800) view = pg.GraphicsLayoutWidget() ## GraphicsView with GraphicsLayout inserted by default mw.setCentralWidget(view) mw.show() mw.setWindowTitle('pyqtgraph example: ScatterPlot') ## create four areas to add plots w1 = view.addPlot() w2 = view.addViewBox() w2.setAspectLocked(True) view.nextRow() w3 = view.addPlot() w4 = view.addPlot() print("Generating data, this takes a few seconds...") ## There are a few different ways we can draw scatter plots; each is optimized for different types of data:
def __init__(self): super(MainW, self).__init__() pg.setConfigOptions(imageAxisOrder="row-major") self.setGeometry(25, 25, 1800, 1000) self.setWindowTitle("Rastermap") icon_path = os.path.join( os.path.dirname(os.path.realpath(__file__)), "logo.png" ) app_icon = QtGui.QIcon() app_icon.addFile(icon_path, QtCore.QSize(16, 16)) app_icon.addFile(icon_path, QtCore.QSize(24, 24)) app_icon.addFile(icon_path, QtCore.QSize(32, 32)) app_icon.addFile(icon_path, QtCore.QSize(48, 48)) app_icon.addFile(icon_path, QtCore.QSize(96, 96)) app_icon.addFile(icon_path, QtCore.QSize(256, 256)) self.setWindowIcon(app_icon) self.setStyleSheet("QMainWindow {background: 'black';}") self.stylePressed = ("QPushButton { " "background-color: rgb(100,50,100); " "color:white;}") self.styleUnpressed = ("QPushButton { " "background-color: rgb(50,50,50); " "color:white;}") self.styleInactive = ("QPushButton { " "background-color: rgb(50,50,50); " "color:gray;}") self.loaded = False # ------ MENU BAR ----------------- loadMat = QtGui.QAction("&Load data matrix", self) loadMat.setShortcut("Ctrl+L") loadMat.triggered.connect(lambda: self.load_mat(name=None)) self.addAction(loadMat) # run rastermap from scratch self.runRMAP = QtGui.QAction("&Run embedding algorithm", self) self.runRMAP.setShortcut("Ctrl+R") self.runRMAP.triggered.connect(self.run_RMAP) self.addAction(self.runRMAP) self.runRMAP.setEnabled(False) # load processed data loadProc = QtGui.QAction("&Load processed data", self) loadProc.setShortcut("Ctrl+P") loadProc.triggered.connect(lambda: self.load_proc(name=None)) self.addAction(loadProc) # load a behavioral trace self.loadBeh = QtGui.QAction( "Load behavior or stim trace (1D only)", self ) self.loadBeh.triggered.connect(self.load_behavior) self.loadBeh.setEnabled(False) self.addAction(self.loadBeh) # export figure exportFig = QtGui.QAction("Export as image (svg)", self) exportFig.triggered.connect(self.export_fig) exportFig.setEnabled(True) self.addAction(exportFig) # make mainmenu! main_menu = self.menuBar() file_menu = main_menu.addMenu("&File") file_menu.addAction(loadMat) file_menu.addAction(loadProc) file_menu.addAction(self.runRMAP) file_menu.addAction(self.loadBeh) file_menu.addAction(exportFig) #### --------- MAIN WIDGET LAYOUT --------- #### #pg.setConfigOption('background', 'w') #cwidget = EventWidget(self) cwidget = QtGui.QWidget() self.l0 = QtGui.QGridLayout() cwidget.setLayout(self.l0) self.setCentralWidget(cwidget) # -------- MAIN PLOTTING AREA ---------- self.win = pg.GraphicsLayoutWidget() #self.win.move(600, 0) #self.win.resize(1000, 500) self.l0.addWidget(self.win, 0, 0, 50, 30) layout = self.win.ci.layout # --- full recording self.pfull = self.win.addPlot(title="FULL VIEW",row=0,col=2,rowspan=1,colspan=3) self.pfull.setMouseEnabled(x=False,y=False) self.imgfull = pg.ImageItem(autoDownsample=True) self.pfull.addItem(self.imgfull) self.pfull.hideAxis('left') #self.pfull.hideAxis('bottom') # --- embedding image self.p0 = self.win.addPlot(row=1, col=0, rowspan=2, colspan=1, lockAspect=True) self.p0.setAspectLocked(ratio=1) self.p0.scene().sigMouseMoved.connect(self.mouse_moved_embedding) # ---- colorbar self.p3 = self.win.addPlot(row=1, col=1, rowspan=3, colspan=1) self.p3.setMouseEnabled(x=False,y=False) self.p3.setMenuEnabled(False) self.colorimg = pg.ImageItem(autoDownsample=True) self.p3.addItem(self.colorimg) self.p3.scene().sigMouseMoved.connect(self.mouse_moved_bar) # --- activity image self.p1 = self.win.addPlot(row=1, col=2, colspan=3, rowspan=3, invertY=True, padding=0) self.p1.setMouseEnabled(x=False, y=False) self.img = pg.ImageItem(autoDownsample=True) self.p1.hideAxis('left') self.p1.setMenuEnabled(False) self.p1.scene().contextMenuItem = self.p1 self.p1.addItem(self.img) self.p1.scene().sigMouseMoved.connect(self.mouse_moved_activity) # bottom row for buttons #self.p2 = self.win.addViewBox(row=2, col=0) #self.p2.setMouseEnabled(x=False,y=False) #self.p2.setMenuEnabled(False) self.win.scene().sigMouseClicked.connect(self.plot_clicked) #self.win.ci.layout.setRowStretchFactor(0, .5) self.win.ci.layout.setRowStretchFactor(1, 2) self.win.ci.layout.setRowStretchFactor(2, 2) #self.win.ci.layout.setColumnStretchFactor(0, .5) self.win.ci.layout.setColumnStretchFactor(1, .1) self.win.ci.layout.setColumnStretchFactor(3, 2) # self.key_on(self.win.scene().keyPressEvent) rs = 2 addROI = QtGui.QLabel("<font color='white'>add an ROI by SHIFT click</font>") self.l0.addWidget(addROI, rs+0, 0, 1, 3) addROI = QtGui.QLabel("<font color='white'>delete an ROI by ALT click</font>") self.l0.addWidget(addROI, rs+1, 0, 1, 3) addROI = QtGui.QLabel("<font color='white'>delete last-drawn ROI by DELETE</font>") self.l0.addWidget(addROI, rs+2, 0, 1, 3) addROI = QtGui.QLabel("<font color='white'>delete all ROIs by ALT-DELETE</font>") self.l0.addWidget(addROI, rs+3, 0, 1, 3) self.updateROI = QtGui.QPushButton("update (SPACE)") self.updateROI.setFont(QtGui.QFont("Arial", 8, QtGui.QFont.Bold)) self.updateROI.clicked.connect(self.ROI_selection) self.updateROI.setStyleSheet(self.styleInactive) self.updateROI.setEnabled(False) self.updateROI.setFixedWidth(100) self.l0.addWidget(self.updateROI, rs+4, 0, 1, 1) self.saveROI = QtGui.QPushButton("save ROIs") self.saveROI.setFont(QtGui.QFont("Arial", 8, QtGui.QFont.Bold)) self.saveROI.clicked.connect(self.ROI_save) self.saveROI.setStyleSheet(self.styleInactive) self.saveROI.setEnabled(False) self.saveROI.setFixedWidth(100) self.l0.addWidget(self.saveROI, rs+5, 0, 1, 1) self.makegrid = QtGui.QPushButton("make ROI grid, n=") self.makegrid.setFont(QtGui.QFont("Arial", 8, QtGui.QFont.Bold)) self.makegrid.clicked.connect(self.make_grid) self.makegrid.setStyleSheet(self.styleInactive) self.makegrid.setEnabled(False) self.makegrid.setFixedWidth(200) self.l0.addWidget(self.makegrid, rs+7, 0, 1, 1) self.gridsize = QtGui.QLineEdit(self) self.gridsize.setValidator(QtGui.QIntValidator(2, 20)) self.gridsize.setText("5") self.gridsize.setFixedWidth(45) self.gridsize.setAlignment(QtCore.Qt.AlignRight) self.gridsize.returnPressed.connect(self.make_grid) self.l0.addWidget(self.gridsize, rs+7, 1, 1, 1) self.dbbutton = QtGui.QPushButton("DBSCAN clusters, ms=") self.dbbutton.setFont(QtGui.QFont("Arial", 8, QtGui.QFont.Bold)) self.dbbutton.clicked.connect(self.dbscan) self.dbbutton.setStyleSheet(self.styleInactive) self.dbbutton.setEnabled(False) self.dbbutton.setFixedWidth(200) self.l0.addWidget(self.dbbutton, rs+8, 0, 1, 1) self.min_samples = QtGui.QLineEdit(self) self.min_samples.setValidator(QtGui.QIntValidator(5, 200)) self.min_samples.setText("50") self.min_samples.setFixedWidth(45) self.min_samples.setAlignment(QtCore.Qt.AlignRight) self.min_samples.returnPressed.connect(self.dbscan) self.l0.addWidget(self.min_samples, rs+8, 1, 1, 1) ysm = QtGui.QLabel("<font color='white'>y-binning</font>") ysm.setFixedWidth(100) self.l0.addWidget(ysm, rs+6, 0, 1, 1) self.smooth = QtGui.QLineEdit(self) self.smooth.setValidator(QtGui.QIntValidator(0, 500)) self.smooth.setText("10") self.smooth.setFixedWidth(45) self.smooth.setAlignment(QtCore.Qt.AlignRight) self.smooth.returnPressed.connect(self.plot_activity) self.l0.addWidget(self.smooth, rs+6, 1, 1, 1) # add slider for levels self.sl = [] txt = ["lower saturation", 'upper saturation'] self.sat = [0.3,0.7] for j in range(2): self.sl.append(Slider(j, self)) self.l0.addWidget(self.sl[j],rs+4-4*j,3,4,1) qlabel = VerticalLabel(text=txt[j]) #qlabel.setStyleSheet('color: white;') self.l0.addWidget(qlabel,rs+4-4*j,4,4,1) colormap = cm.get_cmap("gray_r") colormap._init() lut = (colormap._lut * 255).view(np.ndarray) # Convert matplotlib colormap from 0-1 to 0 -255 for Qt lut = lut[0:-3,:] # apply the colormap self.img.setLookupTable(lut) self.imgfull.setLookupTable(lut) self.img.setLevels([self.sat[0], self.sat[1]]) self.imgfull.setLevels([self.sat[0], self.sat[1]]) # ------ CHOOSE CELL------- #self.ROIedit = QtGui.QLineEdit(self) #self.ROIedit.setValidator(QtGui.QIntValidator(0, 10000)) #self.ROIedit.setText("0") #self.ROIedit.setFixedWidth(45) #self.ROIedit.setAlignment(QtCore.Qt.AlignRight) #self.ROIedit.returnPressed.connect(self.number_chosen) self.startROI = False self.endROI = False self.posROI = np.zeros((3,2)) self.prect = np.zeros((5,2)) self.ROIs = [] self.ROIorder = [] self.Rselected = [] self.Rcolors = [] self.embedded = False self.posAll = [] self.lp = [] #self.fname = '/media/carsen/DATA1/BootCamp/mesoscope_cortex/spks.npy' # self.load_behavior('C:/Users/carse/github/TX4/beh.npy') self.file_iscell = None #self.fname = '/media/carsen/DATA2/grive/rastermap/DATA/embedding.npy' self.fname = 'D:/grive/cshl_suite2p/TX39/embedding.npy' self.load_proc(self.fname) self.show() self.win.show()
def __init__(self, collector, parent=None): """ Constructor. See AbstractInspector constructor for parameters. """ super(PgImagePlot2d, self).__init__(collector, parent=parent) # The sliced array is kept in memory. This may be different per inspector, e.g. 3D # inspectors may decide that this uses to much memory. The slice is therefor not stored # in the collector. self.slicedArray = None self.titleLabel = pg.LabelItem('title goes here...') # The image item self.imagePlotItem = ArgosPgPlotItem() self.viewBox = self.imagePlotItem.getViewBox() self.viewBox.disableAutoRange(BOTH_AXES) self.imageItem = pg.ImageItem() self.imagePlotItem.addItem(self.imageItem) self.histLutItem = HistogramLUTItem() # what about GradientLegend? self.histLutItem.setImageItem(self.imageItem) self.histLutItem.vb.setMenuEnabled(False) self.histLutItem.setHistogramRange(0, 100) # Disables autoscaling # Probe and cross hair plots self.crossPlotRow = None # the row coordinate of the cross hair. None if no cross hair. self.crossPlotCol = None # the col coordinate of the cross hair. None if no cross hair. self.horCrossPlotItem = ArgosPgPlotItem() self.verCrossPlotItem = ArgosPgPlotItem() self.horCrossPlotItem.setXLink(self.imagePlotItem) self.verCrossPlotItem.setYLink(self.imagePlotItem) self.horCrossPlotItem.setLabel('left', ' ') self.verCrossPlotItem.setLabel('bottom', ' ') self.horCrossPlotItem.showAxis('top', True) self.horCrossPlotItem.showAxis('bottom', False) self.verCrossPlotItem.showAxis('right', True) self.verCrossPlotItem.showAxis('left', False) self.crossPen = pg.mkPen("#BFBFBF") self.crossShadowPen = pg.mkPen([0, 0, 0, 100], width=3) self.crossLineHorShadow = pg.InfiniteLine(angle=0, movable=False, pen=self.crossShadowPen) self.crossLineVerShadow = pg.InfiniteLine(angle=90, movable=False, pen=self.crossShadowPen) self.crossLineHorizontal = pg.InfiniteLine(angle=0, movable=False, pen=self.crossPen) self.crossLineVertical = pg.InfiniteLine(angle=90, movable=False, pen=self.crossPen) self.imagePlotItem.addItem(self.crossLineVerShadow, ignoreBounds=True) self.imagePlotItem.addItem(self.crossLineHorShadow, ignoreBounds=True) self.imagePlotItem.addItem(self.crossLineVertical, ignoreBounds=True) self.imagePlotItem.addItem(self.crossLineHorizontal, ignoreBounds=True) self.probeLabel = pg.LabelItem('', justify='left') # Layout # Hiding the horCrossPlotItem and horCrossPlotItem will still leave some space in the # grid layout. We therefore remove them from the layout instead. We need to know if they # are already added. self.horPlotAdded = False self.verPlotAdded = False self.graphicsLayoutWidget = pg.GraphicsLayoutWidget() self.contentsLayout.addWidget(self.graphicsLayoutWidget) self.graphicsLayoutWidget.addItem(self.titleLabel, ROW_TITLE, COL_TITLE, colspan=3) self.graphicsLayoutWidget.addItem(self.histLutItem, ROW_COLOR, COL_COLOR, rowspan=2) self.graphicsLayoutWidget.addItem(self.imagePlotItem, ROW_IMAGE, COL_IMAGE) self.graphicsLayoutWidget.addItem(self.probeLabel, ROW_PROBE, COL_PROBE, colspan=3) gridLayout = self.graphicsLayoutWidget.ci.layout # A QGraphicsGridLayout gridLayout.setHorizontalSpacing(10) gridLayout.setVerticalSpacing(10) #gridLayout.setRowSpacing(ROW_PROBE, 40) gridLayout.setRowStretchFactor(ROW_HOR_LINE, 1) gridLayout.setRowStretchFactor(ROW_IMAGE, 2) gridLayout.setColumnStretchFactor(COL_IMAGE, 2) gridLayout.setColumnStretchFactor(COL_VER_LINE, 1) # Configuration tree self._config = PgImagePlot2dCti(pgImagePlot2d=self, nodeName='2D image plot') # Connect signals # Based mouseMoved on crosshair.py from the PyQtGraph examples directory. # I did not use the SignalProxy because I did not see any difference. self.imagePlotItem.scene().sigMouseMoved.connect(self.mouseMoved)
from pyqtgraph.Qt import QtGui, QtCore import numpy as np import pyqtgraph as pg from pyqtgraph.ptime import time import pyaudio import sys FORMAT = pyaudio.paInt16 # We use 16 bit format per sample CHANNELS = 1 RATE = 44100 # RATE = 96000 # RATE = 48000 CHUNK = 1<<10 # 1024 bytes of data read from the buffer app = QtGui.QApplication([]) win = pg.GraphicsLayoutWidget(show=True, title="Basic plotting examples") win.resize(1000,600) win.setWindowTitle('pyaudio pyqtgraph') # p = pg.plot() p1 = win.addPlot() p1.setLabel('bottom', 'time', units='sec') p1.setRange(QtCore.QRectF(0, -1000, CHUNK/RATE, 2000)) curve1 = p1.plot() def makeBox(p): p.showAxis('right', show=True) p.getAxis('right').setStyle(showValues=False) p.showAxis('top', show=True) p.getAxis('top').setStyle(showValues=False) p.showGrid(x=True, y=True) makeBox(p1)
def __init__(self, parent=None): super(PCViewer, self).__init__(parent) pg.setConfigOptions(imageAxisOrder='row-major') self.setGeometry(70, 70, 1300, 800) self.setWindowTitle('Metrics for registration') self.cwidget = QtGui.QWidget(self) self.setCentralWidget(self.cwidget) self.l0 = QtGui.QGridLayout() #layout = QtGui.QFormLayout() self.cwidget.setLayout(self.l0) #self.p0 = pg.ViewBox(lockAspect=False,name='plot1',border=[100,100,100],invertY=True) self.win = pg.GraphicsLayoutWidget() # --- cells image self.win = pg.GraphicsLayoutWidget() self.l0.addWidget(self.win, 0, 2, 13, 14) layout = self.win.ci.layout # A plot area (ViewBox + axes) for displaying the image self.p3 = self.win.addPlot(row=0, col=0) self.p3.setMouseEnabled(x=False, y=False) self.p3.setMenuEnabled(False) self.p0 = self.win.addViewBox(name='plot1', lockAspect=True, row=1, col=0, invertY=True) self.p1 = self.win.addViewBox(lockAspect=True, row=1, col=1, invertY=True) self.p1.setMenuEnabled(False) self.p1.setXLink('plot1') self.p1.setYLink('plot1') self.p2 = self.win.addViewBox(lockAspect=True, row=1, col=2, invertY=True) self.p2.setMenuEnabled(False) self.p2.setXLink('plot1') self.p2.setYLink('plot1') self.img0 = pg.ImageItem() self.img1 = pg.ImageItem() self.img2 = pg.ImageItem() self.p0.addItem(self.img0) self.p1.addItem(self.img1) self.p2.addItem(self.img2) self.win.scene().sigMouseClicked.connect(self.plot_clicked) self.p4 = self.win.addPlot(row=0, col=1, colspan=2) self.p4.setMouseEnabled(x=False) self.p4.setMenuEnabled(False) self.PCedit = QtGui.QLineEdit(self) self.PCedit.setText('1') self.PCedit.setFixedWidth(40) self.PCedit.setAlignment(QtCore.Qt.AlignRight) self.PCedit.returnPressed.connect(self.plot_frame) self.PCedit.textEdited.connect(self.pause) qlabel = QtGui.QLabel('PC: ') boldfont = QtGui.QFont("Arial", 14, QtGui.QFont.Bold) bigfont = QtGui.QFont("Arial", 14) qlabel.setFont(boldfont) self.PCedit.setFont(bigfont) qlabel.setStyleSheet('color: white;') #qlabel.setAlignment(QtCore.Qt.AlignRight) self.l0.addWidget(QtGui.QLabel(''), 1, 0, 1, 1) self.l0.addWidget(qlabel, 2, 0, 1, 1) self.l0.addWidget(self.PCedit, 2, 1, 1, 1) self.nums = [] self.titles = [] for j in range(3): num1 = QtGui.QLabel('') num1.setStyleSheet('color: white;') self.l0.addWidget(num1, 3 + j, 0, 1, 2) self.nums.append(num1) t1 = QtGui.QLabel('') t1.setStyleSheet('color: white;') self.l0.addWidget(t1, 12, 4 + j * 4, 1, 2) self.titles.append(t1) self.loaded = False self.wraw = False self.wred = False self.wraw_wred = False self.l0.addWidget(QtGui.QLabel(''), 7, 0, 1, 1) self.l0.setRowStretch(7, 1) self.cframe = 0 self.createButtons() self.nPCs = 50 self.PCedit.setValidator(QtGui.QIntValidator(1, self.nPCs)) # play button self.updateTimer = QtCore.QTimer() self.updateTimer.timeout.connect(self.next_frame) #self.win.scene().sigMouseClicked.connect(self.plot_clicked) # if not a combined recording, automatically open binary if hasattr(parent, 'ops'): if parent.ops['save_path'][-8:] != 'combined': fileName = os.path.join(parent.basename, 'ops.npy') print(fileName) self.openFile(fileName)
def init_UI(self, num_plots=4): """Create all the widgets and position them in the layout""" self.centre_widget = QWidget() layout = QGridLayout() # make tabs for each main display self.centre_widget.setLayout(layout) self.setCentralWidget(self.centre_widget) font = QFont() font.setPixelSize(16) # make text size bigger #### menubar at top gives options #### menubar = self.menuBar() # file menubar allows you to save/load data file_menu = menubar.addMenu('File') load_im = QAction('Load Image', self) # display a loaded image load_im.triggered.connect(self.load_image) file_menu.addAction(load_im) make_im = QAction('Make average image', self) # from image files (using file browser) make_im.triggered.connect(self.make_ave_im) file_menu.addAction(make_im) pg.setConfigOption('background', 'w') # set graph background default white pg.setConfigOption('foreground', 'k') # set graph foreground default black # toggle to continuously plot images as they come in self.im_show_toggle = QPushButton('Auto-display last image', self) self.im_show_toggle.setCheckable(True) self.im_show_toggle.clicked[bool].connect(self.set_im_show) layout.addWidget(self.im_show_toggle, 0, 0, 1, 1) # number of ROIs chosen by user nrois_label = QLabel('Number of ROIs: ', self) layout.addWidget(nrois_label, 0, 1, 1, 1) self.nrois_edit = QLineEdit(str(len(self.rh.ROIs)), self) layout.addWidget(self.nrois_edit, 0, 2, 1, 1) self.nrois_edit.setValidator(int_validator) # reset the list of counts in each ROI displayed in the plots self.reset_button = QPushButton('Reset plots', self) self.reset_button.clicked.connect(self.reset_plots) layout.addWidget(self.reset_button, 0, 3, 1, 1) #### display image with ROIs #### im_widget = pg.GraphicsLayoutWidget() # containing widget viewbox = im_widget.addViewBox() # plot area to display image self.im_canvas = pg.ImageItem() # the image viewbox.addItem(self.im_canvas) layout.addWidget(im_widget, 1, 0, 9, 6) # update number of ROIs and display them when user inputs self.nrois_edit.textChanged[str].connect(self.display_rois) #### display plots of counts for each ROI #### self.plots = [] # plot to display counts history k = int(np.sqrt(num_plots)) for i in range(num_plots): pw = pg.PlotWidget() # main subplot of histogram self.plots.append({ 'plot': pw, 'counts': pw.plot(np.zeros(1000)), 'thresh': pw.addLine(y=1, pen='r') }) pw.getAxis('bottom').tickFont = font pw.getAxis('left').tickFont = font layout.addWidget(pw, 1 + (i // k) * 3, 7 + (i % k) * 6, 2, 6) # allocate space in the grid try: r = self.rh.ROIs[i] pw.setTitle('ROI ' + str(r.id)) # line edits with ROI x, y, w, h, threshold, auto update threshold for j, label in enumerate( list(r.edits.values()) + [r.threshedit, r.autothresh]): layout.addWidget(label, (i // k) * 3, 7 + (i % k) * 6 + j, 1, 1) except IndexError as e: pass # logger.warning('Atom Checker has more plots than ROIs') self.display_rois() # put ROIs on the image #### extra buttons #### # send the ROIs used here to the image analysis settings window self.roi_matching = QPushButton('Send ROIs to analysis', self) self.roi_matching.clicked.connect(self.send_rois) layout.addWidget(self.roi_matching, 2 + num_plots // k * 3, 7, 1, 1) # the user can trigger the experiment early by pressing this button self.trigger_button = QPushButton('Manual trigger experiment', self) self.trigger_button.clicked.connect(self.send_trigger) layout.addWidget(self.trigger_button, 2 + num_plots // k * 3, 8, 1, 1) # get ROI coordinates by fitting to image for i, label in enumerate( ['Single ROI', 'Square grid', '2D Gaussian masks']): button = QPushButton(label, self) button.clicked.connect(self.make_roi_grid) button.resize(button.sizeHint()) layout.addWidget(button, 2 + num_plots // k * 3, 9 + i, 1, 1) button = QPushButton('Display masks', self) # button to display masks button.clicked.connect(self.show_ROI_masks) button.resize(button.sizeHint()) layout.addWidget(button, 2 + num_plots // k * 3, 9 + i + 1, 1, 1) # maximum duration to wait for timeout_label = QLabel('Timeout (s): ', self) layout.addWidget(timeout_label, 2 + num_plots // k * 3, 9 + i + 2, 1, 1) self.timeout_edit = QLineEdit('0', self) self.timeout_edit.setValidator(int_validator) self.timeout_edit.textEdited[str].connect(self.change_timeout) layout.addWidget(self.timeout_edit, 2 + num_plots // k * 3, 9 + i + 3, 1, 1) # self.setWindowTitle(self.name + ' - Atom Checker -') self.setWindowIcon(QIcon('docs/atomcheckicon.png'))