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'))
