def __init__(self):
super().__init__()
self.data = None # type: Optional[Orange.data.Table]
self._counts = None # type: Optional[np.ndarray]
box = gui.widgetBox(self.controlArea, "Info")
self._info = QLabel(box, wordWrap=True)
self._info.setText("No data in input\n")
box.layout().addWidget(self._info)
box = gui.widgetBox(self.controlArea, "Filter Type", spacing=-1)
rbg = QButtonGroup(box, exclusive=True)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
for id_ in [Cells, Genes, Data]:
name, _, tip = FilterInfo[id_]
b = QRadioButton(name,
toolTip=tip,
checked=id_ == self.selected_filter_type)
rbg.addButton(b, id_)
layout.addWidget(b, stretch=10, alignment=Qt.AlignCenter)
box.layout().addLayout(layout)
rbg.buttonClicked[int].connect(self.set_filter_type)
self.filter_metric_cb = gui.comboBox(
box,
self,
"selected_filter_metric",
callback=self._update_metric,
enabled=self.selected_filter_type != Data)
for id_ in [DetectionCount, TotalCounts]:
text, ttip = MeasureInfo[id_]
self.filter_metric_cb.addItem(text)
idx = self.filter_metric_cb.count() - 1
self.filter_metric_cb.setItemData(idx, ttip, Qt.ToolTipRole)
self.filter_metric_cb.setCurrentIndex(self.selected_filter_metric)
form = QFormLayout(labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
self._filter_box = box = gui.widgetBox(
self.controlArea, "Filter", orientation=form) # type: QGroupBox
self.threshold_stacks = (
QStackedWidget(enabled=self.limit_lower_enabled),
QStackedWidget(enabled=self.limit_upper_enabled),
)
finfo = np.finfo(np.float64)
for filter_ in [Cells, Genes, Data]:
if filter_ in {Cells, Genes}:
minimum = 0.0
ndecimals = 1
metric = self.selected_filter_metric
else:
minimum = finfo.min
ndecimals = 3
metric = -1
spinlower = QDoubleSpinBox(
self,
minimum=minimum,
maximum=finfo.max,
decimals=ndecimals,
keyboardTracking=False,
)
spinupper = QDoubleSpinBox(
self,
minimum=minimum,
maximum=finfo.max,
decimals=ndecimals,
keyboardTracking=False,
)
lower, upper = self.thresholds.get((filter_, metric), (0, 0))
spinlower.setValue(lower)
spinupper.setValue(upper)
self.threshold_stacks[0].addWidget(spinlower)
self.threshold_stacks[1].addWidget(spinupper)
spinlower.valueChanged.connect(self._limitchanged)
spinupper.valueChanged.connect(self._limitchanged)
self.threshold_stacks[0].setCurrentIndex(self.selected_filter_type)
self.threshold_stacks[1].setCurrentIndex(self.selected_filter_type)
self.limit_lower_enabled_cb = cb = QCheckBox(
"Min", checked=self.limit_lower_enabled)
cb.toggled.connect(self.set_lower_limit_enabled)
cb.setAttribute(Qt.WA_LayoutUsesWidgetRect, True)
form.addRow(cb, self.threshold_stacks[0])
self.limit_upper_enabled_cb = cb = QCheckBox(
"Max", checked=self.limit_upper_enabled)
cb.toggled.connect(self.set_upper_limit_enabled)
cb.setAttribute(Qt.WA_LayoutUsesWidgetRect, True)
form.addRow(cb, self.threshold_stacks[1])
box = gui.widgetBox(self.controlArea, "View")
self._showpoints = gui.checkBox(box,
self,
"display_dotplot",
"Show data points",
callback=self._update_dotplot)
self.controlArea.layout().addStretch(10)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
self._view = pg.GraphicsView()
self._view.enableMouse(False)
self._view.setAntialiasing(True)
self._plot = plot = ViolinPlot()
self._plot.setDataPointsVisible(self.display_dotplot)
self._plot.setSelectionMode(
(ViolinPlot.Low if self.limit_lower_enabled else 0)
| (ViolinPlot.High if self.limit_upper_enabled else 0))
self._plot.selectionEdited.connect(self._limitchanged_plot)
self._view.setCentralWidget(self._plot)
self._plot.setTitle(FilterInfo[self.selected_filter_metric][1])
bottom = self._plot.getAxis("bottom") # type: pg.AxisItem
bottom.hide()
plot.setMouseEnabled(False, False)
plot.hideButtons()
self.mainArea.layout().addWidget(self._view)
# Coalescing commit timer
self._committimer = QTimer(self, singleShot=True)
self._committimer.timeout.connect(self.commit)
self.addAction(
QAction("Select All",
self,
shortcut=QKeySequence.SelectAll,
triggered=self._select_all))
def __init__(self):
super().__init__()
self.matrix = None
self._tree = None
self._ordered_tree = None
self._sorted_matrix = None
self._sort_indices = None
self._selection = None
self.sorting_cb = gui.comboBox(
self.controlArea, self, "sorting", box="Element Sorting",
items=["None", "Clustering", "Clustering with ordered leaves"],
callback=self._invalidate_ordering)
box = gui.vBox(self.controlArea, "Colors")
self.color_box = gui.palette_combo_box(self.palette_name)
self.color_box.currentIndexChanged.connect(self._update_color)
box.layout().addWidget(self.color_box)
form = QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow
)
# form.addRow(
# "Gamma",
# gui.hSlider(box, self, "color_gamma", minValue=0.0, maxValue=1.0,
# step=0.05, ticks=True, intOnly=False,
# createLabel=False, callback=self._update_color)
# )
form.addRow(
"Low:",
gui.hSlider(box, self, "color_low", minValue=0.0, maxValue=1.0,
step=0.05, ticks=True, intOnly=False,
createLabel=False, callback=self._update_color)
)
form.addRow(
"High:",
gui.hSlider(box, self, "color_high", minValue=0.0, maxValue=1.0,
step=0.05, ticks=True, intOnly=False,
createLabel=False, callback=self._update_color)
)
box.layout().addLayout(form)
self.annot_combo = gui.comboBox(
self.controlArea, self, "annotation_idx", box="Annotations",
callback=self._invalidate_annotations, contentsLength=12)
self.annot_combo.setModel(itemmodels.VariableListModel())
self.annot_combo.model()[:] = ["None", "Enumeration"]
self.controlArea.layout().addStretch()
gui.auto_send(self.controlArea, self, "autocommit")
self.view = pg.GraphicsView(background="w")
self.mainArea.layout().addWidget(self.view)
self.grid_widget = pg.GraphicsWidget()
self.grid = QGraphicsGridLayout()
self.grid_widget.setLayout(self.grid)
self.viewbox = pg.ViewBox(enableMouse=False, enableMenu=False)
self.viewbox.setAcceptedMouseButtons(Qt.NoButton)
self.viewbox.setAcceptHoverEvents(False)
self.grid.addItem(self.viewbox, 1, 1)
self.left_dendrogram = DendrogramWidget(
self.grid_widget, orientation=DendrogramWidget.Left,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False
)
self.left_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.left_dendrogram.setAcceptHoverEvents(False)
self.top_dendrogram = DendrogramWidget(
self.grid_widget, orientation=DendrogramWidget.Top,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False
)
self.top_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.top_dendrogram.setAcceptHoverEvents(False)
self.grid.addItem(self.left_dendrogram, 1, 0)
self.grid.addItem(self.top_dendrogram, 0, 1)
self.right_labels = TextList(
alignment=Qt.AlignLeft | Qt.AlignVCenter,
sizePolicy=QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
)
self.bottom_labels = TextList(
orientation=Qt.Horizontal,
alignment=Qt.AlignRight | Qt.AlignVCenter,
sizePolicy=QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
)
self.grid.addItem(self.right_labels, 1, 2)
self.grid.addItem(self.bottom_labels, 2, 1)
self.view.setCentralItem(self.grid_widget)
self.left_dendrogram.hide()
self.top_dendrogram.hide()
self.right_labels.hide()
self.bottom_labels.hide()
self.matrix_item = None
self.dendrogram = None
self.grid_widget.scene().installEventFilter(self)
self.settingsAboutToBePacked.connect(self.pack_settings)
Demonstrate ability of ImageItem to be used as a canvas for painting with
the mouse.
"""
import initExample ## Add path to library (just for examples; you do not need this)
from pyqtgraph.Qt import QtCore, QtGui
import numpy as np
import pyqtgraph as pg
app = pg.mkQApp("Draw Example")
## Create window with GraphicsView widget
w = pg.GraphicsView()
w.show()
w.resize(800,800)
w.setWindowTitle('pyqtgraph example: Draw')
view = pg.ViewBox()
w.setCentralItem(view)
## lock the aspect ratio
view.setAspectLocked(True)
## Create image item
img = pg.ImageItem(np.zeros((200,200)))
view.addItem(img)
## Set initial view bounds
def test_PolyLineROI():
rois = [(pg.PolyLineROI([[0, 0], [10, 0], [0, 15]], closed=True,
pen=0.3), 'closed'),
(pg.PolyLineROI([[0, 0], [10, 0], [0, 15]], closed=False,
pen=0.3), 'open')]
#plt = pg.plot()
plt = pg.GraphicsView()
plt.show()
resizeWindow(plt, 200, 200)
vb = pg.ViewBox()
plt.scene().addItem(vb)
vb.resize(200, 200)
#plt.plotItem = pg.PlotItem()
#plt.scene().addItem(plt.plotItem)
#plt.plotItem.resize(200, 200)
plt.scene().minDragTime = 0 # let us simulate mouse drags very quickly.
# seemingly arbitrary requirements; might need longer wait time for some platforms..
QtTest.QTest.qWaitForWindowExposed(plt)
QtTest.QTest.qWait(100)
for r, name in rois:
vb.clear()
vb.addItem(r)
vb.autoRange()
app.processEvents()
assertImageApproved(plt, 'roi/polylineroi/' + name + '_init',
'Init %s polyline.' % name)
initState = r.getState()
assert len(r.getState()['points']) == 3
# hover over center
center = r.mapToScene(pg.Point(3, 3))
mouseMove(plt, center)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_hover_roi',
'Hover mouse over center of ROI.')
# drag ROI
mouseDrag(plt, center, center + pg.Point(10, -10),
QtCore.Qt.LeftButton)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_drag_roi',
'Drag mouse over center of ROI.')
# hover over handle
pt = r.mapToScene(pg.Point(r.getState()['points'][2]))
mouseMove(plt, pt)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_hover_handle',
'Hover mouse over handle.')
# drag handle
mouseDrag(plt, pt, pt + pg.Point(5, 20), QtCore.Qt.LeftButton)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_drag_handle',
'Drag mouse over handle.')
# hover over segment
pt = r.mapToScene((pg.Point(r.getState()['points'][2]) +
pg.Point(r.getState()['points'][1])) * 0.5)
mouseMove(plt, pt + pg.Point(0, 2))
assertImageApproved(plt, 'roi/polylineroi/' + name + '_hover_segment',
'Hover mouse over diagonal segment.')
# click segment
mouseClick(plt, pt, QtCore.Qt.LeftButton)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_click_segment',
'Click mouse over segment.')
# drag new handle
mouseMove(
plt, pt + pg.Point(10, -10)
) # pg bug: have to move the mouse off/on again to register hover
mouseDrag(plt, pt, pt + pg.Point(10, -10), QtCore.Qt.LeftButton)
assertImageApproved(plt,
'roi/polylineroi/' + name + '_drag_new_handle',
'Drag mouse over created handle.')
# clear all points
r.clearPoints()
assertImageApproved(plt, 'roi/polylineroi/' + name + '_clear',
'All points cleared.')
assert len(r.getState()['points']) == 0
# call setPoints
r.setPoints(initState['points'])
assertImageApproved(plt, 'roi/polylineroi/' + name + '_setpoints',
'Reset points to initial state.')
assert len(r.getState()['points']) == 3
# call setState
r.setState(initState)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_setstate',
'Reset ROI to initial state.')
assert len(r.getState()['points']) == 3
plt.hide()
def visualize_new(lidar):
pg.mkQApp()
w = pg.GraphicsView(useOpenGL=True)
w.show()
def initUI(self):
global app, adc1, adc2, curve1, curve2, ptr, window, current_frame
# set up main window, init, resize, etc
window = pg.GraphicsView()
screen_resolution = app.desktop().screenGeometry()
screenWidth, screenHeight = screen_resolution.width(
), screen_resolution.height()
window.resize(screenWidth, screenHeight)
window.setWindowTitle('Biathlon Team Data Processing')
window.show()
layout = pg.GraphicsLayout(border=(100, 100, 100))
window.setCentralItem(layout)
# add plots
adc1 = layout.addPlot(row=0,
col=0,
rowspan=3,
colspan=3,
title="Hall Effect Sensor Voltage vs Time",
labels={
'left': 'Square Root of Voltage (V)',
'bottom': 'Time (seconds)'
})
adc2 = layout.addPlot(row=3,
col=0,
rowspan=3,
colspan=3,
title="Force Sensor Voltage vs Time",
labels={
'left': 'Voltage (V)',
'bottom': 'Time (seconds)'
})
# add button control
# start capture
proxy_start = QtGui.QGraphicsProxyWidget()
startCap = QtGui.QPushButton('Start Data Capture')
startCap.clicked.connect(self.startCapture)
proxy_start.setWidget(startCap)
laystart = layout.addViewBox(row=3,
col=3,
colspan=1,
rowspan=1,
invertY=True,
lockAspect=True,
enableMouse=False)
laystart.addItem(proxy_start)
laystart.autoRange()
# end capture
proxy_end = QtGui.QGraphicsProxyWidget()
endCap = QtGui.QPushButton('End Data Capture')
endCap.clicked.connect(self.endCapture)
proxy_end.setWidget(endCap)
layend = layout.addViewBox(row=3,
col=4,
colspan=1,
rowspan=1,
invertY=True,
lockAspect=True,
enableMouse=False)
layend.addItem(proxy_end)
layend.autoRange()
# load capture
# proxy_load = QtGui.QGraphicsProxyWidget()
# loadCap = QtGui.QPushButton('Load and Replay Data')
# loadCap.clicked.connect(self.loadCapture)
# proxy_load.setWidget(loadCap)
# layload = layout.addViewBox(row=4, col=3, colspan=1, rowspan=1,invertY=True, lockAspect=True, enableMouse=False)
# layload.addItem(proxy_load)
# layload.autoRange()
# logo
logoDisplay = layout.addViewBox(row=4,
col=4,
rowspan=1,
colspan=1,
lockAspect=True,
enableMouse=False,
invertY=True)
img = cv2.imread('logo.jpg', cv2.IMREAD_UNCHANGED)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
logo = pg.ImageItem(img)
logoDisplay.addItem(logo)
logoDisplay.autoRange()
# exit program
proxy_exit = QtGui.QGraphicsProxyWidget()
exitCap = QtGui.QPushButton('Exit Program')
exitCap.clicked.connect(self.exitProgram)
proxy_exit.setWidget(exitCap)
layexit = layout.addViewBox(row=4,
col=3,
colspan=1,
rowspan=1,
invertY=True,
lockAspect=True,
enableMouse=False)
layexit.addItem(proxy_exit)
layexit.autoRange()
# add video display
self.capture = 0
# start video stream
if not self.capture:
self.capture = QtCapture(0)
exitCap.clicked.connect(self.capture.stop)
self.capture.setParent(self)
self.capture.setWindowFlags(QtCore.Qt.Tool)
self.capture.start()
videoDisplay = layout.addViewBox(row=0,
col=3,
rowspan=3,
colspan=3,
lockAspect=True,
enableMouse=False)
current_frame = pg.ImageItem(
np.zeros((self.capture.height, self.capture.width, 3), np.uint8))
videoDisplay.addItem(current_frame)
# antialiasing for better plots
pg.setConfigOptions(antialias=True)
# set downsampling and clipping to reduce drawing load
adc1.setDownsampling(mode='peak')
adc2.setDownsampling(mode='peak')
adc1.setClipToView(True)
adc2.setClipToView(True)
# set axis parameters
adc1.setRange(xRange=[-100, 10], yRange=[math.sqrt(3), math.sqrt(4.3)])
# adc1.setRange(xRange=[-10, 1], yRange=[-1,5])
adc1.setLimits(xMax=10, xMin=-15, yMax=5, yMin=-1)
adc2.setRange(xRange=[-10, 1], yRange=[-1, 5])
adc2.setLimits(xMax=10, xMin=-15, yMax=5, yMin=-1)
# makes color of both pens yellow
curve1 = adc1.plot(pen='y')
curve2 = adc2.plot(pen='y')
def __init__(self, **kargs):
super(SignalAndSpike, self).__init__(**kargs)
# TODO : add global UI option for this
#~ self.auto_zoom_x = True
#~ self.auto_zoom_x = False
sps = self.spikesorter
self.timerSeeker = TimeSeeker(show_play=False)
self.sigs = getattr(self.spikesorter, self.sig_name)
self.view = pg.GraphicsView()
l = pg.GraphicsLayout()
self.view.setCentralItem(l)
self.plots = []
self.curves = []
self.threshold_curves = []
for i in range(sps.trodness):
l.nextRow()
viewBox = MyViewBox()
plot = l.addPlot(viewBox=viewBox)
self.plots.append(plot)
plot.hideButtons()
curve = plot.plot([np.nan], [np.nan], pen='w')
self.curves.append(curve)
viewBox.disableAutoRange()
if i != sps.trodness - 1:
plot.hideAxis('bottom')
viewBox.yzoom_in.connect(lambda: self.yzoom(.8))
viewBox.yzoom_out.connect(lambda: self.yzoom(1.2))
viewBox.clicked_at_x.connect(self.clicked_at_x)
tc = pg.InfiniteLine(angle=0, movable=False, pen='g')
tc.setPos(0.)
self.threshold_curves.append(tc)
plot.addItem(tc)
tc.hide()
self.scatters = [{} for i in range(sps.trodness)]
self.timerSeeker.fast_time_changed.connect(self.seek)
self.timerSeeker.fast_time_changed.connect(self.on_time_changed)
self.time_by_seg = np.zeros(len(sps.segs), dtype=float)
for s, seg in enumerate(sps.segs):
self.time_by_seg[s] = sps.segs[s].analogsignals[
0].t_start.magnitude
param_global = [
{
'name': 'auto_zoom_on_select',
'type': 'bool',
'value': True
},
{
'name': 'zoom_size',
'type': 'float',
'value': 0.2,
'step': 0.001
},
{
'name': 'plot_threshold',
'type': 'bool',
'value': True
},
]
self.params = pg.parametertree.Parameter.create(name='Global options',
type='group',
children=param_global)
self.treeParam = pg.parametertree.ParameterTree(parent=self)
self.treeParam.header().hide()
self.treeParam.setParameters(self.params, showTop=True)
self.treeParam.setWindowTitle(u'Options for signal viewer')
self.treeParam.setWindowFlags(Qt.Window)
self.createToolBar()
self.mainLayout.addWidget(self.toolbar)
self.mainLayout.addWidget(self.view)
self.mainLayout.addWidget(self.timerSeeker)
self.shared_view_with = None
def __init__(self, x, y):
super(BandSelectorWidget, self).__init__()
# parameters
self.width = 3
self.x = 20
self.x_max = 30.
self.gran = x[1] - x[0]
graphics_widget = pg.GraphicsWidget()
self.middle = pg.LinearRegionItem([self.x, self.x],
pg.LinearRegionItem.Vertical)
self.middle.setBounds(
[0 + self.width / 2, self.x_max - self.width / 2])
self.middle.sigRegionChanged.connect(self.regionChanged)
self.region = pg.LinearRegionItem(
[self.x - self.width / 2, self.x + self.width / 2],
pg.LinearRegionItem.Vertical,
movable=False)
self.region.setBounds((0, self.x_max))
self.region.sigRegionChanged.connect(self.regionChanged)
view_box = pg.ViewBox(parent=graphics_widget,
enableMouse=False,
enableMenu=False)
#view_box.setAspectLocked()
view_box.setYRange(0, 1)
#view_box.enableAutoRange(view_box.XYAxes)
axis = pg.AxisItem('bottom', linkView=view_box, parent=graphics_widget)
plot = pg.PlotDataItem()
plot.setData(x, y / (max(y[x < self.x_max]) or 1))
view_box.setXRange(0, self.x_max)
view_box.addItem(plot)
view_box.addItem(self.region)
view_box.addItem(self.middle)
self.view_box = view_box
# setup grid layout
grid_layout = QtGui.QGraphicsGridLayout(graphics_widget)
grid_layout.addItem(axis, 1, 0)
grid_layout.addItem(view_box, 0, 0)
# view
view = pg.GraphicsView()
view.setCentralItem(graphics_widget)
self.width_slider = ParameterSlider('Band width:',
1,
10,
interval=0.1,
value=self.width,
units='Hz')
self.width_slider.valueChanged.connect(self.changeWidth)
main_layout = QtGui.QVBoxLayout(self)
main_layout.addWidget(view)
main_layout.addWidget(self.width_slider)
self.band = None
btn = QtGui.QPushButton('Select')
btn.clicked.connect(self.select_band)
btn.setMaximumWidth(200)
self.band_str = QtGui.QLabel(
'Band:\t{}\t-\t{} Hz'.format(*self.region.getRegion()))
main_layout.addWidget(self.band_str)
main_layout.addWidget(btn)
def plot_init(self, plot_type, plot_params, plot_ID):
self.plot_ID = plot_ID
self.plot_type = plot_type
self.connect_labrad()
if plot_type == 'Single Frequency': # Required parameters = sources, averaging #. Data will be in format {Source: value}
sources = plot_params['sources'] #Acceptable sources - Counter 0/1/2/3.
self.plot_data['sources'] = sources
self.plot_data['data'] = {}
for source in sources:
self.plot_data['data'][source] = [] # To be plotted
a = QtGui.QApplication( [] )
win = pg.GraphicsWindow()
win.resize(1000,600)
win.setWindowTitle('Single Frequency')
p1 = win.addPlot(title="Single Frequency")
curves = {}
for source in sources:
if source == 'Counter0':
curves[source] = p1.plot(pen={'color':'y', 'width':5})
elif source == 'Counter1':
curves[source] = p1.plot(pen={'color':'r', 'width':5})
elif source == 'Counter2':
curves[source] = p1.plot(pen={'color':'w', 'width':5})
elif source == 'Osc1':
curves[source] = p1.plot(pen={'color':'y', 'width':5})
elif source == 'Osc2':
curves[source] = p1.plot(pen={'color':'r', 'width':5})
elif source == 'Osc3':
curves[source] = p1.plot(pen={'color':'w', 'width':5})
else:
curves[source] = p1.plot(pen={'color':'c', 'width':5})
# Enable antialiasing for prettier plots
pg.setConfigOptions(antialias=True)
def update(timer):
if 'save' in self.plot_data.keys():
if self.plot_data['save'] == True:
timer.stop()
save_path = self.plot_data['save_path']
save_prefixes = self.plot_data['save_prefixes']
exporter = pg.exporters.ImageExporter(p1)
exporterCSV = pg.exporters.CSVExporter(p1)
for save_prefix in save_prefixes:
if not os.path.exists(save_path+str(save_prefix)+'.png'):
exporter.export(save_path+str(save_prefix)+'.png')
exporterCSV.export(save_path+str(save_prefix)+'.csv')
break
for source in sources:
data = self.plot_data['data'][source]
curves[source].setData(data)
timer = QtCore.QTimer()
timer.timeout.connect(partial(update,timer))
timer.start(50)
QtGui.QApplication.instance().exec_()
elif plot_type == 'Frequency Scan': # Required parameters = sources, averaging #, Frequency Range. Data will be in format {Source: value}
sources = plot_params['sources'] #Acceptable sources - Counter 0/1/2/3.
frequencies = plot_params['Frequency Range']
self.plot_data['sources'] = sources
self.plot_data['data'] = {}
for source in sources:
self.plot_data['data'][source] = [] # To be plotted
a = QtGui.QApplication( [] )
win = pg.GraphicsWindow()
win.resize(1000,600)
win.setWindowTitle('Frequency Scan')
p1 = win.addPlot(title="Frequency Scan")
curves = {}
for source in sources:
if source == 'Counter0':
curves[source] = p1.plot(pen={'color':'y', 'width':5})
elif source == 'Counter1':
curves[source] = p1.plot(pen={'color':'r', 'width':5})
elif source == 'Counter1':
curves[source] = p1.plot(pen={'color':'w', 'width':5})
else:
curves[source] = p1.plot(pen={'color':'c', 'width':5})
# Enable antialiasing for prettier plots
pg.setConfigOptions(antialias=True)
def update(timer):
if 'save' in self.plot_data.keys():
if self.plot_data['save'] == True:
self.plot_data['save'] = False
timer.stop()
save_path = self.plot_data['save_path']
save_prefixes = self.plot_data['save_prefixes']
exporter = pg.exporters.ImageExporter(p1)
exporterCSV = pg.exporters.CSVExporter(p1)
for save_prefix in save_prefixes:
if not os.path.exists(save_path+str(save_prefix)+'.png'):
exporter.export(save_path+str(save_prefix)+'.png')
exporterCSV.export(save_path+str(save_prefix)+'.csv')
break
for source in sources:
data = self.plot_data['data'][source]
num_points = len(data)
curves[source].setData(x = frequencies[0:num_points], y = data)
timer = QtCore.QTimer()
timer.timeout.connect(partial(update,timer))
timer.start(50)
QtGui.QApplication.instance().exec_()
elif plot_type == 'Fast Scan': # Required parameters = sources, averaging #, Frequency Range. Data will be in format {Source: value}
sources = plot_params['sources'] #Acceptable sources - Counter 0/1/2/3
self.plot_data['sources'] = sources
self.plot_data['data'] = {}
for source in sources:
self.plot_data['data'][source] = [] # To be plotted
a = QtGui.QApplication( [] )
win = pg.GraphicsWindow()
win.setWindowTitle('Frequency Scan')
win.resize(1000,600)
keepTrace = QtGui.QCheckBox('Keep current trace')
p1 = win.addPlot(title="Frequency Scan")
curves = {}
for source in sources:
if source == 'Counter0':
curves[source] = p1.plot(pen={'color':'y', 'width':5})
curves['keepTrace'+source] = p1.plot(pen={'color':'r', 'width':5})
elif source == 'Counter1':
curves[source] = p1.plot(pen={'color':'w', 'width':5})
curves['keepTrace'+source] = p1.plot(pen={'color':'g', 'width':5})
else:
curves[source] = p1.plot(pen={'color': 'c', 'width':5})
curves['keepTrace'+source] = p1.plot(pen={'color':'r', 'width':5})
# Enable antialiasing for prettier plots
pg.setConfigOptions(antialias=True)
layout = pg.LayoutWidget()
layout.addWidget(keepTrace, row=1, col = 0)
layout.addWidget(win, row = 2, col = 0)
layout.show()
layout.resize(1000,600)
self.fast_scan_keepTrace_past = False
def update(timer):
if 'save' in self.plot_data.keys():
if self.plot_data['save'] == True:
self.plot_data['save'] = False
timer.stop()
save_path = self.plot_data['save_path']
save_prefixes = self.plot_data['save_prefixes']
exporter = pg.exporters.ImageExporter(p1)
exporterCSV = pg.exporters.CSVExporter(p1)
for save_prefix in save_prefixes:
if not os.path.exists(save_path+str(save_prefix)+'.png'):
exporter.export(save_path+str(save_prefix)+'.png')
exporterCSV.export(save_path+str(save_prefix)+'.csv')
break
if keepTrace.isChecked() and not(self.fast_scan_keepTrace_past):
self.fast_scan_keepTrace_past = True
for source in sources:
data = self.plot_data['data'][source]
curves['keepTrace'+source].setData( y = data)
elif not(keepTrace.isChecked()):
self.fast_scan_keepTrace_past = False
for source in sources:
data = self.plot_data['data'][source]
curves['keepTrace'+source].setData( y = [])
for source in sources:
data = self.plot_data['data'][source]
curves[source].setData( y = data)
timer = QtCore.QTimer()
timer.timeout.connect(partial(update,timer))
timer.start(50)
QtGui.QApplication.instance().exec_()
elif plot_type == 'Camera':
self.plot_data['data'] = np.zeros((550,550), dtype=np.uint8).tolist()
self.data_out = np.array([[0]])
pg.mkQApp()
win = pg.GraphicsView()
win.setWindowTitle('Top Camera')
win_lay = pg.GraphicsLayout()
win_vb = win_lay.addViewBox()
win.setCentralItem(win_lay)
# Item for displaying image data
img = pg.ImageItem()
win_vb.addItem(img)
roi = pg.ROI([82, 82], [386,386], angle=0.0, snapSize= 1.0, scaleSnap = True, translateSnap = True, pen = pg.mkPen('r',width=2)) # "top","left","height""width"
roi.addScaleHandle([1, 1], [0, 0])
roi.addScaleHandle([0, 0], [1, 1])
roi.setZValue(10) # make sure ROI is drawn above image
win_vb.addItem(roi)
(rx0,ry0) = roi.pos()
(rxsize,rysize) = roi.size()
win2 = pg.GraphicsWindow()
p2x = win2.addPlot(title="Y projection")
win2.nextRow()
p2y = win2.addPlot(title="X projection")
win2.resize(75,75)
curvex_data = p2x.plot(pen='r', y = np.zeros(int(rxsize)) , x = np.arange(int(rxsize))+int(rx0)-275)
curvey_data = p2y.plot(pen='r', y = np.zeros(int(rysize)) , x = np.arange(int(rysize))+int(ry0)-275)
curvex_fit = p2x.plot(pen='w')
curvey_fit = p2y.plot(pen='w')
NASave = QtGui.QPushButton('Set as No Atoms (NA)')
NARemove = QtGui.QCheckBox('Divide NA')
BkgSave = QtGui.QPushButton('Set as noise')
BkgRemove = QtGui.QCheckBox('Subtract noise')
GetANumber = QtGui.QCheckBox('Get atom number')
newfont = QtGui.QFont("Times", 25, QtGui.QFont.Bold)
atomNumberDisplay = QtGui.QLabel('0')
atomNumberDisplay.setFont(newfont)
atomNumberDisplay_label = QtGui.QLabel('Atom Number')
atomNumberDisplay_label.setFont(newfont)
Rot_label = QtGui.QLabel('Rot angle')
Rot_label.setFont(QtGui.QFont("Times", 15))
Rot = QtGui.QLineEdit('47')
Avg_label = QtGui.QLabel('Averages')
Avg_label.setFont(QtGui.QFont("Times", 15))
Avg = QtGui.QLineEdit('1')
f_label = QtGui.QLabel('Fname: ')
f_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
f_label.setFont(QtGui.QFont("Times", 15))
finput = QtGui.QLineEdit('IM0')
ImSave = QtGui.QPushButton('Save Data')
XDisplay = QtGui.QLabel('0')
XDisplay.setFont(newfont)
XDisplay_label = QtGui.QLabel('X')
XDisplay_label.setFont(newfont)
YDisplay = QtGui.QLabel('0')
YDisplay.setFont(newfont)
YDisplay_label = QtGui.QLabel('Y')
YDisplay_label.setFont(newfont)
SigmaXDisplay = QtGui.QLabel('0')
SigmaXDisplay.setFont(newfont)
SigmaXDisplay_label = QtGui.QLabel(u"\u03C3"+'X')
SigmaXDisplay_label.setFont(newfont)
SigmaYDisplay = QtGui.QLabel('0')
SigmaYDisplay.setFont(newfont)
SigmaYDisplay_label = QtGui.QLabel(u"\u03C3"+'Y')
SigmaYDisplay_label.setFont(newfont)
def saveIm():
filename = QtGui.QFileDialog.getSaveFileName(None ,"Save Image as...", "C:/Users/RoyOutput/Dropbox (MIT)/" + str(finput.text()) + '.png', "Image files (*.png)" )
basename = filename.replace(".png","")
Imexporter = pg.exporters.ImageExporter(win_vb)
Imexporter.export(basename + '.png')
Imexporter = pg.exporters.ImageExporter(p2y)
Imexporter.export(basename + '_X.png')
Imexporter = pg.exporters.ImageExporter(p2x)
Imexporter.export(basename + '_Y.png')
exporterCSV = pg.exporters.CSVExporter(p2x)
exporterCSV.export(basename + '_Y.csv')
exporterCSV = pg.exporters.CSVExporter(p2y)
exporterCSV.export(basename + '_X.csv')
np.savetxt( str(basename) + '.txt', (img.image).astype(float) , delimiter=',')
ImSave.clicked.connect(saveIm)
layout = pg.LayoutWidget()
layout.addWidget(NASave)
layout.addWidget(NARemove)
layout.addWidget(BkgSave)
layout.addWidget(BkgRemove)
layout.addWidget(GetANumber)
layout.addWidget(Rot_label, col=10)
layout.addWidget(Rot, col=11)
layout.addWidget(Avg_label, col=12)
layout.addWidget(Avg, col=13)
layout.addWidget(ImSave, row=6, col = 0 , colspan=2, rowspan=1)
layout.addWidget(f_label,row=6, col = 2 , colspan=1, rowspan=1)
layout.addWidget(finput ,row=6, col = 3 , colspan=1.5, rowspan=1)
layout.addWidget(win, row=1, col=0, colspan=6, rowspan=4)
layout.addWidget(win2, row=2, col=10, colspan=5, rowspan=1)
layout.addWidget(atomNumberDisplay_label, row=5, col=0, colspan=1, rowspan=1)
layout.addWidget(atomNumberDisplay, row=5, col=2, colspan=1, rowspan=1)
layout.addWidget(XDisplay_label, row=5, col=13, colspan=1, rowspan=1)
layout.addWidget(XDisplay, row=5, col=14, colspan=1, rowspan=1)
layout.addWidget(YDisplay_label, row=6, col=13, colspan=1, rowspan=1)
layout.addWidget(YDisplay, row=6, col=14, colspan=1, rowspan=1)
layout.addWidget(SigmaXDisplay_label, row=5, col=10, colspan=1, rowspan=1)
layout.addWidget(SigmaXDisplay, row=5, col=11, colspan=1, rowspan=1)
layout.addWidget(SigmaYDisplay_label, row=6, col=10, colspan=1, rowspan=1)
layout.addWidget(SigmaYDisplay, row=6, col=11, colspan=1, rowspan=1)
layout.resize(1000,800)
layout.show()
def saveBkg():
#data = np.array(self.plot_data['data']).astype(np.uint8)
self.cameraBkg = self.data_ave
BkgSave.clicked.connect(saveBkg)
def saveNA():
#data = np.array(self.plot_data['data']).astype(np.uint8)
self.cameraNA = self.data_ave
NASave.clicked.connect(saveNA)
def gaussian(offset, height, center_x, center_y, width_x, width_y):
"""Returns a gaussian function with the given parameters"""
width_x = float(width_x)
width_y = float(width_y)
return lambda x,y: offset+height*np.exp(
-(((x-center_x)/width_x)**2+((y-center_y)/width_y)**2)/2)
self.camera_data_prev= [0]
self.avg_count = 0
self.data_ave = []
self.data = []
def update():
#Be smarter about this....
temp_data = np.array(self.plot_data['data']).astype(np.float)
if np.array_equal(self.camera_data_prev, temp_data):
return 1
else :
self.camera_data_prev = temp_data
averages = int(Avg.text())
if self.avg_count < averages:
self.avg_count += 1
self.data.append(temp_data)
elif self.avg_count > averages:
self.avg_count = averages
if self.data[0:averages-1]== []:
self.data = [temp_data]
else:
self.data = [temp_data]+ self.data[0:averages-1]
else:
if self.data[1:averages]== []:
self.data = [temp_data]
else:
self.data = [temp_data] + self.data[0:averages-1]
self.data_ave = self.data[0]
data_len = len(self.data)
for i in xrange(data_len-1):
self.data_ave += self.data[i+1]
self.data_ave /= data_len
data = self.data_ave
autoLevels = True
if BkgRemove.isChecked() and NARemove.isChecked():
data = np.true_divide((data - self.cameraBkg),(self.cameraNA - self.cameraBkg))
data[data == np.inf] = 1
data[np.isnan(data)] = 1
data[data <= 0] = 1
autoLevels =False
elif NARemove.isChecked():
data = np.true_divide(data, self.cameraNA)
data[data == np.inf] = 1
data[np.isnan(data)] = 1
autoLevels =False
elif BkgRemove.isChecked():
data = data - self.cameraBkg
data[data <= 0] = 1
rot_angle = float(Rot.text())
data = sp.rotate(data, rot_angle, reshape=False)
try:
data_roi= roi.getArrayRegion(data, img)
except:
print 'Exception!'
data_roi = np.array(data)
self.data_out = data_roi
(rx0,ry0) = roi.pos()
(rxsize,rysize) = roi.size()
if GetANumber.isChecked():
atom_number, offset, height, x, y, width_x, width_y = self.FindAtomNumber(data_roi )
atomNumberDisplay.setText( "{:.3E}".format(atom_number*(topmag**2)))
pixel_ratio = 4.65 #micrometer / pixel
XDisplay.setText( "{:.2E}".format(x+rx0 - 275))
YDisplay.setText( "{:.2E}".format(y+ry0 - 275))
SigmaXDisplay.setText( "{:.2E}".format(pixel_ratio*width_x*topmag))
SigmaYDisplay.setText( "{:.2E}".format(pixel_ratio*width_y*topmag))
fit = gaussian(*[offset, height, x, y, width_x, width_y])
data_fit = fit(*np.indices(data_roi.shape))
curvey_fit.setData(y = data_fit.sum(axis=1), x = np.arange( data_fit.shape[0])+ int(rx0)-275 ) #data_fit.sum(axis=0)
curvex_fit.setData(y = data_fit.sum(axis=0), x = np.arange( data_fit.shape[1])+ int(ry0)-275 ) #data_fit.sum(axis=1)
curvex_data.setData( y = np.log(data_roi).sum(axis=0), x = np.arange(data_roi.shape[1])+ int(ry0)-275 ) #np.log(data_roi).sum(axis=0),
curvey_data.setData( y = np.log(data_roi).sum(axis=1), x = np.arange(data_roi.shape[0])+ int(rx0)-275 ) #np.log(data_roi).sum(axis=1),
if autoLevels:
img.setImage(image=data, autoDownsample = True)
else:
img.setImage(image=data, autoLevels=False, autoDownsample = True, levels = (0.5, 1), lut=lut)
timer = QtCore.QTimer()
timer.timeout.connect(update)
timer.start(100)
QtGui.QApplication.instance().exec_()
elif plot_type == 'Side Camera':
self.plot_data['data'] = np.zeros((480,640), dtype=np.uint8).tolist()
self.data_out = np.array([[0]])
pg.mkQApp()
win = pg.GraphicsView()
win_lay = pg.GraphicsLayout()
win_vb = win_lay.addViewBox()
win.setCentralItem(win_lay)
# Item for displaying image data
img = pg.ImageItem()
win_vb.addItem(img)
roi = pg.ROI([82, 82], [386,386], angle=0.0, snapSize= 1.0, scaleSnap = True, translateSnap = True, pen = pg.mkPen('r',width=2)) # "top","left","height""width"
roi.addScaleHandle([1, 1], [0, 0])
roi.addScaleHandle([0, 0], [1, 1])
roi.setZValue(10) # make sure ROI is drawn above image
win_vb.addItem(roi)
(rx0,ry0) = roi.pos()
(rxsize,rysize) = roi.size()
win2 = pg.GraphicsWindow()
p2x = win2.addPlot(title="Y projection")
win2.nextRow()
p2y = win2.addPlot(title="X projection")
win2.resize(75,75)
curvex_data = p2x.plot(pen='r', y = np.zeros(int(rxsize)) , x = np.arange(int(rxsize))+int(rx0)-275)
curvey_data = p2y.plot(pen='r', y = np.zeros(int(rysize)) , x = np.arange(int(rysize))+int(ry0)-275)
curvex_fit = p2x.plot(pen='w')
curvey_fit = p2y.plot(pen='w')
NASave = QtGui.QPushButton('Set as No Atoms (NA)')
NARemove = QtGui.QCheckBox('Divide NA')
BkgSave = QtGui.QPushButton('Set as noise')
BkgRemove = QtGui.QCheckBox('Subtract noise')
GetANumber = QtGui.QCheckBox('Get atom number')
newfont = QtGui.QFont("Times", 25, QtGui.QFont.Bold)
atomNumberDisplay = QtGui.QLabel('0')
atomNumberDisplay.setFont(newfont)
atomNumberDisplay_label = QtGui.QLabel('Atom Number')
atomNumberDisplay_label.setFont(newfont)
Rot_label = QtGui.QLabel('Rot angle')
Rot_label.setFont(QtGui.QFont("Times", 15))
Rot = QtGui.QLineEdit('0')
Avg_label = QtGui.QLabel('Averages')
Avg_label.setFont(QtGui.QFont("Times", 15))
Avg = QtGui.QLineEdit('1')
f_label = QtGui.QLabel('Fname: ')
f_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
f_label.setFont(QtGui.QFont("Times", 15))
finput = QtGui.QLineEdit('IM0')
ImSave = QtGui.QPushButton('Save Data')
XDisplay = QtGui.QLabel('0')
XDisplay.setFont(newfont)
XDisplay_label = QtGui.QLabel('X')
XDisplay_label.setFont(newfont)
YDisplay = QtGui.QLabel('0')
YDisplay.setFont(newfont)
YDisplay_label = QtGui.QLabel('Y')
YDisplay_label.setFont(newfont)
SigmaXDisplay = QtGui.QLabel('0')
SigmaXDisplay.setFont(newfont)
SigmaXDisplay_label = QtGui.QLabel(u"\u03C3"+'X')
SigmaXDisplay_label.setFont(newfont)
SigmaYDisplay = QtGui.QLabel('0')
SigmaYDisplay.setFont(newfont)
SigmaYDisplay_label = QtGui.QLabel(u"\u03C3"+'Y')
SigmaYDisplay_label.setFont(newfont)
def saveIm():
filename = QtGui.QFileDialog.getSaveFileName(None ,"Save Image as...", "C:/Users/RoyOutput/Dropbox (MIT)/" + str(finput.text()) + '.png', "Image files (*.png)" )
basename = filename.replace(".png","")
Imexporter = pg.exporters.ImageExporter(win_vb)
Imexporter.export(basename + 'S.png')
Imexporter = pg.exporters.ImageExporter(p2y)
Imexporter.export(basename + '_XS.png')
Imexporter = pg.exporters.ImageExporter(p2x)
Imexporter.export(basename + '_YS.png')
exporterCSV = pg.exporters.CSVExporter(p2x)
exporterCSV.export(basename + '_YS.csv')
exporterCSV = pg.exporters.CSVExporter(p2y)
exporterCSV.export(basename + '_XS.csv')
np.savetxt( str(basename) + '_S.txt', (img.image).astype(float) , delimiter=',')
ImSave.clicked.connect(saveIm)
layout = pg.LayoutWidget()
layout.addWidget(NASave)
layout.addWidget(NARemove)
layout.addWidget(BkgSave)
layout.addWidget(BkgRemove)
layout.addWidget(GetANumber)
layout.addWidget(Rot_label, col=10)
layout.addWidget(Rot, col=11)
layout.addWidget(Avg_label, col=12)
layout.addWidget(Avg, col=13)
layout.addWidget(ImSave, row=6, col = 0 , colspan=2, rowspan=1)
layout.addWidget(f_label,row=6, col = 2 , colspan=1, rowspan=1)
layout.addWidget(finput ,row=6, col = 3 , colspan=1.5, rowspan=1)
layout.addWidget(win, row=1, col=0, colspan=6, rowspan=4)
layout.addWidget(win2, row=2, col=10, colspan=5, rowspan=1)
layout.addWidget(atomNumberDisplay_label, row=5, col=0, colspan=1, rowspan=1)
layout.addWidget(atomNumberDisplay, row=5, col=2, colspan=1, rowspan=1)
layout.addWidget(XDisplay_label, row=5, col=13, colspan=1, rowspan=1)
layout.addWidget(XDisplay, row=5, col=14, colspan=1, rowspan=1)
layout.addWidget(YDisplay_label, row=6, col=13, colspan=1, rowspan=1)
layout.addWidget(YDisplay, row=6, col=14, colspan=1, rowspan=1)
layout.addWidget(SigmaXDisplay_label, row=5, col=10, colspan=1, rowspan=1)
layout.addWidget(SigmaXDisplay, row=5, col=11, colspan=1, rowspan=1)
layout.addWidget(SigmaYDisplay_label, row=6, col=10, colspan=1, rowspan=1)
layout.addWidget(SigmaYDisplay, row=6, col=11, colspan=1, rowspan=1)
layout.resize(1000,800)
layout.show()
def saveBkg():
#data = np.array(self.plot_data['data']).astype(np.uint8)
self.cameraBkg = self.data_ave
BkgSave.clicked.connect(saveBkg)
def saveNA():
#data = np.array(self.plot_data['data']).astype(np.uint8)
self.cameraNA = self.data_ave
NASave.clicked.connect(saveNA)
def gaussian(offset, height, center_x, center_y, width_x, width_y):
"""Returns a gaussian function with the given parameters"""
width_x = float(width_x)
width_y = float(width_y)
return lambda x,y: offset+height*np.exp(
-(((x-center_x)/width_x)**2+((y-center_y)/width_y)**2)/2)
self.camera_data_prev= [0]
self.avg_count = 0
self.data = []
def update():
#Be smarter about this....
temp_data = np.array(self.plot_data['data']).astype(np.float)
if np.array_equal(self.camera_data_prev, temp_data):
return 1
else :
self.camera_data_prev = temp_data
averages = int(Avg.text())
if self.avg_count < averages:
self.avg_count += 1
self.data.append(temp_data)
elif self.avg_count > averages:
self.avg_count = averages
if self.data[0:averages-1]== []:
self.data = [temp_data]
else:
self.data = [temp_data]+ self.data[0:averages-1]
else:
if self.data[1:averages]== []:
self.data = [temp_data]
else:
self.data = [temp_data] + self.data[0:averages-1]
data = self.data[0]
data_len = len(self.data)
for i in xrange(data_len-1):
data += self.data[i+1]
data /= data_len
autoLevels = True
if BkgRemove.isChecked() and NARemove.isChecked():
data = np.true_divide((data - self.cameraBkg),(self.cameraNA - self.cameraBkg))
data[data == np.inf] = 1
data[np.isnan(data)] = 1
data[data <= 0] = 1
autoLevels =False
elif NARemove.isChecked():
data = np.true_divide(data, self.cameraNA)
data[data == np.inf] = 1
data[np.isnan(data)] = 1
autoLevels =False
elif BkgRemove.isChecked():
data = data - self.cameraBkg
data[data <= 0] = 1
rot_angle = float(Rot.text())
data = sp.rotate(data, rot_angle, reshape=False)
try:
data_roi= roi.getArrayRegion(data, img)
except:
print 'Exception!'
data_roi = np.array(data)
self.data_out = data_roi
(rx0,ry0) = roi.pos()
(rxsize,rysize) = roi.size()
if GetANumber.isChecked():
atom_number, offset, height, x, y, width_x, width_y = self.FindAtomNumber(data_roi )
atomNumberDisplay.setText( "{:.3E}".format(atom_number*(sidemag**2)))
pixel_ratio = 7.4 #micrometer / pixel
XDisplay.setText( "{:.2E}".format(x+rx0 - 275))
YDisplay.setText( "{:.2E}".format(y+ry0 - 275))
SigmaXDisplay.setText( "{:.2E}".format(pixel_ratio*width_x*sidemag))
SigmaYDisplay.setText( "{:.2E}".format(pixel_ratio*width_y*sidemag))
fit = gaussian(*[offset, height, x, y, width_x, width_y])
data_fit = fit(*np.indices(data_roi.shape))
curvey_fit.setData(y = data_fit.sum(axis=1), x = np.arange( data_fit.shape[0])+ int(rx0)-275 ) #data_fit.sum(axis=0)
curvex_fit.setData(y = data_fit.sum(axis=0), x = np.arange( data_fit.shape[1])+ int(ry0)-275 ) #data_fit.sum(axis=1)
curvex_data.setData( y = np.log(data_roi).sum(axis=0), x = np.arange(data_roi.shape[1])+ int(ry0)-275 ) #np.log(data_roi).sum(axis=0),
curvey_data.setData( y = np.log(data_roi).sum(axis=1), x = np.arange(data_roi.shape[0])+ int(rx0)-275 ) #np.log(data_roi).sum(axis=1),
if autoLevels:
img.setImage(image=data, autoDownsample = True)
else:
img.setImage(image=data, autoLevels=False, autoDownsample = True, levels = (0.5, 1), lut=lut)
timer = QtCore.QTimer()
timer.timeout.connect(update)
timer.start(100)
QtGui.QApplication.instance().exec_()
elif plot_type == 'Side Camera3':
self.plot_data['data'] = np.zeros((480,640), dtype=np.uint8).tolist()
self.data_out = np.array([[0]])
pg.mkQApp()
win = pg.GraphicsView()
win_lay = pg.GraphicsLayout()
win_vb = win_lay.addViewBox()
win.setCentralItem(win_lay)
# Item for displaying image data
img = pg.ImageItem()
win_vb.addItem(img)
roi = pg.ROI([82, 82], [386,386], angle=0.0, snapSize= 1.0, scaleSnap = True, translateSnap = True, pen = pg.mkPen('r',width=2)) # "top","left","height""width"
roi.addScaleHandle([1, 1], [0, 0])
roi.addScaleHandle([0, 0], [1, 1])
roi.setZValue(10) # make sure ROI is drawn above image
win_vb.addItem(roi)
(rx0,ry0) = roi.pos()
(rxsize,rysize) = roi.size()
win2 = pg.GraphicsWindow()
p2x = win2.addPlot(title="Y projection")
win2.nextRow()
p2y = win2.addPlot(title="X projection")
win2.resize(75,75)
curvex_data = p2x.plot(pen='r', y = np.zeros(int(rxsize)) , x = np.arange(int(rxsize))+int(rx0)-275)
curvey_data = p2y.plot(pen='r', y = np.zeros(int(rysize)) , x = np.arange(int(rysize))+int(ry0)-275)
curvex_fit = p2x.plot(pen='w')
curvey_fit = p2y.plot(pen='w')
NASave = QtGui.QPushButton('Set as No Atoms (NA)')
NARemove = QtGui.QCheckBox('Divide NA')
BkgSave = QtGui.QPushButton('Set as noise')
BkgRemove = QtGui.QCheckBox('Subtract noise')
GetANumber = QtGui.QCheckBox('Get atom number')
newfont = QtGui.QFont("Times", 25, QtGui.QFont.Bold)
atomNumberDisplay = QtGui.QLabel('0')
atomNumberDisplay.setFont(newfont)
atomNumberDisplay_label = QtGui.QLabel('Atom Number')
atomNumberDisplay_label.setFont(newfont)
Rot_label = QtGui.QLabel('Rot angle')
Rot_label.setFont(QtGui.QFont("Times", 15))
Rot = QtGui.QLineEdit('0')
Avg_label = QtGui.QLabel('Averages')
Avg_label.setFont(QtGui.QFont("Times", 15))
Avg = QtGui.QLineEdit('1')
f_label = QtGui.QLabel('Fname: ')
f_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
f_label.setFont(QtGui.QFont("Times", 15))
finput = QtGui.QLineEdit('IM0')
ImSave = QtGui.QPushButton('Save Data')
XDisplay = QtGui.QLabel('0')
XDisplay.setFont(newfont)
XDisplay_label = QtGui.QLabel('X')
XDisplay_label.setFont(newfont)
YDisplay = QtGui.QLabel('0')
YDisplay.setFont(newfont)
YDisplay_label = QtGui.QLabel('Y')
YDisplay_label.setFont(newfont)
SigmaXDisplay = QtGui.QLabel('0')
SigmaXDisplay.setFont(newfont)
SigmaXDisplay_label = QtGui.QLabel(u"\u03C3"+'X')
SigmaXDisplay_label.setFont(newfont)
SigmaYDisplay = QtGui.QLabel('0')
SigmaYDisplay.setFont(newfont)
SigmaYDisplay_label = QtGui.QLabel(u"\u03C3"+'Y')
SigmaYDisplay_label.setFont(newfont)
def saveIm():
filename = QtGui.QFileDialog.getSaveFileName(None ,"Save Image as...", "C:/Users/RoyOutput/Dropbox (MIT)/" + str(finput.text()) + '.png', "Image files (*.png)" )
basename = filename.replace(".png","")
Imexporter = pg.exporters.ImageExporter(win_vb)
Imexporter.export(basename + 'S.png')
Imexporter = pg.exporters.ImageExporter(p2y)
Imexporter.export(basename + '_XS.png')
Imexporter = pg.exporters.ImageExporter(p2x)
Imexporter.export(basename + '_YS.png')
exporterCSV = pg.exporters.CSVExporter(p2x)
exporterCSV.export(basename + '_YS.csv')
exporterCSV = pg.exporters.CSVExporter(p2y)
exporterCSV.export(basename + '_XS.csv')
np.savetxt( str(basename) + '_S.txt', (img.image).astype(float) , delimiter=',')
ImSave.clicked.connect(saveIm)
layout = pg.LayoutWidget()
layout.addWidget(NASave)
layout.addWidget(NARemove)
layout.addWidget(BkgSave)
layout.addWidget(BkgRemove)
layout.addWidget(GetANumber)
layout.addWidget(Rot_label, col=10)
layout.addWidget(Rot, col=11)
layout.addWidget(Avg_label, col=12)
layout.addWidget(Avg, col=13)
layout.addWidget(ImSave, row=6, col = 0 , colspan=2, rowspan=1)
layout.addWidget(f_label,row=6, col = 2 , colspan=1, rowspan=1)
layout.addWidget(finput ,row=6, col = 3 , colspan=1.5, rowspan=1)
layout.addWidget(win, row=1, col=0, colspan=6, rowspan=4)
layout.addWidget(win2, row=2, col=10, colspan=5, rowspan=1)
layout.addWidget(atomNumberDisplay_label, row=5, col=0, colspan=1, rowspan=1)
layout.addWidget(atomNumberDisplay, row=5, col=2, colspan=1, rowspan=1)
layout.addWidget(XDisplay_label, row=5, col=13, colspan=1, rowspan=1)
layout.addWidget(XDisplay, row=5, col=14, colspan=1, rowspan=1)
layout.addWidget(YDisplay_label, row=6, col=13, colspan=1, rowspan=1)
layout.addWidget(YDisplay, row=6, col=14, colspan=1, rowspan=1)
layout.addWidget(SigmaXDisplay_label, row=5, col=10, colspan=1, rowspan=1)
layout.addWidget(SigmaXDisplay, row=5, col=11, colspan=1, rowspan=1)
layout.addWidget(SigmaYDisplay_label, row=6, col=10, colspan=1, rowspan=1)
layout.addWidget(SigmaYDisplay, row=6, col=11, colspan=1, rowspan=1)
layout.resize(1000,800)
layout.show()
def saveBkg():
#data = np.array(self.plot_data['data']).astype(np.uint8)
self.cameraBkg = self.data_ave
BkgSave.clicked.connect(saveBkg)
def saveNA():
#data = np.array(self.plot_data['data']).astype(np.uint8)
self.cameraNA = self.data_ave
NASave.clicked.connect(saveNA)
def gaussian(offset, height, center_x, center_y, width_x, width_y):
"""Returns a gaussian function with the given parameters"""
width_x = float(width_x)
width_y = float(width_y)
return lambda x,y: offset+height*np.exp(
-(((x-center_x)/width_x)**2+((y-center_y)/width_y)**2)/2)
self.camera_data_prev= [0]
self.avg_count = 0
self.data = []
def update():
#Be smarter about this....
temp_data = np.array(self.plot_data['data']).astype(np.float)
if np.array_equal(self.camera_data_prev, temp_data):
return 1
else :
self.camera_data_prev = temp_data
averages = int(Avg.text())
if self.avg_count < averages:
self.avg_count += 1
self.data.append(temp_data)
elif self.avg_count > averages:
self.avg_count = averages
if self.data[0:averages-1]== []:
self.data = [temp_data]
else:
self.data = [temp_data]+ self.data[0:averages-1]
else:
if self.data[1:averages]== []:
self.data = [temp_data]
else:
self.data = [temp_data] + self.data[0:averages-1]
data = self.data[0]
data_len = len(self.data)
for i in xrange(data_len-1):
data += self.data[i+1]
data /= data_len
autoLevels = True
if BkgRemove.isChecked() and NARemove.isChecked():
data = np.true_divide((data - self.cameraBkg),(self.cameraNA - self.cameraBkg))
data[data == np.inf] = 1
data[np.isnan(data)] = 1
data[data <= 0] = 1
autoLevels =False
elif NARemove.isChecked():
data = np.true_divide(data, self.cameraNA)
data[data == np.inf] = 1
data[np.isnan(data)] = 1
autoLevels =False
elif BkgRemove.isChecked():
data = data - self.cameraBkg
data[data <= 0] = 1
rot_angle = float(Rot.text())
data = sp.rotate(data, rot_angle, reshape=False)
try:
data_roi= roi.getArrayRegion(data, img)
except:
print 'Exception!'
data_roi = np.array(data)
self.data_out = data_roi
(rx0,ry0) = roi.pos()
(rxsize,rysize) = roi.size()
if GetANumber.isChecked():
atom_number, offset, height, x, y, width_x, width_y = self.FindAtomNumber(data_roi )
atomNumberDisplay.setText( "{:.3E}".format(atom_number*(sidemag**2)))
pixel_ratio = 7.4 #micrometer / pixel
XDisplay.setText( "{:.2E}".format(x+rx0 - 275))
YDisplay.setText( "{:.2E}".format(y+ry0 - 275))
SigmaXDisplay.setText( "{:.2E}".format(pixel_ratio*width_x*sidemag))
SigmaYDisplay.setText( "{:.2E}".format(pixel_ratio*width_y*sidemag))
fit = gaussian(*[offset, height, x, y, width_x, width_y])
data_fit = fit(*np.indices(data_roi.shape))
curvey_fit.setData(y = data_fit.sum(axis=1), x = np.arange( data_fit.shape[0])+ int(rx0)-275 ) #data_fit.sum(axis=0)
curvex_fit.setData(y = data_fit.sum(axis=0), x = np.arange( data_fit.shape[1])+ int(ry0)-275 ) #data_fit.sum(axis=1)
curvex_data.setData( y = np.log(data_roi).sum(axis=0), x = np.arange(data_roi.shape[1])+ int(ry0)-275 ) #np.log(data_roi).sum(axis=0),
curvey_data.setData( y = np.log(data_roi).sum(axis=1), x = np.arange(data_roi.shape[0])+ int(rx0)-275 ) #np.log(data_roi).sum(axis=1),
if autoLevels:
img.setImage(image=data, autoDownsample = True)
else:
img.setImage(image=data, autoLevels=False, autoDownsample = True, levels = (0.5, 1), lut=lut)
timer = QtCore.QTimer()
timer.timeout.connect(update)
timer.start(100)
QtGui.QApplication.instance().exec_()
def __init__(self, client, **kwargs):
super(Gui, self).__init__()
self.path = kwargs.pop('path', None)
self.client = client
self.original_image = None
self.delta = 0.01 # the amount to translate image on UP DOWN LEFT RIGHT key presses
self.client_queue = {} # a queue of requests to send to the RPi
zoom = kwargs.get('zoom')
if zoom:
self.zoom_history = [zoom] # (x, y, width, height) values between 0.0 and 1.0
else:
self.zoom_history = []
self.ocr_params = {
'zoom': zoom,
'rotate': kwargs.get('rotate'),
'threshold': kwargs.get('threshold'),
'dilate': kwargs.get('dilate'),
'erode': kwargs.get('erode'),
'blur': kwargs.get('blur'),
'algorithm': kwargs.get('algorithm', 'tesseract').lower(),
'lang': kwargs.get('lang', 'eng').lower(),
}
self.ocr_label = QtWidgets.QLabel()
self.ocr_label.setFont(QtGui.QFont('Helvetica', 14))
# the canvas widget to display the image
self.graphics_view = pg.GraphicsView(background=None)
self.view_box = pg.ViewBox(invertY=True, lockAspect=True, enableMouse=False, enableMenu=False)
self.graphics_view.setCentralItem(self.view_box)
self.canvas = pg.ImageItem(axisOrder='row-major')
self.view_box.setMouseMode(pg.ViewBox.RectMode)
self.view_box.addItem(self.canvas)
self.view_box.mouseDragEvent = self.select_zoom
graphing_layout = QtWidgets.QVBoxLayout()
graphing_layout.addWidget(self.ocr_label, alignment=QtCore.Qt.AlignCenter)
graphing_layout.addWidget(self.graphics_view)
# the container for all the image-processing widgets
self.image_processing_group = QtWidgets.QGroupBox('Image Processing')
# rotate
self.rotate_label = QtWidgets.QLabel('<html>Rotate [0°]</html>')
self.rotate_slider = QtWidgets.QSlider(orientation=QtCore.Qt.Horizontal)
self.rotate_slider.setToolTip('The angle to rotate the image')
self.rotate_slider.setMinimum(-180)
self.rotate_slider.setMaximum(180)
self.rotate_slider.setSingleStep(1)
self.rotate_slider.setPageStep(15)
self.rotate_slider.valueChanged.connect(self.update_rotate)
if self.ocr_params['rotate']:
self.rotate_slider.setValue(self.ocr_params['rotate'])
# Gaussian blur
self.blur_label = QtWidgets.QLabel('Gaussian Blur [0]')
self.blur_slider = QtWidgets.QSlider(orientation=QtCore.Qt.Horizontal)
self.blur_slider.setToolTip('The pixel radius to use for the Gaussian blur')
self.blur_slider.setMinimum(0)
self.blur_slider.setMaximum(kwargs.pop('max_blur', 9))
self.blur_slider.setSingleStep(1)
self.blur_slider.valueChanged.connect(self.update_blur)
if self.ocr_params['blur']:
self.blur_slider.setValue(self.ocr_params['blur'])
# threshold
self.threshold_label = QtWidgets.QLabel('Threshold [0]')
self.threshold_checkbox = QtWidgets.QCheckBox()
self.threshold_checkbox.setToolTip('Apply thresholding?')
self.threshold_checkbox.clicked.connect(self.update_threshold_checkbox)
self.threshold_slider = QtWidgets.QSlider(orientation=QtCore.Qt.Horizontal)
self.threshold_slider.setToolTip('The threshold value')
self.threshold_slider.setMinimum(0)
self.threshold_slider.setMaximum(255)
self.threshold_slider.setSingleStep(1)
self.threshold_slider.valueChanged.connect(self.update_threshold)
if self.ocr_params['threshold']:
self.threshold_slider.setValue(self.ocr_params['threshold'])
self.threshold_checkbox.setChecked(True)
else:
self.threshold_slider.setEnabled(False)
self.threshold_checkbox.setChecked(False)
# dilate
self.dilate_label = QtWidgets.QLabel('Dilate [0]')
self.dilate_slider = QtWidgets.QSlider(orientation=QtCore.Qt.Horizontal)
self.dilate_spinbox = QtWidgets.QSpinBox()
self.dilate_spinbox.setToolTip('The number of iterations to apply dilation at the specified radius')
self.dilate_spinbox.setMinimum(1)
self.dilate_spinbox.setMaximum(99)
self.dilate_spinbox.setSingleStep(1)
self.dilate_spinbox.valueChanged.connect(self.update_dilate_iter)
self.dilate_slider.setToolTip('The pixel radius to use for dilation')
self.dilate_slider.setMinimum(0)
self.dilate_slider.setMaximum(kwargs.pop('max_dilate', 9))
self.dilate_slider.setSingleStep(1)
self.dilate_slider.valueChanged.connect(self.update_dilate)
if self.ocr_params['dilate']:
self.dilate_slider.setValue(self.ocr_params['dilate'])
# erode
self.erode_label = QtWidgets.QLabel('Erode [0]')
self.erode_slider = QtWidgets.QSlider(orientation=QtCore.Qt.Horizontal)
self.erode_spinbox = QtWidgets.QSpinBox()
self.erode_spinbox.setToolTip('The number of iterations to apply erosion at the specified radius')
self.erode_spinbox.setMinimum(1)
self.erode_spinbox.setMaximum(99)
self.erode_spinbox.setSingleStep(1)
self.erode_spinbox.valueChanged.connect(self.update_erode_iter)
self.erode_slider.setToolTip('The pixel radius to use for erosion')
self.erode_slider.setMinimum(0)
self.erode_slider.setMaximum(kwargs.pop('max_erode', 9))
self.erode_slider.setSingleStep(1)
self.erode_slider.valueChanged.connect(self.update_erode)
if self.ocr_params['erode']:
self.erode_slider.setValue(self.ocr_params['erode'])
# image-processing layout
ip_layout = QtWidgets.QGridLayout()
ip_layout.addWidget(self.rotate_label, 0, 0)
ip_layout.addWidget(self.rotate_slider, 0, 1)
ip_layout.addWidget(self.blur_label, 1, 0)
ip_layout.addWidget(self.blur_slider, 1, 1)
ip_layout.addWidget(self.threshold_label, 2, 0)
ip_layout.addWidget(self.threshold_slider, 2, 1)
ip_layout.addWidget(self.threshold_checkbox, 2, 2)
ip_layout.addWidget(self.dilate_label, 3, 0)
ip_layout.addWidget(self.dilate_slider, 3, 1)
ip_layout.addWidget(self.dilate_spinbox, 3, 2)
ip_layout.addWidget(self.erode_label, 4, 0)
ip_layout.addWidget(self.erode_slider, 4, 1)
ip_layout.addWidget(self.erode_spinbox, 4, 2)
self.image_processing_group.setLayout(ip_layout)
# the container for all the camera widgets
self.camera_config_group = QtWidgets.QGroupBox('Camera Settings')
# ISO
self.iso_combobox = QtWidgets.QComboBox()
self.iso_combobox.setToolTip('The ISO setting of the camera')
self.iso_combobox.addItems(['auto', '100', '200', '320', '400', '500', '640', '800'])
iso = str(kwargs.pop('iso', 'auto'))
if iso == '0':
iso = 'auto'
self.iso_combobox.setCurrentText(iso)
self.update_iso(self.iso_combobox.currentText())
self.iso_combobox.currentTextChanged.connect(self.update_iso)
self.iso_combobox.setEnabled(not self.path)
# resolution
self.resolution_combobox = QtWidgets.QComboBox()
self.resolution_combobox.setToolTip('The resolution of the camera')
self.resolution_combobox.addItems(['VGA', 'SVGA', 'XGA', '720p', 'SXGA', 'UXGA', '1080p', 'MAX'])
self.resolution_combobox.setCurrentText(str(kwargs.pop('resolution', 'VGA')))
self.update_resolution(self.resolution_combobox.currentText())
self.resolution_combobox.currentTextChanged.connect(self.update_resolution)
self.resolution_combobox.setEnabled(not self.path)
# exposure mode
self.exposure_mode_combobox = QtWidgets.QComboBox()
self.exposure_mode_combobox.setToolTip('The exposure mode of the camera')
self.exposure_mode_combobox.addItems(['off', 'auto', 'night', 'nightpreview',
'backlight', 'spotlight', 'sports', 'snow',
'beach', 'verylong', 'fixedfps', 'antishake', 'fireworks'])
self.exposure_mode_combobox.setCurrentText(str(kwargs.pop('exposure_mode', 'auto')))
self.update_exposure_mode(self.exposure_mode_combobox.currentText())
self.exposure_mode_combobox.currentTextChanged.connect(self.update_exposure_mode)
self.exposure_mode_combobox.setEnabled(not self.path)
camera_layout = QtWidgets.QGridLayout()
camera_layout.addWidget(QtWidgets.QLabel('ISO'), 0, 0)
camera_layout.addWidget(self.iso_combobox, 0, 1)
camera_layout.addItem(QtWidgets.QSpacerItem(1, 1, QtWidgets.QSizePolicy.MinimumExpanding), 0, 2)
camera_layout.addWidget(QtWidgets.QLabel('Resolution'), 1, 0)
camera_layout.addWidget(self.resolution_combobox, 1, 1)
camera_layout.addWidget(QtWidgets.QLabel('Exposure Mode'), 2, 0)
camera_layout.addWidget(self.exposure_mode_combobox, 2, 1)
self.camera_config_group.setLayout(camera_layout)
if self.client is None:
self.iso_combobox.setEnabled(False)
self.resolution_combobox.setEnabled(False)
self.exposure_mode_combobox.setEnabled(False)
# the container for all the OCR algorithm widgets
self.ocr_config_group = QtWidgets.QGroupBox('OCR Algorithm Settings')
# tesseract languages
self.tess_lang_combobox = QtWidgets.QComboBox()
self.tess_lang_combobox.addItems(['eng', 'letsgodigital'])
self.tess_lang_combobox.currentTextChanged.connect(self.update_tess_lang)
self.tess_lang_combobox.setToolTip('The language to use for Tesseract')
# tesseract or ssocr
self.tess_radio = QtWidgets.QRadioButton('Tesseract')
self.tess_radio.setToolTip('Use Tesseract')
self.tess_radio.toggled.connect(self.update_algorithm)
self.ssocr_radio = QtWidgets.QRadioButton('SSOCR')
self.ssocr_radio.setToolTip('Use SSOCR')
self.ssocr_radio.toggled.connect(self.update_algorithm)
if self.ocr_params['algorithm'] == 'ssocr':
self.ssocr_radio.setChecked(True)
else:
self.tess_radio.setChecked(True)
algo_layout = QtWidgets.QGridLayout()
algo_layout.addWidget(self.tess_radio, 0, 0)
algo_layout.addWidget(self.tess_lang_combobox, 0, 1)
algo_layout.addItem(QtWidgets.QSpacerItem(1, 1, QtWidgets.QSizePolicy.MinimumExpanding), 0, 2)
algo_layout.addWidget(self.ssocr_radio, 1, 0)
self.ocr_config_group.setLayout(algo_layout)
options_layout = QtWidgets.QVBoxLayout()
options_layout.addWidget(self.image_processing_group)
options_layout.addWidget(self.camera_config_group)
options_layout.addWidget(self.ocr_config_group)
options_layout.addStretch(1)
layout = QtWidgets.QHBoxLayout()
layout.addLayout(graphing_layout)
layout.addLayout(options_layout)
self.setLayout(layout)
if self.path:
self.setAcceptDrops(True)
self.capture_thread = None
self.original_image = utils.to_cv2(self.path)
height, width = self.original_image.shape[:2]
try: # could pass in an already-opened image object (which isn't a path)
basename = os.path.basename(self.path)
except OSError:
basename = 'UNKNOWN'
self.setWindowTitle('OCR || {} [{} x {}]'.format(basename, width, height))
else:
self.setAcceptDrops(False)
self.original_image = None
self.capture_index = 0
self.setWindowTitle('OCR || Capture 0')
self.capture_thread = Capture()
self.capture_thread.add_callback(self.capture)
self.capture_thread.start(self.client)
self.apply_ocr()
def initUI(self):
self.chnButtons = []
self.expSpnBoxes = []
#print channels
self.layout = QtGui.QHBoxLayout()
#self.layout=QtGui.QGridLayout(margin=0,spacing=-1)
self.layout.setSpacing(0)
self.gv = pg.GraphicsView(background='k')
self.gv.setContentsMargins(0, 0, 0, 0)
self.vb = pg.ViewBox()
self.gv.setCentralItem(self.vb)
self.vb.setAspectLocked()
self.vb.setContentsMargins(0, 0, 0, 0)
self.img = pg.ImageItem()
self.vb.addItem(self.img)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.gv)
self.setLayout(self.layout)
self.setAutoFillBackground(True)
p = self.palette()
p.setColor(self.backgroundRole(), QtCore.Qt.black)
self.setPalette(p)
keys = self.exposure_times.keys()
gridlay = QtGui.QGridLayout(margin=0, spacing=-1)
for i, ch in enumerate(self.channels):
btn = QtGui.QPushButton(ch, self)
self.chnButtons.append(btn)
gridlay.addWidget(btn, i, 0)
spnBox = QtGui.QSpinBox(self)
spnBox.setRange(1, 10000)
spnBox.setSingleStep(25)
if ch in keys:
spnBox.setValue(self.exposure_times[ch])
else:
spnBox.setValue(self.mmc.getExposure())
spnBox.setSuffix(" ms")
btn.clicked.connect(self.make_channelButtonClicked(ch, spnBox))
self.expSpnBoxes.append(spnBox)
gridlay.addWidget(spnBox, i, 1)
Nch = len(self.channels)
#auto_exposure button
autoExpBtn = QtGui.QPushButton('Auto set exposure', self)
autoExpBtn.clicked.connect(self.setExposureAuto)
gridlay.addWidget(autoExpBtn, Nch, 0)
#reset focus offset button
focResetBtn = QtGui.QPushButton('Reset Focus Position', self)
focResetBtn.clicked.connect(self.imgSrc.reset_focus_offset)
gridlay.addWidget(focResetBtn, Nch + 1, 0)
#focus lock button
self.isLockedBtn = QtGui.QPushButton('Focus Locked', self)
self.isLockedBtn.setCheckable(True)
self.isLockedBtn.clicked[bool].connect(self.toggleLock)
isLocked = self.imgSrc.get_hardware_autofocus_state()
if isLocked:
self.isLockedBtn.setText('Focus Locked')
self.isLockedBtn.setDown(True)
else:
self.isLockedBtn.setText('Focus UnLocked')
self.isLockedBtn.setDown(False)
gridlay.addWidget(self.isLockedBtn, Nch + 2, 0)
self.layout.addLayout(gridlay)
def main():
print("Mode = "+config.VISUAL_EFFECT)
if config.USE_GUI:
import pyqtgraph as pg
from pyqtgraph.Qt import QtGui, QtCore
# Create GUI window
app = QtGui.QApplication([])
view = pg.GraphicsView()
layout = pg.GraphicsLayout(border=(100,100,100))
view.setCentralItem(layout)
view.show()
view.setWindowTitle('Visualization')
view.resize(800,600)
# Mel filterbank plot
fft_plot = layout.addPlot(title='Filterbank Output', colspan=3)
fft_plot.setRange(yRange=[-0.1, 1.2])
fft_plot.disableAutoRange(axis=pg.ViewBox.YAxis)
x_data = np.array(range(1, config.N_FFT_BINS + 1))
mel_curve = pg.PlotCurveItem()
mel_curve.setData(x=x_data, y=x_data*0)
fft_plot.addItem(mel_curve)
# Visualization plot
layout.nextRow()
led_plot = layout.addPlot(title='Visualization Output', colspan=3)
led_plot.setRange(yRange=[-5, 260])
led_plot.disableAutoRange(axis=pg.ViewBox.YAxis)
# Pen for each of the color channel curves
r_pen = pg.mkPen((255, 30, 30, 200), width=4)
g_pen = pg.mkPen((30, 255, 30, 200), width=4)
b_pen = pg.mkPen((30, 30, 255, 200), width=4)
# Color channel curves
r_curve = pg.PlotCurveItem(pen=r_pen)
g_curve = pg.PlotCurveItem(pen=g_pen)
b_curve = pg.PlotCurveItem(pen=b_pen)
# Define x data
x_data = np.array(range(1, config.N_PIXELS + 1))
r_curve.setData(x=x_data, y=x_data*0)
g_curve.setData(x=x_data, y=x_data*0)
b_curve.setData(x=x_data, y=x_data*0)
# Add curves to plot
led_plot.addItem(r_curve)
led_plot.addItem(g_curve)
led_plot.addItem(b_curve)
# Frequency range label
freq_label = pg.LabelItem('')
# Frequency slider
def freq_slider_change(tick):
minf = freq_slider.tickValue(0)**2.0 * (config.MIC_RATE / 2.0)
maxf = freq_slider.tickValue(1)**2.0 * (config.MIC_RATE / 2.0)
t = 'Frequency range: {:.0f} - {:.0f} Hz'.format(minf, maxf)
freq_label.setText(t)
config.MIN_FREQUENCY = minf
config.MAX_FREQUENCY = maxf
dsp.create_mel_bank()
freq_slider = pg.TickSliderItem(orientation='bottom', allowAdd=False)
freq_slider.addTick((config.MIN_FREQUENCY / (config.MIC_RATE / 2.0))**0.5)
freq_slider.addTick((config.MAX_FREQUENCY / (config.MIC_RATE / 2.0))**0.5)
freq_slider.tickMoveFinished = freq_slider_change
freq_label.setText('Frequency range: {} - {} Hz'.format(
config.MIN_FREQUENCY,
config.MAX_FREQUENCY))
# Effect selection
active_color = '#16dbeb'
inactive_color = '#FFFFFF'
def energy_click(x):
global visualization_effect
visualization_effect = visualize_energy
energy_label.setText('Energy', color=active_color)
scroll_label.setText('Scroll', color=inactive_color)
spectrum_label.setText('Spectrum', color=inactive_color)
def scroll_click(x):
global visualization_effect
visualization_effect = visualize_scroll
energy_label.setText('Energy', color=inactive_color)
scroll_label.setText('Scroll', color=active_color)
spectrum_label.setText('Spectrum', color=inactive_color)
def spectrum_click(x):
global visualization_effect
visualization_effect = visualize_spectrum
energy_label.setText('Energy', color=inactive_color)
scroll_label.setText('Scroll', color=inactive_color)
spectrum_label.setText('Spectrum', color=active_color)
# Create effect "buttons" (labels with click event)
energy_label = pg.LabelItem('Energy')
scroll_label = pg.LabelItem('Scroll')
spectrum_label = pg.LabelItem('Spectrum')
energy_label.mousePressEvent = energy_click
scroll_label.mousePressEvent = scroll_click
spectrum_label.mousePressEvent = spectrum_click
energy_click(0)
# Layout
layout.nextRow()
layout.addItem(freq_label, colspan=3)
layout.nextRow()
layout.addItem(freq_slider, colspan=3)
layout.nextRow()
layout.addItem(energy_label)
layout.addItem(scroll_label)
layout.addItem(spectrum_label)
# Initialize LEDs
led.update()
# Start listening to live audio stream
microphone.start_stream(microphone_update)
def check_getArrayRegion(roi, name, testResize=True):
initState = roi.getState()
#win = pg.GraphicsLayoutWidget()
win = pg.GraphicsView()
win.show()
win.resize(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
img1.setImage(data[0, ..., 0])
vb1.setAspectLocked()
vb1.enableAutoRange(True, True)
roi.setZValue(10)
vb1.addItem(roi)
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()
assertImageApproved(win, name+'/roi_getarrayregion_inverty', 'Simple ROI region selection, view inverted.')
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.')
def _live_view(
*,
state: RecordState,
sample_rate: int,
downsample_to: Optional[int],
seconds: int,
calibrate: Optional[Tuple[int, str]],
):
from pyqtgraph.Qt import QtGui, QtCore
import numpy as np
import pyqtgraph as pg
from pyqtgraph.ptime import time
from pyqtgraph import PlotDataItem
from pyqtgraph.graphicsItems.ViewBox import ViewBox
# https://github.com/pyqtgraph/pyqtgraph/blob/master/examples/GraphicsLayout.py
# data will be downsampled to this value
# downsample_to: Optional[int] = 100
# (hw version, bias path)
# bp = '<grf_python>/test_data/CSM016/bias_20191120.csv'
# calibrate: Optional[Tuple[int, str]] = (1, bp)
# calibrate = None
@contextmanager
def app_closer(app):
try:
yield
finally:
app.quit()
with ExitStack() as stack:
stack.enter_context(LiveViewContext(state))
live_headers = [h for h in HEADERS if not h.get('synthetic')]
if downsample_to is not None:
assert sample_rate % downsample_to == 0, "sample rate must be evenly divisible by downsampled rate"
downsample_factor: Optional[int] = sample_rate // downsample_to
sample_rate = downsample_to
else:
downsample_factor = None
if calibrate is not None:
import importlib.util
import sys
hw_version, bias_path = calibrate
# adding the grf_python folder to path risks breaking stuff
# but it should only break the live view process at worst
# note that tilt_rewrites util will shadow grf_python's
grf_python_path = os.environ['grf_python_path']
sys.path.append(grf_python_path)
from load_table import apply_bias, apply_best_voltage, load_bias
from cop import calc_all_cop, add_cop_columns
from hardware_config import HardwareConfig
import numpy as np
bias_column_mapping = [
(h['csv'], h['cal']) for h in HEADERS
if 'cal' in h and h['csv'].startswith('sensor')
]
# bias_column_mapping_ = [
# ('Dev6/ai18', 'rhl_fx'), ('Dev6/ai19', 'rhl_fy'), ('Dev6/ai20', 'rhl_fz'),
# ('Dev6/ai21', 'rhl_tx'), ('Dev6/ai22', 'rhl_ty'), ('Dev6/ai23', 'rhl_tz'),
# ('Dev6/ai32', 'lhl_fx'), ('Dev6/ai33', 'lhl_fy'), ('Dev6/ai34', 'lhl_fz'),
# ('Dev6/ai35', 'lhl_tx'), ('Dev6/ai36', 'lhl_ty'), ('Dev6/ai37', 'lhl_tz'),
# ('Dev6/ai38', 'fl_fx'), ('Dev6/ai39', 'fl_fy'), ('Dev6/ai48', 'fl_fz'),
# ('Dev6/ai49', 'fl_tx'), ('Dev6/ai50', 'fl_ty'), ('Dev6/ai51', 'fl_tz'),
# ]
# assert bias_column_mapping == bias_column_mapping_
bias = load_bias(bias_path, column_mapping=bias_column_mapping)
hw_conf = HardwareConfig(1)
# data = {
# 'np': np.array([[1.0 for _ in live_headers] for _ in range(10)]),
# 'column_names': [x['cal'] for x in live_headers],
# }
# print(bias)
# apply_bias(data, bias)
# apply_best_voltage(data, hw_conf)
# print(data)
# cop = calc_all_cop(data, hw_conf)
# print(cop)
app = pg.mkQApp("Data")
stack.enter_context(app_closer(app))
view = pg.GraphicsView()
layout = pg.GraphicsLayout(border=(100, 100, 100))
view.setCentralItem(layout)
view.show()
view.setWindowTitle('data')
view.resize(800, 600)
layout.addLabel('red=rhl green=lhl blue=fl')
collectors: List[deque[float]] = [
deque(maxlen=sample_rate * seconds) for _ in live_headers
]
plots = {}
for graph_name, graph_info in GRAPHS.items():
row, col = graph_info['pos']
title = graph_info.get('title', graph_name)
plot = layout.addPlot(row=row + 1, col=col, title=title)
y_max = graph_info.get('y_max')
if y_max:
view_box = plot.getViewBox()
view_box.disableAutoRange(axis=ViewBox.YAxis)
view_box.setRange(yRange=(0, y_max))
plots[graph_name] = plot
def get_curve(i):
h = live_headers[i]
if 'graph' not in h:
# curves.append(None)
# continue
return None
color = h.get('color', (255, 255, 255))
plot = plots[h['graph']]
curve = plot.plot(pen=color)
return curve
curves: List[PlotDataItem] = [
get_curve(i) for i in range(len(live_headers))
]
def update():
try:
data = state.live.queue.get(block=False)
except Empty:
return
if data is None:
app.quit()
return
for i, h in enumerate(live_headers):
# skip timestamp column since it isn't actually in the collected data
if h['csv'] == 'Timestamp':
continue
if downsample_factor is None:
collectors[i].extend(data[i])
else:
downsampled = (
data[i][x]
for x in range(0, len(data[i]), downsample_factor))
collectors[i].extend(downsampled)
def apply_cal():
data = np.array(collectors, dtype=float)
data = data.swapaxes(0, 1)
data = {
'np': data,
'column_names': [x['cal'] for x in live_headers],
}
apply_bias(data, bias)
apply_best_voltage(data, hw_conf)
cop = calc_all_cop(data, hw_conf)
out_data = data['np'].swapaxes(0, 1)
for i, (curve, header) in enumerate(zip(curves, live_headers)):
if curve is not None:
if header['csv'] == 'Strobe':
curve.setData(cop['cop_x'])
elif header['csv'] == 'Start':
curve.setData(cop['cop_y'])
else:
curve.setData(out_data[i])
if calibrate is not None:
apply_cal()
else:
for i, curve in enumerate(curves):
if curve is not None:
curve.setData(collectors[i])
app.processEvents()
timer = QtCore.QTimer()
timer.timeout.connect(update)
timer.start(0)
app.exec_()
def gen_layout(self):
# live EEG inspection and Annotation
self.graph_eeg = pg.PlotItem()
self.graph_emg = pg.PlotItem()
self.graph_ann = pg.PlotItem()
self.view = pg.GraphicsView()
self.lay = pg.GraphicsLayout()
self.lay_brainstate = self.lay.addLayout()
#what's annotated, laser, and current visited timepoint
self.graph_treck = pg.PlotItem()
self.lay_brainstate.addItem(self.graph_treck)
self.lay_brainstate.nextRow()
# color-coded brainstate
self.graph_brainstate = self.lay_brainstate.addPlot()
self.image_brainstate = pg.ImageItem()
self.graph_brainstate.addItem(self.image_brainstate)
self.lay_brainstate.nextRow()
# add whole spectrogram
# self.graph_spectrum contains the image image_spectrum
self.graph_spectrum = self.lay_brainstate.addPlot()
self.image_spectrum = pg.ImageItem()
#self.image_spectrum = pg.ImageView()
self.graph_spectrum.addItem(self.image_spectrum)
self.lay_brainstate.nextRow()
# EMG Amplitude
self.graph_emgampl = self.lay_brainstate.addPlot()
self.lay.nextRow()
# Add live EEG and EMG
self.lay.nextRow()
self.lay.addItem(self.graph_eeg)
self.lay.nextRow()
self.lay.addItem(self.graph_emg)
self.lay.nextRow()
self.lay_ann = self.lay.addLayout()
# add live spectrum
self.graph_fft = self.lay_ann.addPlot()
self.image_fft = pg.ImageItem()
self.graph_fft.addItem(self.image_fft)
self.lay_ann.nextRow()
# add annotation
self.lay_ann.addItem(self.graph_ann)
# explanation how layout in QtMainWindow is organized:
# https://srinikom.github.io/pyside-docs/PySide/QtGui/QMainWindow.html
self.view.setCentralItem(self.lay)
self.setCentralWidget(self.view)
# mix colormaps
# the old colormap which I've used till 05/30/19:
# pos = np.array([0, 0.2, 0.4, 0.6, 0.8])
# color = np.array(
# [[0, 255, 255, 255], [150, 0, 255, 255], [192, 192, 192, 255], (0, 0, 0, 255), (255, 255, 0, 255)],
# dtype=np.ubyte)
# new colormap
color = np.array([[0, 0, 0, 200], [0, 255, 255, 200],
[150, 0, 255, 200], [150, 150, 150, 200]],
dtype=np.ubyte)
pos = np.linspace(0, 1, color.shape[0])
cmap = pg.ColorMap(pos, color)
self.lut_brainstate = cmap.getLookupTable(0, 1, color.shape[0])
pos = np.array([0., 0.05, .2, .4, .6, .9])
color = np.array([[0, 0, 0, 255], [0, 0, 128, 255], [0, 255, 0, 255],
[255, 255, 0, 255], (255, 165, 0, 255),
(255, 0, 0, 255)],
dtype=np.ubyte)
cmap = pg.ColorMap(pos, color)
self.lut_spectrum = cmap.getLookupTable(0.0, 1.0, 256)
def __init__(self):
self.app = QtGui.QApplication([])
self.view = pg.GraphicsView()
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.perf_line = None
self.colors = []
self._curve_data = {}
self._plot_curves = {}
self._rocch = None
self._perf_line = None
self._tooltip_cache = None
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(tbox,
self,
"target_index",
callback=self._on_target_changed,
contentsLength=8,
searchable=True)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed)
abox = gui.vBox(box, "Combine ROC Curves From Folds")
abox.setFlat(True)
gui.comboBox(abox,
self,
"roc_averaging",
items=[
"Merge Predictions from Folds", "Mean TP Rate",
"Mean TP and FP at Threshold",
"Show Individual Curves"
],
callback=self._replot)
hbox = gui.vBox(box, "ROC Convex Hull")
hbox.setFlat(True)
gui.checkBox(hbox,
self,
"display_convex_curve",
"Show convex ROC curves",
callback=self._replot)
gui.checkBox(hbox,
self,
"display_convex_hull",
"Show ROC convex hull",
callback=self._replot)
box = gui.vBox(self.controlArea, "Analysis")
gui.checkBox(box,
self,
"display_def_threshold",
"Default threshold (0.5) point",
callback=self._on_display_def_threshold_changed)
gui.checkBox(box,
self,
"display_perf_line",
"Show performance line",
callback=self._on_display_perf_line_changed)
grid = QGridLayout()
gui.indentedBox(box, orientation=grid)
sp = gui.spin(box,
self,
"fp_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FP Cost:"), 0, 0)
grid.addWidget(sp, 0, 1)
sp = gui.spin(box,
self,
"fn_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FN Cost:"))
grid.addWidget(sp, 1, 1)
self.target_prior_sp = gui.spin(box,
self,
"target_prior",
1,
99,
alignment=Qt.AlignRight,
callback=self._on_target_prior_changed)
self.target_prior_sp.setSuffix(" %")
self.target_prior_sp.addAction(QAction("Auto", sp))
grid.addWidget(QLabel("Prior target class probability:"))
grid.addWidget(self.target_prior_sp, 2, 1)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plotview.scene().sigMouseMoved.connect(self._on_mouse_moved)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("FP Rate (1-Specificity)")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate (Sensitivity)")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self, eventEngine, parent=None):
"""Constructor"""
self.parent = parent
QtGui.QWidget.__init__(self, parent)
self.setWindowTitle(u'VaR监控')
self.setWindowIcon(QtGui.QIcon('./icons/stock.ico'))
self.eventEngine = eventEngine
self.eventEngine.start()
self.eventEngine.register("showData", self.showData)
self.view = pg.GraphicsView()
self.l = pg.GraphicsLayout(border=(100, 100, 100))
self.view.setCentralItem(self.l)
self.view.show()
self.view.resize(800, 600)
self.view2 = pg.GraphicsView()
self.l2 = pg.GraphicsLayout(border=(100, 100, 100))
self.view2.setCentralItem(self.l2)
self.view2.show()
self.view2.resize(800, 600)
self.x = []
self.y = []
self.x1 = []
self.y1 = []
self.btn_load = QtWidgets.QPushButton(U'计算', self)
self.btn_load.setGeometry(QtCore.QRect(242, 0, 81, 25))
#font = QtGui.QFont()
#font.setPointSize(12)
#font.setBold(True)
#font.setWeight(75)
self.btn_load.setFixedSize(80, 35)
#self.btn_load.setFont(font)
self.btn_load.setObjectName("btn_load")
self.btn_load.clicked.connect(self.clickedbutton)
self.c = Communicate()
self.c.closeApp.connect(self.emitSignal)
self.label = QtWidgets.QLabel(self)
self.label.setGeometry(QtCore.QRect(0, 0, 31, 25))
self.label.setFixedSize(80, 35)
self.label.setObjectName("label")
self.label.setText(U"置信区间")
self.cbb_model = QtWidgets.QComboBox(self)
self.cbb_model.setGeometry(QtCore.QRect(500, 0, 51, 25))
self.cbb_model.setFixedSize(80, 35)
self.cbb_model.setObjectName("cbb_model")
self.cbb_model.addItem("0.95")
self.cbb_model.addItem("0.97")
self.cbb_model.addItem("0.99")
self.cbb_model.setCurrentIndex(0)
self.initUI()
# 设置界面
self.hb = QtGui.QVBoxLayout()
#self.hb.addWidget(self.btn_load)
self.hb.addWidget(self.view)
self.mainb = QtGui.QHBoxLayout()
self.mainb.addLayout(self.hb)
self.vb2 = QtGui.QVBoxLayout()
self.vb2.addWidget(self.view2)
self.mainb.addLayout(self.vb2)
self.lastb = QtGui.QVBoxLayout()
self.vb3 = QtGui.QHBoxLayout()
self.vb3.addWidget(self.label)
self.vb3.addWidget(self.cbb_model)
self.vb3.addWidget(self.btn_load)
self.vb3.addWidget(QtWidgets.QLabel(self))
self.lastb.addLayout(self.vb3)
self.lastb.addLayout(self.mainb)
self.view2.setFixedWidth(600)
self.setLayout(self.lastb)
def __init__(self):
super().__init__()
self.matrix = None
self._matrix_range = 0.
self._tree = None
self._ordered_tree = None
self._sorted_matrix = None
self._sort_indices = None
self._selection = None
self.sorting_cb = gui.comboBox(
self.controlArea, self, "sorting", box="Element Sorting",
items=["None", "Clustering", "Clustering with ordered leaves"],
callback=self._invalidate_ordering)
box = gui.vBox(self.controlArea, "Colors")
self.color_map_widget = cmw = ColorGradientSelection(
thresholds=(self.color_low, self.color_high),
)
model = itemmodels.ContinuousPalettesModel(parent=self)
cmw.setModel(model)
idx = cmw.findData(self.palette_name, model.KeyRole)
if idx != -1:
cmw.setCurrentIndex(idx)
cmw.activated.connect(self._update_color)
def _set_thresholds(low, high):
self.color_low, self.color_high = low, high
self._update_color()
cmw.thresholdsChanged.connect(_set_thresholds)
box.layout().addWidget(self.color_map_widget)
self.annot_combo = gui.comboBox(
self.controlArea, self, "annotation_idx", box="Annotations",
contentsLength=12, searchable=True,
callback=self._invalidate_annotations
)
self.annot_combo.setModel(itemmodels.VariableListModel())
self.annot_combo.model()[:] = ["None", "Enumeration"]
gui.rubber(self.controlArea)
gui.auto_send(self.buttonsArea, self, "autocommit")
self.view = pg.GraphicsView(background="w")
self.mainArea.layout().addWidget(self.view)
self.grid_widget = pg.GraphicsWidget()
self.grid = QGraphicsGridLayout()
self.grid_widget.setLayout(self.grid)
self.gradient_legend = GradientLegendWidget(0, 1, self._color_map())
self.gradient_legend.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.gradient_legend.setMaximumWidth(250)
self.grid.addItem(self.gradient_legend, 0, 1)
self.viewbox = pg.ViewBox(enableMouse=False, enableMenu=False)
self.viewbox.setAcceptedMouseButtons(Qt.NoButton)
self.viewbox.setAcceptHoverEvents(False)
self.grid.addItem(self.viewbox, 2, 1)
self.left_dendrogram = DendrogramWidget(
self.grid_widget, orientation=DendrogramWidget.Left,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False
)
self.left_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.left_dendrogram.setAcceptHoverEvents(False)
self.top_dendrogram = DendrogramWidget(
self.grid_widget, orientation=DendrogramWidget.Top,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False
)
self.top_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.top_dendrogram.setAcceptHoverEvents(False)
self.grid.addItem(self.left_dendrogram, 2, 0)
self.grid.addItem(self.top_dendrogram, 1, 1)
self.right_labels = TextList(
alignment=Qt.AlignLeft | Qt.AlignVCenter,
sizePolicy=QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
)
self.bottom_labels = TextList(
orientation=Qt.Horizontal,
alignment=Qt.AlignRight | Qt.AlignVCenter,
sizePolicy=QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
)
self.grid.addItem(self.right_labels, 2, 2)
self.grid.addItem(self.bottom_labels, 3, 1)
self.view.setCentralItem(self.grid_widget)
self.gradient_legend.hide()
self.left_dendrogram.hide()
self.top_dendrogram.hide()
self.right_labels.hide()
self.bottom_labels.hide()
self.matrix_item = None
self.dendrogram = None
self.settingsAboutToBePacked.connect(self.pack_settings)
def make_gui(self):
# Create GUI window
app = QtGui.QApplication([])
view = pg.GraphicsView()
layout = pg.GraphicsLayout(border=(100,100,100))
view.setCentralItem(layout)
view.show()
view.setWindowTitle('Visualization')
view.resize(800,600)
# Mel filterbank plot
fft_plot = layout.addPlot(title='Filterbank Output', colspan=3)
fft_plot.setRange(yRange=[-0.1, 1.2])
fft_plot.disableAutoRange(axis=pg.ViewBox.YAxis)
x_data = np.array(range(1, self.config['N_FFT_BINS'] + 1))
mel_curve = pg.PlotCurveItem()
mel_curve.setData(x=x_data, y=x_data*0)
fft_plot.addItem(mel_curve)
def add_led_plot(o):
# Visualization plot
layout.nextRow()
led_plot = layout.addPlot(title='LED: ' + o['NAME'], colspan=3)
led_plot.setRange(yRange=[-5, 260])
led_plot.disableAutoRange(axis=pg.ViewBox.YAxis)
# Pen for each of the color channel curves
r_pen = pg.mkPen((255, 30, 30, 200), width=4)
g_pen = pg.mkPen((30, 255, 30, 200), width=4)
b_pen = pg.mkPen((30, 30, 255, 200), width=4)
# Color channel curves
r_curve = pg.PlotCurveItem(pen=r_pen)
g_curve = pg.PlotCurveItem(pen=g_pen)
b_curve = pg.PlotCurveItem(pen=b_pen)
# Define x data
x_data = np.array(range(1, o['N_PIXELS'] + 1))
r_curve.setData(x=x_data, y=x_data*0)
g_curve.setData(x=x_data, y=x_data*0)
b_curve.setData(x=x_data, y=x_data*0)
# Add curves to plot
led_plot.addItem(r_curve)
led_plot.addItem(g_curve)
led_plot.addItem(b_curve)
self.led_plots[o['NAME']] = (led_plot, r_curve, g_curve, b_curve)
for o in self.config.get('OUTPUTS') or []:
# TODO: better way to figure this out
if o.get('DEVICE', '').endswith('Strip'):
add_led_plot(o)
# Frequency range label
freq_label = pg.LabelItem('')
# Frequency slider
def freq_slider_change(tick):
minf = freq_slider.tickValue(0)**2.0 * (self.config['MIC_RATE'] / 2.0)
maxf = freq_slider.tickValue(1)**2.0 * (self.config['MIC_RATE'] / 2.0)
t = 'Frequency range: {:.0f} - {:.0f} Hz'.format(minf, maxf)
freq_label.setText(t)
self.config['MIN_FREQUENCY'] = minf
self.config['MAX_FREQUENCY'] = maxf
return
dsp.create_mel_bank()
freq_slider = pg.TickSliderItem(orientation='bottom', allowAdd=False)
freq_slider.addTick((self.config['MIN_FREQUENCY'] / (self.config['MIC_RATE'] / 2.0))**0.5)
freq_slider.addTick((self.config['MAX_FREQUENCY'] / (self.config['MIC_RATE'] / 2.0))**0.5)
freq_slider.tickMoveFinished = freq_slider_change
freq_label.setText('Frequency range: {} - {} Hz'.format(
self.config['MIN_FREQUENCY'],
self.config['MAX_FREQUENCY']))
# # Effect selection
# active_color = '#16dbeb'
# inactive_color = '#FFFFFF'
# def energy_click(x):
# global visualization_effect
# visualization_effect = visualize_energy
# energy_label.setText('Energy', color=active_color)
# scroll_label.setText('Scroll', color=inactive_color)
# spectrum_label.setText('Spectrum', color=inactive_color)
# def scroll_click(x):
# global visualization_effect
# visualization_effect = visualize_scroll
# energy_label.setText('Energy', color=inactive_color)
# scroll_label.setText('Scroll', color=active_color)
# spectrum_label.setText('Spectrum', color=inactive_color)
# def spectrum_click(x):
# global visualization_effect
# visualization_effect = visualize_spectrum
# energy_label.setText('Energy', color=inactive_color)
# scroll_label.setText('Scroll', color=inactive_color)
# spectrum_label.setText('Spectrum', color=active_color)
# # Create effect "buttons" (labels with click event)
# energy_label = pg.LabelItem('Energy')
# scroll_label = pg.LabelItem('Scroll')
# spectrum_label = pg.LabelItem('Spectrum')
# energy_label.mousePressEvent = energy_click
# scroll_label.mousePressEvent = scroll_click
# spectrum_label.mousePressEvent = spectrum_click
# energy_click(0)
# Layout
layout.nextRow()
layout.addItem(freq_label, colspan=3)
layout.nextRow()
layout.addItem(freq_slider, colspan=3)
layout.nextRow()
# layout.addItem(energy_label)
# layout.addItem(scroll_label)
# layout.addItem(spectrum_label)
self.app = app
self.view = view
self.layout = layout
self.mel_curve = mel_curve
def __init__(self):
super().__init__()
self.matrix = None
self._tree = None
self._ordered_tree = None
self._sorted_matrix = None
self._sort_indices = None
self._selection = None
box = gui.widgetBox(self.controlArea, "Element sorting", margin=0)
gui.comboBox(
box,
self,
"sorting",
items=["None", "Clustering", "Clustering with ordered leaves"],
callback=self._invalidate_ordering)
box = gui.widgetBox(self.controlArea, "Colors")
self.colormap_cb = gui.comboBox(box,
self,
"colormap",
callback=self._update_color)
self.colormap_cb.setIconSize(QSize(64, 16))
self.palettes = list(sorted(load_default_palettes()))
self.palettes += [("Blue-Yellow", {2: [(0, 0, 255), (255, 255, 0)]})]
for i, pcolor in enumerate(self.palettes):
if pcolor[0] == 'Blue-Yellow':
self.colormap = i
init_color_combo(self.colormap_cb, self.palettes, QSize(64, 16))
self.colormap_cb.setCurrentIndex(self.colormap)
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
# form.addRow(
# "Gamma",
# gui.hSlider(box, self, "color_gamma", minValue=0.0, maxValue=1.0,
# step=0.05, ticks=True, intOnly=False,
# createLabel=False, callback=self._update_color)
# )
form.addRow(
"Low",
gui.hSlider(box,
self,
"color_low",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self._update_color))
form.addRow(
"High",
gui.hSlider(box,
self,
"color_high",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self._update_color))
box.layout().addLayout(form)
box = gui.widgetBox(self.controlArea, "Annotations")
self.annot_combo = gui.comboBox(box,
self,
"annotation_idx",
callback=self._invalidate_annotations,
contentsLength=12)
self.annot_combo.setModel(itemmodels.VariableListModel())
self.annot_combo.model()[:] = ["None", "Enumeration"]
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea, self, "autocommit", "Send data",
"Auto send is on")
self.view = pg.GraphicsView(background="w")
self.mainArea.layout().addWidget(self.view)
self.grid_widget = pg.GraphicsWidget()
self.grid = QGraphicsGridLayout()
self.grid_widget.setLayout(self.grid)
self.viewbox = pg.ViewBox(enableMouse=False, enableMenu=False)
self.viewbox.setAcceptedMouseButtons(Qt.NoButton)
self.viewbox.setAcceptHoverEvents(False)
self.grid.addItem(self.viewbox, 1, 1)
self.left_dendrogram = DendrogramWidget(
self.grid_widget,
orientation=DendrogramWidget.Left,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False)
self.left_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.left_dendrogram.setAcceptHoverEvents(False)
self.top_dendrogram = DendrogramWidget(
self.grid_widget,
orientation=DendrogramWidget.Top,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False)
self.top_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.top_dendrogram.setAcceptHoverEvents(False)
self.grid.addItem(self.left_dendrogram, 1, 0)
self.grid.addItem(self.top_dendrogram, 0, 1)
self.right_labels = TextList(alignment=Qt.AlignLeft)
self.bottom_labels = TextList(orientation=Qt.Horizontal,
alignment=Qt.AlignRight)
self.grid.addItem(self.right_labels, 1, 2)
self.grid.addItem(self.bottom_labels, 2, 1)
self.view.setCentralItem(self.grid_widget)
self.left_dendrogram.hide()
self.top_dendrogram.hide()
self.right_labels.hide()
self.bottom_labels.hide()
self.matrix_item = None
self.dendrogram = None
self.grid_widget.scene().installEventFilter(self)
self.graphButton.clicked.connect(self.save_graph)
def __init__(self):
super().__init__()
self.results = None
self.scores = None
self.classifier_names = []
self.colors = []
self.line = None
self._last_score_value = -1
box = gui.vBox(self.controlArea, box="Settings")
self.target_cb = gui.comboBox(box,
self,
"target_index",
label="Target:",
orientation=Qt.Horizontal,
callback=self.target_index_changed,
contentsLength=8,
searchable=True)
gui.checkBox(box,
self,
"display_rug",
"Show rug",
callback=self._on_display_rug_changed)
gui.checkBox(box,
self,
"fold_curves",
"Curves for individual folds",
callback=self._replot)
self.classifiers_list_box = gui.listBox(
self.controlArea,
self,
"selected_classifiers",
"classifier_names",
box="Classifier",
selectionMode=QListWidget.ExtendedSelection,
sizePolicy=(QSizePolicy.Preferred, QSizePolicy.Preferred),
sizeHint=QSize(150, 40),
callback=self._on_selection_changed)
box = gui.vBox(self.controlArea, "Metrics")
combo = gui.comboBox(box,
self,
"score",
items=(metric.name for metric in Metrics),
callback=self.score_changed)
self.explanation = gui.widgetLabel(box,
wordWrap=True,
fixedWidth=combo.sizeHint().width())
self.explanation.setContentsMargins(8, 8, 0, 0)
font = self.explanation.font()
font.setPointSizeF(0.85 * font.pointSizeF())
self.explanation.setFont(font)
gui.radioButtons(box,
self,
value="output_calibration",
btnLabels=("Sigmoid calibration",
"Isotonic calibration"),
label="Output model calibration",
callback=self.apply)
self.info_box = gui.widgetBox(self.controlArea, "Info")
self.info_label = gui.widgetLabel(self.info_box)
gui.auto_apply(self.controlArea,
self,
"auto_commit",
commit=self.apply)
self.plotview = pg.GraphicsView(background="w")
axes = {
"bottom": AxisItem(orientation="bottom"),
"left": AxisItem(orientation="left")
}
self.plot = pg.PlotItem(enableMenu=False, axisItems=axes)
self.plot.parameter_setter = ParameterSetter(self.plot)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
for axis_name in ("bottom", "left"):
axis = self.plot.getAxis(axis_name)
axis.setPen(pg.mkPen(color=0.0))
# Remove the condition (that is, allow setting this for bottom
# axis) when pyqtgraph is fixed
# Issue: https://github.com/pyqtgraph/pyqtgraph/issues/930
# Pull request: https://github.com/pyqtgraph/pyqtgraph/pull/932
if axis_name != "bottom": # remove if when pyqtgraph is fixed
axis.setStyle(stopAxisAtTick=(True, True))
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
self._set_explanation()
VisualSettingsDialog(self, self.plot.parameter_setter.initial_settings)
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.setPos(0, img1.height())
img1.setTransform(QtGui.QTransform().scale(1, -1).rotate(20), True)
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 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.setPos(0, 0)
img1.setTransform(QtGui.QTransform.fromScale(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()
###############
if True:
win = QtGui.QMainWindow()
win.resize(1600,600)
win.setWindowTitle('window title')
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)
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()
def test_basics_graphics_view():
app = pg.mkQApp()
view = pg.GraphicsView()
background_role = view.backgroundRole()
assert background_role == QtGui.QPalette.Background
palette = view.palette()
assert palette.isBrushSet(QtGui.QPalette.Active, QtGui.QPalette.Background)
assert palette.color(QtGui.QPalette.Background) == QtCore.Qt.transparent
assert view.backgroundBrush().color() == QtGui.QColor(0, 0, 0, 255)
assert view.focusPolicy() == QtCore.Qt.StrongFocus
assert view.transformationAnchor() == QtGui.QGraphicsView.NoAnchor
minimal_update = QtGui.QGraphicsView.MinimalViewportUpdate
assert view.viewportUpdateMode() == minimal_update
assert view.frameShape() == QtGui.QFrame.NoFrame
assert view.hasMouseTracking() is True
# Default properties
# --------------------------------------
assert view.mouseEnabled is False
assert view.aspectLocked is False
assert view.autoPixelRange is True
assert view.scaleCenter is False
assert view.clickAccepted is False
assert view.centralWidget is not None
assert view._background == "default"
# Set background color
# --------------------------------------
view.setBackground("w")
assert view._background == "w"
palette = view.palette()
assert palette.isBrushSet(QtGui.QPalette.Active, QtGui.QPalette.Background)
assert palette.color(QtGui.QPalette.Background) == QtCore.Qt.transparent
assert view.backgroundBrush().color() == QtCore.Qt.white
# Set anti aliasing
# --------------------------------------
aliasing = QtGui.QPainter.Antialiasing
# Default is set to `False`
assert not view.renderHints() & aliasing == aliasing
view.setAntialiasing(True)
assert view.renderHints() & aliasing == aliasing
view.setAntialiasing(False)
assert not view.renderHints() & aliasing == aliasing
# Enable mouse
# --------------------------------------
view.enableMouse(True)
assert view.mouseEnabled is True
assert view.autoPixelRange is False
view.enableMouse(False)
assert view.mouseEnabled is False
assert view.autoPixelRange is True
# Add and remove item
# --------------------------------------
central_item = QtGui.QGraphicsWidget()
view.setCentralItem(central_item)
assert view.centralWidget is central_item
# XXX: Removal of central item is not clear in code
scene = view.sceneObj
assert isinstance(scene, pg.GraphicsScene)
assert central_item in scene.items()
item = QtGui.QGraphicsWidget()
assert item not in scene.items()
view.addItem(item)
assert item in scene.items()
view.removeItem(item)
assert item not in scene.items()
# Close the graphics view
# --------------------------------------
view.close()
assert view.centralWidget is None
assert view.currentItem is None
assert view.sceneObj is None
assert view.closed is True
del view
app.deleteLater()
def get_data(self, s):
file_name = s.text()
MDIWindow.count = MDIWindow.count + 1
sub = QMdiSubWindow()
sub.resize(600, 600)
sub.setWindowTitle(file_name)
sub.setObjectName(file_name)
if 'ibw' in file_name:
self.opened_wd_names.append(file_name)
self.data_dict = ut.ibw2dict(self.current_dir + '/' + file_name)
elif 'zip' in file_name:
self.opened3D_wd_names.append(file_name)
self.data3D_dict = ut.read_bin_multi_region(
self.current_dir, file_name[:-4])
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]
gr_v = pg.GraphicsView()
l = pg.GraphicsLayout()
gr_v.setCentralWidget(l)
sub.setWidget(gr_v)
self.ui.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)
vb.setMouseMode(vb.RectMode)
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()
hist = pg.HistogramLUTItem(image=img_i)
l.addItem(hist, row=0, col=1)
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')
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)
p1.setTitle('EDC, angle ={:.2f}'.format(p.y()))
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)
p2.setTitle('MDC, energy ={:.2f}'.format(p.x()))
# label2.setText("{}-{}".format(p.x(), p.y()))
img_i.scene().sigMouseMoved.connect(onMouseMoved)
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(tbox,
self,
"target_index",
callback=self._on_target_changed,
contentsLength=8)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed)
gui.checkBox(box,
self,
"display_convex_hull",
"Show lift convex hull",
callback=self._replot)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("P Rate")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def plot(self):
pg.setConfigOption('background', 'w') # set background to white
pg.setConfigOption('foreground', 'k')
self.app = pg.mkQApp()
wintitle = 'test_decorator'
self.view = pg.GraphicsView()
self.layout = pg.GraphicsLayout() #(border=(100,100,100))
self.view.setCentralItem(self.layout)
self.view.resize(800, 600)
self.view.show()
self.plots = {}
nr1 = 6
nc = 10
for i in range(1, nr1):
self.plots['p%d' % i] = None
for i in range(1, nr1 + 1):
self.layout.addLayout(row=i, col=nc)
for i in range(1, nc + 1):
self.layout.addLayout(row=nr1 + 2, col=i)
self.plots['p1'] = self.layout.addPlot(row=1,
col=1,
rowspan=6,
colspan=9,
labels={
'left': 'V (mV)',
'bottom': 'Time (ms)'
})
self.plots['p2'] = self.layout.addPlot(row=7,
col=1,
rowspan=1,
colspan=9,
labels={
'left': 'I (nA)',
'bottom': 'Time (ms)'
})
for k in range(len(self.iv.voltage_traces)):
self.plots['p1'].plot(self.iv.time_values,
np.array(self.iv.voltage_traces[k]),
pen=pg.mkPen('k', width=0.75))
self.plots['p2'].plot(self.iv.time_values,
np.array(self.iv.current_traces[k]),
pen=pg.mkPen('k', width=0.75))
self.plots['p1'].setRange(xRange=(0.,
np.sum(self.durs) - self.initdelay),
yRange=(-160., 40.))
self.plots['p2'].setRange(xRange=(0.,
np.sum(self.durs) - self.initdelay),
yRange=(-1, 1))
PH.noaxes(self.plots['p1'])
PH.calbar(self.plots['p1'],
calbar=[125., -120., 10., 20.],
unitNames={
'x': 'ms',
'y': 'mV'
})
PH.noaxes(self.plots['p2'])
PH.calbar(self.plots['p2'],
calbar=[125, 0.1, 0., 0.5],
unitNames={
'x': 'ms',
'y': 'nA'
})
text = (u"{0:2d}\u00b0C {1:.2f}-{2:.2f} nA".format(
int(self.temperature), np.min(self.iv.current_cmd),
np.max(self.iv.current_cmd)))
ti = pg.TextItem(text, anchor=(1, 0))
ti.setFont(pg.QtGui.QFont('Arial', 9))
ti.setPos(120., -120.)
self.plots['p1'].addItem(ti)
def testincsfa(animate=False):
try:
import mdp.nodes
except ImportError:
raise ('Intall MDP toolkit for check/test')
iterval = 20
t = np.linspace(0, 4 * np.pi, 500)
x1 = np.sin(t) + np.power(np.cos(11 * t), 2)
x2 = np.cos(11 * t)
x = np.zeros([t.shape[0], 2])
x[:, 0] = x1
x[:, 1] = x2
expnode = mdp.nodes.PolynomialExpansionNode(2)
input_data = expnode(x)
##Setup node/trainer
input_dim = input_data.shape[1]
whitening_output_dim = 5
output_dim = 5
node = IncSFANode(input_dim, whitening_output_dim, output_dim, eps=0.05)
trainer = TrainerNode(node, mode='Incremental', ticker=100)
#For check
bsfanode = mdp.nodes.SFANode(output_dim=output_dim)
bsfanode(input_data)
bv = bsfanode.sf.T
if PYQT:
global app
app = pg.QtGui.QApplication([])
pg.setConfigOption('background', 'k')
pg.setConfigOption('foreground', 'w')
pg.setConfigOptions(antialias=True)
##Setup Plot
view = pg.GraphicsView()
l = pg.GraphicsLayout(border=(100, 100, 100))
view.setCentralItem(l)
view.setWindowTitle('IncSFA Test')
view.resize(1200, 500)
## Title at top
text = """
This example demonstrates the working of Incremental Slow Feature Analysis (IncSFA).
"""
l.addLabel(text, col=0, colspan=5, size='20px')
l.nextRow()
pen = pg.mkPen(color=(255, 255, 200), width=1)
labelStyle = {'color': '#FFF', 'font-size': '16px'}
p1 = l.addPlot(rowspan=2, colspan=2)
#Axis Settings
p1.getAxis('left').setPen(pen)
p1.getAxis('bottom').setPen(pen)
p1.showGrid(1, 1, .2)
p1.setLabel('bottom', 'Ticker', units='t', **labelStyle)
p1.setLabel('left', 'DC', **labelStyle)
p1.setTitle('Direction Cosines', size='16px')
p1.setXRange(0, iterval * t.shape[0] / trainer.ticker)
p1.setYRange(0, 1.1)
#Legend
leg = pg.LegendItem(size=(100, 60),
offset=(-20, 100)) # args are (size, offset)
leg.setParentItem(
p1.graphicsItem()) # Note we do NOT call plt.addItem in this case
#init curves
curves1 = [
pg.PlotCurveItem(pen=(i, output_dim * 1.3))
for i in range(output_dim)
]
for i, c in enumerate(curves1):
p1.addItem(c)
leg.addItem(c, 'V-%d' % i)
l2 = l.addLayout(col=2, colspan=2, border=(50, 0, 0))
curves2 = [
pg.PlotCurveItem(pen=(i, output_dim * 1.3)) for i in range(4)
]
l2.setContentsMargins(10, 10, 10, 10)
l2.addLabel("IncSFA Feature Outputs", colspan=3, size='16px')
l2.nextRow()
l2.addLabel('Output Value', angle=-90, rowspan=2, size='16px')
p21 = l2.addPlot()
p21.addItem(curves2[0])
p21.setXRange(0, t.shape[0])
p21.setYRange(-2, 2)
p22 = l2.addPlot()
p22.addItem(curves2[1])
p22.setXRange(0, t.shape[0])
p22.setYRange(-2, 2)
l2.nextRow()
p23 = l2.addPlot()
p23.addItem(curves2[2])
p23.setXRange(0, t.shape[0])
p23.setYRange(-2, 2)
p24 = l2.addPlot()
p24.addItem(curves2[3])
p24.setXRange(0, t.shape[0])
p24.setYRange(-2, 2)
l2.nextRow()
l2.addLabel("Time(t)", col=1, colspan=2, size='16px')
if animate:
view.show()
trn = trainer.itrain(input_data,
iterval=iterval,
monitor_keys=['slowFeatures'])
dcosines = np.zeros(
[iterval * t.shape[0] / trainer.ticker, output_dim])
timer = QtCore.QTimer()
cnt = [0]
_tcnt = time.time()
def animloop():
rtnval = trn.next()
if not rtnval:
timer.stop()
print ''
print 'Total Time for %d iterations: ' % (
iterval), time.time() - _tcnt
print 'Success status: ', np.allclose(dcosines[cnt[0] - 1],
np.ones(output_dim),
atol=1e-2)
print 'Maximum error: ', np.max(
np.abs(np.ones(output_dim) - dcosines[cnt[0] - 1]))
return
v = trainer.monitorVar['slowFeatures'][0]
out = node.execute(input_data)
for dim in xrange(output_dim):
dcosines[cnt[0], dim] = np.abs(np.dot(
v[dim], bv[dim].T)) / (np.linalg.norm(v[dim]) *
np.linalg.norm(bv[dim]))
for i in range(output_dim):
curves1[i].setData(dcosines[:cnt[0], i])
for i in range(4):
curves2[i].setData(out[:, i])
cnt[0] += 1
timer.timeout.connect(animloop)
timer.start(0)
else:
_tcnt = time.time()
trainer.train(input_data,
iterval=iterval,
monitor_keys=['slowFeatures'])
v = trainer.monitorVar['slowFeatures']
dcosines = np.zeros([len(v), output_dim])
for i in xrange(len(v)):
for dim in xrange(output_dim):
dcosines[i, dim] = np.abs(np.dot(v[i][dim], bv[dim].T)) / (
np.linalg.norm(v[i][dim]) * np.linalg.norm(bv[dim]))
out = node.execute(input_data)
for i in range(output_dim):
curves1[i].setData(dcosines[:, i])
for i in range(4):
curves2[i].setData(out[:, i])
view.show()
print ''
print 'Total Time for %d iterations: ' % (
iterval), time.time() - _tcnt
print 'Success status: ', np.allclose(dcosines[-1],
np.ones(output_dim),
atol=1e-2)
print 'Maximum error: ', np.max(
np.abs(np.ones(output_dim) - dcosines[-1]))
app.exec_()
else:
_tcnt = time.time()
trainer.train(input_data,
iterval=iterval,
monitor_keys=['slowFeatures'])
v = trainer.monitorVar['slowFeatures']
dcosines = np.zeros([len(v), output_dim])
for i in xrange(len(v)):
for dim in xrange(output_dim):
dcosines[i, dim] = np.abs(np.dot(v[i][dim], bv[dim].T)) / (
np.linalg.norm(v[i][dim]) * np.linalg.norm(bv[dim]))
print ''
print 'Total Time for %d iterations: ' % (iterval), time.time() - _tcnt
print 'Success status: ', np.allclose(dcosines[-1],
np.ones(output_dim),
atol=1e-2)
print 'Maximum error: ', np.max(
np.abs(np.ones(output_dim) - dcosines[-1]))
plt.figure(figsize=(12, 5))
fig = plt.gcf()
fig.canvas.set_window_title(
'This example demonstrates the working of Incremental Slow Feature Analysis (IncSFA).'
)
plt.subplot2grid((2, 4), (0, 0), colspan=2, rowspan=2)
plt.plot(dcosines)
plt.ylim([0, 1.1])
plt.title('Direction Cosines')
plt.legend(['V-%d' % (i + 1) for i in xrange(output_dim)])
plt.xlabel('Ticker')
out = node.execute(input_data)
plt.subplot2grid((2, 4), (0, 2))
plt.plot(out[:, 0], 'b', linewidth=1.5)
plt.title('SF Out-1')
plt.subplot2grid((2, 4), (0, 3))
plt.plot(out[:, 1], 'g', linewidth=1.5)
plt.title('SF Out-2')
plt.subplot2grid((2, 4), (1, 2))
plt.plot(out[:, 2], 'r', linewidth=1.5)
plt.title('SF Out-3')
plt.subplot2grid((2, 4), (1, 3))
plt.plot(out[:, 3], 'c', linewidth=1.5)
plt.title('SF Out-4')
plt.tight_layout()
plt.show()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setWindowTitle("Neonatal Ventilation Data Annotation Tool")
self.resize(1280, 720)
pg.setConfigOption('foreground', "k")
pg.setConfigOption('background', 'w')
# Label choices
info_layout = QHBoxLayout()
self.pressure_choice = QComboBox()
self.pressure_choice.addItems(MainWindow.pressure_options)
self.flow_choice = QComboBox()
self.flow_choice.addItems(MainWindow.flow_options)
info_layout.addWidget(QLabel("Pressure labels"), 1)
info_layout.addWidget(self.pressure_choice, 2)
info_layout.addWidget(QLabel("Flow labels"), 1)
info_layout.addWidget(self.flow_choice, 2)
# Graphing
self.display = pg.GraphicsView()
self.display_layout = pg.GraphicsLayout()
self.display.setCentralItem(self.display_layout)
self.pressure_plot = self.display_layout.addPlot(
title="Pressure waveform")
self.pressure_plot.showGrid(x=True, y=True)
self.pressure_plot.setMenuEnabled(False)
self.pressure_plot.setLabel("left", "Pressure")
self.pressure_plot.setLabel("bottom", "Time")
self.pressure_plot.scene().sigMouseClicked.connect(
self.__on_graph_click)
self.pressure_plot.sigXRangeChanged.connect(self.__on_axis_change)
self.pressure_plot.setClipToView(True)
self.display_layout.nextRow()
self.flow_plot = self.display_layout.addPlot(title="Flow waveform")
self.flow_plot.showGrid(x=True, y=True)
self.flow_plot.setMenuEnabled(False)
self.flow_plot.setLabel("left", "Flow")
self.flow_plot.setLabel("bottom", "Time")
self.flow_plot.setClipToView(True)
self.flow_plot.getViewBox().setXLink(self.pressure_plot)
self.pressure_pen = pg.mkPen(color="r", width=2)
self.flow_pen = pg.mkPen(color="b", width=2)
widget = QWidget()
layout = QVBoxLayout()
layout.addLayout(info_layout)
layout.addWidget(self.display)
widget.setLayout(layout)
self.setCentralWidget(widget)
# Default values
self.data = None
self.w_len = 500
self.interval = 0
self.pressure_labels = []
self.flow_labels = []
self.pressure_markers = []
self.flow_markers = []
self.xmin = 0
self.xmax = 0
# For file i/o
self.File = self.menuBar().addMenu("&File")
load_waveforms = QAction("Load Waveforms", self)
load_waveforms.triggered.connect(self.__load_waveforms)
self.File.addAction(load_waveforms)
save_annotations = QAction("Save Annotations", self)
save_annotations.triggered.connect(self.__save_annotations)
self.File.addAction(save_annotations)
load_annotations = QAction("Load Annotations", self)
load_annotations.triggered.connect(self.__load_annotations)
self.File.addAction(load_annotations)
save_graph = QAction("Save graph", self)
save_graph.triggered.connect(self.__save_graph)
self.File.addAction(save_graph)
# For view settings
self.View = self.menuBar().addMenu("&View")
view_settings = QAction("Display Settings", self)
view_settings.triggered.connect(self.__display_setting)
self.View.addAction(view_settings)
