class ScanPlotWidget(PlotWidget):
"""
Extend the PlotWidget Class with more functionality used for qudi scan images.
Supported features:
- draggable/static crosshair with optional range and size constraints.
- zoom feature by rubberband selection
- rubberband area selection
This class depends on the ScanViewBox class defined further below.
This class can be promoted in the Qt designer.
"""
sigMouseAreaSelected = QtCore.Signal(
QtCore.QRectF) # mapped rectangle mouse cursor selection
sigCrosshairPosChanged = QtCore.Signal(QtCore.QPointF)
sigCrosshairDraggedPosChanged = QtCore.Signal(QtCore.QPointF)
def __init__(self, *args, **kwargs):
kwargs['viewBox'] = ScanViewBox() # Use custom pg.ViewBox subclass
super().__init__(*args, **kwargs)
self.getViewBox().sigMouseAreaSelected.connect(
self.sigMouseAreaSelected)
self._min_crosshair_factor = 0.02
self._crosshair_size = (0, 0)
self._crosshair_range = None
self.getViewBox().sigRangeChanged.connect(
self._constraint_crosshair_size)
self.crosshair = ROI((0, 0), (0, 0),
pen={
'color': '#00ff00',
'width': 1
})
self.hline = InfiniteLine(pos=0,
angle=0,
movable=True,
pen={
'color': '#00ff00',
'width': 1
},
hoverPen={
'color': '#ffff00',
'width': 1
})
self.vline = InfiniteLine(pos=0,
angle=90,
movable=True,
pen={
'color': '#00ff00',
'width': 1
},
hoverPen={
'color': '#ffff00',
'width': 1
})
self.vline.sigDragged.connect(self._update_pos_from_line)
self.hline.sigDragged.connect(self._update_pos_from_line)
self.crosshair.sigRegionChanged.connect(self._update_pos_from_roi)
self.sigCrosshairDraggedPosChanged.connect(self.sigCrosshairPosChanged)
@property
def crosshair_enabled(self):
items = self.items()
return (self.vline in items) and (self.hline
in items) and (self.crosshair
in items)
@property
def crosshair_movable(self):
return bool(self.crosshair.translatable)
@property
def crosshair_position(self):
pos = self.vline.pos()
pos[1] = self.hline.pos()[1]
return tuple(pos)
@property
def crosshair_size(self):
return tuple(self._crosshair_size)
@property
def crosshair_min_size_factor(self):
return float(self._min_crosshair_factor)
@property
def crosshair_range(self):
if self._crosshair_range is None:
return None
return tuple(self._crosshair_range)
@property
def selection_enabled(self):
return bool(self.getViewBox().rectangle_selection)
@property
def zoom_by_selection_enabled(self):
return bool(self.getViewBox().zoom_by_selection)
def toggle_selection(self, enable):
"""
De-/Activate the rectangular rubber band selection tool.
If active you can select a rectangular region within the ViewBox by dragging the mouse
with the left button. Each selection rectangle in real-world data coordinates will be
emitted by sigMouseAreaSelected.
By using activate_zoom_by_selection you can optionally de-/activate zooming in on the
selection.
@param bool enable: Toggle selection on (True) or off (False)
"""
return self.getViewBox().toggle_selection(enable)
def toggle_zoom_by_selection(self, enable):
"""
De-/Activate automatic zooming into a selection.
See also: toggle_selection
@param bool enable: Toggle zoom upon selection on (True) or off (False)
"""
return self.getViewBox().toggle_zoom_by_selection(enable)
def _update_pos_from_line(self, obj):
"""
Called each time the position of the InfiniteLines has been changed by a user drag.
Causes the crosshair rectangle to follow the lines.
"""
if obj not in (self.hline, self.vline):
return
pos = self.vline.pos()
pos[1] = self.hline.pos()[1]
size = self.crosshair.size()
self.crosshair.blockSignals(True)
self.crosshair.setPos((pos[0] - size[0] / 2, pos[1] - size[1] / 2))
self.crosshair.blockSignals(False)
self.sigCrosshairDraggedPosChanged.emit(QtCore.QPointF(pos[0], pos[1]))
return
def _update_pos_from_roi(self, obj):
"""
Called each time the position of the rectangular ROI has been changed by a user drag.
Causes the InfiniteLines to follow the ROI.
"""
if obj is not self.crosshair:
return
pos = self.crosshair.pos()
size = self.crosshair.size()
pos[0] += size[0] / 2
pos[1] += size[1] / 2
self.vline.setPos(pos[0])
self.hline.setPos(pos[1])
self.sigCrosshairDraggedPosChanged.emit(QtCore.QPointF(pos[0], pos[1]))
return
def toggle_crosshair(self, enable, movable=True):
"""
Disable/Enable the crosshair within the PlotWidget. Optionally also toggle if it can be
dragged by the user.
@param bool enable: enable crosshair (True), disable crosshair (False)
@param bool movable: enable user drag (True), disable user drag (False)
"""
if not isinstance(enable, bool):
raise TypeError('Positional argument "enable" must be bool type.')
if not isinstance(movable, bool):
raise TypeError('Optional argument "movable" must be bool type.')
self.toggle_crosshair_movable(movable)
is_enabled = self.crosshair_enabled
if enable and not is_enabled:
self.addItem(self.vline)
self.addItem(self.hline)
self.addItem(self.crosshair)
elif not enable and is_enabled:
self.removeItem(self.vline)
self.removeItem(self.hline)
self.removeItem(self.crosshair)
return
def toggle_crosshair_movable(self, enable):
"""
Toggle if the crosshair can be dragged by the user.
@param bool enable: enable (True), disable (False)
"""
self.crosshair.translatable = bool(enable)
self.vline.setMovable(enable)
self.hline.setMovable(enable)
return
def set_crosshair_pos(self, pos):
"""
Set the crosshair center to the given coordinates.
@param QPointF|float[2] pos: (x,y) position of the crosshair
"""
try:
pos = tuple(pos)
except TypeError:
pos = (pos.x(), pos.y())
size = self.crosshair.size()
self.crosshair.blockSignals(True)
self.vline.blockSignals(True)
self.hline.blockSignals(True)
self.crosshair.setPos(pos[0] - size[0] / 2, pos[1] - size[1] / 2)
self.vline.setPos(pos[0])
self.hline.setPos(pos[1])
self.crosshair.blockSignals(False)
self.vline.blockSignals(False)
self.hline.blockSignals(False)
self.sigCrosshairPosChanged.emit(QtCore.QPointF(*pos))
return
def set_crosshair_size(self, size, force_default=True):
"""
Set the default size of the crosshair rectangle (x, y) and update the display.
@param QSize|float[2] size: the (x,y) size of the crosshair rectangle
@param bool force_default: Set default crosshair size and enforce minimal size (True).
Enforce displayed crosshair size while keeping default size
untouched (False).
"""
try:
size = tuple(size)
except TypeError:
size = (size.width(), size.height())
if force_default:
if size[0] <= 0 and size[1] <= 0:
self._crosshair_size = (0, 0)
else:
self._crosshair_size = size
# Check if actually displayed size needs to be adjusted due to minimal size
size = self._get_corrected_crosshair_size(size)
pos = self.vline.pos()
pos[1] = self.hline.pos()[1] - size[1] / 2
pos[0] -= size[0] / 2
if self._crosshair_range:
crange = self._crosshair_range
self.crosshair.maxBounds = QtCore.QRectF(
crange[0][0] - size[0] / 2, crange[1][0] - size[1] / 2,
crange[0][1] - crange[0][0] + size[0],
crange[1][1] - crange[1][0] + size[1])
self.crosshair.blockSignals(True)
self.crosshair.setSize(size)
self.crosshair.setPos(pos)
self.crosshair.blockSignals(False)
return
def set_crosshair_min_size_factor(self, factor):
"""
Sets the minimum crosshair size factor. This will determine the minimum size of the
smallest edge of the crosshair center rectangle.
This minimum size is calculated by taking the smallest visible axis of the ViewBox and
multiplying it with the scale factor set by this method.
The crosshair rectangle will be then scaled accordingly if the set crosshair size is
smaller than this minimal size.
@param float factor: The scale factor to set. If <= 0 no minimal crosshair size enforced.
"""
if factor <= 0:
self._min_crosshair_factor = 0
elif factor <= 1:
self._min_crosshair_factor = float(factor)
else:
raise ValueError('Crosshair min size factor must be a value <= 1.')
return
def set_crosshair_range(self, new_range):
"""
Sets a range boundary for the crosshair position.
@param float[2][2] new_range: two min-max range value tuples (for x and y axis).
If None set unlimited ranges.
"""
if new_range is None:
self.vline.setBounds([None, None])
self.hline.setBounds([None, None])
self.crosshair.maxBounds = None
else:
self.vline.setBounds(new_range[0])
self.hline.setBounds(new_range[1])
size = self.crosshair.size()
pos = self.crosshair_position
self.crosshair.maxBounds = QtCore.QRectF(
new_range[0][0] - size[0] / 2, new_range[1][0] - size[1] / 2,
new_range[0][1] - new_range[0][0] + size[0],
new_range[1][1] - new_range[1][0] + size[1])
self.crosshair.setPos(pos[0] - size[0] / 2, pos[1] - size[1] / 2)
self._crosshair_range = new_range
return
def set_crosshair_pen(self, pen):
"""
Sets the pyqtgraph compatible pen to be used for drawing the crosshair lines.
@param pen: pyqtgraph compatible pen to use
"""
self.crosshair.setPen(pen)
self.vline.setPen(pen)
self.hline.setPen(pen)
return
def _constraint_crosshair_size(self):
if self._min_crosshair_factor == 0:
return
if self._crosshair_size[0] == 0 or self._crosshair_size[1] == 0:
return
corr_size = self._get_corrected_crosshair_size(self._crosshair_size)
if corr_size != tuple(self.crosshair.size()):
self.set_crosshair_size(corr_size, force_default=False)
return
def _get_corrected_crosshair_size(self, size):
try:
size = tuple(size)
except TypeError:
size = (size.width(), size.height())
min_size = min(size)
if min_size == 0:
return size
vb_size = self.getViewBox().viewRect().size()
short_index = int(vb_size.width() > vb_size.height())
min_vb_size = vb_size.width() if short_index == 0 else vb_size.height()
min_vb_size *= self._min_crosshair_factor
if min_size < min_vb_size:
scale_factor = min_vb_size / min_size
size = (size[0] * scale_factor, size[1] * scale_factor)
return size
class Aditi(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
# title
self.setWindowTitle("Aditi")
self.setDockOptions(QMainWindow.VerticalTabs | QMainWindow.AnimatedDocks)
#self.showMaximized()
# model
self.rawfiles_by_short_path = {}
self.xic_by_rawfile_short_path = {}
self.tic_by_rawfile_short_path = {}
self.spec_by_rawfile_short_path = {}
self.inf_line_tic_item = None
self.curr_scan_id_by_short_path = {}
# menu
self.file_menu = self.menuBar().addMenu('&File')
#self.file_menu.setTearOffEnabled(False)
open_action = QAction("&Open...", self)
open_action.setToolTip("Open a rawfile")
open_action.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_O))
self.file_menu.addAction(open_action)
open_action.triggered.connect(self.show_open_dialog)
exit_action = QAction("&Exit", self)
exit_action.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_Q))
self.file_menu.addAction(exit_action)
exit_action.triggered.connect(self.quit)
self.tab_widget = QTabWidget(self)
# spectrum plot Widget
self.graphics_layout_widget = GraphicsLayoutWidget(parent=self.tab_widget)
self.graphics_layout_widget.keyPressEvent = self.handle_key_press_event
self.graphics_layout_widget.useOpenGL(False)
self.graphics_layout_widget.setAntialiasing(False)
self.plot_widget_tic = self.graphics_layout_widget.addPlot(title="TIC(s)",
labels={'left': "Intensity",
'bottom': "Retention Time (sec)"})
self.plot_widget_tic.showGrid(x=True, y=True)
self.graphics_layout_widget.nextRow()
self.plot_widget_spectrum = self.graphics_layout_widget.addPlot(title="Spectrum", labels={'left': "Intensity",
'bottom': "m/z"})
self.plot_widget_spectrum.showGrid(x=True, y=True)
# finally add tab
self.tab_widget.addTab(self.graphics_layout_widget, "Spectrum")
# Xic plotWidget
self.plot_widget_xic = PlotWidget(name="MainPlot", labels={'left': "Intensity",
'bottom': "Retention Time (sec)"})
self.plot_widget_xic.showGrid(x=True, y=True)
self.tab_widget.addTab(self.plot_widget_xic, "Xic extraction")
self.setCentralWidget(self.tab_widget)
self.statusBar().showMessage("Ready")
# dock 1
self.rawfile_dock_widget = QDockWidget("Rawfiles")
self.rawfile_table_view = QTableView()
self.rawfile_table_view.horizontalHeader().setVisible(False)
self.rawfile_table_view.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
self.rawfile_dock_widget.setWidget(self.rawfile_table_view)
self.rawfile_model = QStandardItemModel()
self.rawfile_model.setHorizontalHeaderLabels(["Rawfiles"])
self.rawfile_table_view.setModel(self.rawfile_model)
self.rawfile_model.itemChanged.connect(self.item_changed)
self.addDockWidget(0x2, self.rawfile_dock_widget)
# xic dock widget extraction parameter
self.xic_dock_widget = QDockWidget("Xic extraction")
self.xic_widget = XicWidget()
self.xic_widget.plotButton.clicked.connect(self.plot)
self.xic_dock_widget.setWidget(self.xic_widget)
self.addDockWidget(0x2, self.xic_dock_widget)
def handle_key_press_event(self, evt):
if self.inf_line_tic_item is None:
return
times = []
if evt.key() == Qt.Key_Left:
for rawfile in self.rawfiles_by_short_path.values()[:1]:
if not rawfile.is_checked:
continue
curr_scan_id = self.curr_scan_id_by_short_path[rawfile.short_path]
scan_ids = rawfile.reader.rt_by_scan_id_by_ms_level[1].keys()
idx = scan_ids.index(curr_scan_id)
times.append(rawfile.reader.rt_by_scan_id_by_ms_level[1][scan_ids[idx - 1]])
self.curr_scan_id_by_short_path[rawfile.short_path] = scan_ids[idx - 1]
elif evt.key() == Qt.Key_Right:
for rawfile in self.rawfiles_by_short_path.values()[:1]:
if not rawfile.is_checked:
continue
curr_scan_id = self.curr_scan_id_by_short_path[rawfile.short_path]
scan_ids = rawfile.reader.rt_by_scan_id_by_ms_level[1].keys()
idx = scan_ids.index(curr_scan_id)
times.append(rawfile.reader.rt_by_scan_id_by_ms_level[1][scan_ids[idx + 1]])
self.curr_scan_id_by_short_path[rawfile.short_path] = scan_ids[idx + 1]
self._plot_spectrum()
if times:
self.inf_line_tic_item.setPos(sum(times) / float(len(times)))
def _plot_spectrum(self):
self.plot_widget_spectrum.clear()
min_mz, max_mz = 1e9, 0
min_int, max_int = 1e10, 0
for rawfile in self.rawfiles_by_short_path.values():
if not rawfile.is_checked:
continue
scan_id, mzs, intensities = rawfile.reader.get_scan(self.curr_scan_id_by_short_path[rawfile.short_path])
min_mz = min(min_mz, mzs[0])
max_mz = max(max_mz, mzs[-1])
min_int = min(min_int, min(intensities))
max_int = max(max_int, max(intensities))
item = BarGraphItem(x=mzs, height=intensities, width=0.01, pen=rawfile.qcolor, brush=rawfile.qcolor)
self.plot_widget_spectrum.addItem(item)
self.plot_widget_spectrum.setLimits(xMin=min_mz, xMax=max_mz, yMin=min_int, yMax=max_int)
def plot_spectrum(self, ev):
#clear
if ev.button() == Qt.RightButton:
return
self.plot_widget_spectrum.clear()
vb = self.plot_widget_tic.vb
mouse_point = vb.mapSceneToView(ev.scenePos())
t = mouse_point.x()
if self.inf_line_tic_item is None:
self.inf_line_tic_item = InfiniteLine(pos=t, angle=90)
self.plot_widget_tic.addItem(self.inf_line_tic_item)
self.inf_line_tic_item.setMovable(True)
else:
self.inf_line_tic_item.setPos(t)
min_mz, max_mz = 1e9, 0
min_int, max_int = 1e10, 0
for rawfile in self.rawfiles_by_short_path.values():
if not rawfile.is_checked:
continue
scan_id, mzs, intensities = rawfile.reader.get_scan_for_time(t)
self.curr_scan_id_by_short_path[rawfile.short_path] = scan_id
min_mz = min(min_mz, mzs[0])
max_mz = max(max_mz, mzs[-1])
min_int = min(min_int, min(intensities))
max_int = max(max_int, max(intensities))
item = BarGraphItem(x=mzs, height=intensities, width=0.01, pen=rawfile.qcolor, brush=rawfile.qcolor)
self.plot_widget_spectrum.addItem(item)
self.plot_widget_spectrum.setLimits(xMin=min_mz, xMax=max_mz, yMin=min_int, yMax=max_int)
def item_changed(self, item):
print "item changed", item.text()
s = item.text()
if item.checkState():
self.rawfiles_by_short_path[s].is_checked = True
else:
self.rawfiles_by_short_path[s].is_checked = False
#self.qApp.emit(SIGNAL('redraw()'))
self.update_plot_()
def show_open_dialog(self):
files = QFileDialog(self).getOpenFileNames()
if files:
preload = Preloader(files, self)
preload.loaded.connect(self.update_rawfile_model)
preload.start()
def update_rawfile_model(self, obj):
files, r = obj[0], obj[1]
n = len(files)
not_database = []
min_time, max_time = 1e9, 0
min_int, max_int = 1e9, 0
for i, f in enumerate(files):
i_f = float(i)
c = WithoutBlank.get_color(i_f / n, asQColor=True)
c_ = WithoutBlank.get_color(i_f / n, asQColor=True)
filename = f.split("\\")[-1]
abs_path = str(f.replace("\\", "\\\\"))
if r[i]:
rawfile = Rawfile(abs_path, c, filename)
self.rawfiles_by_short_path[filename] = rawfile #[MzDBReader(abs_path), c, True]
self.rawfile_model.appendRow(Aditi.get_coloured_root_item(filename, c, c_))
times, intensities = rawfile.reader.get_tic()
min_time = min(min_time, min(times))
max_time = max(max_time, max(times))
min_int = min(min_int, min(intensities))
max_int = max(max_int, max(intensities))
self.plot_widget_tic.plot(times, intensities, pen=mkPen(color=rawfile.qcolor, width=1.3))
else:
not_database.append(str(filename))
self.plot_widget_tic.setLimits(xMin=min_time, xMax=max_time, yMin=min_int, yMax=max_int)
self.plot_widget_tic.scene().sigMouseClicked.connect(self.plot_spectrum)
if not_database:
v = "\n".join(not_database)
QMessageBox.information(self, "Error",
"The following files are not valid sqlite database:\n" + v)
@staticmethod
def get_coloured_root_item(filepath, color, colorr):
root = QStandardItem(filepath)
gradient = QLinearGradient(-100, -100, 100, 100)
gradient.setColorAt(0.7, colorr)
gradient.setColorAt(1, color)
root.setBackground(QBrush(gradient))
root.setEditable(False)
root.setCheckState(Qt.Checked)
root.setCheckable(True)
return root
def quit(self):
res = QMessageBox.warning(self, "Exiting...", "Are you sure ?", QMessageBox.Ok | QMessageBox.Cancel)
if res == QMessageBox.Cancel:
return
QtGui.qApp.quit()
def plot(self):
#clear pw
self.plot_widget_xic.clear()
# check sample checked
checked_files = [rawfile for rawfile in self.rawfiles_by_short_path.values() if rawfile.is_checked]
mz = self.xic_widget.mzSpinBox.value()
mz_tol = self.xic_widget.mzTolSpinBox.value()
mz_diff = mz * mz_tol / 1e6
min_mz, max_mz = mz - mz_diff, mz + mz_diff
#Thread implementation not as fast
# args = [(data[0], min_mz, max_mz, data[2]) for data in checked_files]
# extractor_thread = Extractor(args, self)
# extractor_thread.extracted.connect(self._plot)
# extractor_thread.start()
min_time_val, max_time_val = 10000, 0
min_int_val, max_int_val = 1e9, 0
for rawfile in checked_files:
t1 = time.clock()
times, intensities = rawfile.reader.get_xic(min_mz, max_mz)
print "elapsed: ", time.clock() - t1
# min_time_val = min(min_time_val, times[0])
# max_time_val = max(max_time_val, times[-1])
# min_int_val = min(min_int_val, min(intensities))
# max_int_val = max(max_int_val, max(intensities))
item = self.plot_widget_xic.plot(times, intensities, pen=mkPen(color=rawfile.qcolor, width=1.3))
item.curve.setClickable(True)
def on_curve_clicked():
if not rawfile.is_highlighted:
item.setPen(mkPen(color=rawfile.qcolor, width=4))
rawfile.is_highlighted = True
else:
item.setPen(mkPen(color=rawfile.qcolor, width=2))
rawfile.is_highlighted = False
item.sigClicked.connect(on_curve_clicked)
#item.sigHovered = on_curve_clicked
self.xic_by_rawfile_short_path[rawfile.short_path] = item
self.plot_widget_xic.setTitle(title="Xic@" + str(mz))
#self.plot_widget_xic.setLimits(xMin=min_time_val, xMax=max_time_val, yMin=min_int_val, yMax=max_int_val)
def update_plot_(self):
for rawfile in self.rawfiles_by_short_path.viewvalues():
if rawfile.is_checked:
try:
self.plot_widget_xic.addItem(self.xic_by_rawfile_short_path[rawfile.short_path])
except KeyError:
mz = self.xic_widget.mzSpinBox.value()
mz_tol = self.xic_widget.mzTolSpinBox.value()
mz_diff = mz * mz_tol / 1e6
min_mz, max_mz = mz - mz_diff, mz + mz_diff
times, intensities = rawfile.reader.get_xic(min_mz, max_mz)
item = self.plot_widget_xic.plot(times, intensities, pen=mkPen(color=rawfile.qcolor, width=2))
self.xic_by_rawfile_short_path[rawfile.short_path] = item
else:
try:
#self.plot_widget_xic.removeItem(self.xic_by_rawfile_short_path[rawfile.short_path])
self.xic_by_rawfile_short_path[rawfile.short_path].hide()
except KeyError:
pass
class ScanPlotWidget(PlotWidget):
"""
Extend the PlotWidget Class with more functionality used for qudi scan images.
Supported features:
- draggable/static crosshair with optional range and size constraints.
- zoom feature by rubberband selection
- rubberband area selection
This class depends on the ScanViewBox class defined further below.
This class can be promoted in the Qt designer.
"""
sigMouseAreaSelected = QtCore.Signal(QtCore.QRectF) # mapped rectangle mouse cursor selection
sigCrosshairPosChanged = QtCore.Signal(QtCore.QPointF)
sigCrosshairDraggedPosChanged = QtCore.Signal(QtCore.QPointF)
def __init__(self, *args, **kwargs):
kwargs['viewBox'] = ScanViewBox() # Use custom pg.ViewBox subclass
super().__init__(*args, **kwargs)
self.getViewBox().sigMouseAreaSelected.connect(self.sigMouseAreaSelected)
self._min_crosshair_factor = 0.02
self._crosshair_size = (0, 0)
self._crosshair_range = None
self.getViewBox().sigRangeChanged.connect(self._constraint_crosshair_size)
self.crosshair = ROI((0, 0), (0, 0), pen={'color': '#00ff00', 'width': 1})
self.hline = InfiniteLine(pos=0,
angle=0,
movable=True,
pen={'color': '#00ff00', 'width': 1},
hoverPen={'color': '#ffff00', 'width': 1})
self.vline = InfiniteLine(pos=0,
angle=90,
movable=True,
pen={'color': '#00ff00', 'width': 1},
hoverPen={'color': '#ffff00', 'width': 1})
self.vline.sigDragged.connect(self._update_pos_from_line)
self.hline.sigDragged.connect(self._update_pos_from_line)
self.crosshair.sigRegionChanged.connect(self._update_pos_from_roi)
self.sigCrosshairDraggedPosChanged.connect(self.sigCrosshairPosChanged)
@property
def crosshair_enabled(self):
items = self.items()
return (self.vline in items) and (self.hline in items) and (self.crosshair in items)
@property
def crosshair_movable(self):
return bool(self.crosshair.translatable)
@property
def crosshair_position(self):
pos = self.vline.pos()
pos[1] = self.hline.pos()[1]
return tuple(pos)
@property
def crosshair_size(self):
return tuple(self._crosshair_size)
@property
def crosshair_min_size_factor(self):
return float(self._min_crosshair_factor)
@property
def crosshair_range(self):
if self._crosshair_range is None:
return None
return tuple(self._crosshair_range)
@property
def selection_enabled(self):
return bool(self.getViewBox().rectangle_selection)
@property
def zoom_by_selection_enabled(self):
return bool(self.getViewBox().zoom_by_selection)
def toggle_selection(self, enable):
"""
De-/Activate the rectangular rubber band selection tool.
If active you can select a rectangular region within the ViewBox by dragging the mouse
with the left button. Each selection rectangle in real-world data coordinates will be
emitted by sigMouseAreaSelected.
By using activate_zoom_by_selection you can optionally de-/activate zooming in on the
selection.
@param bool enable: Toggle selection on (True) or off (False)
"""
return self.getViewBox().toggle_selection(enable)
def toggle_zoom_by_selection(self, enable):
"""
De-/Activate automatic zooming into a selection.
See also: toggle_selection
@param bool enable: Toggle zoom upon selection on (True) or off (False)
"""
return self.getViewBox().toggle_zoom_by_selection(enable)
def _update_pos_from_line(self, obj):
"""
Called each time the position of the InfiniteLines has been changed by a user drag.
Causes the crosshair rectangle to follow the lines.
"""
if obj not in (self.hline, self.vline):
return
pos = self.vline.pos()
pos[1] = self.hline.pos()[1]
size = self.crosshair.size()
self.crosshair.blockSignals(True)
self.crosshair.setPos((pos[0] - size[0] / 2, pos[1] - size[1] / 2))
self.crosshair.blockSignals(False)
self.sigCrosshairDraggedPosChanged.emit(QtCore.QPointF(pos[0], pos[1]))
return
def _update_pos_from_roi(self, obj):
"""
Called each time the position of the rectangular ROI has been changed by a user drag.
Causes the InfiniteLines to follow the ROI.
"""
if obj is not self.crosshair:
return
pos = self.crosshair.pos()
size = self.crosshair.size()
pos[0] += size[0] / 2
pos[1] += size[1] / 2
self.vline.setPos(pos[0])
self.hline.setPos(pos[1])
self.sigCrosshairDraggedPosChanged.emit(QtCore.QPointF(pos[0], pos[1]))
return
def toggle_crosshair(self, enable, movable=True):
"""
Disable/Enable the crosshair within the PlotWidget. Optionally also toggle if it can be
dragged by the user.
@param bool enable: enable crosshair (True), disable crosshair (False)
@param bool movable: enable user drag (True), disable user drag (False)
"""
if not isinstance(enable, bool):
raise TypeError('Positional argument "enable" must be bool type.')
if not isinstance(movable, bool):
raise TypeError('Optional argument "movable" must be bool type.')
self.toggle_crosshair_movable(movable)
is_enabled = self.crosshair_enabled
if enable and not is_enabled:
self.addItem(self.vline)
self.addItem(self.hline)
self.addItem(self.crosshair)
elif not enable and is_enabled:
self.removeItem(self.vline)
self.removeItem(self.hline)
self.removeItem(self.crosshair)
return
def toggle_crosshair_movable(self, enable):
"""
Toggle if the crosshair can be dragged by the user.
@param bool enable: enable (True), disable (False)
"""
self.crosshair.translatable = bool(enable)
self.vline.setMovable(enable)
self.hline.setMovable(enable)
return
def set_crosshair_pos(self, pos):
"""
Set the crosshair center to the given coordinates.
@param QPointF|float[2] pos: (x,y) position of the crosshair
"""
try:
pos = tuple(pos)
except TypeError:
pos = (pos.x(), pos.y())
size = self.crosshair.size()
self.crosshair.blockSignals(True)
self.vline.blockSignals(True)
self.hline.blockSignals(True)
self.crosshair.setPos(pos[0] - size[0] / 2, pos[1] - size[1] / 2)
self.vline.setPos(pos[0])
self.hline.setPos(pos[1])
self.crosshair.blockSignals(False)
self.vline.blockSignals(False)
self.hline.blockSignals(False)
self.sigCrosshairPosChanged.emit(QtCore.QPointF(*pos))
return
def set_crosshair_size(self, size, force_default=True):
"""
Set the default size of the crosshair rectangle (x, y) and update the display.
@param QSize|float[2] size: the (x,y) size of the crosshair rectangle
@param bool force_default: Set default crosshair size and enforce minimal size (True).
Enforce displayed crosshair size while keeping default size
untouched (False).
"""
try:
size = tuple(size)
except TypeError:
size = (size.width(), size.height())
if force_default:
if size[0] <= 0 and size[1] <= 0:
self._crosshair_size = (0, 0)
else:
self._crosshair_size = size
# Check if actually displayed size needs to be adjusted due to minimal size
size = self._get_corrected_crosshair_size(size)
pos = self.vline.pos()
pos[1] = self.hline.pos()[1] - size[1] / 2
pos[0] -= size[0] / 2
if self._crosshair_range:
crange = self._crosshair_range
self.crosshair.maxBounds = QtCore.QRectF(crange[0][0] - size[0] / 2,
crange[1][0] - size[1] / 2,
crange[0][1] - crange[0][0] + size[0],
crange[1][1] - crange[1][0] + size[1])
self.crosshair.blockSignals(True)
self.crosshair.setSize(size)
self.crosshair.setPos(pos)
self.crosshair.blockSignals(False)
return
def set_crosshair_min_size_factor(self, factor):
"""
Sets the minimum crosshair size factor. This will determine the minimum size of the
smallest edge of the crosshair center rectangle.
This minimum size is calculated by taking the smallest visible axis of the ViewBox and
multiplying it with the scale factor set by this method.
The crosshair rectangle will be then scaled accordingly if the set crosshair size is
smaller than this minimal size.
@param float factor: The scale factor to set. If <= 0 no minimal crosshair size enforced.
"""
if factor <= 0:
self._min_crosshair_factor = 0
elif factor <= 1:
self._min_crosshair_factor = float(factor)
else:
raise ValueError('Crosshair min size factor must be a value <= 1.')
return
def set_crosshair_range(self, new_range):
"""
Sets a range boundary for the crosshair position.
@param float[2][2] new_range: two min-max range value tuples (for x and y axis).
If None set unlimited ranges.
"""
if new_range is None:
self.vline.setBounds([None, None])
self.hline.setBounds([None, None])
self.crosshair.maxBounds = None
else:
self.vline.setBounds(new_range[0])
self.hline.setBounds(new_range[1])
size = self.crosshair.size()
pos = self.crosshair_position
self.crosshair.maxBounds = QtCore.QRectF(new_range[0][0] - size[0] / 2,
new_range[1][0] - size[1] / 2,
new_range[0][1] - new_range[0][0] + size[0],
new_range[1][1] - new_range[1][0] + size[1])
self.crosshair.setPos(pos[0] - size[0] / 2, pos[1] - size[1] / 2)
self._crosshair_range = new_range
return
def set_crosshair_pen(self, pen):
"""
Sets the pyqtgraph compatible pen to be used for drawing the crosshair lines.
@param pen: pyqtgraph compatible pen to use
"""
self.crosshair.setPen(pen)
self.vline.setPen(pen)
self.hline.setPen(pen)
return
def _constraint_crosshair_size(self):
if self._min_crosshair_factor == 0:
return
if self._crosshair_size[0] == 0 or self._crosshair_size[1] == 0:
return
corr_size = self._get_corrected_crosshair_size(self._crosshair_size)
if corr_size != tuple(self.crosshair.size()):
self.set_crosshair_size(corr_size, force_default=False)
return
def _get_corrected_crosshair_size(self, size):
try:
size = tuple(size)
except TypeError:
size = (size.width(), size.height())
min_size = min(size)
if min_size == 0:
return size
vb_size = self.getViewBox().viewRect().size()
short_index = int(vb_size.width() > vb_size.height())
min_vb_size = vb_size.width() if short_index == 0 else vb_size.height()
min_vb_size *= self._min_crosshair_factor
if min_size < min_vb_size:
scale_factor = min_vb_size / min_size
size = (size[0] * scale_factor, size[1] * scale_factor)
return size
class Cursor(QObject):
moved = pyqtSignal(list, name='moved')
def __init__(self,
parent,
curveIndex,
xLine,
yLine,
symb,
cPen,
curve=None):
super(Cursor, self).__init__()
self.parent = parent
if abs(curveIndex) > len(self.parent.curves):
raise ValueError('The curve you selected does not exist')
self.refPlot = self.parent.curves[
curveIndex] if curve is None else curve
xStart = self.refPlot.xData[0]
yStart = self.refPlot.yData[0]
self.xRef = None
self.yRef = None
self.singleLine = ''
if not xLine and not yLine:
raise ValueError(
'You cannot create a cursor without a reference Line')
if xLine:
self.xRef = InfiniteLine(
pos=xStart,
angle=90,
movable=True,
pen=cPen,
bounds=[min(self.refPlot.xData),
max(self.refPlot.xData)])
self.parent.addItem(self.xRef)
self.xRef.sigPositionChanged.connect(self.updateCursor)
if not yLine:
self.singleLine = 'self.refPlot.xData'
if yLine:
self.yRef = InfiniteLine(
pos=yStart,
angle=0,
movable=not xLine,
pen=cPen,
bounds=[min(self.refPlot.yData),
max(self.refPlot.yData)])
self.parent.addItem(self.yRef)
if not xLine:
self.yRef.sigPositionChanged.connect(self.updateCursor)
self.singleLine = 'self.refPlot.yData'
self.point = self.parent.plot([self.refPlot.xData[0]],
[self.refPlot.yData[0]],
pen=None,
symbol=symb,
symbolPen=cPen,
symbolBrush=cPen)
self.color = cPen
self.symbol = symb
if xLine and yLine:
self.whoMovesWho = {
self.xRef: [self.yRef, 'self.refPlot.xData', 0],
self.yRef: [self.xRef, 'self.refPlot.yData', 1]
}
def updateCursor(self, evt):
culprit = evt.sender()
changedPos = culprit.pos()
utilStr = 'where(array('
newPoint = [0, 0]
if self.xRef is not None and self.yRef is not None:
utilStr2 = ')>=changedPos[self.whoMovesWho[culprit][2]])[0][0]'
toMove = self.whoMovesWho[culprit][0]
baseStr = self.whoMovesWho[culprit][1]
approxInd = eval(utilStr + baseStr + utilStr2)
newValCulp = eval(baseStr + '[' + str(approxInd) + ']')
newValMove = eval(self.whoMovesWho[toMove][1] + '[' +
str(approxInd) + ']')
newPoint[self.whoMovesWho[culprit][2]] = newValCulp
newPoint[self.whoMovesWho[toMove][2]] = newValMove
toMove.setPos(newPoint)
culprit.sigPositionChanged.disconnect()
culprit.setPos(newPoint)
culprit.sigPositionChanged.connect(self.updateCursor)
else:
baseStr = self.singleLine
utilStr2 = ')>=changedPos[' + str(
int(self.xRef is None)) + '])[0][0]'
approxInd = eval(utilStr + baseStr + utilStr2)
newPoint[0] = self.refPlot.xData[approxInd]
newPoint[1] = self.refPlot.yData[approxInd]
self.point.setData([newPoint[0]], [newPoint[1]])
self.moved.emit(newPoint)
def pos(self):
return [self.point.xData[0], self.point.yData[0]]
def trafficLight(self, xLight, yLight):
if self.xRef is not None:
self.xRef.setMovable(xLight)
if self.yRef is not None:
self.yRef.setMovable(yLight)
def suicide(self):
if self.xRef is not None:
self.parent.removeItem(self.xRef)
if self.yRef is not None:
self.parent.removeItem(self.yRef)
self.parent.removeItem(self.point)