def initUI(self):
custom_vb = xrftomo.CustomViewBox()
# custom_vb.disableAutoRange(axis="xy")
# custom_vb.setRange(xRange=(0,1), yRange=(0,1), padding=0)
# custom_vb.invertY(True)
#___________________ scatter view ___________________
self.p1 = self.addPlot(viewBox=custom_vb, enableMouse=False)
self.p1.setAutoPan(x=None, y=None)
# self.p1.setYRange(0,1)
# self.p1.setXRange(0,1)
self.plotView = pyqtgraph.ScatterPlotItem()
self.plotView2 = pyqtgraph.ScatterPlotItem()
# self.ROI = pyqtgraph.LineSegmentROI(positions=([0,0],[1,1]), pos=[0,0], movable=False, maxBounds=QtCore.QRectF(0, 0, 1, 1))
self.ROI = pyqtgraph.LineSegmentROI(positions=([0, 0], [1000, 1000]),
pos=[0, 0],
movable=False)
self.ROI.sigRegionChangeFinished.connect(self.roi_dragged)
self.p1.addItem(self.plotView)
self.p1.addItem(self.plotView2)
self.p1.addItem(self.ROI)
self.p1.scene().sigMouseMoved.connect(self.mouseMoved)
self.p1.scene().sigMouseClicked.connect(self.mouseClick)
self.p1.setMouseEnabled(x=False, y=False)
self.p1.vb = custom_vb
def initialize(self, orientation=None):
""" Emits :signal: `sig_initialized`. """
logger.debug('initialize()')
# Change the orientation if one is given
if orientation:
self.orientation = orientation
# Remove the old LineSegmentROI if necessary
self.plot.removeItem(self.roi)
# Put a new LineSegmentROI in the center of the plot in the right
# orientation
lower_left, upper_right = self.calculate_endpoints()
self.roi = pg.LineSegmentROI(positions=[lower_left, upper_right],
pen='m')
# self.roi.setPos(lower_left)
self.plot.addItem(self.roi, ignoreBounds=True)
# Reconnect signal handling
# Wrap the LineSegmentROI's sigRegionChanged
self.sig_region_changed = self.roi.sigRegionChanged
# self.plot.sig_axes_changed.connect(self.initialize)
logger.info('Emitting sig_initialized.')
self.sig_initialized.emit()
def init_plot_area(self):
win2 = pg.GraphicsLayoutWidget() #title="Camera")
win2.setWindowTitle('Camera')
self.imv = pg.ImageItem(np.random.normal(size=(4096, 3000)))
imv = self.imv
view = pg.ViewBox()
view.setAspectLocked(True)
view.addItem(imv)
self.roi = pg.LineSegmentROI([[10, 10], [100, 100]], pen='r')
self.roi.sigRegionChanged.connect(self.update_cut)
view.addItem(self.roi)
win2.addItem(view)
hist = pg.HistogramLUTItem()
hist.setImageItem(imv)
hist.setLevels(0, 2**8) # 2**12)
win2.addItem(hist)
win2.nextRow()
self.p2 = win2.addPlot(colspan=2)
self.p2.setMaximumHeight(250)
self.win2 = win2
def __init__(self, data, title=None):
PgDataPlot.__init__(self, data)
self.dim = self._data[0].output_data.shape
self.win = pg.QtGui.QMainWindow()
self.win.resize(800, 800)
self.win.setWindowTitle("PgSlicePlot: {}".format(title))
self.cw = pg.QtGui.QWidget()
self.win.setCentralWidget(self.cw)
self.l = pg.QtGui.QGridLayout()
self.cw.setLayout(self.l)
self.image_view = pg.ImageView(name="img_view")
self.l.addWidget(self.image_view, 0, 0)
self.slice_view = pg.PlotWidget(name="slice")
self.l.addWidget(self.slice_view)
self.win.show()
# self.imv2 = pg.ImageView()
# self.l.addWidget(self.imv2, 1, 0)
self.roi = pg.LineSegmentROI(
[[0, self.dim[1] - 1], [self.dim[0] - 1, self.dim[1] - 1]],
pen='r')
self.image_view.addItem(self.roi)
self.image_view.setImage(self._data[0].output_data)
def lineProfile(self):
if self.lineROI is None:
self.lineROI = pg.LineSegmentROI([[10, 64], [120, 64]], pen='r')
self.vb.addItem(self.lineROI)
self.lplotWidget.show()
else:
self.vb.removeItem(self.lineROI)
self.lineROI = pg.LineSegmentROI([[10, 64], [120, 64]], pen='r')
self.vb.addItem(self.lineROI)
self.lineROI.sigRegionChanged.connect(self.updateLineProfile)
def addROI(self, start, stop):
self.roi = pg.LineSegmentROI((start, stop),
movable=True,
removable=True)
self.addItem(self.roi)
self.roi.sigRemoveRequested.connect(self.removeROI)
self.roi.sigRegionChanged.connect(self.updatePlot)
self.roi.sigClicked.connect(self.setWinFocus)
def add_lin_ROI(self, status, a_str, a_end, e_str, e_end, e_w, a_w, iv):
if status:
roi_edc = pg.LineSegmentROI(
[[e_str, (a_str + a_end) / 2], [e_end, (a_str + a_end) / 2]],
pen='r',
removable=True)
iv.addItem(roi_edc)
roi_mdc = pg.LineSegmentROI(
[[(e_str + e_end) / 2, a_str], [(e_str + e_end) / 2, a_end]],
pen='b',
removable=True)
iv.addItem(roi_mdc)
else:
print(iv.getRoiPlot)
iv.getRoiPlot.removeSegment()
iv.removeItem(iv.getRoiPlot)
def __init__(self,nr=0,*args,**kwargs):
super().__init__(*args,**kwargs)
self.setAcceptDrops(True)
self.nrotation = 0
l = QtGui.QGridLayout()
self.setLayout(l)
self.win = pg.GraphicsWindow()
self.axis_order = np.array([0,1,2])
w1 = self.win.addLayout(row=0, col=0)
self.plot = w1.addViewBox(row=1, col=0, lockAspect=True)
self.plot.disableAutoRange('xy')
self.imv1 = pg.ImageItem()
self.plot.addItem(self.imv1)
"""
self.plot = self.win.addPlot(lockAspect=True)
self.imv1 = pg.ImageItem(lockAspect=True)
self.plot.addItem(self.imv1)"""
#self.imv1.setResizable(False)
self.psizes = None
self.loadButton = QtGui.QPushButton("Load")
self.loadButton.clicked.connect(self.load_prompt)
self.dataset_name = "example data"
self.datasetLabel = QtGui.QLineEdit(self.dataset_name)
def update_name():
self.dataset_name = self.datasetLabel.text()
self.datasetLabel.editingFinished.connect(update_name)
l.addWidget(self.win, 1, 0,2,2)
l.addWidget(self.loadButton,0,0)
l.addWidget(self.datasetLabel,0,1)
self.imageNumber = nr
self.roi = pg.LineSegmentROI([[10, 64], [120,64]], pen='r')
#if self.imageNumber==0:
self.plot.addItem(self.roi)
x1 = np.linspace(-30, 10, 128)[:, np.newaxis, np.newaxis]
x2 = np.linspace(-20, 20, 128)[:, np.newaxis, np.newaxis]
y = np.linspace(-30, 10, 128)[np.newaxis, :, np.newaxis]
z = np.linspace(-20, 20, 128)[np.newaxis, np.newaxis, :]
d1 = np.sqrt(x1**2 + y**2 + z**2)
d2 = 2*np.sqrt(x1[::-1]**2 + y**2 + z**2)
d3 = 4*np.sqrt(x2**2 + y[:,::-1]**2 + z**2)
self.data = (np.sin(d1) / d1**2) + (np.sin(d2) / d2**2) + (np.sin(d3) / d3**2)
self.all_data = self.data.copy()
self.data = self.data[:,:,0]
self.slice=np.ones(3)
self.roi.sigRegionChanged.connect(self.update_roi_master)
## Display the data
self.imv1.setImage(self.data)
self.plot.autoRange()
def annotate_maxima(image, feature):
image = np.moveaxis(image, -1, 0) # x,y,z ---> z,x,y
pg.mkQApp()
window = pg.GraphicsLayoutWidget()
p1 = window.addPlot(row=1, col=0, rowspan=3)
p1.setPreferredHeight(1)
p2 = window.addPlot(row=4, col=0, rowspane=1)
p2.setXRange(0, len(image))
vline = pg.LineSegmentROI([[1, 0], [1, 10]], pen='r') # vertical line
p2.addItem(vline)
axis = pg.ScatterPlotItem()
canvas = pg.ImageItem()
region = pg.LinearRegionItem()
region.setRegion([0, 2])
p2.addItem(region)
feature = feature.T
def vline_update():
z = int(vline.pos()[0])
z = (z > 0) * z
z = (z < len(image)) * z + (z >= len(image) * len(image) - 1)
refresh_image(canvas, image, z)
lower, upper = region.getRegion()
rw = upper - lower # region_width
region.setRegion([z - rw / 2, z + rw / 2])
def region_update():
lower, upper = region.getRegion()
lower = int(lower)
upper = int(upper)
refresh_scatter(axis,
feature,
upper,
lower,
size=10,
brush=pg.mkBrush(color=(255, 0, 0, 255)))
refresh_scatter(axis,
feature,
0,
1,
size=10,
brush=pg.mkBrush(color=(255, 0, 0, 255)))
refresh_image(canvas, image, 1)
vline.sigRegionChanged.connect(vline_update)
region.sigRegionChanged.connect(region_update)
p1.addItem(axis)
p1.addItem(canvas)
canvas.setZValue(-100)
window.resize(800, 800)
window.show()
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
def __init__(self):
self.imv1 = pg.ImageView()
self.imv2 = pg.ImageView()
self.cross_section = pg.GraphicsWindow()
self.slice_plot = self.cross_section.addPlot()
self.roi = pg.LineSegmentROI([[0, 50], [100, 50]], pen='r')
self.xDim = None
self.yDim = None
self.image = None
self.vox_model = None
self.roi.sigRegionChanged.connect(self.update_cross_section)
def click(self, event):
event.accept()
pos = event.pos()
modifiers = QtGui.QApplication.keyboardModifiers()
if self.man_active_flag == 1:
if modifiers == QtCore.Qt.ShiftModifier:
if self.c_count - 2 * (self.c_count / 2) == 0:
self.pos1 = pos
else:
self.roi = pg.LineSegmentROI([self.pos1, pos], pen='r')
self.framepp1.addItem(self.roi)
self.c_count += 1
def addSegment(self, h1, h2, index=None):
seg = pg.LineSegmentROI(handles=(h1, h2),
pen=self.pen,
parent=self,
movable=False)
if index is None:
self.segments.append(seg)
else:
self.segments.insert(index, seg)
#seg.sigClicked.connect(self.segmentClicked)
#seg.setAcceptedMouseButtons(QtCore.Qt.LeftButton)
seg.setZValue(self.zValue() + 1)
for h in seg.handles:
h['item'].setDeletable(False)
def addSegment(self, h1, h2, index=None):
seg = pg.LineSegmentROI(handles=(h1, h2), pen=self.pen, parent=self, movable=False)
if index is None:
self.segments.append(seg)
else: #transform image
#self.transformPlt = pg.PlotItem()
#self.ui.transformImage.setCentralItem(self.transformPlt)
#self.transformImage = pg.ImageItem()
#self.transformPlt.addItem(self.transformImage)
self.segments.insert(index, seg)
#seg.sigClicked.connect(self.segmentClicked)
#seg.setAcceptedMouseButtons(QtCore.Qt.LeftButton)
seg.setZValue(self.zValue()+1)
for h in seg.handles:
h['item'].setDeletable(False)
def __init__(self, *args, **kwargs):
if kwargs.get("view", None) is None:
kwargs["view"] = pg.PlotItem()
self.plotWidget = FakePlotWidget()
self.plotWidget.plotItem = kwargs["view"]
super(ImageViewWithPlotItemContainer, self).__init__(*args, **kwargs)
self.timeLine.setPen(pg.mkPen('k'))
auto = self.ui.histogram.item.vb.menu.addAction("Autoscale Histogram")
auto.triggered.connect(
lambda: self.ui.histogram.item.imageChanged(True))
self.view.removeItem(self.roi)
self.roi = pg.LineSegmentROI([(0, 0), (0, 10)])
self.roi.setZValue(20)
self.view.addItem(self.roi)
self.roi.hide()
self.roi.sigRegionChanged.connect(self.roiChanged)
self.roiCurve.setPen('k')
def setROIType(self, t): #{
logging.debug('setROIType()')
if bool(self.roi): #{
logging.debug('removing current roi')
self.img_view_box.removeItem(self.roi)
#}
logging.debug('roi is now of type ' + t)
if (t == 'N'): #{
self.roi = None
self.plt_itm.clear()
if bool(self.plt): #{
self.plt_itm.clear()
self.plt = self.plt_itm.plot()
#}
self.plt_itm.setTitle('Image Histogram')
y, x = np.histogram(self.img, 256)
self.plt_itm.plot(x, y, stepMode=True)
elif (t == 'L'): #}{
self.roi = pg.LineSegmentROI(
[[self.obj2d_org[0], self.obj2d_org[1]], [20, 20]], pen=(0, 9))
self.roi.sigRegionChanged.connect(self.updateROI)
self.img_view_box.addItem(self.roi)
if bool(self.plt): #{
self.plt_itm.clear()
self.plt = self.plt_itm.plot()
#}
self.plt_itm.setTitle('Line Profile')
elif (t == 'R'): #}{
self.roi = pg.RectROI([self.obj2d_org[0], self.obj2d_org[1]],
[20, 20],
pen=(0, 9))
self.roi.sigRegionChanged.connect(self.updateROI)
self.img_view_box.addItem(self.roi)
if bool(self.plt): #{
self.plt_itm.clear()
self.plt = self.plt_itm.plot()
#}
self.plt_itm.setTitle('ROI Histogram')
#}
self.roi_type = t
def initUI(self):
# A plot area (ViewBox + axes) for displaying the image
plot_area = self.addPlot(lockAspect=True)
# Item for displaying image data
self.image_view = pg.ImageItem()
plot_area.addItem(self.image_view)
# Isocurve drawing
self.iso_curve = pg.IsocurveItem(level=0.8, pen='g')
self.iso_curve.setParentItem(self.image_view)
self.iso_curve.setZValue(5)
# Contrast/color control
self.hist = pg.HistogramLUTItem()
self.hist.setImageItem(self.image_view)
self.addItem(self.hist)
# Draggable line for setting isocurve level
self.iso_line = pg.InfiniteLine(angle=0, movable=True, pen='g')
self.iso_line.setValue(0.8)
self.iso_line.setZValue(1000) # bring iso line above contrast controls
self.iso_line.sigDragged.connect(self.updateIsoCurve)
self.hist.vb.addItem(self.iso_line)
self.hist.vb.setMouseEnabled(y=False)
self.nextRow()
self.line_plot = self.addPlot(colspan=2)
self.line_plot.plot((0, 100), (0, 150))
self.roi = pg.LineSegmentROI([[0, 0], [100, 150]], pen=(5, 9))
self.roi.setZValue(10)
plot_area.addItem(self.roi)
self.roi.sigRegionChanged.connect(self.update_roi)
def linecut(self):
"""
toggles the line cut
"""
self.viewbox.removeItem(self.region)
self.parentwindow.difftoolbar.actionVertical_Cut.setChecked(False)
self.parentwindow.difftoolbar.actionHorizontal_Cut.setChecked(False)
if self.parentwindow.difftoolbar.actionLine_Cut.isChecked():
self.region = pg.LineSegmentROI(
[[
self.dimg.experiment.getvalue('Center X'),
self.dimg.experiment.getvalue('Center Y')
],
[
self.dimg.experiment.getvalue('Center X'),
self.dimg.data.shape[0]
]])
self.viewbox.addItem(self.region)
self.replot()
self.region.sigRegionChanged.connect(self.replot)
else:
self.region = None
self.replot()
return
## Create window with two ImageView widgets
win = QtWidgets.QMainWindow()
win.resize(800, 800)
win.setWindowTitle('pyqtgraph example: DataSlicing')
cw = QtWidgets.QWidget()
win.setCentralWidget(cw)
l = QtWidgets.QGridLayout()
cw.setLayout(l)
imv1 = pg.ImageView()
imv2 = pg.ImageView()
l.addWidget(imv1, 0, 0)
l.addWidget(imv2, 1, 0)
win.show()
roi = pg.LineSegmentROI([[10, 64], [120, 64]], pen='r')
imv1.addItem(roi)
x1 = np.linspace(-30, 10, 128)[:, np.newaxis, np.newaxis]
x2 = np.linspace(-20, 20, 128)[:, np.newaxis, np.newaxis]
y = np.linspace(-30, 10, 128)[np.newaxis, :, np.newaxis]
z = np.linspace(-20, 20, 128)[np.newaxis, np.newaxis, :]
d1 = np.sqrt(x1**2 + y**2 + z**2)
d2 = 2 * np.sqrt(x1[::-1]**2 + y**2 + z**2)
d3 = 4 * np.sqrt(x2**2 + y[:, ::-1]**2 + z**2)
data = (np.sin(d1) / d1**2) + (np.sin(d2) / d2**2) + (np.sin(d3) / d3**2)
def update():
global data, imv1, imv2
d2 = roi.getArrayRegion(data, imv1.imageItem, axes=(1, 2))
def computeParameters(self, dt_audio=1/80000, dt_video=1/4000, debug=False):
"""Compute parameters from GAW
:param dt_audio: audio sampling time in seconds, defaults to 1/80000
:type dt_audio: float, optional
:param dt_video: video sampling time in seconds, defaults to 1/4000
:type dt_video: float, optional
:param debug: shows debugging information and plots, defaults to False
:type debug: bool, optional
"""
# Convert raw segmentations to binary masks
seg = np.asarray(self.segmentations).round().astype(np.bool)
# Predict midline from segmentation
M = Midline(seg)
M.predict()
# Use midline for left and right GAW
gaws = M.side()
left_gaw = gaws[..., 0]
right_gaw = gaws[..., 1]
# Compute and show values
gaw = GAW(seg.sum((1,2)),
use_filtered_signal=False,
use_hanning=False,
dt=dt_video)
gaw.setLeftRightGAW(left_gaw, right_gaw)
params_GAW = gaw.computeParameters()
# Create summary table for parameters
self.t = Table(params_GAW, title="GAW parameters")
self.t.show()
if debug:
# Show complete segmentation with midline
im = pg.image(seg.transpose(0, 2, 1),
title="Segmentation with midline")
line = pg.LineSegmentROI([M.coordinates[0, :2],
M.coordinates[0, 2:],],
pen="y")
im.getView().addItem(line)
# Show complete GAW plot with detected cycles
gaw_plot = pg.plot(gaw.t, gaw.raw_signal,
title="GAW with cycles")
cs = [(241, 196, 15), (231, 76, 60)]
i = 0
for o, c in zip(gaw.opening, gaw.closing):
i1 = pg.PlotCurveItem(gaw.t[o:c], np.zeros_like(gaw.t[o:c]))
i2 = pg.PlotCurveItem(gaw.t[o:c], gaw.raw_signal[o:c])
between = pg.FillBetweenItem(i1, i2, brush=cs[i % len(cs)])
gaw_plot.getPlotItem().addItem(between)
i += 1
# Show left and right gaw
LR_plot = pg.plot(title="Left and right GAW")
LR_plot.plot(gaw.t, left_gaw)
LR_plot.plot(gaw.t, -right_gaw)
# Compute and show phonovibrogram
pvg = M.pvg()
pg.image(pvg, title="Phonovibrogram")
# If audio data is available
if type(self.synced_audio) != type(None):
if debug:
pg.plot(self.synced_audio,
title="Synchronized audio")
a = Audio(self.synced_audio,
dt=dt_audio)
params_Audio = a.computeParameters()
self.t2 = Table(params_Audio, title="Audio parameters")
self.t2.show()
else:
params_Audio = None
return dict(GAW=params_GAW, Audio=params_Audio)
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.setEnabled(True)
MainWindow.resize(793, 498)
font = QtGui.QFont()
font.setBold(False)
font.setWeight(50)
MainWindow.setFont(font)
MainWindow.setMouseTracking(False)
MainWindow.setAcceptDrops(False)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("body.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
MainWindow.setWindowIcon(icon)
MainWindow.setToolTip(_fromUtf8(""))
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.gridLayout = QtGui.QGridLayout(self.centralwidget)
self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
self.graphicsView = QtGui.QGraphicsView(self.centralwidget)
self.graphicsView.setObjectName(_fromUtf8("graphicsView"))
self.gridLayout.addWidget(self.graphicsView, 0, 1, 1, 1)
self.line = QtGui.QFrame(self.centralwidget)
self.line.setFrameShape(QtGui.QFrame.HLine)
self.line.setFrameShadow(QtGui.QFrame.Sunken)
self.line.setObjectName(_fromUtf8("line"))
self.gridLayout.addWidget(self.line, 2, 0, 1, 1)
self.lcdNumber = QtGui.QLCDNumber(self.centralwidget)
self.lcdNumber.setObjectName(_fromUtf8("lcdNumber"))
self.gridLayout.addWidget(self.lcdNumber, 0, 0, 1, 1)
self.pushButton = QtGui.QPushButton(self.centralwidget)
self.pushButton.setCheckable(False)
self.pushButton.setAutoDefault(False)
self.pushButton.setDefault(False)
self.pushButton.setFlat(False)
self.pushButton.setObjectName(_fromUtf8("pushButton"))
self.gridLayout.addWidget(self.pushButton, 2, 1, 1, 1)
self.verticalSlider = QtGui.QSlider(self.centralwidget)
self.verticalSlider.setOrientation(QtCore.Qt.Vertical)
self.verticalSlider.setObjectName(_fromUtf8("verticalSlider"))
self.gridLayout.addWidget(self.verticalSlider, 3, 0, 1, 1)
self.gridLayout_2 = QtGui.QGridLayout()
self.gridLayout_2.setObjectName(_fromUtf8("gridLayout_2"))
self.comboBox = QtGui.QComboBox(self.centralwidget)
self.comboBox.setObjectName(_fromUtf8("comboBox"))
self.gridLayout_2.addWidget(self.comboBox, 2, 0, 1, 1)
self.groupBox = QtGui.QGroupBox(self.centralwidget)
self.groupBox.setObjectName(_fromUtf8("groupBox"))
self.toolBox = QtGui.QToolBox(self.groupBox)
self.toolBox.setGeometry(QtCore.QRect(40, 0, 171, 123))
self.toolBox.setObjectName(_fromUtf8("toolBox"))
self.page = QtGui.QWidget()
self.page.setGeometry(QtCore.QRect(0, 0, 171, 69))
self.page.setObjectName(_fromUtf8("page"))
self.toolBox.addItem(self.page, _fromUtf8(""))
self.page_2 = QtGui.QWidget()
self.page_2.setGeometry(QtCore.QRect(0, 0, 171, 69))
self.page_2.setObjectName(_fromUtf8("page_2"))
self.toolBox.addItem(self.page_2, _fromUtf8(""))
self.gridLayout_2.addWidget(self.groupBox, 5, 0, 1, 1)
self.frame = QtGui.QFrame(self.centralwidget)
self.frame.setFrameShape(QtGui.QFrame.StyledPanel)
self.frame.setFrameShadow(QtGui.QFrame.Raised)
self.frame.setObjectName(_fromUtf8("frame"))
self.gridLayout_2.addWidget(self.frame, 6, 0, 1, 1)
self.tableView = QtGui.QTableView(self.centralwidget)
self.tableView.setObjectName(_fromUtf8("tableView"))
self.gridLayout_2.addWidget(self.tableView, 1, 0, 1, 1)
self.areuok = QtGui.QCheckBox(self.centralwidget)
self.areuok.setObjectName(_fromUtf8("areuok"))
self.gridLayout_2.addWidget(self.areuok, 10, 0, 1, 1)
self.listView = QtGui.QListView(self.centralwidget)
self.listView.setObjectName(_fromUtf8("listView"))
self.gridLayout_2.addWidget(self.listView, 9, 0, 1, 1)
self.columnView = QtGui.QColumnView(self.centralwidget)
self.columnView.setObjectName(_fromUtf8("columnView"))
self.gridLayout_2.addWidget(self.columnView, 3, 0, 1, 1)
self.tableWidget = QtGui.QTableWidget(self.centralwidget)
self.tableWidget.setObjectName(_fromUtf8("tableWidget"))
self.tableWidget.setColumnCount(0)
self.tableWidget.setRowCount(0)
self.gridLayout_2.addWidget(self.tableWidget, 8, 0, 1, 1)
self.textEdit = QtGui.QTextEdit(self.centralwidget)
self.textEdit.setObjectName(_fromUtf8("textEdit"))
self.gridLayout_2.addWidget(self.textEdit, 7, 0, 1, 1)
self.gridLayout.addLayout(self.gridLayout_2, 3, 1, 1, 1)
self.line_2 = QtGui.QFrame(self.centralwidget)
self.line_2.setFrameShape(QtGui.QFrame.VLine)
self.line_2.setFrameShadow(QtGui.QFrame.Sunken)
self.line_2.setObjectName(_fromUtf8("line_2"))
self.gridLayout.addWidget(self.line_2, 1, 1, 1, 1)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 793, 21))
self.menubar.setObjectName(_fromUtf8("menubar"))
self.menuFile = QtGui.QMenu(self.menubar)
self.menuFile.setObjectName(_fromUtf8("menuFile"))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.dockWidget = QtGui.QDockWidget(MainWindow)
self.dockWidget.setObjectName(_fromUtf8("dockWidget"))
self.dockWidgetContents = QtGui.QWidget()
self.dockWidgetContents.setObjectName(_fromUtf8("dockWidgetContents"))
self.dockWidget.setWidget(self.dockWidgetContents)
MainWindow.addDockWidget(QtCore.Qt.DockWidgetArea(8), self.dockWidget)
self.actionSave = QtGui.QAction(MainWindow)
self.actionSave.setObjectName(_fromUtf8("actionSave"))
self.actionOpen = QtGui.QAction(MainWindow)
self.actionOpen.setObjectName(_fromUtf8("actionOpen"))
self.actionExit = QtGui.QAction(MainWindow)
self.actionExit.setObjectName(_fromUtf8("actionExit"))
self.menuFile.addAction(self.actionSave)
self.menuFile.addAction(self.actionOpen)
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionExit)
self.menubar.addAction(self.menuFile.menuAction())
imv1 = pg.ImageView()
self.gridLayout.addWidget(imv1, 2, 1, 1, 1)
roi = pg.LineSegmentROI([[10, 64], [120,64]], pen='r')
imv1.addItem(roi)
x1 = np.linspace(-30, 10, 128)[:, np.newaxis, np.newaxis]
x2 = np.linspace(-20, 20, 128)[:, np.newaxis, np.newaxis]
y = np.linspace(-30, 10, 128)[np.newaxis, :, np.newaxis]
z = np.linspace(-20, 20, 128)[np.newaxis, np.newaxis, :]
d1 = np.sqrt(x1**2 + y**2 + z**2)
d2 = 2*np.sqrt(x1[::-1]**2 + y**2 + z**2)
d3 = 4*np.sqrt(x2**2 + y[:,::-1]**2 + z**2)
data = (np.sin(d1) / d1**2) + (np.sin(d2) / d2**2) + (np.sin(d3) / d3**2)
def update(self):
global data, imv1, imv2
d2 = roi.getArrayRegion(data, imv1.imageItem, axes=(1,2))
imv2.setImage(d2)
# roi.sigRegionChanged.connect(self.update())
## Display the data
imv1.setImage(data)
imv1.setHistogramRange(-0.01, 0.01)
imv1.setLevels(-0.003, 0.003)
# self.update()
self.retranslateUi(MainWindow)
self.toolBox.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
#add time slider
slider1 = QtGui.QSlider(QtCore.Qt.Horizontal)
slider1.setFocusPolicy(QtCore.Qt.StrongFocus)
slider1.setTickPosition(QtGui.QSlider.TicksBothSides)
slider1.setMinimum(0)
slider1.setMaximum(nVols)
slider1.setTickInterval(1)
slider1.setSingleStep(1)
d5.addWidget(slider1)
#display window
win.show()
#define single line roi
roi1 = pg.LineSegmentROI([[10, 64], [120, 64]], pen='r')
imv1.addItem(roi1)
#define crosshair rois
roi2 = pg.LineSegmentROI([[0, 0], [width, 0]],
pen='y',
maxBounds=QtCore.QRect(0, 0, 0, height))
imv1.addItem(roi2)
roi3 = pg.LineSegmentROI([[0, 0], [0, height]],
pen='y',
maxBounds=QtCore.QRect(0, 0, width, 0))
imv1.addItem(roi3)
#define update calls for each roi
l.addWidget(imv1, 0, 0)
l.addWidget(imv2, 1, 0)
# Create jet colormap
jet_rgba = np.load('jet.npy')
jet_vals = np.linspace(0, 1, 256)
jet_cmap = pg.ColorMap(jet_vals, jet_rgba)
jet_lut = jet_cmap.getLookupTable(0.0, 1.0, 256)
imv1.ui.histogram.gradient.setColorMap(jet_cmap)
imv2.ui.histogram.gradient.setColorMap(jet_cmap)
# imv1.getImageItem().setLookupTable(jet_lut)
# imv2.getImageItem().setLookupTable(jet_lut)
win.show()
roi = pg.LineSegmentROI([[10, 10], [80, 80]], pen='r')
imv1.addItem(roi)
data = np.load('data_grid.npy')
def update():
global data, imv1, imv2
d2 = roi.getArrayRegion(data, imv1.imageItem, axes=(0, 2))
imv2.setImage(d2[:, ::-1])
roi.sigRegionChanged.connect(update)
## Display the data
imv1.setImage(data[:, 345 // 2, :])
def get_data3D(self, s):
file_name = s.text()
self.opened3D_wd_names.append(file_name)
MDIWindow.count = MDIWindow.count + 1
sub = QMdiSubWindow()
sub.resize(800, 800)
sub.setWindowTitle(file_name)
sub.setObjectName(file_name)
self.data3D_dict = ut.read_bin_multi_region(self.current_dir,
file_name[:-4])
E_axis = np.array([
self.data3D_dict['w_of'], self.data3D_dict['w_of'] +
self.data3D_dict['w'] * self.data3D_dict['w_dt']
])
A_axis = np.array([
self.data3D_dict['h_of'], self.data3D_dict['h_of'] +
self.data3D_dict['h'] * self.data3D_dict['h_dt']
])
D_axis = np.array([
self.data3D_dict['d_of'], self.data3D_dict['d_of'] +
self.data3D_dict['d'] * self.data3D_dict['d_dt']
])
a_max = np.max(np.abs(np.concatenate((A_axis, D_axis), axis=None)))
asscale, ascale, escale = self.data3D_dict['d_dt'], self.data3D_dict[
'h_dt'], self.data3D_dict['w_dt']
cw = QWidget()
l = QGridLayout()
cw.setLayout(l)
sub.setWidget(cw)
self.ui.mdi.addSubWindow(sub)
sub.show()
plt1 = pg.PlotItem(labels={
'bottom': ('slits', 'degrees'),
'left': ('deflector', 'degrees')
})
imv1 = pg.ImageView(view=plt1)
plt1.setAspectLocked(False)
plt1.setRange(xRange=[-a_max, a_max],
yRange=[-a_max, a_max],
padding=0)
vb1 = plt1.getViewBox()
vb1.setMouseMode(vb1.RectMode)
print('vb1 rectg: {}'.format(vb1.screenGeometry()))
histo1 = vb1.menu.addAction('histogram')
no_histo1 = vb1.menu.addAction('no histogram')
no_histo1.triggered.connect(imv1.ui.histogram.hide)
histo1.triggered.connect(imv1.ui.histogram.show)
plt2 = pg.PlotItem(labels={
'bottom': ('slits', 'degrees'),
'left': ('Kin. Energy', 'eV')
})
imv2 = pg.ImageView(view=plt2)
plt2.setAspectLocked(False)
plt2.invertY(False)
plt2.setRange(xRange=[-a_max, a_max], yRange=[E_axis[0], E_axis[-1]])
vb2 = plt2.getViewBox()
vb2.setMouseMode(vb2.RectMode)
histo2 = vb2.menu.addAction('histogram')
no_histo2 = vb2.menu.addAction('no histogram')
no_histo2.triggered.connect(imv2.ui.histogram.hide)
histo2.triggered.connect(imv2.ui.histogram.show)
plt3 = pg.PlotItem(labels={
'bottom': ('Kin. Energy', 'eV'),
'left': ('deflector', 'degrees')
})
imv3 = pg.ImageView(view=plt3)
plt3.setAspectLocked(False)
plt3.setRange(xRange=[E_axis[0], E_axis[-1]], yRange=[-a_max, a_max])
vb3 = plt3.getViewBox()
vb3.setMouseMode(vb3.RectMode)
histo3 = vb3.menu.addAction('histogram')
no_histo3 = vb3.menu.addAction('no histogram')
no_histo3.triggered.connect(imv3.ui.histogram.hide)
histo3.triggered.connect(imv3.ui.histogram.show)
hlayout = QHBoxLayout()
hlayout.addWidget(imv1.ui.histogram)
hlayout.addWidget(imv2.ui.histogram)
hlayout.addWidget(imv3.ui.histogram)
hist_wdg = QWidget()
hist_wdg.setLayout(hlayout)
l.addWidget(imv2, 0, 0)
l.addWidget(imv1, 1, 0)
l.addWidget(imv3, 1, 1)
l.addWidget(hist_wdg, 0, 1)
roi2 = pg.LineSegmentROI([[A_axis[0], (D_axis[0] + D_axis[-1]) / 2],
[A_axis[-1], (D_axis[0] + D_axis[-1]) / 2]],
pen='r')
imv1.addItem(roi2)
roi3 = pg.LineSegmentROI([[(A_axis[0] + A_axis[1]) / 2, D_axis[0]],
[(A_axis[0] + A_axis[-1]) / 2, D_axis[-1]]],
pen='b')
imv1.addItem(roi3)
def update2():
d2 = roi2.getArrayRegion(self.data3D_dict['data'],
imv1.imageItem,
axes=(1, 2))
imv2.setImage(np.transpose(d2),
pos=[A_axis[0], E_axis[0]],
scale=[ascale, escale],
autoHistogramRange=False)
# imv2.ui.histogram.hide()
imv2.ui.roiBtn.hide()
imv2.ui.menuBtn.hide()
roi2.sigRegionChanged.connect(update2)
def update3():
d3 = roi3.getArrayRegion(self.data3D_dict['data'],
imv1.imageItem,
axes=(1, 2))
imv3.setImage(d3,
pos=[E_axis[0], D_axis[0]],
scale=[escale, asscale],
autoHistogramRange=False)
# imv3.ui.histogram.hide()
imv3.ui.roiBtn.hide()
imv3.ui.menuBtn.hide()
roi3.sigRegionChanged.connect(update3)
## Display the data
imv1.setImage(self.data3D_dict['data'], xvals=np.linspace(E_axis[0], E_axis[-1], self.data3D_dict['data'].shape[0]),\
pos=[A_axis[0], D_axis[0]], scale=[ascale, asscale])
imv1.setCurrentIndex(self.data3D_dict['data'].shape[0] // 2)
# imv1.ui.histogram.hide()
imv1.ui.roiBtn.hide()
imv1.ui.menuBtn.hide()
#imv1.setImage(data)
#imv1.setHistogramRange(-0.01, 0.01)
#imv1.setLevels(-0.003, 0.003)
update2()
update3()
win = QtGui.QMainWindow()
win.resize(800, 800)
win.setWindowTitle('pyqtgraph example: DataSlicing')
cw = QtGui.QWidget()
win.setCentralWidget(cw)
l = QtGui.QGridLayout()
cw.setLayout(l)
imv1 = pg.ImageView()
p = pg.plot()
curve = p.plot()
l.addWidget(imv1, 0, 0)
l.addWidget(p, 1, 0)
win.show()
if dir == 'x':
roi = pg.LineSegmentROI([[2, 50], [x.max() - 2, 50]], pen='r')
elif dir == 'y':
roi = pg.LineSegmentROI([[50, y.max() - 2], [50, 2]], pen='r')
imv1.addItem(roi)
def update():
global D, imv1, curve
d2 = roi.getArrayRegion(D, imv1.imageItem)
curve.setData(d2)
roi.sigRegionChanged.connect(update)
## Display the data
def on_activate(self):
""" Initializes all needed UI files and establishes the connectors.
"""
self._logic = self.camera_logic()
self._save_logic = self.savelogic()
# Windows
self._mw = CameraWindow()
self._mw.centralwidget.hide()
self._mw.setDockNestingEnabled(True)
self.initSettingsUI()
self._sd.exposureDSpinBox.setDecimals(5)
self._mw.start_video_Action.setEnabled(True)
self._mw.start_video_Action.setChecked(self._logic.enabled)
self._mw.start_video_Action.triggered.connect(self.start_video_clicked)
self._mw.start_image_Action.setEnabled(True)
self._mw.start_image_Action.setChecked(self._logic.enabled)
self._mw.start_image_Action.triggered.connect(self.start_image_clicked)
self._mw.action_toggle_cooling.toggled.connect(self.toggle_fan)
self._logic.sigUpdateDisplay.connect(self.update_data)
self._logic.sigAcquisitionFinished.connect(self.acquisition_finished)
self._logic.sigVideoFinished.connect(self.enable_start_image_action)
# starting the physical measurement
self.sigVideoStart.connect(self._logic.start_loop)
self.sigVideoStop.connect(self._logic.stop_loop)
self.sigImageStart.connect(self._logic.start_single_acquistion)
# connect Settings action under Options menu
self._mw.actionSettings.triggered.connect(self.menu_settings)
# connect save action to save function
self._mw.actionSave_XY_Scan.triggered.connect(self.save_xy_scan_data)
raw_data_image = self._logic.get_last_image()
# This allows the camera GUI to take care of a 3darray of images if the cam GUI is initialized after
# and ODMR measuremnt.
try:
if raw_data_image.ndim > 2:
raw_data_image = np.zeros(self._logic.get_sensor())
except BaseException:
pass
self._image = pg.ImageItem(image=raw_data_image, axisOrder='row-major')
self._mw.image_PlotWidget.addItem(self._image)
# Set ROI widget with default sensor size, snapping true and invisible color until and image is clicked.
# Extra scale handles are added as well.
# It has not been added to main window yet, so as to give a clean look when an image has not yet been
# clicked.
self.roi_p1 = self.roi_p2 = 0
self.roi_s1, self.roi_s2 = self._logic.get_sensor()
self.roi = pg.RectROI([self.roi_p1, self.roi_p2],
[self.roi_s1, self.roi_s2],
pen=(0, 0, 0, 0),
scaleSnap=True,
translateSnap=True,
maxBounds=QtCore.QRectF(self.roi_p1, self.roi_p2,
self.roi_s1,
self.roi_s2),
movable=False)
self.roi.handleSize = 12
self.roi.addScaleHandle((0, 1), (1, 0))
self.roi.addScaleHandle((0, 0), (1, 1))
self.roi.addScaleHandle((1, 0), (0, 1))
self.roi.addTranslateHandle((1, 1), (0, 0))
# self._mw.image_PlotWidget.addItem(self.roi)
self._mw.image_PlotWidget.setAspectLocked(True)
self.sigROISet.connect(self._logic.set_image_roi)
# ROI button actions
self._mw.DefaultRoi.clicked.connect(self.default_roi)
self._mw.SetRoi.clicked.connect(self.set_roi)
self._mw.DefaultRoi.setEnabled(False)
self._mw.SetRoi.setEnabled(False)
self._mw.image_PlotWidget.addItem(self.roi)
self.cross = pg.CrosshairROI(pos=(self.roi_s1 / 2, self.roi_s2 / 2),
size=(40, 40),
translateSnap=True,
rotateSnap=True,
maxBounds=QtCore.QRectF(0, 0, 1200, 1200))
self.cross.sigRegionChanged.connect(self.print_counts)
self._mw.image_PlotWidget.addItem(self.cross)
self.scaleBar = pg.LineSegmentROI(([0, 0], [100, 0]),
pen={
'color': "#E0D8D8",
'width': 3
})
self._mw.image_PlotWidget.addItem(self.scaleBar)
self.scaleBar.sigRegionChanged.connect(self.print_scale)
# Get the colorscale and set the LUTs
self.my_colors = ColorScaleInferno()
self._image.setLookupTable(self.my_colors.lut)
# Connect the buttons and inputs for the colorbar
self._mw.xy_cb_manual_RadioButton.clicked.connect(
self.update_xy_cb_range)
self._mw.xy_cb_centiles_RadioButton.clicked.connect(
self.update_xy_cb_range)
self._mw.xy_cb_min_DoubleSpinBox.valueChanged.connect(
self.shortcut_to_xy_cb_manual)
self._mw.xy_cb_max_DoubleSpinBox.valueChanged.connect(
self.shortcut_to_xy_cb_manual)
self._mw.xy_cb_low_percentile_DoubleSpinBox.valueChanged.connect(
self.shortcut_to_xy_cb_centiles)
self._mw.xy_cb_high_percentile_DoubleSpinBox.valueChanged.connect(
self.shortcut_to_xy_cb_centiles)
# create color bar
self.xy_cb = ColorBar(self.my_colors.cmap_normed,
width=100,
cb_min=0,
cb_max=100)
self.depth_cb = ColorBar(self.my_colors.cmap_normed,
width=100,
cb_min=0,
cb_max=100)
self._mw.xy_cb_ViewWidget.addItem(self.xy_cb)
self._mw.xy_cb_ViewWidget.hideAxis('bottom')
self._mw.xy_cb_ViewWidget.setLabel('left', 'Fluorescence', units='c')
self._mw.xy_cb_ViewWidget.setMouseEnabled(x=False, y=False)
})
imv3 = pg.ImageView(view=plt3)
#imv2.setImage(np.transpose(data[:,:,0]))
plt3.setAspectLocked(False)
#plt3.invertY(False)
#plt3.invertX(False)
#plt3.setRange(xRange=[E0,E1], yRange=[AS0,AS1],padding = 0)
plt3.setRange(xRange=[E0, E1], yRange=[-a_max, a_max])
l.addWidget(imv2, 0, 0)
l.addWidget(imv1, 1, 0)
l.addWidget(imv3, 1, 1)
win.show()
roi2 = pg.LineSegmentROI([[A0, (AS0 + AS1) / 2], [A1, (AS0 + AS1) / 2]],
pen='r')
imv1.addItem(roi2)
roi3 = pg.LineSegmentROI([[(A0 + A1) / 2, AS0], [(A0 + A1) / 2, AS1]], pen='b')
imv1.addItem(roi3)
def update2():
# global data, imv1, imv2, E0,A0,escale,ascale
d2 = roi2.getArrayRegion(data, imv1.imageItem, axes=(1, 2))
imv2.setImage(np.transpose(d2), pos=[A0, E0], scale=[asscale, escale])
imv2.ui.histogram.hide()
imv2.ui.roiBtn.hide()
imv2.ui.menuBtn.hide()
def __init__(self):
super().__init__()
self._ui = Ui_MainWindow()
self._ui.setupUi(self)
self.connx = createBridge.Connection()
### Connections for Days
# Select Slide Dropdown
self._ui.actionIbidi_8_Well.triggered.connect(self.loadIBIDISlide)
self._ui.selectedSlide_graphicsView.ui.menuBtn.hide()
self._ui.selectedSlide_graphicsView.ui.histogram.hide()
self._ui.selectedSlide_graphicsView.ui.roiBtn.hide()
self._ui.selectedSlide_graphicsView.view.setAspectLocked()
# Image Push Buttons
self._ui.snapTop_pushButton.clicked.connect(self.pressSnapTop)
self._ui.snapBottom_pushButton.clicked.connect(self.pressSnapBottom)
self._ui.snapLeft_pushButton.clicked.connect(self.pressSnapLeft)
self._ui.snapRight_pushButton.clicked.connect(self.pressSnapRight)
# Turn off default pyqtgraph visualization settings
# Top Image
self._ui.topImage_graphicsView.ui.histogram.hide()
self._ui.topImage_graphicsView.ui.roiBtn.hide()
self._ui.topImage_graphicsView.ui.menuBtn.hide()
self._ui.topImage_graphicsView.view.setAspectLocked()
self._ui.topImage_graphicsView.view.invertX()
self.roiTop = pg.LineSegmentROI([[10, 256], [492, 256]], pen='r')
self._ui.topImage_graphicsView.view.addItem(self.roiTop)
self.roiTop.sigRegionChangeFinished.connect(self.updateTop)
# Bottom Image
self._ui.bottomImage_graphicsView.ui.histogram.hide()
self._ui.bottomImage_graphicsView.ui.roiBtn.hide()
self._ui.bottomImage_graphicsView.ui.menuBtn.hide()
self._ui.bottomImage_graphicsView.view.setAspectLocked()
self._ui.bottomImage_graphicsView.view.invertX()
self.roiBottom = pg.LineSegmentROI([[10, 256], [492, 256]], pen='b')
self._ui.bottomImage_graphicsView.view.addItem(self.roiBottom)
self.roiBottom.sigRegionChangeFinished.connect(self.updateBottom)
# Left Image
self._ui.leftImage_graphicsView.ui.histogram.hide()
self._ui.leftImage_graphicsView.ui.roiBtn.hide()
self._ui.leftImage_graphicsView.ui.menuBtn.hide()
self._ui.leftImage_graphicsView.view.setAspectLocked()
self._ui.leftImage_graphicsView.view.invertX()
self.roiLeft = pg.LineSegmentROI([[256, 10], [256, 492]], pen='g')
self._ui.leftImage_graphicsView.view.addItem(self.roiLeft)
self.roiLeft.sigRegionChangeFinished.connect(self.updateLeft)
# right Image
self._ui.rightImage_graphicsView.ui.histogram.hide()
self._ui.rightImage_graphicsView.ui.roiBtn.hide()
self._ui.rightImage_graphicsView.ui.menuBtn.hide()
self._ui.rightImage_graphicsView.view.setAspectLocked()
self._ui.rightImage_graphicsView.view.invertX()
self.roiRight = pg.LineSegmentROI([[256, 10], [256, 492]], pen='y')
self._ui.rightImage_graphicsView.view.addItem(self.roiRight)
self.roiRight.sigRegionChangeFinished.connect(self.updateRight)
# Push Calculate Button
self._ui.runCalc_pushButton.clicked.connect(self.pressRunCalc)
# Push Slide ROIs Button
self._ui.ROIMap_pushButton.clicked.connect(self.pressCreateROImap)
def __init__(self, *args, **kwargs):
"""
Initialize the main window, set up all plots, and connect to defined buttons.
"""
super(MainWindow, self).__init__(*args, **kwargs)
uic.loadUi('Mainwindow.ui', self)
self.setWindowIcon(QtGui.QIcon('icon.ico'))
self.RootVidPlot = self.VideoWidget.getPlotItem()
self.RootVidPlot.setAspectLocked(True)
self.RootVidPlot.hideAxis('bottom')
self.RootVidPlot.hideAxis('left')
self.RootVidPlot.invertY(True)
self.VideoItem = pg.ImageItem()
self.RootVidPlot.addItem(self.VideoItem)
self.LeftEdgeItem = pg.PlotCurveItem(
pen=pg.mkPen(color='#ff7f0e', width=2))
self.RightEdgeItem = pg.PlotCurveItem(
pen=pg.mkPen(color='#1f77b4', width=2))
self.LeftEdgeFit = pg.PlotCurveItem(
pen=pg.mkPen(color='#ff7f0e', width=4))
self.RightEdgeFit = pg.PlotCurveItem(
pen=pg.mkPen(color='#1f77b4', width=4))
self.RootVidPlot.addItem(self.LeftEdgeItem)
self.RootVidPlot.addItem(self.RightEdgeItem)
self.RootVidPlot.addItem(self.RightEdgeFit)
self.RootVidPlot.addItem(self.LeftEdgeFit)
self.updateVideo.connect(self.VideoItem.setImage)
self.updateLeftEdge.connect(self.LeftEdgeItem.setData)
self.updateRightEdge.connect(self.RightEdgeItem.setData)
self.updateLeftEdgeFit.connect(self.LeftEdgeFit.setData)
self.updateRightEdgeFit.connect(self.RightEdgeFit.setData)
self.ThetaLeftPlot = pg.ScatterPlotItem(pen='#ff7f0e',
brush='#ff7f0e',
symbol='o')
self.ThetaRightPlot = pg.ScatterPlotItem(pen='#1f77b4',
brush='#1f77b4',
symbol='o')
self.PlotItem = self.PlotWidget.getPlotItem()
self.updatePlotLeft.connect(self.ThetaLeftPlot.setData)
self.updatePlotRight.connect(self.ThetaRightPlot.setData)
self.BaseLine = pg.LineSegmentROI([(15, 90), (100, 90)], pen='#d62728')
self.CropRoi = pg.RectROI([10, 10], [110, 110], scaleSnap=True)
self.CropRoi.addScaleHandle([0, 0], [1, 1])
self.VideoWidget.addItem(self.CropRoi)
self.VideoWidget.addItem(self.BaseLine)
self.actionOpen.triggered.connect(self.openCall)
self.actionSaveData.triggered.connect(self.SaveResult)
self.actionSettings.triggered.connect(self.configSettings)
self.StartStopButton.clicked.connect(self.StartStop)
self.CameraToggleButton.clicked.connect(self.CameraToggle)
self.VidRecordButton.clicked.connect(self.recordVid)
self.VidRecordButton.hide()
self.actionSaveVideo.triggered.connect(self.SaveVideo)
self.actionExportVideo.triggered.connect(self.ExportVideo)
self.FrameSource = FrameSupply.FrameSupply()
self.MeasurementResult = pd.DataFrame(columns=[
'thetaleft', 'thetaright', 'contactpointleft', 'contactpointright',
'volume', 'time'
])
self.MaybeSave = False
self.settings = settings.settings(self)
self.kInputSlider.setValue(
self.settings.config['sessiledrop']['defaultfitpixels'])
self.kInputSpinbox.setValue(self.kInputSlider.value())
self.kInputSlider.valueChanged.connect(
lambda: self.kInputSpinbox.setValue(self.kInputSlider.value()))
self.kInputSpinbox.valueChanged.connect(
lambda: self.kInputSlider.setValue(self.kInputSpinbox.value()))
self.updateFrameCount.connect(
lambda f, n: self.FrameCounterText.setText('Frame: ' + str(f) + '/'
+ str(n)))
def file_open(self):
self.fl_name = File_dlg.openDirNameDialog(self)
self.lineEdit_dir.setText(os.path.dirname(self.fl_name))
self.lineEdit_file.setText(os.path.basename(self.fl_name))
# print(os.path.splitext(os.path.basename(self.fl_name))[0])
# loader(os.path.splitext(os.path.basename(self.fl_name))[0], os.path.dirname(self.fl_name))
w, w_of, w_dt, h, h_of, h_dt, d, d_of, d_dt, data, rgs_ls = \
read_bin_multi_region(os.path.dirname(self.fl_name), os.path.splitext(os.path.basename(self.fl_name))[0])
print(np.shape(data))
en = w_of + w_dt * np.arange(0, w)
ang = h_of + h_dt * np.arange(0, h)
ang_s = d_of + d_dt * np.arange(0, d)
E0, E1 = (en[0], en[-1])
A0, A1 = (ang[0], ang[-1])
AS0, AS1 = (ang_s[0], ang_s[-1])
asscale, ascale, escale = (AS1 - AS0) / data.shape[0], (
A1 - A0) / data.shape[1], (E1 - E0) / data.shape[2]
print(E0, E1, A0, A1, AS0, AS1)
print(asscale, ascale, escale)
data = np.transpose(data, axes=(2, 1, 0))
a_max = np.max(np.abs(np.array([A0, A1, AS0, AS1])))
print(np.shape(data), a_max)
plt1 = pg.PlotItem(labels={
'bottom': ('slits', 'degrees'),
'left': ('deflector', 'degrees')
})
plt1.setAspectLocked(True)
plt1.invertY(False)
plt1.invertX(False)
plt1.setRange(xRange=[-a_max, a_max],
yRange=[-a_max, a_max],
padding=0)
plt2 = pg.PlotItem(labels={
'bottom': ('slits', 'degrees'),
'left': ('Kin. Energy', 'eV')
})
plt2.setAspectLocked(False)
plt2.invertY(False)
plt2.invertX(False)
plt2.setRange(xRange=[E0, E1], yRange=[-a_max, a_max])
plt3 = pg.PlotItem(labels={
'bottom': ('Kin. Energy', 'eV'),
'left': ('deflector', 'degrees')
})
plt3.setAspectLocked(False)
plt3.invertY(False)
plt3.invertX(False)
plt3.setRange(xRange=[E0, E1], yRange=[-a_max, a_max])
self.gv_00.view = plt2
self.gv_10.view = plt1
self.gv_10.view.setLabel('bottom', text='slits', units='degrees')
self.gv_11.view = plt3
print(self.gv_10.view.getLabel('bottom'))
roi2 = pg.LineSegmentROI([[A0, (AS0 + AS1) / 2], [A1,
(AS0 + AS1) / 2]],
pen='r')
self.gv_10.addItem(roi2)
roi3 = pg.LineSegmentROI([[(A0 + A1) / 2, AS0], [(A0 + A1) / 2, AS1]],
pen='b')
self.gv_10.addItem(roi3)
def update2():
# global data, self.gv_10, self.gv_00, E0,A0,escale,ascale
d2 = roi2.getArrayRegion(data, self.gv_10.imageItem, axes=(1, 2))
self.gv_00.setImage(np.transpose(d2),
pos=[A0, E0],
scale=[ascale, escale])
self.gv_00.ui.histogram.hide()
self.gv_00.ui.roiBtn.hide()
self.gv_00.ui.menuBtn.hide()
roi2.sigRegionChanged.connect(update2)
def update3():
# global data, self.gv_10,self.gv_11, E0,AS0,escale,asscale
d3 = roi3.getArrayRegion(data, self.gv_10.imageItem, axes=(1, 2))
self.gv_11.setImage(d3, pos=[E0, AS0], scale=[escale, asscale])
self.gv_11.ui.histogram.hide()
self.gv_11.ui.roiBtn.hide()
self.gv_11.ui.menuBtn.hide()
roi3.sigRegionChanged.connect(update3)
## Display the data
self.gv_10.setImage(data, xvals=np.linspace(en[0], en[-1], data.shape[0]),\
pos=[A0, AS0], scale=[ascale, asscale])
self.gv_10.ui.histogram.hide()
self.gv_10.ui.roiBtn.hide()
self.gv_10.ui.menuBtn.hide()
#imv1.setImage(data)
#imv1.setHistogramRange(-0.01, 0.01)
#imv1.setLevels(-0.003, 0.003)
update2()
update3()
## Display the data and assign each frame a time value from 1.0 to 3.0
# self.graphicsView.setImage(data1)
# set position and scale of image
## Set a custom color map
colors = [(0, 0, 0), (45, 5, 61), (84, 42, 55), (150, 87, 60),
(208, 171, 141), (255, 255, 255)]
cmap = pg.ColorMap(pos=np.linspace(0.0, 1.0, 6), color=colors)
self.gv_11.setColorMap(cmap)
from PyQt5.QtWidgets import QApplication
import pyqtgraph as pg
import imageio as io
app = QApplication([])
# Load an example segmentation
seg = io.mimread(r"./openhsv/examples/segmentation.mp4",
memtest=False)
seg = (np.asarray(seg)[..., 0] > 128)
# Create analysis class and show widget
M = Midline(seg)
M.predict()
# Show segmentation with predicted midline
im = pg.image(seg.transpose(0, 2, 1),
title="Segmentation with midline")
line = pg.LineSegmentROI([M.coordinates[0, :2],
M.coordinates[0, 2:],],
pen="y")
im.getView().addItem(line)
# Compute and show phonovibrogram
pvg = M.pvg()
pg.image(pvg, title="Phonovibrogram")
app.exec_()
