def draw_vrot(self, qp):
qp.begin(self.plotBitMap)
qp.setRenderHint(qp.Antialiasing)
qp.setRenderHint(qp.TextAntialiasing)
vrot_pix = self.vrot_to_pix(self.vrot)
# plot the white dashed line
pen = QtGui.QPen(self.fg_color, 1.5, QtCore.Qt.DotLine)
qp.setPen(pen)
qp.drawLine(vrot_pix, self.prob_to_pix(0), vrot_pix, self.prob_to_pix(70))
# Draw the probabilties.
color = QtGui.QColor(self.EF01_color)
pen = QtGui.QPen(color, 1, QtCore.Qt.SolidLine)
qp.setPen(pen)
rect = QtCore.QRectF(self.vrot_to_pix(self.vrot-7), self.prob_to_pix(self.probef01), 4, 7)
qp.drawText(rect, QtCore.Qt.TextDontClip | QtCore.Qt.AlignLeft, utils.INT2STR(self.probef01))
color = QtGui.QColor(self.EF23_color)
pen = QtGui.QPen(color, 1, QtCore.Qt.SolidLine)
qp.setPen(pen)
rect = QtCore.QRectF(self.vrot_to_pix(self.vrot), self.prob_to_pix(self.probef23), 4, 7)
qp.drawText(rect, QtCore.Qt.TextDontClip | QtCore.Qt.AlignLeft, utils.INT2STR(self.probef23))
color = QtGui.QColor(self.EF45_color)
pen = QtGui.QPen(color, 1, QtCore.Qt.SolidLine)
qp.setPen(pen)
rect = QtCore.QRectF(self.vrot_to_pix(self.vrot), self.prob_to_pix(self.probef45), 4, 7)
qp.drawText(rect, QtCore.Qt.TextDontClip | QtCore.Qt.AlignLeft, utils.INT2STR(self.probef45))
qp.end()
def updateSize(self, s=2):
size = self.size
self.circle = QtGui.QPainterPath()
self.circle.addEllipse(QtCore.QRectF(-size, -size, size * s, size * s))
self.square = QtGui.QPainterPath()
self.square.addRect(QtCore.QRectF(-size, -size, size * s, size * s))
self.setPath(self.square if self.hovering else self.circle)
def fitInView(self):
rect = QtCore.QRectF(self._image.pixmap().rect())
if not rect.isNull():
unity = self.transform().mapRect(QtCore.QRectF(0, 0, 1, 1))
self.scale(1 / unity.width(), 1 / unity.height())
viewrect = self.viewport().rect()
scenerect = self.transform().mapRect(rect)
factor = min(viewrect.width() / scenerect.width(),
viewrect.height() / scenerect.height())
self.scale(factor, factor)
self.centerOn(rect.center())
self._zoom = 0
def update_figure(self):
self.update_sm_extent()
x0, x1, y0, y1 = self.sm_extent
#self.sm_isocurve_item.setData(self.sm_show, level=self.threshold.val)
#self.sm_isocurve_item_rect = QtCore.QRectF(x0, y0, x1-x0, y1-y0)
self.sm_img_item.setImage(self.sm, opacity=self.sm_opacity.val)
self.sm_img_item_rect = QtCore.QRectF(x0, y0, x1 - x0, y1 - y0)
self.sm_img_item.setRect(self.sm_img_item_rect)
self.sm_img_item.rotate(self.angle.val)
#bm
self.bm_img_item.setImage(self.bm)
x0, x1, y0, y1 = self.bm_imshow_extent
self.bm_img_item.setRect(QtCore.QRectF(x0, y0, x1 - x0, y1 - y0))
def test_synchronization_of_view_range(self):
# calibration and mask view
self.calibration_widget.img_widget.img_view_box.setRange(
QtCore.QRectF(-10, -10, 20, 20))
click_button(self.controller.widget.mask_mode_btn)
self.assertAlmostEqual(np.sum(np.array(self.calibration_widget.img_widget.img_view_box.targetRange()) - \
np.array(self.mask_widget.img_widget.img_view_box.targetRange())), 0)
self.mask_widget.img_widget.img_view_box.setRange(
QtCore.QRectF(100, 100, 300, 300))
click_button(self.controller.widget.calibration_mode_btn)
self.assertAlmostEqual(np.sum(np.array(self.calibration_widget.img_widget.img_view_box.targetRange()) - \
np.array(self.mask_widget.img_widget.img_view_box.targetRange())), 0)
def refresh_matrix(self):
""" Refresh the xy-matrix image """
self.scan_matrix_image.setImage(self._voltscan_logic.scan_matrix, axisOrder='row-major')
self.scan_matrix_image.setRect(
QtCore.QRectF(
self._voltscan_logic.scan_range[0],
0,
self._voltscan_logic.scan_range[1] - self._voltscan_logic.scan_range[0],
self._voltscan_logic.number_of_repeats)
)
self.scan_matrix_image2.setImage(self._voltscan_logic.scan_matrix2, axisOrder='row-major')
self.scan_matrix_image2.setRect(
QtCore.QRectF(
self._voltscan_logic.scan_range[0],
0,
self._voltscan_logic.scan_range[1] - self._voltscan_logic.scan_range[0],
self._voltscan_logic.number_of_repeats)
)
self.refresh_scan_colorbar()
scan_image_data = self._voltscan_logic.scan_matrix
# If "Centiles" is checked, adjust colour scaling automatically to centiles.
# Otherwise, take user-defined values.
if self._mw.voltscan_cb_centiles_RadioButton.isChecked():
low_centile = self._mw.voltscan_cb_low_centile_InputWidget.value()
high_centile = self._mw.voltscan_cb_high_centile_InputWidget.value()
cb_min = np.percentile(scan_image_data, low_centile)
cb_max = np.percentile(scan_image_data, high_centile)
else:
cb_min = self._mw.voltscan_cb_min_InputWidget.value()
cb_max = self._mw.voltscan_cb_max_InputWidget.value()
# Now update image with new color scale, and update colorbar
self.scan_matrix_image.setImage(
image=scan_image_data,
levels=(cb_min, cb_max),
axisOrder='row-major')
scan_image_data2 = self._voltscan_logic.scan_matrix2
# Now update image with new color scale, and update colorbar
self.scan_matrix_image2.setImage(
image=scan_image_data2,
levels=(cb_min, cb_max),
axisOrder='row-major')
self.refresh_scan_colorbar()
def mouseMoveEvent(self, event):
super(ImageView, self).mouseMoveEvent(event)
# update selection display
if self.rubberband is not None:
self.rubberband.setGeometry(
QtCore.QRect(self.start_drag, event.pos()).normalized()
)
if self.panning:
end_drag = event.pos()
pan_vector = end_drag - self.start_drag
scene2view = self.transform()
# skip shear
sx = scene2view.m11()
sy = scene2view.m22()
scene_pan_x = pan_vector.x() / sx
scene_pan_y = pan_vector.y() / sy
scene_pan_vector = QtCore.QPointF(scene_pan_x, scene_pan_y)
roi = self.current_scene_ROI
top_left = roi.topLeft()
new_top_left = top_left - scene_pan_vector
scene_rect = self.sceneRect()
new_top_left.setX(
clamp(new_top_left.x(), scene_rect.left(), scene_rect.right())
)
new_top_left.setY(
clamp(new_top_left.y(), scene_rect.top(), scene_rect.bottom())
)
nroi = QtCore.QRectF(new_top_left, roi.size())
self.fitInView(nroi, Qt.KeepAspectRatio)
self.start_drag = end_drag
self.update()
def updateMainViewBox(self, srcview=None):
if not self.graphicsview.scene():
return
if not srcview:
# @TODO: check API
srcview = self.app.currentGraphicsView()
elif srcview is not self.app.currentGraphicsView():
# current view not yet updated: do nothing
return
if srcview:
assert srcview.scene() == self.graphicsview.scene() # @TODO: check
hbar = srcview.horizontalScrollBar()
vbar = srcview.verticalScrollBar()
# @TODO: bug report: mapping to scene seems to introduce a
# spurious offset "x1 = 2*x0" and y1 = 2*y0;
# this doesn't happen for "w" and "h"
# polygon = srcview.mapToScene(hbar.value(), vbar.value(),
# hbar.pageStep(), vbar.pageStep())
# @TODO: in case of rotations it should be better keep using
# a polygon
# self.graphicsview.viewbox = polygon.boundingRect()
# @NOTE: this is a workaround; mapToScene should be used instead
rect = QtCore.QRectF(hbar.value(), vbar.value(), hbar.pageStep(),
vbar.pageStep())
transform = srcview.transform().inverted()[0]
self.graphicsview.viewbox = transform.mapRect(rect)
def update_scene_rect(self):
pixmap = self.pixmap
self.setSceneRect(
QtCore.QRectF(
QtCore.QPointF(0, 0), QtCore.QPointF(pixmap.width(), pixmap.height())
)
)
def paint(self, painter, option, index):
options = QtWidgets.QStyleOptionViewItem(option)
self.initStyleOption(options, index)
painter.save()
doc = QtGui.QTextDocument()
doc.setTextWidth(options.rect.width())
text_option = QtGui.QTextOption()
text_option.setWrapMode(QtGui.QTextOption.NoWrap)
text_option.setAlignment(options.displayAlignment)
doc.setDefaultTextOption(text_option)
doc.setHtml(options.text)
options.text = ""
options.widget.style().drawControl(QtWidgets.QStyle.CE_ItemViewItem,
options, painter)
iconSize = options.icon.actualSize(options.rect.size())
painter.translate(options.rect.left() + iconSize.width(),
options.rect.top())
clip = QtCore.QRectF(0, 0,
options.rect.width() + iconSize.width(),
options.rect.height())
doc.drawContents(painter, clip)
painter.restore()
def myMouseDragEvent(self, ev, axis=None):
# most of this code is copied behavior mouse drag from the original code
ev.accept()
pos = ev.pos()
lastPos = ev.lastPos()
dif = pos - lastPos
dif *= -1
if ev.button() == QtCore.Qt.RightButton or \
(ev.button() == QtCore.Qt.LeftButton and
ev.modifiers() & QtCore.Qt.ControlModifier):
# determine the amount of translation
tr = dif
tr = self.view_box.mapToView(tr) - self.view_box.mapToView(pg.Point(0, 0))
x = tr.x()
y = tr.y()
self.view_box.translateBy(x=x, y=y)
if ev.start:
self.range_changed_timer.start()
if ev.isFinish():
self.range_changed_timer.stop()
self.emit_sig_range_changed()
else:
if ev.isFinish(): # This is the final move in the drag; change the view scale now
self.auto_range = False
self.view_box.rbScaleBox.hide()
ax = QtCore.QRectF(pg.Point(ev.buttonDownPos(ev.button())), pg.Point(pos))
ax = self.view_box.childGroup.mapRectFromParent(ax)
self.view_box.showAxRect(ax)
self.view_box.axHistoryPointer += 1
self.view_box.axHistory = self.view_box.axHistory[:self.view_box.axHistoryPointer] + [ax]
self.emit_sig_range_changed()
else:
# update shape of scale box
self.view_box.updateScaleBox(ev.buttonDownPos(), ev.pos())
def painterPath(self):
p = QPainterPath()
roundness = int(99 * float(self._alen) / 16 / 90)
r = QtCore.QRectF(self._rect)
r.moveTo(self.state['pos'])
p.addRoundRect(r, roundness)
return p
def generatePicture(self,data=None,redraw=False):
"""重新生成图形对象"""
# 重画或者只更新最后一个K线
if redraw:
self.pictures = []
elif self.pictures:
self.pictures.pop()
w = 0.2
t = 0
for d in data:
if t >= len(self.pictures):
tShift = t
picture = QtGui.QPicture()
p = QtGui.QPainter(picture)
# 下跌蓝色（实心）, 上涨红色（空心）
p.setPen(self.bPen)
p.setBrush(self.bBrush)
# 画K线方块和上下影线
p.drawRect(QtCore.QRectF(tShift - w, 0, w * 2, d))
p.end()
self.pictures.append(picture)
t += 1
def __init__(self, parent_hud, window):
QtWidgets.QGraphicsRectItem.__init__(self, parent_hud)
self.window = window
self.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor))
self.setBrush(QtGui.QBrush(QtGui.QColor(0, 0, 0, 128)))
self.setPos(20, -140)
self.setZValue(19)
self.font = QtGui.QFont()
self.font.setPointSize(12)
self.font.setStyleHint(QtGui.QFont.Monospace)
self.font.setFixedPitch(True)
self.text = QtWidgets.QGraphicsSimpleTextItem(self)
self.text.setFont(self.font)
self.text.setBrush(QtGui.QBrush(QtGui.QColor("white")))
self.text.setZValue(10)
self.text.setPos(5, 10)
self.setRect(QtCore.QRectF(0, 0, 110, 110))
BoxGrabber(self)
self.dragged = False
self.closeDataFile()
def scale_view(self, scale):
factor = (self.transform()
.scale(scale, scale)
.mapRect(QtCore.QRectF(0, 0, 1, 1))
.width())
if factor < 0.07 or factor > 100.0:
return
self.zoom = scale
adjust_scrollbars = True
scrollbar = self.verticalScrollBar()
if scrollbar:
value = scrollbar.value()
min_ = scrollbar.minimum()
max_ = scrollbar.maximum()
range_ = max_ - min_
distance = value - min_
nonzero_range = range_ > 0.1
if nonzero_range:
scrolloffset = distance/range_
else:
adjust_scrollbars = False
self.setTransformationAnchor(QtWidgets.QGraphicsView.NoAnchor)
self.scale(scale, scale)
scrollbar = self.verticalScrollBar()
if scrollbar and adjust_scrollbars:
min_ = scrollbar.minimum()
max_ = scrollbar.maximum()
range_ = max_ - min_
value = min_ + int(float(range_) * scrolloffset)
scrollbar.setValue(value)
def mouseMoveEvent(self, ev):
if QtCore.Qt.LeftButton & ev.buttons():
if self.state == self.START:
#print("Draw Cursor")
self.canvas.overrideCursor(CURSOR_DRAW)
return
if self.state == self.DEFINE:
#print("GrabCut: Mouse Moved")
self.canvas.overrideCursor(CURSOR_MOVE)
pos = self.canvas.event_point_in_image(ev)
self.rect = QtCore.QRectF(min(self.rect.x(), pos.x()), min(self.rect.y(), pos.y()),
abs(self.rect.x() - pos.x()), abs(self.rect.y() - pos.y()))
self.canvas.update()
return
if (QtCore.Qt.LeftButton | QtCore.Qt.RightButton) & ev.buttons():
if self.state == self.EDIT:
self.canvas.overrideCursor(CURSOR_EDIT)
pos = self.canvas.event_point_in_image(ev)
rf = self.SCALE
if self.mask_background:
cv2.circle(self.mask, (int(rf*pos.x()), int(rf*pos.y())), 2, 0, -1)
else:
cv2.circle(self.mask, (int(rf*pos.x()), int(rf*pos.y())), 2, 1, -1)
self.canvas.update()
return
def sceneEventFilter(self, obj, event):
if (event.type() == QtCore.QEvent.GraphicsSceneMousePress
and event.button() == QtCore.Qt.LeftButton):
assert self.rubberband is None
self.rubberband = QtWidgets.QRubberBand(
QtWidgets.QRubberBand.Rectangle)
self.rubberband.setGeometry(
QtCore.QRect(event.screenPos(), QtCore.QSize()))
self.rubberband.show()
return True
if (event.type() == QtCore.QEvent.GraphicsSceneMouseRelease
and event.button() == QtCore.Qt.LeftButton):
assert self.rubberband is not None
self.rubberband.hide()
self.rubberband = None
rect = QtCore.QRectF(
event.buttonDownScenePos(QtCore.Qt.LeftButton),
event.scenePos()).normalized()
item = obj.addEllipse(rect, self.pen, self.brush)
item.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable, True)
item.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, True)
return True
elif (event.type() == QtCore.QEvent.GraphicsSceneMouseMove
and bool(event.buttons() & QtCore.Qt.LeftButton)):
assert self.rubberband is not None
rect = QtCore.QRect(
event.buttonDownScreenPos(QtCore.Qt.LeftButton),
event.screenPos()).normalized()
self.rubberband.setGeometry(rect)
return True
return False
def update_display(self):
#self.log.debug('update_display')
if self.initial_scan_setup_plotting:
if self.settings['show_previous_scans']:
self.img_item = pg.ImageItem()
self.img_items.append(self.img_item)
self.img_plot.addItem(self.img_item)
self.hist_lut.setImageItem(self.img_item)
self.img_item.setImage(self.display_image_map[0, :, :])
x0, x1, y0, y1 = self.imshow_extent
self.log.debug('update_display set bounds {} {} {} {}'.format(
x0, x1, y0, y1))
self.img_item_rect = QtCore.QRectF(x0, y0, x1 - x0, y1 - y0)
self.img_item.setRect(self.img_item_rect)
self.log.debug('update_display set bounds {}'.format(
self.img_item_rect))
self.initial_scan_setup_plotting = False
else:
#if self.settings.scan_type.val in ['raster']
kk, jj, ii = self.current_scan_index
self.disp_img = self.display_image_map[kk, :, :].T
self.img_item.setImage(self.disp_img,
autoRange=False,
autoLevels=False)
self.img_item.setRect(
self.img_item_rect
) # Important to set rectangle after setImage for non-square pixels
self.update_LUT()
def update_matrix_axes(self):
""" Adjust the x and y axes in the image according to the input. """
self.odmr_matrix_image.setRect(
QtCore.QRectF(self._odmr_logic.mw_start, 0,
self._odmr_logic.mw_stop - self._odmr_logic.mw_start,
self._odmr_logic.number_of_lines))
def update_display(self):
if self.settings['live_cam_show']:
self.live_cam_img_item.setVisible(True)
toup_cam_M = self.app.measurements['toupcam_live']
im = toup_cam_M.get_rgb_image()
self.live_cam_img_item.setImage(
im.swapaxes(0, 1),
autoLevels=toup_cam_M.settings['auto_level'])
Ny, Nx, _ = im.shape
cx = self.settings['live_cam_cx']
cy = self.settings['live_cam_cy']
img_scale = self.settings['live_cam_scale'] # um/pixel
x = self.stage_hw.settings['x_position']
y = self.stage_hw.settings['y_position']
w = Nx * img_scale
h = Ny * img_scale
self.live_cam_img_item.setRect(
QtCore.QRectF(x - w / 2, y - h / 2, w, h))
self.live_cam_img_item.setZValue(-1)
else:
self.live_cam_img_item.setVisible(False)
def zoomROICentered(self, p, zoom_level_delta):
pixmap = self.graphics_pixmap.pixmap()
roi = self.current_scene_ROI
roi_dims = QtCore.QPointF(roi.width(), roi.height())
roi_scalef = 1
if zoom_level_delta > 0:
roi_scalef = 1 / self.zoom_factor
elif zoom_level_delta < 0:
roi_scalef = self.zoom_factor
nroi_dims = roi_dims * roi_scalef
nroi_dims.setX(max(nroi_dims.x(), 1))
nroi_dims.setY(max(nroi_dims.y(), 1))
if (nroi_dims.x() > self.pixmap.size().width()
or nroi_dims.y() > self.pixmap.size().height()):
self.reset()
else:
nroi_center = p
nroi_dimsh = nroi_dims / 2
nroi_topleft = nroi_center - nroi_dimsh
nroi = QtCore.QRectF(nroi_topleft.x(), nroi_topleft.y(),
nroi_dims.x(), nroi_dims.y())
self.fitInView(nroi, Qt.KeepAspectRatio)
self.update()
def refresh_matrix(self):
""" Refresh the xy-matrix image """
# self.odmr_matrix_image.setImage(self._odmr_logic.ODMR_plot_xy.transpose())
# self.odmr_matrix_image.setRect(QtCore.QRectF(self._odmr_logic.mw_start,0,self._odmr_logic.mw_stop-self._odmr_logic.mw_start,self._odmr_logic.number_of_lines))
# self.refresh_odmr_colorbar()
odmr_image_data = self._odmr_logic.ODMR_plot_xy.transpose()
# If "Centiles" is checked, adjust colour scaling automatically to centiles.
# Otherwise, take user-defined values.
if self._mw.odmr_cb_centiles_RadioButton.isChecked():
low_centile = self._mw.odmr_cb_low_centile_InputWidget.value()
high_centile = self._mw.odmr_cb_high_centile_InputWidget.value()
cb_min = np.percentile( odmr_image_data, low_centile )
cb_max = np.percentile( odmr_image_data, high_centile )
else:
cb_min = self._mw.odmr_cb_min_InputWidget.value()
cb_max = self._mw.odmr_cb_max_InputWidget.value()
# Now update image with new color scale, and update colorbar
self.odmr_matrix_image.setImage(image=odmr_image_data, levels=(cb_min, cb_max) )
self.odmr_matrix_image.setRect(QtCore.QRectF(self._odmr_logic.mw_start,0,self._odmr_logic.mw_stop-self._odmr_logic.mw_start,self._odmr_logic.number_of_lines))
self.refresh_odmr_colorbar()
def zoomROITo(self, p, zoom_level_delta):
pixmap = self.graphics_pixmap.pixmap()
roi = self.current_scene_ROI
roi_dims = QtCore.QPointF(roi.width(), roi.height())
roi_topleft = roi.topLeft()
roi_scalef = 1.0
if zoom_level_delta > 0:
roi_scalef = 1.0 / self.zoom_factor
elif zoom_level_delta < 0:
roi_scalef = self.zoom_factor
nroi_dims = roi_dims * roi_scalef
nroi_dims.setX(max(nroi_dims.x(), 1))
nroi_dims.setY(max(nroi_dims.y(), 1))
if (nroi_dims.x() > self.pixmap.size().width()
or nroi_dims.y() > self.pixmap.size().height()):
self.reset()
else:
prel_scaled_x = (p.x() - roi_topleft.x()) / roi_dims.x()
prel_scaled_y = (p.y() - roi_topleft.y()) / roi_dims.y()
nroi_topleft_x = p.x() - prel_scaled_x * nroi_dims.x()
nroi_topleft_y = p.y() - prel_scaled_y * nroi_dims.y()
nroi = QtCore.QRectF(nroi_topleft_x, nroi_topleft_y, nroi_dims.x(),
nroi_dims.y())
self.fitInView(nroi, Qt.KeepAspectRatio)
self.update()
def drawPrimitive(self, pe, opt, p: QtGui.QPainter, widget):
# QToolButton elements:
# 13: PE_PanelButtonCommand (Fusion) - Fusion button background, called from 15 and 24 calls
# 15: PE_PanelButtonTool (Windows, Fusion) - left part background (XP/Vista styles do not draw it with `drawPrimitive`)
# 19: PE_IndicatorArrowDown (Windows, Fusion) - right part down arrow (XP/Vista styles draw it in 24 call)
# 24: PE_IndicatorButtonDropDown (Windows, XP, Vista, Fusion) - right part background (+arrow for XP/Vista)
#
# Arrow is drawn along with PE_IndicatorButtonDropDown (XP/Vista)
# https://github.com/qt/qtbase/blob/0c51a8756377c40180619046d07b35718fcf1784/src/plugins/styles/windowsvista/qwindowsxpstyle.cpp#L1406
# https://github.com/qt/qtbase/blob/0c51a8756377c40180619046d07b35718fcf1784/src/plugins/styles/windowsvista/qwindowsxpstyle.cpp#L666
# drawBackground paints with DrawThemeBackgroundEx WinApi function
# https://docs.microsoft.com/en-us/windows/win32/api/uxtheme/nf-uxtheme-drawthemebackgroundex
if (self.stylename in self.win_modern
and pe == self.PE_IndicatorButtonDropDown):
pe = self.PE_IndicatorArrowDown # see below
if pe == self.PE_IndicatorArrowDown:
opt_ = QtWidgets.QStyleOptionToolButton()
widget.initStyleOption(opt_)
rc = super().subControlRect(self.CC_ToolButton, opt_,
self.SC_ToolButtonMenu, widget)
if self.stylename in self.win_modern:
# By default PE_IndicatorButtonDropDown draws arrow along
# with right button art. Draw 2px clipped left part instead
path = QtGui.QPainterPath()
path.addRect(QtCore.QRectF(rc))
p.setClipPath(path)
super().drawPrimitive(self.PE_PanelButtonTool, opt, p, widget)
# centered square
rc.moveTop(int((rc.height() - rc.width()) / 2))
rc.setHeight(rc.width())
# p.setRenderHint(p.Antialiasing)
p.drawPixmap(rc, self.arrow_pix, QtCore.QRect())
else:
super().drawPrimitive(pe, opt, p, widget)
def get_confocal_image(self):
""" Update the roi_map_data in poi manager logic, and use this updated
data to redraw an image of the ROI.
"""
# Make poi manager logic get the confocal data
self._poi_manager_logic.get_confocal_image_data()
# the image data is the fluorescence part, transposed for appropriate plotting
self.roi_xy_image_data = self._poi_manager_logic.roi_map_data[:, :,
3].transpose(
)
# Also get the x and y range limits and hold them locally
self.roi_map_xmin = np.min(self._poi_manager_logic.roi_map_data[:, :,
0])
self.roi_map_xmax = np.max(self._poi_manager_logic.roi_map_data[:, :,
0])
self.roi_map_ymin = np.min(self._poi_manager_logic.roi_map_data[:, :,
1])
self.roi_map_ymax = np.max(self._poi_manager_logic.roi_map_data[:, :,
1])
self.roi_map_image.getViewBox().enableAutoRange()
self.roi_map_image.setRect(
QtCore.QRectF(self.roi_map_xmin, self.roi_map_ymin,
self.roi_map_xmax - self.roi_map_xmin,
self.roi_map_ymax - self.roi_map_ymin))
self.roi_map_image.setImage(image=self.roi_xy_image_data,
autoLevels=True)
def __init__(self,
parent: QtWidgets.QWidget,
width: int,
text: str = "",
font: Optional[QtGui.QFont] = None,
scale: float = 1) -> None:
QtWidgets.QGraphicsRectItem.__init__(self, parent)
self.parent = parent
self.setAcceptHoverEvents(True)
# self.setCursor(QCursor(QtCore.Qt.OpenHandCursor))
self.text = QtWidgets.QGraphicsSimpleTextItem(self)
if font is None:
font = QtGui.QFont("", 11 / scale)
else:
font.setPointSize(int(11 / scale))
self.text.setFont(font)
self.text.setText(text)
self.text.setPos((width - self.text.boundingRect().width()) / 2 + 1, 0)
self.text.setBrush(QtGui.QBrush(QtGui.QColor("white")))
self.setRect(
QtCore.QRectF(0, 0, width,
self.text.boundingRect().height()))
self.setBrush(QtGui.QBrush(QtGui.QColor(0, 0, 0, 128)))
self.signals = TextButtonSignals()
self.clicked = self.signals.clicked
def fit_view_to_items(self, items):
if not items:
rect = self.scene().itemsBoundingRect()
else:
x_min = y_min = maxsize
x_max = y_max = -maxsize
for item in items:
pos = item.pos()
item_rect = item.boundingRect()
x_off = item_rect.width() * 5
y_off = item_rect.height() * 10
x_min = min(x_min, pos.x())
y_min = min(y_min, pos.y()-y_off)
x_max = max(x_max, pos.x()+x_off)
y_max = max(y_max, pos.y())
rect = QtCore.QRectF(x_min, y_min, x_max-x_min, y_max-y_min)
x_adjust = GraphView.x_adjust
y_adjust = GraphView.y_adjust
rect.setX(rect.x() - x_adjust)
rect.setY(rect.y() - y_adjust)
rect.setHeight(rect.height() + y_adjust*2)
rect.setWidth(rect.width() + x_adjust*2)
self.fitInView(rect, Qt.KeepAspectRatio)
self.scene().invalidate()
def set_roi(self):
'''The ROI coord. dict. is emitted to update the camera of the coorect ROI, starts image updation by
calling the image_clicked function and repositons the ROI to fit the new ROIed imaged.
'''
was_enabled = False
if self.roi.saveState()['size'] < (3, 3):
return
if self._logic.enabled:
self._mw.start_video_Action.setText('Start Video')
self.sigVideoStop.emit()
was_enabled = True
self.sigROISet.emit(self.roi.saveState())
self.start_image_clicked()
self.roi.setSize(self.roi.saveState()['size'])
self.cross.maxBounds = QtCore.QRectF(
0, 0,
self.roi.saveState()['size'][0] - 1,
self.roi.saveState()['size'][1] - 1)
self.cross.setPos((self.roi.saveState()['size'][0] / 2,
self.roi.saveState()['size'][1] / 2))
self.roi.setPos((self.roi_p1, self.roi_p2))
if was_enabled:
self._mw.start_video_Action.setText('Stop Video')
self.sigVideoStart.emit()
was_enabled = False
def __init__(self, source, dest):
QtWidgets.QGraphicsItem.__init__(self)
self.setAcceptedMouseButtons(Qt.NoButton)
self.source = source
self.dest = dest
self.commit = source.commit
self.setZValue(-2)
dest_pt = Commit.item_bbox.center()
self.source_pt = self.mapFromItem(self.source, dest_pt)
self.dest_pt = self.mapFromItem(self.dest, dest_pt)
self.line = QtCore.QLineF(self.source_pt, self.dest_pt)
width = self.dest_pt.x() - self.source_pt.x()
height = self.dest_pt.y() - self.source_pt.y()
rect = QtCore.QRectF(self.source_pt, QtCore.QSizeF(width, height))
self.bound = rect.normalized()
# Choose a new color for new branch edges
if self.source.x() < self.dest.x():
color = EdgeColor.cycle()
line = Qt.SolidLine
elif self.source.x() != self.dest.x():
color = EdgeColor.current()
line = Qt.SolidLine
else:
color = EdgeColor.current()
line = Qt.SolidLine
self.pen = QtGui.QPen(color, 4.0, line, Qt.SquareCap, Qt.RoundJoin)
def adjust_drawing(self):
"""
When the user resizes the window, the drawing elements follow the x-positions of the corresponding
attribute_widgets.
"""
for item in self.graphic_items:
item.move_to_right_position()
for conn in self.connections:
conn.adjust()
iq = self.module_widgets[0]
for index, prop in enumerate([
"input", "acbandwidth", "frequency", "bandwidth",
"quadrature_factor", "gain", "amplitude", "output_direct"
][::2]):
widget = iq.attribute_widgets[prop]
self.frames[index].setFixedSize(
widget.width() + iq.main_layout.spacing(), self.height())
self.frames[index].move(
widget.x() + iq.pos().x() - iq.main_layout.spacing() / 2, 0)
self.frames_drawing[index].setFixedSize(
widget.width() + iq.main_layout.spacing(), self.height())
self.frames_drawing[index].move(
widget.x() + iq.pos().x() - self.view.pos().x() -
iq.main_layout.spacing() / 2, 0)
self.scene.setSceneRect(QtCore.QRectF(self.view.rect()))
#x, y = self.view.pos().x(), self.view.pos().y()
button_width = 150
self.button_hide.move(self.width() / 2 - button_width / 2,
self.height() - 17)
self.button_hide.setFixedWidth(button_width)
self.button_hide.raise_()
