def __init__(self,
source,
axis=None,
scale=None,
title=None,
invertY=False,
minMax=None,
screen=None,
parent=None,
*args):
### Images soures
self.initializeSources(source, axis=axis, scale=scale)
#print('init')
### Gui Construction
pg.QtGui.QWidget.__init__(self, parent, *args)
#print('gui')
if title is None:
if isinstance(source, str):
title = source
elif isinstance(source, io.src.Source):
title = source.location
if title is None:
title = 'DataViewer'
self.setWindowTitle(title)
self.resize(1600, 1200)
#print('title')
self.layout = pg.QtGui.QGridLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
#print('layout')
# image pane
self.view = pg.ViewBox()
self.view.setAspectLocked(True)
self.view.invertY(invertY)
self.graphicsView = pg.GraphicsView()
self.graphicsView.setObjectName("GraphicsView")
self.graphicsView.setCentralItem(self.view)
splitter = pg.QtGui.QSplitter()
splitter.setOrientation(pg.QtCore.Qt.Horizontal)
splitter.setSizes([self.width() - 10, 10])
self.layout.addWidget(splitter)
image_splitter = pg.QtGui.QSplitter()
image_splitter.setOrientation(pg.QtCore.Qt.Vertical)
image_splitter.setSizePolicy(pg.QtGui.QSizePolicy.Expanding,
pg.QtGui.QSizePolicy.Expanding)
splitter.addWidget(image_splitter)
#print('image')
# Image plots
image_options = dict(clipToView=True,
autoDownsample=True,
autoLevels=False,
useOpenGL=None)
self.image_items = [
pg.ImageItem(s[self.source_slice[:s.ndim]], **image_options)
for s in self.sources
]
for i in self.image_items:
i.setRect(
pg.QtCore.QRect(0, 0, self.source_range_x,
self.source_range_y))
i.setCompositionMode(pg.QtGui.QPainter.CompositionMode_Plus)
self.view.addItem(i)
self.view.setXRange(0, self.source_range_x)
self.view.setYRange(0, self.source_range_y)
#print('plots')
# Slice Selector
self.slicePlot = pg.PlotWidget()
sizePolicy = pg.QtGui.QSizePolicy(pg.QtGui.QSizePolicy.Preferred,
pg.QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.slicePlot.sizePolicy().hasHeightForWidth())
self.slicePlot.setSizePolicy(sizePolicy)
self.slicePlot.setMinimumSize(pg.QtCore.QSize(0, 40))
self.slicePlot.setObjectName("roiPlot")
#self.sliceCurve = self.slicePlot.plot()
self.sliceLine = pg.InfiniteLine(0, movable=True)
self.sliceLine.setPen((255, 255, 255, 200))
self.sliceLine.setZValue(1)
self.slicePlot.addItem(self.sliceLine)
self.slicePlot.hideAxis('left')
self.updateSlicer()
self.sliceLine.sigPositionChanged.connect(self.updateSlice)
#print('slice')
# Axis Tools
axis_tools_layout = pg.QtGui.QGridLayout()
self.axis_buttons = []
axesnames = ['x', 'y', 'z']
for d in range(3):
button = pg.QtGui.QRadioButton(axesnames[d])
button.setMaximumWidth(50)
axis_tools_layout.addWidget(button, 0, d)
button.clicked.connect(ft.partial(self.setSliceAxis, d))
self.axis_buttons.append(button)
self.axis_buttons[self.source_axis].setChecked(True)
axis_tools_widget = pg.QtGui.QWidget()
axis_tools_widget.setLayout(axis_tools_layout)
#print('axis')
# coordinate label
self.source_pointer = [0, 0, 0]
self.source_label = pg.QtGui.QLabel("")
axis_tools_layout.addWidget(self.source_label, 0, 3)
self.graphicsView.scene().sigMouseMoved.connect(
self.updateLabelFromMouseMove)
#print('coords')
#compose the image viewer
image_splitter.addWidget(self.graphicsView)
image_splitter.addWidget(self.slicePlot)
image_splitter.addWidget(axis_tools_widget)
image_splitter.setSizes([self.height() - 35 - 20, 35, 20])
#print('viewer')
# lut widgets
if self.nsources == 1:
cols = ['flame']
elif self.nsources == 2:
cols = ['purple', 'green']
else:
cols = np.array(['white', 'green', 'red', 'blue', 'purple'] *
self.nsources)[:self.nsources]
self.luts = [
LUT(image=i, color=c) for i, c in zip(self.image_items, cols)
]
lut_layout = pg.QtGui.QGridLayout()
lut_layout.setContentsMargins(0, 0, 0, 0)
for d, l in enumerate(self.luts):
lut_layout.addWidget(l, 0, d)
lut_widget = pg.QtGui.QWidget()
lut_widget.setLayout(lut_layout)
lut_widget.setContentsMargins(0, 0, 0, 0)
#lut_widget.setSizePolicy(pg.QtGui.QSizePolicy.Maximum, pg.QtGui.QSizePolicy.Expanding)
lut_widget.setSizePolicy(pg.QtGui.QSizePolicy.Preferred,
pg.QtGui.QSizePolicy.Expanding)
splitter.addWidget(lut_widget)
splitter.setStretchFactor(0, 1)
splitter.setStretchFactor(1, 0)
#self.source_levelMin = [];
#self.source_levelMax = [];
#for i,s in enumerate(self.sources):
# lmin, lmax = list(map(float, self.quickMinMax(s[self.source_slice])));
# self.levelMin.append(lmin);
# self.levelMax.append(lmax);
#print('lut')
# update scale
for l in self.luts:
l.range_buttons[1][2].click()
if minMax is not None:
self.setMinMax(minMax)
self.show()
def plot_spectrogram(stream, channels=None, w_size=(1920, 1080)):
"""
plots spectrogram of data stream from inlet. one row per channel.
Args:
stream (neurol.streams object): neurol stream for a data source.
channels: channels to plot. list/tuple of channel indices,
or dict with indices as keys and names as values.
Defaults to None (plots all channels w/o names).
w_size (tuple, optional): initial size of window in pixels.
Defaults to (1920, 1080).
"""
# get info about stream
n_channels = stream.n_channels
s_rate = stream.sampling_rate
buffer_length = stream.buffer_length
# get format of frequencies and times
freqs, ts, _ = signal.spectrogram(stream.buffer[:, 0],
s_rate,
mode='magnitude')
ts = np.max(ts) - ts # reverse ts s.t. it takes the range [-max_ts, 0]
# initialize pyqt graph app, window
win = pg.GraphicsLayoutWidget(show=True)
win.setWindowTitle('Spectrogram Live Plot')
app = pg.QtGui.QApplication
win.resize(w_size[0], w_size[1])
# interpret image data as row-major to match scipy output
pg.setConfigOptions(imageAxisOrder='row-major')
# initialize plots/curves
plots = []
plot_imgs = []
#plot_hists = []
if channels is None:
channels = list(range(n_channels))
# TODO: implement x-axis time range using ts defined above
# TODO: implement y-axis frequency range using freqs defined above
if isinstance(channels, (list, tuple)):
for ch_ind in channels:
plt = win.addPlot(title=f'channel {ch_ind}')
plt.setMouseEnabled(x=False, y=False)
img = pg.ImageItem()
plt.addItem(img)
# interactive histogram
hist = pg.HistogramLUTItem()
# link the histogram to the image
hist.setImageItem(img)
# set histogram gradient
hist.gradient.restoreState({
'mode':
'rgb',
'ticks': [(0.5, (0, 182, 188, 255)), (1.0, (246, 111, 0, 255)),
(0.0, (75, 0, 113, 255))]
})
win.addItem(hist)
plots.append(plt)
plot_imgs.append(img)
win.nextRow()
ch_inds = list(channels)
elif isinstance(channels, dict):
for ch_ind, ch_name in channels.items():
plt = win.addPlot(title=f'{ch_name} channel')
plt.setMouseEnabled(x=False, y=False)
img = pg.ImageItem()
plt.addItem(img)
# interactive histogram
hist = pg.HistogramLUTItem()
# link the histogram to the image
hist.setImageItem(img)
# set histogram gradient
hist.gradient.restoreState({
'mode':
'rgb',
'ticks': [(0.5, (0, 182, 188, 255)), (1.0, (246, 111, 0, 255)),
(0.0, (75, 0, 113, 255))]
})
win.addItem(hist)
plots.append(plt)
plot_imgs.append(img)
win.nextRow()
ch_inds = list(channels.keys())
else:
raise ValueError('`channels` argument should be list, tuple, or dict')
# label bottom plot's x-axis
plots[-1].setLabel('bottom', 'time', units='s')
# process initialization events
app.processEvents()
running = True
while running:
if stream.update_buffer(): # update buffer if new data available
for ch_ind, plot_img in zip(ch_inds, plot_imgs):
freqs, _, Sxx = signal.spectrogram(stream.buffer[:, ch_ind],
s_rate,
mode='magnitude')
# FIXME: temp fix of outliers
Sxx_clipped = np.clip(Sxx, 0, 100)
plot_img.setImage(Sxx_clipped)
app.processEvents()
if not win.isVisible():
running = False
app.quit()
text = """
This example demonstrates the use of GraphicsLayout to arrange items in a grid.<br>
The items added to the layout must be subclasses of QGraphicsWidget (this includes <br>
PlotItem, ViewBox, LabelItem, and GrphicsLayout itself).
"""
l.addLabel(text, col=1, colspan=4)
l.nextRow()
## Put vertical label on left side
l.addLabel('Long Vertical Label', angle=-90, rowspan=3)
## Add 3 plots into the first row (automatic position)
p1 = l.addPlot(title="Plot 1")
p2 = l.addPlot(title="Plot 2")
vb = l.addViewBox(lockAspect=True)
img = pg.ImageItem(np.random.normal(size=(100,100)))
vb.addItem(img)
vb.autoRange()
## Add a sub-layout into the second row (automatic position)
## The added item should avoid the first column, which is already filled
l.nextRow()
l2 = l.addLayout(colspan=3, border=(50,0,0))
l2.setContentsMargins(10, 10, 10, 10)
l2.addLabel("Sub-layout: this layout demonstrates the use of shared axes and axis labels", colspan=3)
l2.nextRow()
l2.addLabel('Vertical Axis Label', angle=-90, rowspan=2)
p21 = l2.addPlot()
p22 = l2.addPlot()
l2.nextRow()
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
self.loaded = False
# A plot area (ViewBox + axes) for displaying the image
self.vmain = pg.ViewBox(lockAspect=True, invertY=True, name="plot1")
self.win.addItem(self.vmain, row=0, col=0)
self.vmain.setMenuEnabled(False)
self.imain = pg.ImageItem()
self.vmain.addItem(self.imain)
self.maskmain = pg.ImageItem()
# side box
self.vside = pg.ViewBox(lockAspect=True, invertY=True)
self.vside.setMenuEnabled(False)
self.iside = pg.ImageItem()
self.vside.addItem(self.iside)
self.maskside = pg.ImageItem()
# view red channel
self.redbox = QtGui.QCheckBox("view red channel")
self.redbox.setStyleSheet("color: white;")
self.redbox.setEnabled(False)
self.redbox.toggled.connect(self.add_red)
self.l0.addWidget(self.redbox, 0, 5, 1, 1)
# view masks
self.maskbox = QtGui.QCheckBox("view masks")
self.maskbox.setStyleSheet("color: white;")
self.maskbox.setEnabled(False)
self.maskbox.toggled.connect(self.add_masks)
self.l0.addWidget(self.maskbox, 0, 6, 1, 1)
# view raw binary
self.rawbox = QtGui.QCheckBox("view raw binary")
self.rawbox.setStyleSheet("color: white;")
self.rawbox.setEnabled(False)
self.rawbox.toggled.connect(self.add_raw)
self.l0.addWidget(self.rawbox, 0, 7, 1, 1)
# view zstack
self.zbox = QtGui.QCheckBox("view z-stack")
self.zbox.setStyleSheet("color: white;")
self.zbox.setEnabled(False)
self.zbox.toggled.connect(self.add_zstack)
self.l0.addWidget(self.zbox, 0, 8, 1, 1)
self.p1 = self.win.addPlot(name='plot1', row=1, col=0, colspan=2)
self.p1.setMouseEnabled(x=True, y=False)
self.p1.setMenuEnabled(False)
self.scatter1 = pg.ScatterPlotItem()
self.p1.addItem(self.scatter1)
self.p2 = self.win.addPlot(name='plot2', row=2, col=0, colspan=2)
self.p2.setMouseEnabled(x=True, y=False)
self.p2.setMenuEnabled(False)
self.scatter2 = pg.ScatterPlotItem()
self.p2.addItem(self.scatter2)
self.p2.setXLink('plot1')
#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.raw_on = False
self.red_on = 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.abspath(
os.path.join(parent.basename, 'ops.npy'))
print(fileName)
self.Fcell = parent.Fcell
self.stat = parent.stat
self.Floaded = True
self.openFile(fileName, True)
for idx in range(width):
modulation[idx] = -0.05 * np.sin(200 * np.pi * idx / width)
for idx in range(height):
img[:, idx] = gradient + (idx / (height - 1)) * modulation
num_bars = 0
lw.addLabel('=== local color maps ===')
num_bars += 1
lw.nextRow()
list_of_maps = pg.colormap.listMaps()
for map_name in list_of_maps:
num_bars += 1
lw.addLabel(map_name)
cmap = pg.colormap.get(map_name)
imi = pg.ImageItem()
imi.setImage(img)
imi.setLookupTable(cmap.getLookupTable(alpha=True))
vb = lw.addViewBox(lockAspect=True, enableMouse=False)
vb.addItem(imi)
lw.nextRow()
lw.addLabel('=== Matplotlib import ===')
num_bars += 1
lw.nextRow()
list_of_maps = pg.colormap.listMaps('matplotlib')
for map_name in list_of_maps:
num_bars += 1
lw.addLabel(map_name)
cmap = pg.colormap.get(map_name, source='matplotlib', skipCache=True)
if cmap is not None:
def __init__(self, annots1, annots2, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle('Compare Call Pairs')
self.setWindowIcon(QIcon('img/Avianz.ico'))
self.setWindowFlags((self.windowFlags() ^ Qt.WindowContextHelpButtonHint) | Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint)
self.parent = parent
self.rec1 = annots1[0].recname
self.rec2 = annots2[0].recname
self.annots1 = annots1
self.annots2 = annots2
# Set colour map
# cmap = self.config['cmap'] # TODO Read these from config
self.lut = colourMaps.getLookupTable("Grey")
self.cmapInverted = False
self.topLabel = QLabel("Comparing recorders %s (top) and %s (bottom)" %(self.rec1, self.rec2))
self.labelPair = QLabel()
# Volume, brightness and contrast sliders. (NOTE hardcoded init)
self.specControls = SupportClasses_GUI.BrightContrVol(80, 20, False)
self.specControls.colChanged.connect(self.setColourLevels)
# self.specControls.volChanged.connect(self.volSliderMoved)
# TODO add volume and playback at some point
# spectrograms
self.wPlot = pg.GraphicsLayoutWidget()
self.pPlot1 = self.wPlot.addViewBox(enableMouse=False, row=0, col=1)
self.pPlot2 = self.wPlot.addViewBox(enableMouse=False, row=1, col=1)
self.plot1 = pg.ImageItem()
self.plot2 = pg.ImageItem()
self.pPlot1.addItem(self.plot1)
self.pPlot2.addItem(self.plot2)
# Y (freq) axis
self.sg_axis1 = pg.AxisItem(orientation='left')
self.sg_axis1.linkToView(self.pPlot1)
self.sg_axis2 = pg.AxisItem(orientation='left')
self.sg_axis2.linkToView(self.pPlot2)
self.wPlot.addItem(self.sg_axis1, row=0, col=0)
self.wPlot.addItem(self.sg_axis2, row=1, col=0)
# The buttons to move through the overview
self.leftBtn = QToolButton()
self.leftBtn.setArrowType(Qt.LeftArrow)
self.leftBtn.clicked.connect(self.moveLeft)
self.leftBtn.setToolTip("View previous pair")
self.rightBtn = QToolButton()
self.rightBtn.setArrowType(Qt.RightArrow)
self.rightBtn.clicked.connect(self.moveRight)
self.rightBtn.setToolTip("View next pair")
self.leftBtn.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.MinimumExpanding)
self.rightBtn.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.MinimumExpanding)
# accept / close
closeBtn = QPushButton("Close")
closeBtn.clicked.connect(self.accept)
# init GUI with page 1 data
self.currpage = 1
self.leftBtn.setEnabled(False)
if len(self.annots1)==1:
self.rightBtn.setEnabled(False)
self.setData()
# layout
box = QVBoxLayout()
box.addWidget(self.topLabel)
box.addWidget(self.labelPair)
box.addWidget(self.specControls)
midHBox = QHBoxLayout()
midHBox.addWidget(self.leftBtn)
midHBox.addWidget(self.wPlot, stretch=10)
midHBox.addWidget(self.rightBtn)
box.addLayout(midHBox)
box.addWidget(closeBtn)
self.setLayout(box)
def __init__(self, *args, experiment=None, **kwargs):
"""
:param experiment: experiment to which this belongs
(:class:Experiment <stytra.Experiment> object)
"""
super().__init__(*args, **kwargs)
self.experiment = experiment
if experiment is not None:
self.camera = experiment.camera
experiment.gui_timer.timeout.connect(self.retrieve_image)
else:
self.gui_timer = QTimer()
self.gui_timer.setSingleShot(False)
self.control_params = self.experiment.camera_state
# Create the layout for the camera view:
self.camera_display_widget = pg.GraphicsLayoutWidget()
# Display area for showing the camera image:
self.display_area = pg.ViewBox(lockAspect=1, invertY=False)
self.display_area.setRange(QRectF(0, 0, 640, 480),
update=True,
disableAutoRange=True)
self.scale = 640
self.display_area.invertY(True)
# Image to which the frame will be set, initially black:
self.image_item = pg.ImageItem()
self.image_item.setImage(np.zeros((640, 480), dtype=np.uint8))
self.display_area.addItem(self.image_item)
self.camera_display_widget.addItem(self.display_area)
# Queue of frames coming from the camera
if hasattr(experiment, "frame_dispatcher"):
self.frame_queue = self.experiment.frame_dispatcher.gui_queue
else:
self.frame_queue = self.camera.frame_queue
# Queue of control parameters for the camera:
self.control_queue = self.camera.control_queue
self.camera_rotation = self.camera.rotation
self.layout = QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.camera_display_widget)
self.layout_control = QHBoxLayout()
self.layout_control.setContentsMargins(10, 0, 10, 10)
self.btn_pause = ControlToggleIcon(
self.experiment.camera_state,
"paused",
icon_on=get_icon("play"),
icon_off=get_icon("pause"),
action_off="Pause",
action_on="Play",
)
self.layout_control.addWidget(self.btn_pause)
if hasattr(self.experiment.camera_state, "replay"):
self.experiment.camera_state.replay = False
self.btn_rewind = ControlToggleIcon(
self.experiment.camera_state,
"replay",
icon_on=get_icon("rewind"),
action_off="Resume",
action_on="Replay",
)
self.layout_control.addWidget(self.btn_rewind)
if self.control_queue is not None:
self.btn_camera_param = IconButton(icon_name="edit_camera",
action_name="Configure camera")
self.btn_camera_param.clicked.connect(self.show_params_gui)
self.layout_control.addWidget(self.btn_camera_param)
self.btn_capture = IconButton(icon_name="camera_flash",
action_name="Capture frame")
self.btn_capture.clicked.connect(self.save_image)
self.layout_control.addWidget(self.btn_capture)
self.btn_autorange = ToggleIconButton(icon_off="autoscale",
icon_on="autoscaleOFF",
action_on="Autoscale")
self.layout_control.addWidget(self.btn_autorange)
self.layout.addLayout(self.layout_control)
self.current_image = None
self.setLayout(self.layout)
self.current_frame_time = None
self.param_widget = None
def saveDisp(self):
print("saving main window")
mydialog = QtGui.QFileDialog()
options = mydialog.Options()
thedir = str(
mydialog.getExistingDirectory(options=options, caption="Image output directory")
)
print("thedir=", thedir)
thename = self.map.namebase + self.map.name
# make a square background
thesquarewin = pg.ImageItem()
thesquarewin.translate(0, 0)
maximpervox = np.max([self.impixpervoxx, self.impixpervoxy, self.impixpervoxz])
maxdim = np.max([self.xdim, self.ydim, self.zdim])
thesquarewin.scale(maximpervox, maximpervox)
thesquarewin.setImage(np.zeros((maxdim, maxdim), dtype=float), autoLevels=True)
# make a rectangular background
therectwin = pg.ImageItem()
therectwin.translate(0, 0)
therectwin.scale(maximpervox, maximpervox)
therectwin.setImage(np.zeros((maxdim // 10, maxdim), dtype=float), autoLevels=True)
(thecolorbarfgwin, thecolorbarbgwin, thecolorbarviewbox, colorbarvals,) = newColorbar(
0, 0, maximpervox, maximpervox, maxdim
)
cbim = self.applyLUT(
colorbarvals, (colorbarvals * 0 + 1).astype("int"), self.map.theLUT, 0.0, 1.0,
)
thecolorbarfgwin.setImage(cbim.astype("float"))
thecolorbarbgwin.setImage(cbim.astype("float"), autoLevels=True)
print(thecolorbarfgwin)
print(thecolorbarbgwin)
print(thecolorbarviewbox)
self.saveandcomposite(
thesquarewin,
self.axviewwin,
self.axviewbgwin,
thename + "_ax",
thedir,
self.xdim * self.xsize,
self.ydim * self.ysize,
)
self.saveandcomposite(
thesquarewin,
self.corviewwin,
self.corviewbgwin,
thename + "_cor",
thedir,
self.xdim * self.xsize,
self.zdim * self.zsize,
)
self.saveandcomposite(
thesquarewin,
self.sagviewwin,
self.sagviewbgwin,
thename + "_sag",
thedir,
self.ydim * self.ysize,
self.zdim * self.zsize,
)
"""self.saveandcomposite(therectwin,
thecolorbarfgwin, thecolorbarbgwin,
thename + '_colorbar', thedir,
maximpervox * maxdim // 10,
maximpervox * maxdim)"""
with open(os.path.join(thedir, thename + "_lims.txt"), "w") as FILE:
FILE.writelines(str(self.map.dispmin) + "\t" + str(self.map.dispmax))
def mix_images(self):
component1Enum = None
component2Enum = None
percentage_of_component1_image1 = 0.0
percentage_of_component2_image1 = 0.0
outputText = self.ui.comboBox_output.currentText()
component1ComponentText = self.ui.component1_component_comboBox.currentText(
)
component1ImageText = self.ui.component1_image_comboBox.currentText()
component2ComponentText = self.ui.component2_component_comboBox.currentText(
)
component2ImageText = self.ui.component2_image_comboBox.currentText()
if (outputText == "Choose output 1 or 2"
or component1ComponentText == "choose component"
or component1ImageText == "Choose image 1 or 2"
or component2ComponentText == "choose component"
or component2ImageText == "Choose image 1 or 2"):
self.show_popup("fill all comboboxes")
return
if ((component1ComponentText == "Magnitude"
and component2ComponentText != "Phase")
and (component1ComponentText == "Magnitude"
and component2ComponentText != "Uni_Phase")):
self.show_popup("you cannot mix by these components")
return
elif ((component1ComponentText == "Phase"
and component2ComponentText != "Magnitude")
and (component1ComponentText == "Phase"
and component2ComponentText != "Uni_Mag")):
self.show_popup("you cannot mix by these components")
return
elif ((component1ComponentText == "Uni_Mag"
and component2ComponentText != "Phase")
and (component1ComponentText == "Uni_Mag"
and component2ComponentText != "Uni_Phase")):
self.show_popup("you cannot mix by these components")
return
elif ((component1ComponentText == "Uni_Phase"
and component2ComponentText != "Magnitude")
and (component1ComponentText == "Uni_Phase"
and component2ComponentText != "Uni_Mag")):
self.show_popup("you cannot mix by these components")
return
if (component1ComponentText == "Real"
and component2ComponentText != "Imag"):
self.show_popup("you cannot mix by these components")
return
elif (component1ComponentText == "Imag"
and component2ComponentText != "Real"):
self.show_popup("you cannot mix by these components")
return
if (component1ComponentText == "Magnitude"):
component1Enum = Modes.MagnitudeComponent
elif (component1ComponentText == "Phase"):
component1Enum = Modes.PhaseComponent
elif (component1ComponentText == "Real"):
component1Enum = Modes.RealComponent
elif (component1ComponentText == "Imag"):
component1Enum = Modes.ImagComponent
if (component2ComponentText == "Magnitude"):
component2Enum = Modes.MagnitudeComponent
elif (component2ComponentText == "Phase"):
component2Enum = Modes.PhaseComponent
elif (component2ComponentText == "Real"):
component2Enum = Modes.RealComponent
elif (component2ComponentText == "Imag"):
component2Enum = Modes.ImagComponent
if (component1ImageText == "Image1"):
percentage_of_component1_image1 = self.ui.component1_Percentage.value(
) * 0.01
if (component1ComponentText == "Uni_Mag"):
component1Enum = Modes.Uni_Magnitude_Image_1
elif (component1ComponentText == "Uni_Phase"):
component1Enum = Modes.Uni_Phase_Image_1
else:
percentage_of_component1_image1 = (
100 - self.ui.component1_Percentage.value()) * 0.01
if (component1ComponentText == "Uni_Mag"):
component1Enum = Modes.Uni_Magnitude_Image_2
elif (component1ComponentText == "Uni_Phase"):
component1Enum = Modes.Uni_Phase_Image_2
if (component2ImageText == "Image1"):
percentage_of_component2_image1 = self.ui.component2_Percentage.value(
) * 0.01
if (component2ComponentText == "Uni_Mag"):
component2Enum = Modes.Uni_Magnitude_Image_1
elif (component2ComponentText == "Uni_Phase"):
component2Enum = Modes.Uni_Phase_Image_1
else:
percentage_of_component2_image1 = (
100 - self.ui.component2_Percentage.value()) * 0.01
if (component2ComponentText == "Uni_Mag"):
component2Enum = Modes.Uni_Magnitude_Image_2
elif (component2ComponentText == "Uni_Phase"):
component2Enum = Modes.Uni_Phase_Image_2
logging.info("Components for mixing are : " + component1ComponentText +
" , " + component2ComponentText)
output = imageClass.mixTwoImages(self.image_arr[0], self.image_arr[1],
percentage_of_component1_image1,
percentage_of_component2_image1,
component1Enum, component2Enum)
image = pg.ImageItem(output)
image.rotate(270)
if (outputText == "Output1"):
logging.info("user chose mixture to be shown in Output1 window")
self.ui.output1_graphicsView.clear()
self.ui.output1_graphicsView.addItem(image)
elif (outputText == "Output2"):
logging.info("user chose mixture to be shown in Output2 window")
self.ui.output2_graphicsView.clear()
self.ui.output2_graphicsView.addItem(image)
def add_components(self):
# Widgets
self.graphics_widget = pg.GraphicsLayoutWidget()
self.graphics_widget.view = self.graphics_widget.addViewBox()
## lock the aspect ratio so pixels are always square
self.graphics_widget.view.setAspectLocked(True)
## Create image item
self.graphics_widget.img = pg.ImageItem(border='w')
self.graphics_widget.view.addItem(self.graphics_widget.img)
self.playButton = QtGui.QPushButton()
self.playButton.setEnabled(False)
self.playButton.setCheckable(True)
self.playButton.setIcon(self.style().standardIcon(
QtWidgets.QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.recordButton = QtGui.QPushButton()
self.recordButton.setEnabled(False)
self.recordButton.setCheckable(True)
self.recordButton.setIcon(self.style().standardIcon(
QtWidgets.QStyle.SP_DialogYesButton))
self.recordButton.clicked.connect(self.record)
self.positionSlider = QtGui.QSlider(QtCore.Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.setEnabled(False)
self.positionSlider_prevValue = 0
self.positionSpinBox = QtGui.QDoubleSpinBox()
self.positionSpinBox.setRange(0, 0)
self.positionSpinBox.setSingleStep(0.01)
self.positionSpinBox.setEnabled(False)
self.positionSpinBox_prevValue = 0
# Add ROI
self.roi_pos = (0.5, 0.5)
self.roi_size = (100, 100)
self.ROI = pg.CircleROI(self.roi_pos,
self.roi_size,
scaleSnap=True,
translateSnap=True)
# self.ROI.addScalehandle((0,0),(1,1))
self.graphics_widget.view.addItem(self.ROI)
self.ROI.hide()
self.ROI.sigRegionChanged.connect(self.updateROI)
self.roi_pos = self.ROI.pos()
self.roi_size = self.ROI.size()
# Connections
self.positionSlider.valueChanged.connect(self.positionSpinBox_setValue)
self.positionSpinBox.valueChanged.connect(self.positionSlider_setValue)
# Create layouts to place inside widget
controlLayout = QtGui.QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.positionSpinBox)
controlLayout.addWidget(self.recordButton)
layout = QtGui.QVBoxLayout()
layout.addWidget(self.graphics_widget)
layout.addLayout(controlLayout)
self.setLayout(layout)
def create_widget(self, parent):
widget = PgImageWidget(parent, self)
self.image_item = pg.ImageItem()
widget.addItem(self.image_item)
self.image # note: need read image to trigger observers
return widget
win = QtGui.QMainWindow()
win.resize(1600, 600)
win.setWindowTitle(sys.argv[0])
glw = QtGui.QWidget()
#glw = pg.GraphicsLayoutWidget()
l = QtGui.QGridLayout()
glw.setLayout(l)
win.setCentralWidget(glw)
#view = glw.addViewBox()
v = pg.GraphicsView()
view = pg.ViewBox()
view.setAspectLocked(True)
v.setCentralItem(view)
img = pg.ImageItem(border='y')
view.addItem(img)
#img.setTitle('test')
v2 = pg.GraphicsView()
l2 = pg.GraphicsLayout()
v2.setCentralItem(l2)
plot1 = l2.addPlot()
curve1 = plot1.plot(pen=(200, 200, 200),
symbolBrush=(0, 255, 0),
symbolPen='w')
# plot1.setYRange(0.01, 1000000)
plot1.setLogMode(x=False, y=p.param("LogScaleRow?").value())
l2.nextRow()
plot2 = l2.addPlot()
curve2 = plot2.plot(pen=(200, 200, 200),
def __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
self.logic = MainLogic()
self.setWindowFlags(QtCore.Qt.Window)
self.setWindowTitle("Defect Detector")
self.open_avi_action = QtWidgets.QAction("Open video...")
self.open_avi_action.triggered.connect(self.open_avi)
self.open_csv_action = QtWidgets.QAction("Open CSV...")
self.open_csv_action.triggered.connect(self.open_csv)
self.open_csv_action.setShortcut("Ctrl+O")
self.menuBar().addAction(self.open_avi_action)
self.menuBar().addAction(self.open_csv_action)
self.gaps_list = QtWidgets.QListView()
self.gaps_model = QtGui.QStandardItemModel()
self.gaps_list.setModel(self.gaps_model)
self.gaps_list.pressed["const QModelIndex&"].connect(
self.on_select_element)
self.gaps_list.activated["const QModelIndex&"].connect(
self.on_select_element)
self.info_label = QtWidgets.QLabel("Мин. зазор, мм")
self.gap_limit_spinbox = QtWidgets.QSpinBox()
self.gap_limit_spinbox.setRange(0, 1000)
self.gap_limit_spinbox.setValue(0)
self.gap_limit_spinbox.setSingleStep(1)
self.gap_limit_spinbox.valueChanged["int"].connect(
self.change_gap_limit)
self.rail_combo = QtWidgets.QComboBox()
self.rail_combo.addItems(self.logic.RAILS)
self.rail_combo.currentIndexChanged["int"].connect(
self.change_rail_combo)
self.hbox_filter = QtWidgets.QHBoxLayout()
self.hbox_filter.addWidget(self.info_label, stretch=0)
self.hbox_filter.addWidget(self.gap_limit_spinbox, stretch=10)
self.hbox_filter.addWidget(self.rail_combo, stretch=10)
self.vbox_data = QtWidgets.QVBoxLayout()
self.vbox_data.addLayout(self.hbox_filter)
self.vbox_data.addWidget(self.gaps_list)
self.board_widget = QtWidgets.QWidget()
self.board_widget.setLayout(self.vbox_data)
self.plot_area = self.create_plot_area(self)
self.image_item = pg.ImageItem()
self.plot_area.addItem(self.image_item)
self.plot_area_nn = self.create_plot_area(self)
self.image_item_nn = pg.ImageItem()
self.plot_area_nn.addItem(self.image_item_nn)
self.splitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
self.splitter.addWidget(self.board_widget)
self.splitter2 = QtWidgets.QSplitter(QtCore.Qt.Vertical)
self.splitter2.addWidget(self.plot_area)
self.splitter2.addWidget(self.plot_area_nn)
self.splitter.addWidget(self.splitter2)
self.vbox = QtWidgets.QVBoxLayout(self)
self.vbox.addWidget(self.splitter)
self.setCentralWidget(QtWidgets.QWidget(self))
self.centralWidget().setLayout(self.vbox)
self.showMaximized()
self.rectangle_region = None
def create_ui(self):
"""
Setup the whole UI of the radar data viewer. Creates several member variables for sliders, comboBoxes etc.
:return: None
"""
self.setWindowTitle("Radar Data Viewer")
self.main_grid_layout = QtWidgets.QGridLayout()
self.central_widget = QtWidgets.QWidget()
self.central_widget.setLayout(self.main_grid_layout)
self.setCentralWidget(self.central_widget)
self.plot_item = pg.PlotWidget()
self.plot_item.setBackground("#0B0F14")
self.main_grid_layout.addWidget(self.plot_item, 0, 0)
# Options Dock Widget
self.options_layout = QtWidgets.QVBoxLayout()
self.options_layout.setAlignment(QtCore.Qt.AlignTop)
self.doppler_arrows_cb = QtWidgets.QCheckBox("Doppler Velocity Arrows")
self.doppler_arrows_cb.setChecked(True)
self.options_layout.addWidget(self.doppler_arrows_cb)
# scaling of doppler arrows
self.doppler_h_layout = QtWidgets.QHBoxLayout()
self.doppler_h_layout.setContentsMargins(20, 0, 0, 10)
self.doppler_scale_label = QtWidgets.QLabel()
self.doppler_scale_label.setText("Scale")
self.doppler_scale_label.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed))
self.doppler_h_layout.addWidget(self.doppler_scale_label)
self.doppler_scale_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
self.doppler_scale_slider.setMinimum(1)
self.doppler_scale_slider.setMaximum(20)
self.doppler_scale_slider.setValue(7)
self.doppler_scale_slider.setFixedWidth(150)
self.doppler_h_layout.addWidget(self.doppler_scale_slider)
self.options_layout.addLayout(self.doppler_h_layout)
self.label_text_cb = QtWidgets.QCheckBox("Class Names of True Label")
self.label_text_cb.setChecked(True)
self.options_layout.addWidget(self.label_text_cb)
self.convex_hulls_cb = QtWidgets.QCheckBox("Convex Hulls Around True Objects")
self.options_layout.addWidget(self.convex_hulls_cb)
self.color_by_label = QtWidgets.QLabel()
self.color_by_label.setText("Color Detections by")
self.color_by_label.setStyleSheet(
"""
QLabel {
margin-top: 10px;
}
"""
)
self.options_layout.addWidget(self.color_by_label)
self.color_by_list = QtWidgets.QComboBox()
self.color_by_list.setStyleSheet(
"""
QComboBox::item:checked {
height: 12px;
border: 1px solid #32414B;
margin-top: 0px;
margin-bottom: 0px;
padding: 4px;
padding-left: 0px;
}
QComboBox {
margin-left: 20px;
}
"""
)
self.color_by_list.addItems([x.value for x in ColorOpts])
self.color_by_list.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed))
self.color_by_list.setCurrentIndex(6)
self.options_layout.addWidget(self.color_by_list)
options_widget = QtWidgets.QWidget()
options_widget.setLayout(self.options_layout)
self.options_dock = QtWidgets.QDockWidget("Options", self)
self.options_dock.setWidget(options_widget)
self.options_dock.setFloating(False)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.options_dock)
# Detection Info Dock Widget
self.info_dock = QtWidgets.QDockWidget("Information", self)
self.info_dock.setMinimumWidth(350)
self.info_dock.setMinimumHeight(200)
self.detection_info_label = QtWidgets.QTextEdit(text="No detection selected.")
self.detection_info_label.setMinimumWidth(200)
flags = QtCore.Qt.TextInteractionFlags(QtCore.Qt.TextInteractionFlag.TextSelectableByMouse)
self.detection_info_label.setTextInteractionFlags(flags)
self.info_dock.setWidget(self.detection_info_label)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.info_dock)
# Camera Dock Widget
self.cam_graphics_layout = pg.GraphicsLayoutWidget()
self.cam_viewbox = self.cam_graphics_layout.addViewBox()
self.cam_viewbox.setAspectLocked(True)
self.camera_widget = pg.ImageItem()
self.camera_widget.rotate(-90)
self.cam_viewbox.addItem(self.camera_widget)
self.camera_dock = QtWidgets.QDockWidget("Camera", self)
self.camera_dock.setMinimumWidth(300)
self.camera_dock.setMinimumHeight(300)
self.camera_dock.setWidget(self.cam_graphics_layout)
self.camera_dock.setFloating(False)
self.camera_dock.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Expanding))
self.camera_dock.widget().setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Expanding)
)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.camera_dock)
# Timeline: Slider, Spinboxes, Labes
self.timeline_grid_layout = QtWidgets.QGridLayout()
self.timeline_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
self.timeline_slider.setStyleSheet("""
.QSlider {
min-height: 20px;
max-height: 20px;
}
.QSlider::groove:horizontal {
height: 15px;
}
""")
self.timeline_spinbox = QtWidgets.QSpinBox()
self.timeline_spinbox.setMaximum(10000)
self.timeline_spinbox.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed))
self.timeline_label = QtWidgets.QLabel()
self.timeline_label.setText("Current Frame:")
self.timeline_label.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed))
self.prev_frames_spinbox = QtWidgets.QSpinBox()
self.prev_frames_spinbox.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed))
self.prev_frames_spinbox.setMaximum(30)
self.prev_frames_label = QtWidgets.QLabel()
self.prev_frames_label.setText("Show Previous Frames:")
self.prev_frames_label.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed))
self.future_frames_spinbox = QtWidgets.QSpinBox()
self.future_frames_spinbox.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed))
self.future_frames_spinbox.setMaximum(30)
self.future_frames_spinbox.setValue(4)
self.future_frames_label = QtWidgets.QLabel()
self.future_frames_label.setText("Show Future Frames:")
self.future_frames_label.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed))
self.timeline_grid_layout.addWidget(self.timeline_slider, 0, 0, 1, 8)
self.timeline_grid_layout.addWidget(self.timeline_label, 1, 1)
self.timeline_grid_layout.addWidget(self.timeline_spinbox, 1, 2)
self.timeline_grid_layout.addWidget(self.prev_frames_label, 1, 3)
self.timeline_grid_layout.addWidget(self.prev_frames_spinbox, 1, 4)
self.timeline_grid_layout.addWidget(self.future_frames_label, 1, 5)
self.timeline_grid_layout.addWidget(self.future_frames_spinbox, 1, 6)
self.main_grid_layout.addLayout(self.timeline_grid_layout, 1, 0)
# Menu
self.menu = self.menuBar()
self.file_menu = self.menu.addMenu("File")
self.view_menu = self.menu.addMenu("View")
self.view_menu.addAction(self.options_dock.toggleViewAction())
self.view_menu.addAction(self.info_dock.toggleViewAction())
self.view_menu.addAction(self.camera_dock.toggleViewAction())
## Exit QAction
exit_action = QtWidgets.QAction("Exit", self)
exit_action.setShortcut(QtGui.QKeySequence.Quit)
exit_action.triggered.connect(self.close)
# Open Sequence Action
self.open_action = QtWidgets.QAction("Open Sequence", self)
self.open_action.setShortcut(QtGui.QKeySequence.Open)
self.open_action.triggered.connect(self.open_sequence)
# Open Predictions Action
self.open_pred_action = QtWidgets.QAction("Open Predictions", self)
self.open_pred_action.triggered.connect(self.open_predictions)
self.file_menu.addAction(self.open_action)
self.file_menu.addAction(self.open_pred_action)
self.file_menu.addAction(exit_action)
# Status Bar
self.status = self.statusBar()
self.status_label = QtWidgets.QLabel()
self.status_label.setText(
"Frame {}/{}.\t\t Current Timestamp: {}.\t\t Time Window Size: {}s".format(0, 0, 0, 0.0))
self.status.addPermanentWidget(self.status_label)
transform = np.array([[0.5, 1.3], [-1.7, 0.2]]) measure_coords_2d = (measure_coords_2d[..., None] * transform[None, None, ...]).sum(axis=2) + origin measure_vals_2d = np.random.normal(size=(w, h)) + 10 measure_vals_2d = scipy.ndimage.gaussian_filter(measure_vals_2d, (2, 2)) measure_coords = measure_coords_2d.reshape(w*h, 2) measure_vals = measure_vals_2d.reshape(w*h) plt = pg.plot() plt.resize(1000, 1000) colors = [pg.mkBrush(np.clip([(x-10)*250 + 50, (x-10)*250, (x-10)*250 - 50], 0, 255)) for x in measure_vals] scatter = plt.plot(measure_coords[:,0], measure_coords[:,1], symbolBrush=colors, symbolPen=None, pen=None, symbol='o', symbolSize=3) x_bounds = -100, 0 y_bounds = 300, 380 img_coords = np.zeros((50, 50, 2)) img_coords[:, :, 0] = np.linspace(x_bounds[0], x_bounds[1], 50)[None, :] img_coords[:, :, 1] = np.linspace(y_bounds[0], y_bounds[1], 50)[:, None] interp = LinearNDInterpolator(measure_coords, measure_vals) img_vals = interp(img_coords) img = pg.ImageItem(img_vals.T, levels=[8, 15]) plt.addItem(img) brect = pg.QtCore.QRectF(x_bounds[0], y_bounds[0], x_bounds[1]-x_bounds[0], y_bounds[1]-y_bounds[0]) img.setRect(brect) img.setZValue(-10)
def myLayout(self):
self.layout = QtGui.QHBoxLayout(self) #the whole window, main layout
self.leftLayout = QtGui.QVBoxLayout()
self.middleLayout = QtGui.QVBoxLayout()
self.rightLayout = QtGui.QHBoxLayout()
self.controlsLayout = QtGui.QGridLayout()
self.lineoutsLayout = QtGui.QGridLayout()
self.cameraLayout = QtGui.QVBoxLayout()
self.plotLayout = QtGui.QVBoxLayout()
self.phaseLayout = QtGui.QVBoxLayout()
self.layout.addLayout(self.leftLayout)
self.layout.addLayout(self.middleLayout)
self.layout.addLayout(self.rightLayout)
self.middleLayout.addLayout(self.controlsLayout)
self.leftLayout.addLayout(self.lineoutsLayout)
self.leftLayout.addLayout(self.cameraLayout)
self.rightLayout.addLayout(self.plotLayout)
self.rightLayout.addLayout(self.phaseLayout)
self.plotWidget1 = pq.PlotWidget(title='BC1 horn antenna')
self.plotWidget1.setVisible(True)
self.plotWidget1.setMaximumSize(350, 170)
self.plot11 = self.plotWidget1.plot()
self.plotWidget2 = pq.PlotWidget(title='BC2 horn antenna')
self.plotWidget2.setVisible(True)
self.plotWidget2.setMaximumSize(350, 170)
self.plot21 = self.plotWidget2.plot(
axisItems=['signal sum', 'pixel', '', ''])
self.plotWidget3 = pq.PlotWidget(title='BC1 horn antenna trend')
self.plotWidget3.setVisible(True)
self.plotWidget3.setMaximumSize(350, 185)
self.plot31 = self.plotWidget3.plot()
self.plotWidget4 = pq.PlotWidget(title='BC2 horn antenna trend')
self.plotWidget4.setVisible(True)
self.plotWidget4.setMaximumSize(350, 185)
self.plot41 = self.plotWidget4.plot()
self.lineoutsLayout.addWidget(self.plotWidget1)
self.lineoutsLayout.addWidget(self.plotWidget3)
self.lineoutsLayout.addWidget(self.plotWidget2)
self.lineoutsLayout.addWidget(self.plotWidget4)
#camera image
#self.cameraWindow = pq.GraphicsLayoutWidget()
self.cameraWindow = pq.PlotWidget()
self.cameraWindow.setMaximumSize(350, 350)
#self.cameraWindow.setSizePolicy(QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding)
self.cameraLayout.addWidget(self.cameraWindow)
#self.view = self.cameraWindow.addViewBox()
#self.view.setAspectLocked(True)
self.img = pq.ImageItem(border='w')
self.cameraWindow.addItem(self.img)
#roi
self._roi = pq.ROI([300, 440], [self._pixX, self._pixY])
self._roi.addScaleHandle(1, 0)
self._roi.scaleSnap = True # Force ROI to integer snap positions
#self._roi.maxBounds = QtCore.QRect(0, 0, 1280, 1024)
self._roi.sigRegionChangeFinished.connect(self.change_roi)
self.cameraWindow.addItem(self._roi)
self._roi.setZValue(10) # make sure ROI is drawn above image
self.chooseScreenBox = QtGui.QComboBox()
self.chooseScreenBox.addItems(self.cameraNames)
#self.screenSelectedLabel = QtGui.QLabel("none selected")
#self.screenBoxLabel = QtGui.QLabel("select camera")
#self.cameraStartButton = QtGui.QPushButton("start camera")
#self.cameraStopButton = QtGui.QPushButton("stop camera")
self.saveImagesButton = QtGui.QPushButton("save images")
self.noImagesBox = QtGui.QSpinBox()
self.noImagesBox.setValue(5)
self.imageNameBox = QtGui.QLineEdit()
self.imageFolderNameBox = QtGui.QLineEdit()
#camera box
self.cameraBox = QtGui.QGroupBox()
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum,
QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.cameraBox.sizePolicy().hasHeightForWidth())
self.cameraBox.setSizePolicy(sizePolicy)
self.cameraBox.setMinimumSize(QtCore.QSize(150, 0))
self.cameraBox.setMaximumSize(QtCore.QSize(200, 80))
#self.cameraBox.setObjectName("Select Camera")
self.chooseScreenBox = QtGui.QComboBox(self.cameraBox)
self.chooseScreenBox.setGeometry(QtCore.QRect(20, 20, 50, 15))
self.chooseScreenBox.setObjectName("chooseScreenBox")
self.chooseScreenBox.addItems(self.cameraNames)
self.screenSelectedLabel = QtGui.QLabel(self.cameraBox)
self.chooseScreenBox.setGeometry(QtCore.QRect(20, 50, 50, 15))
#self.screenSelectedLabel.setText("none selected")
self.screenBoxLabel = QtGui.QLabel(self.cameraBox)
self.screenBoxLabel.setText("select camera")
self.cameraStartButton = QtGui.QPushButton(self.cameraBox)
self.cameraStartButton.setText("start camera")
self.cameraStartButton.setGeometry(QtCore.QRect(20, 80, 20, 15))
self.cameraStopButton = QtGui.QPushButton("stop camera",
self.cameraBox)
self.cameraStopButton.setGeometry(QtCore.QRect(20, 110, 20, 15))
self.controlsLayout.addWidget(self.cameraBox)
self.saveImagesButton = QtGui.QPushButton("save images")
self.noImagesBox = QtGui.QSpinBox()
self.noImagesBox.setValue(5)
self.imageNameBox = QtGui.QLineEdit()
self.imageFolderNameBox = QtGui.QLineEdit()
self.VExpSpacer = QtGui.QSpacerItem(100, 100,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.VFixSpacer = QtGui.QSpacerItem(100, 100,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Minimum)
self.VFixSmallSpacer = QtGui.QSpacerItem(100, 25,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Minimum)
#phase scan controls
self.scanPhaseRadioButtonLabel = QtGui.QLabel('Scan L00 phase')
self.scanPhaseRadioButton = QtGui.QRadioButton()
self.scanPhaseInitialLabel = QtGui.QLabel('initial phase')
self.scanPhaseFinalLabel = QtGui.QLabel('final phase')
self.scanPhaseFinal = QtGui.QDoubleSpinBox()
#self.controlsLayout.addWidget(self.screenBoxLabel,8,0)
#self.controlsLayout.addWidget(self.chooseScreenBox,9,0)
#self.controlsLayout.addWidget(self.screenSelectedLabel,10,0)
#self.controlsLayout.addWidget(self.cameraStartButton,11,0)
#self.controlsLayout.addWidget(self.cameraStopButton,12,0)
#self.controlsLayout.addItem(self.VExpSpacer,13,0)
#self.controlsLayout.addWidget(self.)
self.controlsLayout.addItem(self.VExpSpacer, 13, 0)
self.controlsLayout.addWidget(self.saveImagesButton, 14, 0)
self.controlsLayout.addWidget(self.noImagesBox, 15, 0)
self.controlsLayout.addWidget(QtGui.QLabel("file name"), 16, 0)
self.controlsLayout.addWidget(self.imageNameBox, 17, 0)
self.controlsLayout.addWidget(QtGui.QLabel("folder name"), 18, 0)
self.controlsLayout.addWidget(self.imageFolderNameBox, 19, 0)
self.controlsLayout.addItem(self.VExpSpacer, 20, 0)
self.saveBkgndButton = QtGui.QPushButton('Save Background')
self.saveBkgndButton.clicked.connect(self.saveBkgnd)
self.subtractBkgndButton = QtGui.QRadioButton()
self.subtractBkgndButton.setText('Subtract bkgnd')
self.controlsLayout.addWidget(self.saveBkgndButton, 21, 0)
self.controlsLayout.addWidget(self.subtractBkgndButton, 22, 0)
self.chooseScreenBox.activated.connect(self.updatescreenSelected)
self.cameraStartButton.clicked.connect(self.cameraStart)
self.cameraStopButton.clicked.connect(self.cameraStop)
self.saveImagesButton.clicked.connect(self.saveImages)
self.rightLayout.addLayout(self.plotLayout)
self.plotWidget5 = pq.PlotWidget(title='beam lineout')
self.plotWidget5.setVisible(True)
self.plotWidget5.setMaximumSize(350, 185)
self.plot51 = self.plotWidget5.plot()
self.plot52 = self.plotWidget5.plot()
self.plotWidget6 = pq.PlotWidget(title='beam trans. std trend')
self.plotWidget6.setVisible(True)
self.plotWidget6.setMaximumSize(350, 185)
self.plot61 = self.plotWidget6.plot()
#self.plotLayout.addWidget(self.plotWidget3)
#self.plotLayout.addWidget(self.plotWidget4)
self.plotLayout.addWidget(self.cameraWindow)
self.plotLayout.addWidget(self.plotWidget5)
self.plotLayout.addWidget(self.plotWidget6)
#phases
self.L00PhaseCrest = QtGui.QLineEdit()
self.L00PhaseCrest.setText('1000')
self.L00PhaseWrite = QtGui.QDoubleSpinBox()
self.L00PhaseWrite.setRange(0, 1000)
self.L00PhaseRead = QtGui.QLabel()
self.L01PhaseCrest = QtGui.QLineEdit()
self.L01PhaseCrest.setText('303')
self.L01PhaseWrite = QtGui.QDoubleSpinBox()
self.L01PhaseWrite.setRange(0, 1000)
self.L01PhaseRead = QtGui.QLabel()
self.L02PhaseCrest = QtGui.QLineEdit()
self.L02PhaseCrest.setText('163')
self.L02PhaseWrite = QtGui.QDoubleSpinBox()
self.L02PhaseWrite.setRange(0, 1000)
self.L02PhaseRead = QtGui.QLabel()
self.phaseLayout.addWidget(QtGui.QLabel("L00 crest phase"))
self.phaseLayout.addWidget(self.L00PhaseCrest)
self.phaseLayout.addWidget(QtGui.QLabel("L00 phase"))
self.phaseLayout.addWidget(self.L00PhaseWrite)
L00Phase = self.L00PhaseDevice.read_attribute('PhaseDifference').value
self.L00PhaseWrite.setValue(L00Phase)
self.L00PhaseWrite.valueChanged.connect(self.setL00Phase)
self.phaseLayout.addWidget(self.L00PhaseRead)
self.L00PhaseDevice.read_attribute('PhaseDifference').value
self.L00PhaseRead.setText(
str(self.L00PhaseDevice.read_attribute('PhaseDifference').value))
self.phaseLayout.addItem(self.VFixSpacer)
self.phaseLayout.addWidget(QtGui.QLabel("L01 crest phase"))
self.phaseLayout.addWidget(self.L01PhaseCrest)
self.phaseLayout.addWidget(QtGui.QLabel("L01 phase"))
self.phaseLayout.addWidget(self.L01PhaseWrite)
L01Phase = self.L01PhaseDevice.read_attribute('PhaseDifference').value
self.L01PhaseWrite.setValue(L01Phase)
self.L01PhaseWrite.valueChanged.connect(self.setL01Phase)
self.phaseLayout.addWidget(self.L01PhaseRead)
self.L01PhaseDevice.read_attribute('PhaseDifference').value
self.L01PhaseRead.setText(
str(self.L01PhaseDevice.read_attribute('PhaseDifference').value))
self.phaseLayout.addItem(self.VFixSpacer)
self.phaseLayout.addWidget(QtGui.QLabel("L02 crest phase"))
self.phaseLayout.addWidget(self.L02PhaseCrest)
self.phaseLayout.addWidget(QtGui.QLabel("L02 phase"))
self.phaseLayout.addWidget(self.L02PhaseWrite)
L02Phase = self.L02PhaseDevice.read_attribute('PhaseDifference').value
self.L02PhaseWrite.setValue(L02Phase)
self.L02PhaseWrite.valueChanged.connect(self.setL02Phase)
self.phaseLayout.addWidget(self.L02PhaseRead)
self.L02PhaseDevice.read_attribute('PhaseDifference').value
self.L02PhaseRead.setText(
str(self.L02PhaseDevice.read_attribute('PhaseDifference').value))
self.phaseLayout.addItem(self.VExpSpacer)
def __init__(self, geometry, plane=-1):
super(viewport, self).__init__(border=None)
# add a view box, which is a widget that allows an image to be shown
self._view = self.addViewBox(border=None)
# add an image item which handles drawing (and refreshing) the image
self._item = pg.ImageItem(useOpenGL=True)
# self._item._setPen((0,0,0))
self._view.addItem(self._item)
# connect the scene to click events, used to get wires
self.scene().sigMouseClicked.connect(self.mouseClicked)
# connect the views to mouse move events, used to update the info box at the bottom
self.scene().sigMouseMoved.connect(self.mouseMoved)
self._plane = plane
self._cmSpace = False
self._geometry = geometry
self._dataPoints = []
self._drawnPoints = []
self._polygon = QtGui.QPolygonF()
self._path = QtGui.QPainterPath()
self._path.addPolygon(self._polygon)
self._polyGraphicsItem = QtGui.QGraphicsPathItem(self._path)
self._view.addItem(self._polyGraphicsItem)
# Connect scale changes to handle the scale bar correctly
self._view.sigYRangeChanged.connect(self.scaleHandler)
self._view.sigXRangeChanged.connect(self.scaleHandler)
self._xBar = None
self._xBarText = None
# self._yBar = None
# self._yBarText = None
self.useScaleBar = False
# Set up the blank data:
# self._blankData = np.ones((self._geometry.wRange(self._plane),self._geometry.tRange()))
self.setBackground('w')
self._useLogo = False
self._logo = None
# each drawer contains its own color gradient and levels
# this class can return a widget containing the right layout for everything
# Define some color collections:
self._colorMap = self._geometry.colorMap(self._plane)
self._cmap = pg.GradientWidget(orientation='right')
self._cmap.restoreState(self._colorMap)
self._cmap.sigGradientChanged.connect(self.refreshGradient)
self._cmap.resize(1, 1)
# These boxes control the levels.
self._upperLevel = QtGui.QLineEdit()
self._lowerLevel = QtGui.QLineEdit()
self._upperLevel.returnPressed.connect(self.levelChanged)
self._lowerLevel.returnPressed.connect(self.levelChanged)
self._lowerLevel.setText(str(self._geometry.getLevels(self._plane)[0]))
self._upperLevel.setText(str(self._geometry.getLevels(self._plane)[1]))
# Fix the maximum width of the widgets:
self._upperLevel.setMaximumWidth(35)
self._cmap.setMaximumWidth(25)
self._lowerLevel.setMaximumWidth(35)
colors = QtGui.QVBoxLayout()
colors.addWidget(self._upperLevel)
colors.addWidget(self._cmap)
colors.addWidget(self._lowerLevel)
self._totalLayout = QtGui.QHBoxLayout()
self._totalLayout.addWidget(self)
self._totalLayout.addLayout(colors)
self._widget = QtGui.QWidget()
self._widget.setLayout(self._totalLayout)
def run(self):
## Always start by initializing Qt (only once per application)
app = QtGui.QApplication([])
## Define a top-level widget to hold everything
w = QtGui.QWidget()
w.resize(800, 800)
w.setWindowTitle("AMCL Viewer")
## Create some widgets to be placed inside
#text = QtGui.QLineEdit('enter text')
p2d = pg.GraphicsView()
button_play = QtGui.QPushButton('Play')
button_play.setFixedWidth(110)
button_play.clicked.connect(self.handleButton_play)
button_next = QtGui.QPushButton('Next')
button_next.setFixedWidth(110)
button_next.clicked.connect(self.handleButton_next)
self.checkbox_show_likelihood_field = QtGui.QCheckBox(
"Show likelihood field")
self.checkbox_show_likelihood_field.setChecked(False)
## Create a grid layout to manage the widgets size and position
layout = QtGui.QGridLayout()
w.setLayout(layout)
## Add widgets to the layout in their proper positions
layout.addWidget(p2d, 0, 0, 1, 5)
layout.addWidget(button_play, 2, 0)
layout.addWidget(button_next, 2, 1)
layout.addWidget(self.checkbox_show_likelihood_field, 2, 2)
# Create a viewBox for 2D image
vb = pg.ViewBox()
vb.setAspectLocked()
p2d.setCentralItem(vb)
self.prob_map = gl.GLSurfacePlotItem(z=np.zeros((80, 80)),
shader='shaded',
color=(0.5, 0.5, 1, 1))
self.prob_map.scale(0.5, 0.5, 1.0)
self.prob_map.translate(-20, -20, 0)
#Create ImageItem for map
self.img = pg.ImageItem(np.zeros((400, 400)))
vb.addItem(self.img)
## Display the widget as a new window
w.show()
## Set image level
self.img.setLevels([0, 1])
#Create ScatterPlotItem for scan data
self.sct = pg.ScatterPlotItem(pen=pg.mkPen(None),
brush=pg.mkBrush("g"),
size=5,
antialias=False)
self.sct.setParentItem(self.img)
#Create RobotItem(custom) for showing robot pose
self.robot = RobotItem('b')
self.robot.setParentItem(self.img)
self.robot.setZValue(10)
#Set timer
timer = pg.QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(300)
## Start the Qt event loop
app.exec_()
def __init__(self):
TemplateBaseClass.__init__(self)
self.setWindowTitle('muscle imaging browser')
# Create the main window
self.ui = WindowTemplate()
#initialize the items created in designer
self.ui.setupUi(self)
#frame view
self.plt = pg.PlotItem()
self.ui.frameView.setCentralItem(self.plt)
self.frameView = pg.ImageItem()
self.plt.addItem(self.frameView)
#gama plot
self.gammaPlt = pg.PlotItem()
self.ui.gammaPlot.setCentralItem(self.gammaPlt)
self.ui.gammaSlider.valueChanged.connect(self.gammaChange)
#default gama
self.gammaf = lambda x: x**1
self.gammax = np.linspace(0,2,100)
self.gammaCurve = self.gammaPlt.plot(self.gammax,self.gammaf(self.gammax))
#timeSeries
self.timeSeriesPlt = pg.PlotItem()
self.ui.timeSeriesPlt.setCentralItem(self.timeSeriesPlt)
#self.tserTrace = self.timeSeriesPlt.plot(np.ones(1000))
self.tpointLine = pg.InfiniteLine(pos = 0,movable = True)
self.tpointLine.sigPositionChanged.connect(self.tpointLineMoved)
self.timeSeriesPlt.addItem(self.tpointLine)
#load frames button
self.ui.loadFrames.clicked.connect(self.loadFrames)
self.ui.applyDemix.clicked.connect(self.extract_signals)
#save data button
self.ui.saveFit.clicked.connect(self.saveFit)
self.ui.loadFit.clicked.connect(self.loadFit)
##scroll bar
self.ui.frameScrollBar.valueChanged.connect(self.frameScrollBar_valueChanged)
# Contrast/color control
self.hist = pg.HistogramLUTItem()
self.hist.setImageItem(self.frameView)
self.ui.frameHist.setCentralItem(self.hist)
#load data
self.loadModel()
self.current_frame = 0
self.show()
#self.ui.commentBox
self.ui.frameNumber.setText(str(self.current_frame))
self.ui.frameNumber.textEdited.connect(self.frameInput)
#addEpoch
self.epochPlots = dict()
self.epoch_dict = dict()
self.ui.newEpoch.clicked.connect(self.newEpoch)
self.ui.saveEpoch.clicked.connect(self.saveEpoch)
self.ui.epochStart.textEdited.connect(self.updateEpochFromText)
self.ui.epochEnd.textEdited.connect(self.updateEpochFromText)
def get_data(self, s):
print('get data')
if isinstance(s, QMdiSubWindow) and str(
s.objectName()) in self.opened_wd_names:
sub = self.mdi.currentSubWindow()
self.data_dict = ut.ibw2dict(self.current_dir + '/' +
str(s.objectName()))
elif isinstance(s, QListWidgetItem):
file_name = s.text()
self.opened_wd_names.append(file_name)
MDIWindow.count = MDIWindow.count + 1
sub = QMdiSubWindow()
sub.resize(550, 550)
sub.setWindowTitle(file_name)
sub.setObjectName(file_name)
self.data_dict = ut.ibw2dict(self.current_dir + '/' + file_name)
else:
print(isinstance(s, QMdiSubWindow), isinstance(s, QListWidgetItem))
print(type(s))
return
e_sc = self.data_dict['E_axis'][1] - self.data_dict['E_axis'][0]
a_sc = self.data_dict['A_axis'][1] - self.data_dict['A_axis'][0]
e_rg = self.data_dict['E_axis'][-1] - self.data_dict['E_axis'][0]
a_rg = self.data_dict['A_axis'][-1] - self.data_dict['A_axis'][0]
e_str = self.data_dict['E_axis'][0]
a_str = self.data_dict['A_axis'][0]
e_end = self.data_dict['E_axis'][-1]
a_end = self.data_dict['A_axis'][-1]
print(e_str, a_str)
print(e_end, a_end)
print(e_rg, a_rg)
print(e_sc, a_sc)
gr_v = pg.GraphicsView()
l = pg.GraphicsLayout()
gr_v.setCentralWidget(l)
sub.setWidget(gr_v)
self.mdi.addSubWindow(sub)
sub.show()
p1 = l.addPlot(x=[1, 2],
y=[1, 2],
name="Plot1",
title="EDC",
pen="r",
row=0,
col=0)
# label1 = pg.LabelItem(justify='right')
# p1.addItem(label1)
plt_i = pg.PlotItem(labels={
'left': ('slits', 'degrees'),
'bottom': ('Kin. Energy', 'eV')
})
plt_i.setRange(xRange=[e_str, e_end],
yRange=[a_str, a_end],
update=True,
padding=0)
vb = plt_i.getViewBox()
vb.setLimits(xMin=e_str, xMax=e_end, yMin=a_str, yMax=a_end)
l.addItem(plt_i, row=1, col=0)
img_i = pg.ImageItem(self.data_dict['data'], border=None)
qrect = vb.viewRect()
img_i.setRect(qrect)
vb.addItem(img_i)
vb.autoRange()
# vb.invertX()
vb.invertY()
p2 = l.addPlot(x=[1, 2],
y=[2, 1],
name="Plot2",
title="MDC",
pen="g",
row=1,
col=1)
# label2 = pg.LabelItem(justify='left')
# plt_i.addItem(label2)
# cross hair
vLine = pg.InfiniteLine(angle=90, movable=False)
hLine = pg.InfiniteLine(angle=0, movable=False)
p1.addItem(vLine, ignoreBounds=False)
p1.addItem(hLine, ignoreBounds=False)
vb1 = p1.vb
pcv = plt_i.addLine(x=e_end, pen='r')
pch = plt_i.addLine(y=a_str, pen='r')
# lROI = pg.ROI(((e_str+e_end)/2,a_str), size=(5*e_sc,a_rg))
# vb.addItem(lROI)
# slice, coor = lROI.getArrayRegion(self.data_dict['data'], img_i ,returnMappedCoords = True)
# print('slice')
# sl_sum=np.sum(slice, axis=0)
# print(sl_sum[0:10])
# print(type(slice), slice.shape)
# print(type(coor), coor.shape)
# print(coor[1,0,0:10])
# p2.invertY()
# p2.setYLink(plt_i)
# p2.plot(y=coor[1,0,:], x=sl_sum)
def onMouseMoved(point):
p = vb.mapSceneToView(point)
pcv.setValue(p.x())
pch.setValue(p.y())
# print(p.x(), p.y())
hROI = pg.ROI((e_str, p.y()), size=(e_rg, 5 * a_sc))
vb.addItem(hROI)
hROI.hide()
sl, co = hROI.getArrayRegion(self.data_dict['data'],
img_i,
returnMappedCoords=True)
sl_sum = np.sum(sl, axis=1)
p1.setXLink(plt_i)
p1.plot(x=co[0, :, 0], y=sl_sum, clear=True)
vROI = pg.ROI((p.x(), a_str), size=(5 * e_sc, a_rg))
vb.addItem(vROI)
vROI.hide()
slc, coo = vROI.getArrayRegion(self.data_dict['data'],
img_i,
returnMappedCoords=True)
sl_sum = np.sum(slc, axis=0)
p2.invertY()
p2.setYLink(plt_i)
p2.plot(y=coo[1, 0, :], x=sl_sum, clear=True)
# label2.setText("{}-{}".format(p.x(), p.y()))
img_i.scene().sigMouseMoved.connect(onMouseMoved)
## create GUI
app = QtGui.QApplication([])
w = pg.GraphicsWindow(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)
v1a.disableAutoRange('xy')
v1b.disableAutoRange('xy')
v1a.autoRange()
v1b.autoRange()
rois = []
rois.append(pg.RectROI([20, 20], [20, 20], pen=(0, 9)))
rois[-1].addRotateHandle([1, 0], [0.5, 0.5])
rois.append(pg.LineROI([0, 60], [20, 80], width=5, pen=(1, 9)))
rois.append(
pg.MultiRectROI([[20, 90], [50, 60], [60, 90]], width=5, pen=(2, 9)))
rois.append(pg.EllipseROI([60, 10], [30, 20], pen=(3, 9)))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
uic.loadUi("MainApp.ui", self)
# Variables for UI and SDR
self.center_freq = 100.0e6
self.band_width = 2.4e6
self.CHUNK = 1024
self.PPM = 60
self.isRunning = False
self.gain = 0.0
self.aspect_ratio = 1.0
self.isPeaks = False
self.tmp = 0
self.history_length = 128
#self.PSD = np.arange(-1,2)
#self.freq = np.arange(-1,2)*self.band_width/2.0 + self.center_freq
self.calc_freq = lambda bw, nfft, cf: np.linspace(
-bw / 2, bw / 2, nfft) + cf
self.freq = self.calc_freq(self.band_width, self.CHUNK,
self.center_freq)
self.data = np.random.rand(self.CHUNK) * 1e-6
self.history = np.zeros(shape=(self.history_length, self.CHUNK))
self.waterfallView.plot()
self.waterfallView.setLabel("bottom", "Frequency", units="Hz")
self.waterfallView.setLabel("left", "Time")
self.waterfallView.setLimits(xMin=self.freq[0],
xMax=self.freq[-1],
yMin=-self.history_length,
yMax=0)
# We need to construct image for waterfall
self.img_waterfall = pg.ImageItem()
self.waterfallView.addItem(self.img_waterfall)
"""
grad = QtGui.QLinearGradient(0, 0, 0, 0.000004)
grad.setColorAt(0.000007, pg.mkColor('#000000'))
grad.setColorAt(0.000005, pg.mkColor('b'))
brush = QtGui.QBrush(grad)
"""
self.spectrumView.setLimits(xMin=self.freq[0], xMax=self.freq[-1])
self.curve = self.spectrumView.plot(x=self.freq,
y=self.data,
pen='w',
fillLevel=-8,
fillBrush=(55, 155, 255, 100),
padding=0.0,
autoRange=False)
self.curve.setPen((255, 255, 195, 90), width=1)
self.curvePeaks = self.spectrumView.plot(self.freq,
self.freq * 1.0e-5,
pen=None,
symbol='d',
symbolBrush=(215, 155, 255,
200))
self.spectrumView.setLabel("left", "Power", units="dB")
self.spectrumView.setLimits(yMin=-4, yMax=-1)
self.spectrumView.setLogMode(x=None, y=True)
self.spectrumView.showGrid(x=True, y=None, alpha=0.8)
self.spectrumView.setLabel("bottom", "Frequency", units="Hz")
self.spectrumView.showButtons()
# Create crosshair
self.vLine = pg.InfiniteLine(angle=90, movable=False, pen='#aaaabb')
self.vLine.setZValue(1000)
self.hLine = pg.InfiniteLine(angle=0, movable=False, pen='#aaaabb')
self.hLine.setZValue(1000)
self.spectrumView.addItem(self.vLine, ignoreBounds=True)
self.spectrumView.addItem(self.hLine, ignoreBounds=True)
self.vLine2 = pg.InfiniteLine(angle=90, movable=False, pen='#aaaabb')
self.vLine2.setZValue(1000)
self.waterfallView.addItem(self.vLine2, ignoreBounds=True)
self.spectrumView.setTitle('Power Spectral Density')
# Link ranges and focus of spectrum and waterfall
self.spectrumView.setXLink(self.waterfallView)
# Gradient color level selector
self.histogram_layout = pg.GraphicsLayoutWidget()
self.verticalLayout.addWidget(self.histogram_layout)
self.histogram = pg.HistogramLUTItem(fillHistogram=False)
self.histogram_layout.addItem(self.histogram)
# Load a predefined gradient. Currently defined gradients are:
self.gradient_presets = [
'thermal', 'flame', 'yellowy', 'bipolar', 'spectrum', 'cyclic',
'greyclip', 'grey'
]
self.histogram.gradient.loadPreset(self.gradient_presets[1])
#self.histogram.setHistogramRange(-50, 0)
self.histogram.setLevels(-1.0e-3, 1.0e-2)
self.histogram.setHistogramRange(-2.0e-2, 2.0e-3, padding=1)
# Lables
self.lblFreq.setText(str(self.center_freq))
#
self.spinBoxFrequency.setValue(self.center_freq)
self.spinBoxPPM.setValue(self.PPM)
# averaging filter for psd
self.doubleSpinBoxAlfa.setValue(0.9)
self.comboBoxGain.currentIndex = 21
self.pushButtonConnect.clicked.connect(self.initThread)
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.abspath(
os.path.join(parent.basename, 'ops.npy'))
print(fileName)
self.openFile(fileName)
import pyqtgraph as pg
# build lookup table
lut = np.zeros((255, 3), dtype=np.ubyte)
lut[:128, 0] = np.arange(0, 255, 2)
lut[128:, 0] = 255
lut[:, 1] = np.arange(255)
# random image data
img = np.random.normal(size=(100, 100))
# GUI
win = pg.GraphicsWindow()
view = win.addViewBox()
view.setAspectLocked(True)
item = pg.ImageItem(img)
item.setLookupTable(lut)
item.setLevels([0, 1])
view.addItem(item)
# Equivalently, you could use a ColorMap to generate the lookup table:
# pos = np.array([0.0, 0.5, 1.0])
# color = np.array([[0,0,0,255], [255,128,0,255], [255,255,0,255]], dtype=np.ubyte)
# map = pg.ColorMap(pos, color)
# lut = map.getLookupTable(0.0, 1.0, 256)
## Start Qt event loop unless running in interactive mode.
if __name__ == '__main__':
import sys
import initExample ## Add path to library (just for examples; you do not need this)
import pyqtgraph as pg
from pyqtgraph.Qt import QtCore, QtGui, QtWidgets
import numpy as np
pg.mkQApp()
win = pg.GraphicsLayoutWidget()
win.setWindowTitle('pyqtgraph example: Image Analysis')
# A plot area (ViewBox + axes) for displaying the image
p1 = win.addPlot()
# Item for displaying image data
img = pg.ImageItem()
p1.addItem(img)
# Custom ROI for selecting an image region
roi = pg.ROI([-8, 14], [6, 5])
roi.addScaleHandle([0.5, 1], [0.5, 0.5])
roi.addScaleHandle([0, 0.5], [0.5, 0.5])
p1.addItem(roi)
roi.setZValue(10) # make sure ROI is drawn above image
# Isocurve drawing
iso = pg.IsocurveItem(level=0.8, pen='g')
iso.setParentItem(img)
iso.setZValue(5)
# Contrast/color control
def __init__(self):
TemplateBaseClass.__init__(self)
self.setWindowTitle('pyqtgraph example: Qt Designer')
# Create the main window
self.ui = WindowTemplate()
self.ui.setupUi(self)
#frame view
self.vb = pg.ViewBox()
self.vb.setAspectLocked()
self.ui.frameView.setCentralItem(self.vb)
self.frameView = pg.ImageItem()
self.vb.addItem(self.frameView)
#load frames button
self.ui.loadFrames.clicked.connect(self.loadFrames)
#save data button
self.ui.saveTracks.clicked.connect(self.saveTracks)
self.ui.loadTracks.clicked.connect(self.loadTracks)
##scroll bar
self.ui.frameScrollBar.valueChanged.connect(
self.frameScrollBar_valueChanged)
# Contrast/color control
self.hist = pg.HistogramLUTItem()
self.hist.setImageItem(self.frameView)
self.ui.frameHist.setCentralItem(self.hist)
self.current_frame = 0
self.show()
### ROI's
self.roi_b1 = PolyMaskROI([[0., 0.], [5., 10.], [10., 5.]],
closed=True,
pen=(1, 8))
self.roi_b1.img = pg.ImageItem()
self.roi_b2 = PolyMaskROI([[0., 0.], [5., 10.], [10., 5.]],
closed=True,
pen=(2, 8))
self.roi_b2.img = pg.ImageItem()
self.roi_b3 = PolyMaskROI([[0., 0.], [5., 10.], [10., 5.]],
closed=True,
pen=(3, 8))
self.roi_b3.img = pg.ImageItem()
self.roi_i1 = PolyMaskROI([[0., 0.], [5., 10.], [10., 5.]],
closed=True,
pen=(4, 8))
self.roi_i1.img = pg.ImageItem()
self.roi_i2 = PolyMaskROI([[0., 0.], [5., 10.], [10., 5.]],
closed=True,
pen=(4, 8))
self.roi_i2.img = pg.ImageItem()
self.roi_iii1 = PolyMaskROI([[0., 0.], [5., 10.], [10., 5.]],
closed=True,
pen=(5, 8))
self.roi_iii1.img = pg.ImageItem()
self.roi_iii234 = PolyMaskROI([[0., 0.], [5., 10.], [10., 5.]],
closed=True,
pen=(6, 8))
self.roi_iii234.img = pg.ImageItem()
self.roi_hg1 = PolyMaskROI([[0., 0.], [5., 10.], [10., 5.]],
closed=True,
pen=(7, 8))
self.roi_hg1.img = pg.ImageItem()
self.roi_hg234 = PolyMaskROI([[0., 0.], [5., 10.], [10., 5.]],
closed=True,
pen=(8, 8))
self.roi_hg234.img = pg.ImageItem()
self.view_b1 = pg.PlotWidget()
self.view_b2 = pg.PlotWidget()
self.view_b3 = pg.PlotWidget()
self.view_i1 = pg.PlotWidget()
self.view_i2 = pg.PlotWidget()
self.view_iii1 = pg.PlotWidget()
self.view_iii234 = pg.PlotWidget()
self.view_hg1 = pg.PlotWidget()
self.view_hg234 = pg.PlotWidget()
self.roi_list = [
self.roi_b1, self.roi_b2, self.roi_b3, self.roi_i1, self.roi_i2,
self.roi_iii1, self.roi_iii234, self.roi_hg1, self.roi_hg234
]
self.view_list = [
self.view_b1,
self.view_b2,
self.view_b3,
self.view_i1,
self.view_i2,
self.view_iii1,
self.view_iii234,
self.view_hg1,
self.view_hg234,
]
for i, r, r_view, name in zip(
range(len(self.roi_list)), self.roi_list, self.view_list,
['b1', 'b2', 'b3', 'i1', 'i2', 'iii1', 'iii234', 'hg1', 'hg234']):
self.viewb.addItem(r)
r_view.addItem(r.img)
r_view.invertY(True)
r_view.setAspectLocked(True)
self.roi_layout.addWidget(r_view, i, 1, 1, 1)
r.sigRegionChanged.connect(self.updateRoi)
c = self.roi_curves.plot(pen=r.pen)
r.curve = c
r.muscle_name = name
self.muscle_data = dict()
self.roi_layout.addWidget(self.roi_curves, 10, 1, 1, 1)
self.main_layout.addLayout(self.roi_layout, 0, 3, 7, 1)
i1 = model_data['i1']
iii3 = model_data['iii3']
i2 = model_data['i2']
basis = Basis()
basis['a2'] = e1[1] - e2[0]
basis['a1'] = e2[1] - e2[0]
basis['p'] = e2[0]
thorax = GeometricModel(muscle_dict, basis)
thorax_view = ModelView(thorax)
app = QtGui.QApplication([])
#img = pg.ImageItem(np.transpose(sumimg,(1,0,2)))
img = pg.ImageItem(sumimg)
plt = pg.plot()
plt.addItem(img)
img.setZValue(-100)
roi = BasisROI(thorax.basis)
plt.addItem(roi)
plt.disableAutoRange('xy')
plt.autoRange()
#import polygonitem as pgi
#pgitem = pgi.PolygonItem(data = [[(1,0),(3,2),(2,4)]])
#plt.addItem(pgitem)
import copy
plot_basis = copy.copy(thorax.basis)
thorax_view.plot(plot_basis, plt)
def createLayout(self):
print 'Creating layout...'
self.setWindowTitle('Interferometry Acquisition GUI')
#self.widget = QtGui.QWidget()
#self.setCentralWidget(self.widget)
self.layout = pg.LayoutWidget()
#self.widget.setLayout(self.layout)
self.setCentralWidget(self.layout)
#Create GUI
sizePolicyBt = QtGui.QSizePolicy(1, 1)
sizePolicyBt.setHorizontalStretch(0)
sizePolicyBt.setVerticalStretch(0)
self.btOpen = QtGui.QPushButton("Open\nprevious results")
sizePolicyBt.setHeightForWidth(
self.btOpen.sizePolicy().hasHeightForWidth())
self.btOpen.setSizePolicy(sizePolicyBt)
self.btOpen.setStyleSheet(
"background-color: yellow; font-size: 16px; font: bold")
self.btStart = QtGui.QPushButton("Start\nacquisition")
sizePolicyBt.setHeightForWidth(
self.btStart.sizePolicy().hasHeightForWidth())
self.btStart.setSizePolicy(sizePolicyBt)
self.btStart.setStyleSheet(
"background-color: green; font-size: 16px; font: bold")
self.btStart.clicked.connect(self.startAcquisition)
self.btStop = QtGui.QPushButton("Stop\nacquisition")
sizePolicyBt.setHeightForWidth(
self.btStop.sizePolicy().hasHeightForWidth())
self.btStop.setSizePolicy(sizePolicyBt)
self.btStop.setStyleSheet(
"background-color: red; font-size: 16px; font: bold")
self.btStop.clicked.connect(self.stopAcquisition)
self.btStop.setEnabled(False)
self.paramTree = ParameterTree()
self.paramTree.setParameters(Parameters.paramObject, showTop=False)
self.paramTree.setWindowTitle('pyqtgraph example: Parameter Tree')
self.paramTree.setMinimumWidth(350)
self.paramTree.setMaximumWidth(350)
sizePolicyPt = QtGui.QSizePolicy(1, 1)
sizePolicyPt.setHorizontalStretch(QtGui.QSizePolicy.Fixed)
sizePolicyPt.setVerticalStretch(1)
self.paramTree.setSizePolicy(sizePolicyPt)
## Create random 2D data
data = np.random.normal(size=(
512, 512)) + pg.gaussianFilter(np.random.normal(size=(512, 512)),
(5, 5)) * 20 + 100
data = data[:, :, np.newaxis]
data = data.repeat(3, 2)
self.plotTl = pg.GraphicsView()
self.plotTlImage = pg.ImageItem(data[:, :, :]) #parent=self.plotTl
self.plotTlViewBox = pg.ViewBox()
self.plotTl.setCentralWidget(self.plotTlViewBox)
self.plotTlViewBox.addItem(self.plotTlImage)
self.plotTr = pg.PlotWidget(title="Interferometry",
labels={
'left': 'Signal amplitude (A.U.)',
'bottom': 'Distance (mm)'
})
#self.plotTlViewBox2.addItem(self.plotTr)
self.plotTrCurve = self.plotTr.plot(pen=(255, 0, 0), name='C1') #Red
self.plotTrCurve2 = self.plotTr.plot(pen=(0, 255, 0),
name='C2') #Green
#self.plotTlViewBox2.enableAutoRange('xy', True) ## stop auto-scaling after the first data set is plotted
#self.plotTr.addLegend('Test')
self.plotTr.setYRange(-1000, 1000)
self.plotBl = pg.PlotWidget(title="Distance",
labels={
'left': 'Distance (mm)',
'bottom': 'Number of acquisitions'
})
self.plotBlCurve = self.plotBl.plot(pen=(255, 0, 0), name='C1')
self.plotBl.enableAutoRange(
'xy',
True) ## stop auto-scaling after the first data set is plotted
self.plotBl.setMaximumWidth(3500)
self.tbInfo = QtGui.QTextEdit()
self.tbInfo.setEnabled(False)
palette = self.tbInfo.palette()
palette.setColor(QtGui.QPalette.Base,
QtGui.QColor("white")) #White background
self.tbInfo.setPalette(palette)
self.tbInfo.setTextColor(QtGui.QColor("black"))
self.tbInfo.insertPlainText("Useful information will appear here.")
#Create list view of multiple items
self.tbStatus = QtGui.QListView()
self.tbStatus.setEnabled(False)
palette = self.tbStatus.palette()
palette.setColor(QtGui.QPalette.Base,
QtGui.QColor("white")) #White background
self.tbStatus.setPalette(palette)
itemModelStatus = QtGui.QStandardItemModel(self.tbStatus)
self.tbStatus.setModel(itemModelStatus)
#Add system status
self.itemStatus = QtGui.QStandardItem()
self.setStatus(False)
itemModelStatus.appendRow(self.itemStatus)
#Add camera status
self.itemCameraStatus = QtGui.QStandardItem()
self.setCameraStatus(False)
itemModelStatus.appendRow(self.itemCameraStatus)
#Add memory usage
self.itemMemory = QtGui.QStandardItem(
"Acquisition board memory usage: N/A")
self.itemMemory.setForeground(QtGui.QColor("black"))
itemModelStatus.appendRow(self.itemMemory)
#Add max value position
self.itemMaxValPos = QtGui.QStandardItem(
"Maximum RF value position: N/A")
self.itemMaxValPos.setForeground(QtGui.QColor("black"))
itemModelStatus.appendRow(self.itemMaxValPos)
#layout.addWidget(QtGui.QLabel("These are two views of the same data. They should always display the same values."), 0, 0, 1, 2)
self.layout.addWidget(self.btOpen, 9, 6, 1, 1)
self.layout.addWidget(self.btStart, 9, 7, 1, 1)
self.layout.addWidget(self.btStop, 9, 8, 1, 1)
self.layout.addWidget(self.paramTree, 0, 0, 10, 3)
self.layout.addWidget(self.plotTl, 0, 3, 5, 3)
self.layout.addWidget(self.plotTr, 0, 6, 5, 3)
self.layout.addWidget(self.plotBl, 5, 3, 5, 3)
self.layout.addWidget(self.tbInfo, 5, 6, 2, 3)
self.layout.addWidget(self.tbStatus, 7, 6, 2, 3)
self.layout.layout.setColumnStretch(3, 1)
self.layout.layout.setColumnStretch(4, 1)
self.layout.layout.setColumnStretch(5, 1)
self.layout.layout.setColumnStretch(6, 1)
self.layout.layout.setColumnStretch(7, 1)
self.layout.layout.setColumnStretch(8, 1)
self.show()
self.resize(1500, 800)
self.move(100, 100)
Parameters.paramObject.param('Save/Restore functionality',
'Save State').sigActivated.connect(
self.saveParam)
Parameters.paramObject.param('Save/Restore functionality',
'Restore State').sigActivated.connect(
self.restoreParam)
Parameters.paramObject.child(
"Acquisition Parameters",
"Rotation speed (%)").sigValueChanged.connect(
self.motorSpeedChanged)
Parameters.paramObject.child(
"Trigger Options",
"Acquisition mode").sigValueChanged.connect(self.triggerChanged)
Parameters.paramObject.child(
"Trigger Options",
"Trigger amplitude").sigValueChanged.connect(self.triggerChanged)
Parameters.paramObject.child(
"Trigger Options",
"Trigger switch 1/2").sigActivated.connect(self.triggerHalfSwitch)
# adding by emitting signal in different thread
self.workThread = AcquisitionWorker()
self.workThread.updateDataCamera.connect(self.setDataCurveTl)
self.workThread.updateDataInterf.connect(self.setDataCurveTr)
self.workThread.updateDataDistance.connect(self.setDataCurveBl)
self.workThread.updateDataDistance2.connect(self.setDataCurveBl2)
self.workThread.updateWire.connect(self.setWire)
self.workThread.setStatus.connect(self.setStatus)
self.workThread.setInfo.connect(self.setInfo)
self.testCount = 0
#Fill the plots with dummy data
self.data = np.random.normal(size=(10, 1000))
self.plotTrXAxis = np.arange(1000) * (0.01)
self.plotBlXAxis = np.arange(1000) * (1)
self.plotTrCurve.setData(x=self.plotTrXAxis,
y=self.data[2 % 10],
name='C1')
self.plotTrCurve2.setData(x=self.plotTrXAxis,
y=self.data[3 % 10],
name='C2')
self.plotBlCurve.setData(x=self.plotBlXAxis,
y=self.data[4 % 10],
name='C1')
self.valueTest = 1
def __init__(self, main_window):
super(DataViewWidget, self).__init__()
# Currently displayed field
self.current_field = 'velocity'
# Keep ref to main window
self.main_window = main_window
### Create image items for each data field
fields = ['smb', 'bed', 'surface', 'thickness', 'velocity']
# Image items, color bars, and color maps for each data field
self.image_items = {}
self.cbars = {}
for field in fields:
# Load image
color_data = main_window.color_loader.color_data[field]
self.image_items[field] = pg.ImageItem(color_data)
self.image_items[field].setOpts(axisOrder = 'row-major')
self.image_items[field].setZValue(0)
# Respond to mouse click event
self.image_items[field].mouseClickEvent = main_window.mouseClick
# Load color bar
cmap, cbar = main_window.color_loader.get_cmap_cbar(field)
self.cbars[field] = cbar
# Set displayed field
self.addItem(self.image_items[self.current_field])
### Setup the plot widget
# Set some options of the plot widget
self.setAspectLocked(True)
# Create a widget that will anchor the color bar in the top right corner
self.cbar_anchor = ColorBarAnchorWidget()
self.cbar_anchor.hideAxis('left')
self.cbar_anchor.hideAxis('bottom')
self.cbar_anchor.addItem(self.cbars[self.current_field])
self.addItem(self.cbar_anchor)
self.cbar_anchor.setFixedWidth(158)
self.cbar_anchor.setFixedHeight(250)
self.cbar_anchor.setAspectLocked(True)
self.cbar_anchor.getViewBox().setRange(xRange = [-64.0, 114], yRange = [-15, 247], padding = 0.0)
self.cbar_anchor.invertY(True)
self.cbar_anchor.setParentItem(self.getPlotItem())
self.cbar_anchor.getViewBox().setMouseEnabled(x = False, y = False)
self.cbar_anchor.anchor(itemPos = (1, 0), parentPos=(1, 0), offset = (-10, -10))
# Set view ranges
self.getViewBox().setRange(xRange=[0, 10018], yRange=[0, 17964], padding=0.1)
# Mouse move event
self.getViewBox().hoverEvent = main_window.mouseMove
### Flow line stuff
# List of flowlines
self.flowlines = []
# Pen for flow line drawing
self.flowline_pen = pg.mkPen(color=(255, 0, 0), width=2)
# Object for integrating velocity field along flowline
self.flow_integrator = FlowIntegrator(self.main_window.data_loader)
### Flow region stuff
self.flowline_graphs = []
def check_getArrayRegion(roi, name, testResize=True, transpose=False):
initState = roi.getState()
#win = pg.GraphicsLayoutWidget()
win = pg.GraphicsView()
win.show()
resizeWindow(win, 200, 400)
# Don't use Qt's layouts for testing--these generate unpredictable results.
#vb1 = win.addViewBox()
#win.nextRow()
#vb2 = win.addViewBox()
# Instead, place the viewboxes manually
vb1 = pg.ViewBox()
win.scene().addItem(vb1)
vb1.setPos(6, 6)
vb1.resize(188, 191)
vb2 = pg.ViewBox()
win.scene().addItem(vb2)
vb2.setPos(6, 203)
vb2.resize(188, 191)
img1 = pg.ImageItem(border='w')
img2 = pg.ImageItem(border='w')
vb1.addItem(img1)
vb2.addItem(img2)
np.random.seed(0)
data = np.random.normal(size=(7, 30, 31, 5))
data[0, :, :, :] += 10
data[:, 1, :, :] += 10
data[:, :, 2, :] += 10
data[:, :, :, 3] += 10
if transpose:
data = data.transpose(0, 2, 1, 3)
img1.setImage(data[0, ..., 0])
vb1.setAspectLocked()
vb1.enableAutoRange(True, True)
roi.setZValue(10)
vb1.addItem(roi)
if isinstance(roi, pg.RectROI):
if transpose:
assert roi.getAffineSliceParams(data, img1, axes=(1, 2)) == ([28.0, 27.0], ((1.0, 0.0), (0.0, 1.0)), (1.0, 1.0))
else:
assert roi.getAffineSliceParams(data, img1, axes=(1, 2)) == ([27.0, 28.0], ((1.0, 0.0), (0.0, 1.0)), (1.0, 1.0))
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
#assert np.all((rgn == data[:, 1:-2, 1:-2, :]) | (rgn == 0))
img2.setImage(rgn[0, ..., 0])
vb2.setAspectLocked()
vb2.enableAutoRange(True, True)
app.processEvents()
assertImageApproved(win, name+'/roi_getarrayregion', 'Simple ROI region selection.')
with pytest.raises(TypeError):
roi.setPos(0, False)
roi.setPos([0.5, 1.5])
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(win, name+'/roi_getarrayregion_halfpx', 'Simple ROI region selection, 0.5 pixel shift.')
roi.setAngle(45)
roi.setPos([3, 0])
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(win, name+'/roi_getarrayregion_rotate', 'Simple ROI region selection, rotation.')
if testResize:
roi.setSize([60, 60])
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(win, name+'/roi_getarrayregion_resize', 'Simple ROI region selection, resized.')
img1.scale(1, -1)
img1.setPos(0, img1.height())
img1.rotate(20)
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(win, name+'/roi_getarrayregion_img_trans', 'Simple ROI region selection, image transformed.')
vb1.invertY()
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
# on windows, one edge of one ROI handle is shifted slightly; letting this slide with pxCount=10
if sys.platform == 'win32' and pg.Qt.QT_LIB in ('PyQt4', 'PySide'):
pxCount = 10
else:
pxCount=-1
assertImageApproved(win, name+'/roi_getarrayregion_inverty', 'Simple ROI region selection, view inverted.', pxCount=pxCount)
roi.setState(initState)
img1.resetTransform()
img1.setPos(0, 0)
img1.scale(1, 0.5)
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(win, name+'/roi_getarrayregion_anisotropic', 'Simple ROI region selection, image scaled anisotropically.')
# allow the roi to be re-used
roi.scene().removeItem(roi)
win.hide()
