class GridViewerCell(QGraphicsPolygonItem):
def __init__(self, gridViewer, x, y):
super(GridViewerCell, self).__init__()
self.gridViewer = gridViewer
self.x = x
self.y = y
self.selected = False
def generate(self, points, show_label=False):
qpolygon = QPolygonF([QPointF(xp, yp) for xp, yp in points])
self.setPolygon(qpolygon)
pen = QPen()
pen.setWidth(3)
self.setPen(pen)
self.setFlag(QGraphicsItem.ItemIsFocusable)
self.label = QGraphicsSimpleTextItem("{}-{}".format(self.x, self.y),
parent=self)
self.label.setVisible(show_label)
if len(points) == 6:
k = 0.5 if (self.x % 2) != 0 else 0
self.label.setPos(
QPointF(((self.x * 0.866) + 0.2886) * 120,
(self.y + k + 0.5) * 120))
else:
self.label.setPos(QPointF(self.x * 120, self.y * 120))
font = QFont()
font.setPointSize(20)
self.label.setFont(font)
def select(self):
self.setBrush(QBrush(QColor(200, 0, 0, 100)))
self.selected = True
self.gridViewer.add_to_selection(self.x, self.y)
def unselect(self):
self.setBrush(QBrush())
self.selected = False
self.gridViewer.remove_from_selection(self.x, self.y)
def mousePressEvent(self, *args, **kwargs):
if self.selected:
self.unselect()
else:
self.select()
def show_label(self, visible):
self.label.setVisible(visible)
def init_ui(self):
scene = QGraphicsScene()
scene.setBackgroundBrush(QColor(100, 100, 100))
scene.setItemIndexMethod(QGraphicsScene.BspTreeIndex)
scene.setSceneRect(scene.itemsBoundingRect())
self.setDragMode(QGraphicsView.RubberBandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)
self.frame_item = QGraphicsPixmapItem()
self.text_item_offset = 0
self.rect_item_array = []
self.text_item_array = []
for i in range(0, 5):
rect_item = QGraphicsRectItem()
rect_item.setVisible(False)
rect_item.setZValue(20.0)
rect_item.setPen(QPen(Qt.red, 5))
rect_item.setRect(20, 20, 20, 20)
scene.addItem(rect_item)
self.rect_item_array.append(rect_item)
text_item = QGraphicsSimpleTextItem("")
text_item.setBrush(QBrush(Qt.red))
text_item.setZValue(20.0)
text_item.setPos(10, 50)
text_item.setFont(QFont("黑体", 32))
text_item.setVisible(False)
scene.addItem(text_item)
self.text_item_array.append(text_item)
scene.addItem(self.frame_item)
self.curr_factor = 1.0
self.setScene(scene)
def init_ui(self):
scene = QGraphicsScene()
scene.setBackgroundBrush(QColor(100, 100, 100))
scene.setItemIndexMethod(QGraphicsScene.BspTreeIndex)
scene.setSceneRect(scene.itemsBoundingRect())
self.setDragMode(QGraphicsView.RubberBandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)
self.frame_item = QGraphicsPixmapItem()
self.text_item_offset = 0
self.rect_item_array = []
self.text_item_array = []
for i in range(0, 5):
rect_item = QGraphicsRectItem()
rect_item.setVisible(False)
rect_item.setZValue(20.0)
rect_item.setPen(QPen(Qt.red, 5))
rect_item.setRect(20, 20, 20, 20)
scene.addItem(rect_item)
self.rect_item_array.append(rect_item)
text_item = QGraphicsSimpleTextItem("")
text_item.setBrush(QBrush(Qt.red))
text_item.setZValue(20.0)
text_item.setPos(10, 50)
text_item.setFont(QFont("黑体", 24))
text_item.setVisible(False)
scene.addItem(text_item)
self.text_item_array.append(text_item)
scene.addItem(self.frame_item)
self.curr_factor = 1.0
self.setScene(scene)
class ActiveSliceItem(QGraphicsRectItem):
"""ActiveSliceItem for the Path View"""
def __init__(self, part_item, active_base_index):
super(ActiveSliceItem, self).__init__(part_item)
self._part_item = part_item
self._getActiveTool = part_item._getActiveTool
self._active_slice = 0
self._low_drag_bound = 0
self._high_drag_bound = self.part().maxBaseIdx()
self._controller = ActiveSliceItemController(self, part_item.part())
self._label = QGraphicsSimpleTextItem("", parent=self)
self._label.setPos(0, -18)
self._label.setFont(_FONT)
self._label.setBrush(_LABEL_BRUSH)
self._label.hide()
self.setFlag(QGraphicsItem.ItemIsMovable)
self.setAcceptHoverEvents(True)
self.setZValue(styles.ZACTIVESLICEHANDLE)
self.setRect(QRectF(0, 0, _BASE_WIDTH,\
self._part_item.boundingRect().height()))
self.setPos(active_base_index*_BASE_WIDTH, 0)
self.setBrush(_BRUSH)
self.setPen(_PEN)
# reuse select tool methods for other tools
self.addSeqToolMousePress = self.selectToolMousePress
self.addSeqToolMouseMove = self.selectToolMouseMove
self.breakToolMousePress = self.selectToolMousePress
self.breakToolMouseMove = self.selectToolMouseMove
self.insertionToolMousePress = self.selectToolMousePress
self.insertionToolMouseMove = self.selectToolMouseMove
self.paintToolMousePress = self.selectToolMousePress
self.paintToolMouseMove = self.selectToolMouseMove
self.pencilToolMousePress = self.selectToolMousePress
self.pencilToolMouseMove = self.selectToolMouseMove
self.skipToolMousePress = self.selectToolMousePress
self.skipToolMouseMove = self.selectToolMouseMove
# end def
### SLOTS ###
def strandChangedSlot(self, sender, vh):
pass
# end def
def updateRectSlot(self, part):
bw = _BASE_WIDTH
new_rect = QRectF(0, 0, bw,\
self._part_item.virtualHelixBoundingRect().height())
if new_rect != self.rect():
self.setRect(new_rect)
self._hideIfEmptySelection()
self.updateIndexSlot(part, part.activeBaseIndex())
return new_rect
# end def
def updateIndexSlot(self, part, base_index):
"""The slot that receives active slice changed notifications from
the part and changes the receiver to reflect the part"""
label = self._label
bw = _BASE_WIDTH
bi = util.clamp(int(base_index), 0, self.part().maxBaseIdx())
self.setPos(bi * bw, -styles.PATH_HELIX_PADDING)
self._active_slice = bi
if label:
label.setText("%d" % bi)
label.setX((bw - label.boundingRect().width()) / 2)
# end def
### ACCESSORS ###
def activeBaseIndex(self):
return self.part().activeBaseIndex()
# end def
def part(self):
return self._part_item.part()
# end def
def partItem(self):
return self._part_item
# end def
### PUBLIC METHODS FOR DRAWING / LAYOUT ###
def removed(self):
scene = self.scene()
scene.removeItem(self._label)
scene.removeItem(self)
self._part_item = None
self._label = None
self._controller.disconnectSignals()
self.controller = None
# end def
def resetBounds(self):
"""Call after resizing virtualhelix canvas."""
self._high_drag_bound = self.part().maxBaseIdx()
# end def
### PRIVATE SUPPORT METHODS ###
def _hideIfEmptySelection(self):
vis = self.part().numberOfVirtualHelices() > 0
self.setVisible(vis)
self._label.setVisible(vis)
# end def
def _setActiveBaseIndex(self, base_index):
self.part().setActiveBaseIndex(base_index)
# end def
### EVENT HANDLERS ###
def hoverEnterEvent(self, event):
self.setCursor(Qt.OpenHandCursor)
self._part_item.updateStatusBar("%d" % self.part().activeBaseIndex())
QGraphicsItem.hoverEnterEvent(self, event)
# end def
def hoverLeaveEvent(self, event):
self.setCursor(Qt.ArrowCursor)
self._part_item.updateStatusBar("")
QGraphicsItem.hoverLeaveEvent(self, event)
# end def
def mousePressEvent(self, event):
"""
Parses a mousePressEvent, calling the approproate tool method as
necessary. Stores _move_idx for future comparison.
"""
if event.button() != Qt.LeftButton:
event.ignore()
QGraphicsItem.mousePressEvent(self, event)
return
self.scene().views()[0].addToPressList(self)
self._move_idx = int(floor((self.x() + event.pos().x()) / _BASE_WIDTH))
tool_method_name = self._getActiveTool().methodPrefix() + "MousePress"
if hasattr(self, tool_method_name): # if the tool method exists
modifiers = event.modifiers()
getattr(self, tool_method_name)(modifiers) # call tool method
def mouseMoveEvent(self, event):
"""
Parses a mouseMoveEvent, calling the approproate tool method as
necessary. Updates _move_idx if it changed.
"""
tool_method_name = self._getActiveTool().methodPrefix() + "MouseMove"
if hasattr(self, tool_method_name): # if the tool method exists
idx = int(floor((self.x() + event.pos().x()) / _BASE_WIDTH))
if idx != self._move_idx: # did we actually move?
modifiers = event.modifiers()
self._move_idx = idx
getattr(self, tool_method_name)(modifiers, idx) # call tool method
def customMouseRelease(self, event):
"""
Parses a mouseReleaseEvent, calling the approproate tool method as
necessary. Deletes _move_idx if necessary.
"""
tool_method_name = self._getActiveTool().methodPrefix() + "MouseRelease"
if hasattr(self, tool_method_name): # if the tool method exists
modifiers = event.modifiers()
x = event.pos().x()
getattr(self, tool_method_name)(modifiers, x) # call tool method
if hasattr(self, '_move_idx'):
del self._move_idx
### TOOL METHODS ###
def selectToolMousePress(self, modifiers):
"""
Set the allowed drag bounds for use by selectToolMouseMove.
"""
if (modifiers & Qt.AltModifier) and (modifiers & Qt.ShiftModifier):
self.part().undoStack().beginMacro("Auto-drag Scaffold(s)")
for vh in self.part().getVirtualHelices():
# SCAFFOLD
# resize 3' first
for strand in vh.scaffoldStrandSet():
idx5p = strand.idx5Prime()
idx3p = strand.idx3Prime()
if not strand.hasXoverAt(idx3p):
lo, hi = strand.getResizeBounds(idx3p)
if strand.isDrawn5to3():
strand.resize((idx5p, hi))
else:
strand.resize((lo, idx5p))
# resize 5' second
for strand in vh.scaffoldStrandSet():
idx5p = strand.idx5Prime()
idx3p = strand.idx3Prime()
if not strand.hasXoverAt(idx5p):
lo, hi = strand.getResizeBounds(idx5p)
if strand.isDrawn5to3():
strand.resize((lo, idx3p))
else:
strand.resize((idx3p, hi))
# STAPLE
# resize 3' first
for strand in vh.stapleStrandSet():
idx5p = strand.idx5Prime()
idx3p = strand.idx3Prime()
if not strand.hasXoverAt(idx3p):
lo, hi = strand.getResizeBounds(idx3p)
if strand.isDrawn5to3():
strand.resize((idx5p, hi))
else:
strand.resize((lo, idx5p))
# resize 5' second
for strand in vh.stapleStrandSet():
idx5p = strand.idx5Prime()
idx3p = strand.idx3Prime()
if not strand.hasXoverAt(idx3p):
lo, hi = strand.getResizeBounds(idx5p)
if strand.isDrawn5to3():
strand.resize((lo, idx3p))
else:
strand.resize((idx3p, hi))
self.part().undoStack().endMacro()
# end def
def selectToolMouseMove(self, modifiers, idx):
"""
Given a new index (pre-validated as different from the prev index),
calculate the new x coordinate for self, move there, and notify the
parent strandItem to redraw its horizontal line.
"""
idx = util.clamp(idx, self._low_drag_bound, self._high_drag_bound)
x = int(idx * _BASE_WIDTH)
self.setPos(x, self.y())
self.updateIndexSlot(None, idx)
self._setActiveBaseIndex(idx)
self._part_item.updateStatusBar("%d" % self.part().activeBaseIndex())
class StickWidget(QGraphicsObject):
font: QFont = QFont("monospace", 32)
delete_clicked = pyqtSignal(Stick)
link_initiated = pyqtSignal('PyQt_PyObject') # Actually StickWidget
link_accepted = pyqtSignal('PyQt_PyObject')
hovered = pyqtSignal(['PyQt_PyObject', 'PyQt_PyObject'])
stick_changed = pyqtSignal('PyQt_PyObject')
sibling_changed = pyqtSignal(bool)
right_clicked = pyqtSignal('PyQt_PyObject')
handle_idle_brush = QBrush(QColor(0, 125, 125, 50))
handle_hover_brush = QBrush(QColor(125, 125, 0, 50))
handle_press_brush = QBrush(QColor(200, 200, 0, 0))
handle_idle_pen = QPen(QColor(0, 0, 0, 255))
handle_press_pen = QPen(QColor(200, 200, 0, 255))
handle_size = 20
normal_color = QColor(0, 200, 120)
negative_color = QColor(200, 0, 0)
positive_color = QColor(0, 200, 0)
mismatched = pyqtSignal('PyQt_PyObject')
misplaced = pyqtSignal('PyQt_PyObject')
measurement_corrected = pyqtSignal('PyQt_PyObject')
clearly_visible = pyqtSignal('PyQt_PyObject')
zero_clicked = pyqtSignal('PyQt_PyObject')
def __init__(self, stick: Stick, camera: Camera, parent: Optional[QGraphicsItem] = None):
QGraphicsObject.__init__(self, parent)
self.camera = camera
self.stick = stick
self.line = QLineF()
self.gline = QGraphicsLineItem(self.line)
self.stick_label_text = QGraphicsSimpleTextItem("0", self)
self.stick_label_text.setFont(StickWidget.font)
self.stick_label_text.setPos(self.line.p1() - QPoint(0, 24))
self.stick_label_text.setBrush(QBrush(QColor(0, 255, 0)))
self.stick_label_text.hide()
self.setZValue(10)
self.mode = StickMode.Display
self.btn_delete = Button("delete", "x", parent=self)
self.btn_delete.setFlag(QGraphicsItem.ItemIgnoresTransformations, True)
self.btn_delete.set_base_color([ButtonColor.RED])
self.btn_delete.setVisible(False)
btn_size = max(int(np.linalg.norm(self.stick.top - self.stick.bottom) / 5.0), 15)
self.btn_delete.set_height(12)
self.btn_delete.clicked.connect(self.handle_btn_delete_clicked)
self.btn_delete.setPos(self.line.p1() - QPointF(0.5 * self.btn_delete.boundingRect().width(), 1.1 * self.btn_delete.boundingRect().height()))
self.btn_delete.set_opacity(0.7)
self.top_handle = QGraphicsEllipseItem(0, 0, self.handle_size, self.handle_size, self)
self.mid_handle = QGraphicsEllipseItem(0, 0, self.handle_size, self.handle_size, self)
self.bottom_handle = QGraphicsEllipseItem(0, 0, self.handle_size, self.handle_size, self)
self.top_handle.setAcceptedMouseButtons(Qt.NoButton)
self.mid_handle.setAcceptedMouseButtons(Qt.NoButton)
self.bottom_handle.setAcceptedMouseButtons(Qt.NoButton)
self.top_handle.setBrush(self.handle_idle_brush)
self.top_handle.setPen(self.handle_idle_pen)
self.mid_handle.setBrush(self.handle_idle_brush)
self.mid_handle.setPen(self.handle_idle_pen)
self.bottom_handle.setBrush(self.handle_idle_brush)
self.bottom_handle.setPen(self.handle_idle_pen)
self.hovered_handle: Optional[QGraphicsRectItem] = None
self.handles = [self.top_handle, self.mid_handle, self.bottom_handle]
self.link_button = Button("link", "Link to...", parent=self)
self.link_button.set_base_color([ButtonColor.GREEN])
self.link_button.set_height(12)
self.link_button.set_label("Link", direction="vertical")
self.link_button.fit_to_contents()
self.link_button.clicked.connect(lambda: self.link_initiated.emit(self))
self.link_button.setVisible(False)
self.link_button.setFlag(QGraphicsObject.ItemIgnoresTransformations, False)
self.adjust_line()
self.setAcceptHoverEvents(True)
self.top_handle.setZValue(4)
self.bottom_handle.setZValue(4)
self.mid_handle.setZValue(4)
self.top_handle.hide()
self.mid_handle.hide()
self.bottom_handle.hide()
self.handle_mouse_offset = QPointF(0, 0)
self.available_for_linking = False
self.link_source = False
self.current_highlight_color: QColor = StickWidget.normal_color
self.highlighted = False
self.frame_color: Optional[None] = self.normal_color
self.is_linked = False
self.is_master = True
self.selected = False
self.measured_height: int = -1
self.current_color = self.normal_color
self.show_label = False
self.highlight_animation = QPropertyAnimation(self, b"highlight_color")
self.highlight_animation.valueChanged.connect(self.handle_highlight_animation_value_changed)
self.deleting = False
self.update_tooltip()
self.show_measurements: bool = False
self.proposed_snow_height: int = -1
self.zero_btn = Button("zero_btn", "0", parent=self)
self.zero_btn.setFlag(QGraphicsItem.ItemIgnoresTransformations, True)
self.zero_btn.setVisible(False)
self.zero_btn.setPos(self.boundingRect().center() + QPointF(self.zero_btn.boundingRect().width() * -0.5,
self.boundingRect().height() * 0.5))
self.zero_btn.clicked.connect(self.handle_zero)
@pyqtSlot()
def handle_btn_delete_clicked(self):
self.delete_clicked.emit(self.stick)
def prepare_for_deleting(self):
self.deleting = True
self.highlight_animation.stop()
self.btn_delete.setParentItem(None)
self.scene().removeItem(self.btn_delete)
self.btn_delete.deleteLater()
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem,
widget: Optional[PyQt5.QtWidgets.QWidget] = ...):
painter.setPen(QPen(self.current_color, 1.0))
brush = QBrush(self.current_highlight_color)
pen = QPen(brush, 4)
painter.setPen(pen)
if self.highlighted:
painter.fillRect(self.boundingRect(), QBrush(self.current_highlight_color))
if self.frame_color is not None and self.mode != StickMode.Edit and self.mode != StickMode.EditDelete:
painter.setPen(QPen(self.frame_color, 4))
painter.drawRect(self.boundingRect())
pen = QPen(QColor(0, 255, 0, 255))
pen.setWidth(1.0)
pen.setColor(QColor(255, 0, 255, 255))
pen.setStyle(Qt.DotLine)
painter.setPen(pen)
off = 10
painter.drawLine(self.line.p1() - QPointF(0, off), self.line.p1() + QPointF(0, off))
painter.drawLine(self.line.p1() - QPointF(off, 0), self.line.p1() + QPointF(off, 0))
painter.drawLine(self.line.p2() - QPointF(0, off), self.line.p2() + QPointF(0, off))
painter.drawLine(self.line.p2() - QPointF(off, 0), self.line.p2() + QPointF(off, 0))
pen.setStyle(Qt.SolidLine)
pen.setColor(QColor(0, 255, 0, 255))
painter.setPen(pen)
if self.mode != StickMode.EditDelete:
pen.setWidth(2.0)
br = painter.brush()
painter.setPen(pen)
painter.drawEllipse(self.line.p1(), 10, 10)
painter.drawEllipse(self.line.p2(), 10, 10)
painter.setBrush(br)
if self.mode == StickMode.Measurement and self.proposed_snow_height >= 0:
point = QPointF(self.boundingRect().x(), -self.proposed_snow_height + self.line.p2().y())
pen = QPen(QColor(200, 100, 0, 255), 3.0)
painter.setPen(pen)
painter.drawLine(point,
point + QPointF(self.boundingRect().width(), 0.0))
if self.measured_height >= 0:
vec = (self.stick.top - self.stick.bottom) / np.linalg.norm(self.stick.top - self.stick.bottom)
dist_along_stick = self.measured_height / np.dot(np.array([0.0, -1.0]), vec)
point = self.line.p2() + dist_along_stick * QPointF(vec[0], vec[1])
point = QPointF(self.boundingRect().x(), point.y())
pen = QPen(QColor(0, 100, 200, 255), 3.0)
painter.setPen(pen)
painter.drawLine(point,
point + QPointF(self.boundingRect().width(), 0.0))
else:
painter.drawLine(self.line.p1(), self.line.p2())
if self.selected:
pen.setColor(QColor(255, 125, 0, 255))
pen.setStyle(Qt.DashLine)
painter.setPen(pen)
painter.drawRect(self.boundingRect().marginsAdded(QMarginsF(5, 5, 5, 5)))
if self.show_measurements:
painter.fillRect(self.stick_label_text.boundingRect().translated(self.stick_label_text.pos()),
QBrush(QColor(0, 0, 0, 120)))
def boundingRect(self) -> PyQt5.QtCore.QRectF:
return self.gline.boundingRect().united(self.top_handle.boundingRect()).\
united(self.mid_handle.boundingRect()).united(self.bottom_handle.boundingRect())
def set_edit_mode(self, value: bool):
if value:
self.set_mode(StickMode.EditDelete)
else:
self.set_mode(StickMode.Display)
def set_mode(self, mode: StickMode):
if mode == StickMode.Display:
self.btn_delete.setVisible(False)
self.top_handle.setVisible(False)
self.mid_handle.setVisible(False)
self.bottom_handle.setVisible(False)
self.link_button.setVisible(False)
self.available_for_linking = False
self.link_source = False
self.zero_btn.setVisible(False)
self.setVisible(self.stick.is_visible)
elif mode == StickMode.EditDelete:
self.set_mode(StickMode.Display)
self.top_handle.setVisible(True)
self.mid_handle.setVisible(True)
self.bottom_handle.setVisible(True)
self.available_for_linking = False
self.link_source = False
self.btn_delete.setVisible(True)
elif mode == StickMode.LinkSource:
self.set_mode(StickMode.Display)
self.link_source = True
self.available_for_linking = False
self.link_button.setPos(self.boundingRect().topLeft())
self.link_button.set_width(int(self.boundingRect().width()))
self.link_button.set_button_height(int(self.boundingRect().height()))
self.link_button.adjust_text_to_button()
elif mode == StickMode.LinkTarget:
self.set_mode(StickMode.Display)
self.link_source = False
self.available_for_linking = True
elif mode == StickMode.Edit:
self.set_mode(StickMode.EditDelete)
self.btn_delete.setVisible(False)
elif mode == StickMode.Measurement:
self.zero_btn.setVisible(True)
self.setVisible(True)
self.mode = mode
self.update_tooltip()
self.update()
def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
if self.mode != StickMode.EditDelete:
return
if self.hovered_handle is None:
return
self.hovered_handle.setBrush(self.handle_press_brush)
if self.hovered_handle == self.mid_handle:
self.bottom_handle.setBrush(self.handle_press_brush)
self.bottom_handle.setPen(self.handle_press_pen)
self.bottom_handle.setOpacity(0.5)
self.top_handle.setBrush(self.handle_press_brush)
self.top_handle.setPen(self.handle_press_pen)
self.top_handle.setOpacity(0.5)
self.hovered_handle.setPen(self.handle_press_pen)
self.hovered_handle.setOpacity(0.5)
self.handle_mouse_offset = self.hovered_handle.rect().center() - event.pos()
self.btn_delete.setVisible(False)
def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent):
if self.available_for_linking:
self.link_accepted.emit(self)
return
if self.mode == StickMode.Measurement:
old_snow = self.stick.snow_height_px
self.measured_height = self.proposed_snow_height
self.stick.set_snow_height_px(self.proposed_snow_height)
if abs(old_snow - self.proposed_snow_height) > 0:
self.measurement_corrected.emit(self)
self.proposed_snow_height = -1
if self.mode != StickMode.EditDelete and self.mode != StickMode.Edit:
return
if self.hovered_handle is not None:
self.hovered_handle.setBrush(self.handle_hover_brush)
self.hovered_handle.setPen(self.handle_idle_pen)
self.hovered_handle.setOpacity(1.0)
if self.hovered_handle == self.mid_handle:
self.bottom_handle.setBrush(self.handle_idle_brush)
self.bottom_handle.setPen(self.handle_idle_pen)
self.bottom_handle.setOpacity(1.0)
self.top_handle.setBrush(self.handle_idle_brush)
self.top_handle.setPen(self.handle_idle_pen)
self.top_handle.setOpacity(1.0)
self.stick_changed.emit(self)
self.hovered_handle = None
if self.mode == StickMode.EditDelete:
self.btn_delete.setVisible(True)
def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent):
if self.hovered_handle is None:
return
if self.hovered_handle == self.top_handle:
self.line.setP1((event.pos() + self.handle_mouse_offset).toPoint())
elif self.hovered_handle == self.bottom_handle:
self.line.setP2((event.pos() + self.handle_mouse_offset).toPoint())
else:
displacement = event.pos() - event.lastPos()
self.setPos(self.pos() + displacement)
self.adjust_handles()
self.adjust_stick()
self.scene().update()
def set_top(self, pos: QPoint):
self.line.setP1(pos)
self.adjust_handles()
self.adjust_stick()
self.scene().update()
def set_bottom(self, pos: QPoint):
self.line.setP2(pos)
self.adjust_handles()
self.adjust_stick()
self.scene().update()
def hoverEnterEvent(self, event: QGraphicsSceneHoverEvent):
if self.available_for_linking:
self.hovered.emit(True, self)
elif self.link_source:
self.link_button.setVisible(True)
self.scene().update()
def hoverLeaveEvent(self, event: QGraphicsSceneHoverEvent):
for h in self.handles:
h.setBrush(self.handle_idle_brush)
self.hovered_handle = None
if self.available_for_linking:
self.hovered.emit(False, self)
self.link_button.setVisible(False)
self.proposed_snow_height = -1
self.scene().update()
def hoverMoveEvent(self, event: QGraphicsSceneHoverEvent):
if self.mode != StickMode.EditDelete and self.mode != StickMode.Edit and self.mode != StickMode.Measurement:
return
if self.mode == StickMode.Measurement:
self.proposed_snow_height = max(self.line.p2().y() - event.pos().y(), 0)
self.update()
return
hovered_handle = list(filter(lambda h: h.rect().contains(event.pos()), self.handles))
if len(hovered_handle) == 0:
if self.hovered_handle is not None:
self.hovered_handle.setBrush(self.handle_idle_brush)
self.hovered_handle = None
return
if self.hovered_handle is not None and self.hovered_handle != hovered_handle[0]:
self.hovered_handle.setBrush(self.handle_idle_brush)
self.hovered_handle = hovered_handle[0]
if self.hovered_handle == self.top_handle:
self.top_handle.setBrush(self.handle_hover_brush)
elif self.hovered_handle == self.bottom_handle:
self.bottom_handle.setBrush(self.handle_hover_brush)
else:
self.mid_handle.setBrush(self.handle_hover_brush)
self.scene().update()
def adjust_stick(self):
self.stick.top[0] = self.pos().x() + self.line.p1().x()
self.stick.top[1] = self.pos().y() + self.line.p1().y()
self.stick.bottom[0] = self.pos().x() + self.line.p2().x()
self.stick.bottom[1] = self.pos().y() + self.line.p2().y()
def adjust_handles(self):
if self.line.p1().y() > self.line.p2().y():
p1, p2 = self.line.p1(), self.line.p2()
self.line.setP1(p2)
self.line.setP2(p1)
if self.hovered_handle is not None:
self.hovered_handle.setBrush(self.handle_idle_brush)
self.hovered_handle.setPen(self.handle_idle_pen)
self.hovered_handle = self.top_handle if self.hovered_handle == self.bottom_handle else self.bottom_handle
self.hovered_handle.setBrush(self.handle_press_brush)
self.hovered_handle.setPen(self.handle_press_pen)
rect = self.top_handle.rect()
rect.moveCenter(self.line.p1())
self.top_handle.setRect(rect)
rect = self.bottom_handle.rect()
rect.moveCenter(self.line.p2())
self.bottom_handle.setRect(rect)
rect = self.mid_handle.rect()
rect.moveCenter(self.line.center())
self.mid_handle.setRect(rect)
self.btn_delete.setPos(self.top_handle.rect().center() - QPointF(self.btn_delete.boundingRect().width() / 2,
self.btn_delete.boundingRect().height() + self.top_handle.boundingRect().height() / 2))
def set_available_for_linking(self, available: bool):
self.available_for_linking = available
def set_is_link_source(self, is_source: bool):
self.link_source = is_source
self.link_button.setPos(self.boundingRect().topLeft())
self.link_button.set_width(int(self.boundingRect().width()))
self.link_button.set_button_height(int(self.boundingRect().height()))
self.link_button.adjust_text_to_button()
def set_frame_color(self, color: Optional[QColor]):
self.frame_color = color if color is not None else self.normal_color
self.update()
def set_is_linked(self, value: bool):
self.is_linked = value
if not self.is_linked:
self.set_frame_color(None)
if self.available_for_linking:
self.highlight(QColor(0, 255, 0, 100))
else:
self.highlight(None)
self.update_tooltip()
def adjust_line(self):
self.setPos(QPointF(0.5 * (self.stick.top[0] + self.stick.bottom[0]), 0.5 * (self.stick.top[1] + self.stick.bottom[1])))
vec = 0.5 * (self.stick.top - self.stick.bottom)
self.line.setP1(QPointF(vec[0], vec[1]))
self.line.setP2(-self.line.p1())
self.gline.setLine(self.line)
self.adjust_handles()
self.stick_label_text.setPos(self.line.p1() - QPointF(0.5 * self.stick_label_text.boundingRect().width(),
1.3 * self.stick_label_text.boundingRect().height()))
self.update()
def set_selected(self, selected: bool):
self.selected = selected
self.update()
def is_selected(self) -> bool:
return self.selected
def set_snow_height(self, height: int):
self.measured_height = height
self.update()
def border_normal(self):
self.current_color = self.normal_color
self.update()
def border_positive(self):
self.current_color = self.positive_color
self.update()
def border_negative(self):
self.current_color = self.negative_color
self.update()
@pyqtProperty(QColor)
def highlight_color(self) -> QColor:
return self.current_highlight_color
@highlight_color.setter
def highlight_color(self, color: QColor):
self.current_highlight_color = color
def highlight(self, color: Optional[QColor], animated: bool = False):
self.highlighted = color is not None
if not animated or color is None:
self.highlight_animation.stop()
self.current_highlight_color = self.normal_color if color is None else color
self.update()
return
self.highlight_animation.setStartValue(color)
self.highlight_animation.setEndValue(color)
self.highlight_animation.setKeyValueAt(0.5, color.darker())
self.highlight_animation.setDuration(2000)
self.highlight_animation.setLoopCount(-1)
self.highlight_animation.start()
def handle_link_button_hovered(self, btn: Dict[str, Any]):
self.link_button.setVisible(btn['hovered'])
def handle_highlight_animation_value_changed(self, new: QColor):
if not self.deleting:
self.update(self.boundingRect().marginsAdded(QMarginsF(10, 10, 10, 10)))
def contextMenuEvent(self, event: QGraphicsSceneContextMenuEvent) -> None:
self.right_clicked.emit({'stick_widget': self})
def set_stick_label(self, label: str):
self.stick.label = label
self.stick_label_text.setText(label)
self.update_tooltip()
self.update()
def get_stick_label(self) -> str:
return self.stick.label
def get_stick_length_cm(self) -> int:
return self.stick.length_cm
def set_stick_length_cm(self, length: int):
self.stick.length_cm = length
self.update_tooltip()
self.update()
def update_tooltip(self):
if self.mode != StickMode.Display or self.mode == StickMode.Measurement:
self.setToolTip("")
return
snow_txt = "Snow height: "
if self.stick.snow_height_px >= 0:
snow_txt += str(self.stick.snow_height_cm) + " cm"
self.stick_label_text.setText(str(self.stick.snow_height_cm))
else:
snow_txt = "not measured"
self.stick_label_text.setVisible(False)
self.stick_label_text.setText(self.stick.label)
self.stick_label_text.setVisible(True)
stick_view_text = ''
role = ''
if self.stick.alternative_view is not None:
alt_view = self.stick.alternative_view
role = " - primary"
alt = "Secondary"
if not self.stick.primary:
role = " - secondary"
alt = "Primary"
stick_view_text = f'\n{alt} view: {alt_view.label} in {alt_view.camera_folder.name}\n'
mark = '*' if self.stick.determines_quality else ''
self.setToolTip(f'{mark}{self.stick.label}{role}{stick_view_text}\nLength: {self.stick.length_cm} cm\n{snow_txt}')
def set_stick(self, stick: Stick):
self.reset_d_btns()
self.stick = stick
self.adjust_line()
self.adjust_handles()
self.set_snow_height(stick.snow_height_px)
self.update_tooltip()
self.set_show_measurements(self.show_measurements)
if self.mode == StickMode.Measurement:
self.set_frame_color(QColor(200, 100, 0, 100) if not self.stick.is_visible else None)
self.setVisible(True)
self.clearly_visible_btn.setVisible(not self.stick.is_visible)
else:
self.setVisible(self.stick.is_visible)
def set_show_measurements(self, show: bool):
self.show_measurements = show
if self.show_measurements:
self.stick_label_text.setText(str(self.stick.snow_height_cm) if self.stick.snow_height_cm >= 0 else
"n/a")
else:
self.stick_label_text.setText(self.stick.label)
self.update()
def handle_zero(self):
self.measured_height = 0
self.stick.set_snow_height_px(0)
self.measurement_corrected.emit(self)
def reset_d_btns(self):
self.zero_btn.set_default_state()
class ActiveSliceItem(QGraphicsRectItem):
"""ActiveSliceItem for the Path View"""
def __init__(self, part_item, active_base_index):
super(ActiveSliceItem, self).__init__(part_item)
self._part_item = part_item
self._getActiveTool = part_item._getActiveTool
self._active_slice = 0
self._low_drag_bound = 0
self._high_drag_bound = self.part().maxBaseIdx()
self._controller = ActiveSliceItemController(self, part_item.part())
self._label = QGraphicsSimpleTextItem("", parent=self)
self._label.setPos(0, -18)
self._label.setFont(_FONT)
self._label.setBrush(_LABEL_BRUSH)
self._label.hide()
self.setFlag(QGraphicsItem.ItemIsMovable)
self.setAcceptHoverEvents(True)
self.setZValue(styles.ZACTIVESLICEHANDLE)
self.setRect(QRectF(0, 0, _BASE_WIDTH,\
self._part_item.boundingRect().height()))
self.setPos(active_base_index * _BASE_WIDTH, 0)
self.setBrush(_BRUSH)
self.setPen(_PEN)
# reuse select tool methods for other tools
self.addSeqToolMousePress = self.selectToolMousePress
self.addSeqToolMouseMove = self.selectToolMouseMove
self.breakToolMousePress = self.selectToolMousePress
self.breakToolMouseMove = self.selectToolMouseMove
self.insertionToolMousePress = self.selectToolMousePress
self.insertionToolMouseMove = self.selectToolMouseMove
self.paintToolMousePress = self.selectToolMousePress
self.paintToolMouseMove = self.selectToolMouseMove
self.pencilToolMousePress = self.selectToolMousePress
self.pencilToolMouseMove = self.selectToolMouseMove
self.skipToolMousePress = self.selectToolMousePress
self.skipToolMouseMove = self.selectToolMouseMove
# end def
### SLOTS ###
def strandChangedSlot(self, sender, vh):
pass
# end def
def updateRectSlot(self, part):
bw = _BASE_WIDTH
new_rect = QRectF(0, 0, bw,\
self._part_item.virtualHelixBoundingRect().height())
if new_rect != self.rect():
self.setRect(new_rect)
self._hideIfEmptySelection()
self.updateIndexSlot(part, part.activeBaseIndex())
return new_rect
# end def
def updateIndexSlot(self, part, base_index):
"""The slot that receives active slice changed notifications from
the part and changes the receiver to reflect the part"""
label = self._label
bw = _BASE_WIDTH
bi = util.clamp(int(base_index), 0, self.part().maxBaseIdx())
self.setPos(bi * bw, -styles.PATH_HELIX_PADDING)
self._active_slice = bi
if label:
label.setText("%d" % bi)
label.setX((bw - label.boundingRect().width()) / 2)
# end def
### ACCESSORS ###
def activeBaseIndex(self):
return self.part().activeBaseIndex()
# end def
def part(self):
return self._part_item.part()
# end def
def partItem(self):
return self._part_item
# end def
### PUBLIC METHODS FOR DRAWING / LAYOUT ###
def removed(self):
scene = self.scene()
scene.removeItem(self._label)
scene.removeItem(self)
self._part_item = None
self._label = None
self._controller.disconnectSignals()
self.controller = None
# end def
def resetBounds(self):
"""Call after resizing virtualhelix canvas."""
self._high_drag_bound = self.part().maxBaseIdx()
# end def
### PRIVATE SUPPORT METHODS ###
def _hideIfEmptySelection(self):
vis = self.part().numberOfVirtualHelices() > 0
self.setVisible(vis)
self._label.setVisible(vis)
# end def
def _setActiveBaseIndex(self, base_index):
self.part().setActiveBaseIndex(base_index)
# end def
### EVENT HANDLERS ###
def hoverEnterEvent(self, event):
self.setCursor(Qt.OpenHandCursor)
self._part_item.updateStatusBar("%d" % self.part().activeBaseIndex())
QGraphicsItem.hoverEnterEvent(self, event)
# end def
def hoverLeaveEvent(self, event):
self.setCursor(Qt.ArrowCursor)
self._part_item.updateStatusBar("")
QGraphicsItem.hoverLeaveEvent(self, event)
# end def
def mousePressEvent(self, event):
"""
Parses a mousePressEvent, calling the approproate tool method as
necessary. Stores _move_idx for future comparison.
"""
if event.button() != Qt.LeftButton:
event.ignore()
QGraphicsItem.mousePressEvent(self, event)
return
self.scene().views()[0].addToPressList(self)
self._move_idx = int(floor((self.x() + event.pos().x()) / _BASE_WIDTH))
tool_method_name = self._getActiveTool().methodPrefix() + "MousePress"
if hasattr(self, tool_method_name): # if the tool method exists
modifiers = event.modifiers()
getattr(self, tool_method_name)(modifiers) # call tool method
def mouseMoveEvent(self, event):
"""
Parses a mouseMoveEvent, calling the approproate tool method as
necessary. Updates _move_idx if it changed.
"""
tool_method_name = self._getActiveTool().methodPrefix() + "MouseMove"
if hasattr(self, tool_method_name): # if the tool method exists
idx = int(floor((self.x() + event.pos().x()) / _BASE_WIDTH))
if idx != self._move_idx: # did we actually move?
modifiers = event.modifiers()
self._move_idx = idx
getattr(self, tool_method_name)(modifiers,
idx) # call tool method
def customMouseRelease(self, event):
"""
Parses a mouseReleaseEvent, calling the approproate tool method as
necessary. Deletes _move_idx if necessary.
"""
tool_method_name = self._getActiveTool().methodPrefix(
) + "MouseRelease"
if hasattr(self, tool_method_name): # if the tool method exists
modifiers = event.modifiers()
x = event.pos().x()
getattr(self, tool_method_name)(modifiers, x) # call tool method
if hasattr(self, '_move_idx'):
del self._move_idx
### TOOL METHODS ###
def selectToolMousePress(self, modifiers):
"""
Set the allowed drag bounds for use by selectToolMouseMove.
"""
if (modifiers & Qt.AltModifier) and (modifiers & Qt.ShiftModifier):
self.part().undoStack().beginMacro("Auto-drag Scaffold(s)")
for vh in self.part().getVirtualHelices():
# SCAFFOLD
# resize 3' first
for strand in vh.scaffoldStrandSet():
idx5p = strand.idx5Prime()
idx3p = strand.idx3Prime()
if not strand.hasXoverAt(idx3p):
lo, hi = strand.getResizeBounds(idx3p)
if strand.isDrawn5to3():
strand.resize((idx5p, hi))
else:
strand.resize((lo, idx5p))
# resize 5' second
for strand in vh.scaffoldStrandSet():
idx5p = strand.idx5Prime()
idx3p = strand.idx3Prime()
if not strand.hasXoverAt(idx5p):
lo, hi = strand.getResizeBounds(idx5p)
if strand.isDrawn5to3():
strand.resize((lo, idx3p))
else:
strand.resize((idx3p, hi))
# STAPLE
# resize 3' first
for strand in vh.stapleStrandSet():
idx5p = strand.idx5Prime()
idx3p = strand.idx3Prime()
if not strand.hasXoverAt(idx3p):
lo, hi = strand.getResizeBounds(idx3p)
if strand.isDrawn5to3():
strand.resize((idx5p, hi))
else:
strand.resize((lo, idx5p))
# resize 5' second
for strand in vh.stapleStrandSet():
idx5p = strand.idx5Prime()
idx3p = strand.idx3Prime()
if not strand.hasXoverAt(idx3p):
lo, hi = strand.getResizeBounds(idx5p)
if strand.isDrawn5to3():
strand.resize((lo, idx3p))
else:
strand.resize((idx3p, hi))
self.part().undoStack().endMacro()
# end def
def selectToolMouseMove(self, modifiers, idx):
"""
Given a new index (pre-validated as different from the prev index),
calculate the new x coordinate for self, move there, and notify the
parent strandItem to redraw its horizontal line.
"""
idx = util.clamp(idx, self._low_drag_bound, self._high_drag_bound)
x = int(idx * _BASE_WIDTH)
self.setPos(x, self.y())
self.updateIndexSlot(None, idx)
self._setActiveBaseIndex(idx)
self._part_item.updateStatusBar("%d" % self.part().activeBaseIndex())
class CameraView(QGraphicsObject):
font: QFont = QFont("monospace", 16)
stick_link_requested = pyqtSignal(StickWidget)
stick_context_menu = pyqtSignal('PyQt_PyObject', 'PyQt_PyObject')
stick_widgets_out_of_sync = pyqtSignal('PyQt_PyObject')
visibility_toggled = pyqtSignal()
synchronize_clicked = pyqtSignal('PyQt_PyObject')
previous_photo_clicked = pyqtSignal('PyQt_PyObject')
next_photo_clicked = pyqtSignal('PyQt_PyObject')
sync_confirm_clicked = pyqtSignal('PyQt_PyObject')
sync_cancel_clicked = pyqtSignal('PyQt_PyObject')
first_photo_clicked = pyqtSignal('PyQt_PyObject')
enter_pressed = pyqtSignal()
def __init__(self, scale: float, parent: Optional[QGraphicsItem] = None):
QGraphicsObject.__init__(self, parent)
self.current_highlight_color = QColor(0, 0, 0, 0)
self.current_timer = -1
self.scaling = scale
self.pixmap = QGraphicsPixmapItem(self)
self.stick_widgets: List[StickWidget] = []
self.link_cam_text = QGraphicsSimpleTextItem("Link camera...", self)
self.link_cam_text.setZValue(40)
self.link_cam_text.setVisible(False)
self.link_cam_text.setFont(CameraView.font)
self.link_cam_text.setPos(0, 0)
self.link_cam_text.setPen(QPen(QColor(255, 255, 255, 255)))
self.link_cam_text.setBrush(QBrush(QColor(255, 255, 255, 255)))
self.show_add_buttons = False
self.camera = None
self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True)
self.show_stick_widgets = False
self.setAcceptHoverEvents(True)
self.stick_edit_mode = False
self.original_pixmap = self.pixmap.pixmap()
self.hovered = False
self.mode = 0 # TODO make enum Mode
self.click_handler = None
self.double_click_handler: Callable[[int, int], None] = None
self.stick_widget_mode = StickMode.Display
self.highlight_animation = QPropertyAnimation(self, b"highlight_color")
self.highlight_animation.setEasingCurve(QEasingCurve.Linear)
self.highlight_animation.valueChanged.connect(
self.handle_highlight_color_changed)
self.highlight_rect = QGraphicsRectItem(self)
self.highlight_rect.setZValue(4)
self.highlight_rect.setPen(QPen(QColor(0, 0, 0, 0)))
self.title_btn = Button('btn_title', '', parent=self)
self.title_btn.setFlag(QGraphicsItem.ItemIgnoresTransformations, False)
self.title_btn.setZValue(5)
self.title_btn.setVisible(False)
self.sticks_without_width: List[Stick] = []
self.current_image_name: str = ''
self.control_widget = ControlWidget(parent=self)
self.control_widget.setFlag(QGraphicsItem.ItemIgnoresTransformations,
False)
self.control_widget.setVisible(True)
self._connect_control_buttons()
self.image_available = True
self.blur_eff = QGraphicsBlurEffect()
self.blur_eff.setBlurRadius(5.0)
self.blur_eff.setEnabled(False)
self.pixmap.setGraphicsEffect(self.blur_eff)
self.overlay_message = QGraphicsSimpleTextItem('not available',
parent=self)
font = self.title_btn.font
font.setPointSize(48)
self.overlay_message.setFont(font)
self.overlay_message.setBrush(QBrush(QColor(200, 200, 200, 200)))
self.overlay_message.setPen(QPen(QColor(0, 0, 0, 200), 2.0))
self.overlay_message.setVisible(False)
self.overlay_message.setZValue(6)
self.stick_box = QGraphicsRectItem(parent=self)
self.stick_box.setFlag(QGraphicsItem.ItemIsMovable, True)
self.stick_box.setVisible(False)
self.stick_box_start_pos = QPoint()
def _connect_control_buttons(self):
self.control_widget.synchronize_btn.clicked.connect(
lambda: self.synchronize_clicked.emit(self))
self.control_widget.prev_photo_btn.clicked.connect(
lambda: self.previous_photo_clicked.emit(self))
self.control_widget.next_photo_btn.clicked.connect(
lambda: self.next_photo_clicked.emit(self))
self.control_widget.accept_btn.clicked.connect(
lambda: self.sync_confirm_clicked.emit(self))
self.control_widget.cancel_btn.clicked.connect(
lambda: self.sync_cancel_clicked.emit(self))
self.control_widget.first_photo_btn.clicked.connect(
lambda: self.first_photo_clicked.emit(self))
def paint(self, painter: QPainter,
option: PyQt5.QtWidgets.QStyleOptionGraphicsItem,
widget: QWidget):
if self.pixmap.pixmap().isNull():
return
painter.setRenderHint(QPainter.Antialiasing, True)
if self.show_stick_widgets:
brush = QBrush(QColor(255, 255, 255, 100))
painter.fillRect(self.boundingRect(), brush)
if self.mode and self.hovered:
pen = QPen(QColor(0, 125, 200, 255))
pen.setWidth(4)
painter.setPen(pen)
def boundingRect(self) -> PyQt5.QtCore.QRectF:
return self.pixmap.boundingRect().united(
self.title_btn.boundingRect().translated(self.title_btn.pos()))
def initialise_with(self, camera: Camera):
if self.camera is not None:
self.camera.stick_added.disconnect(self.handle_stick_created)
self.camera.sticks_added.disconnect(self.handle_sticks_added)
self.camera.stick_removed.disconnect(self.handle_stick_removed)
self.camera.sticks_removed.disconnect(self.handle_sticks_removed)
self.camera.stick_changed.disconnect(self.handle_stick_changed)
self.camera = camera
self.prepareGeometryChange()
self.set_image(camera.rep_image, Path(camera.rep_image_path).name)
self.title_btn.set_label(self.camera.folder.name)
self.title_btn.set_height(46)
self.title_btn.fit_to_contents()
self.title_btn.set_width(int(self.boundingRect().width()))
self.title_btn.setPos(0, self.boundingRect().height())
self.control_widget.title_btn.set_label(self.camera.folder.name)
self.camera.stick_added.connect(self.handle_stick_created)
self.camera.sticks_added.connect(self.handle_sticks_added)
self.camera.stick_removed.connect(self.handle_stick_removed)
self.camera.sticks_removed.connect(self.handle_sticks_removed)
self.camera.stick_changed.connect(self.handle_stick_changed)
self.control_widget.set_font_height(32)
self.control_widget.set_widget_height(
self.title_btn.boundingRect().height())
self.control_widget.set_widget_width(int(self.boundingRect().width()))
self.control_widget.setPos(0,
self.pixmap.boundingRect().height()
) #self.boundingRect().height())
self.control_widget.set_mode('view')
self.update_stick_widgets()
def set_image(self,
img: Optional[np.ndarray] = None,
image_name: Optional[str] = None):
if img is None:
self.show_overlay_message('not available')
return
self.show_overlay_message(None)
self.prepareGeometryChange()
barray = QByteArray(img.tobytes())
image = QImage(barray, img.shape[1], img.shape[0],
QImage.Format_BGR888)
self.original_pixmap = QPixmap.fromImage(image)
self.pixmap.setPixmap(self.original_pixmap)
self.highlight_rect.setRect(self.boundingRect())
self.current_image_name = image_name
def update_stick_widgets(self):
stick_length = 60
for stick in self.camera.sticks:
sw = StickWidget(stick, self.camera, self)
sw.set_mode(self.stick_widget_mode)
self.connect_stick_widget_signals(sw)
self.stick_widgets.append(sw)
stick_length = stick.length_cm
self.update_stick_box()
self.scene().update()
def scale_item(self, factor: float):
self.prepareGeometryChange()
pixmap = self.original_pixmap.scaledToHeight(
int(self.original_pixmap.height() * factor))
self.pixmap.setPixmap(pixmap)
self.__update_title()
def set_show_stick_widgets(self, value: bool):
for sw in self.stick_widgets:
sw.setVisible(value)
self.scene().update()
def hoverEnterEvent(self, e: QGraphicsSceneHoverEvent):
self.hovered = True
self.scene().update(self.sceneBoundingRect())
def hoverLeaveEvent(self, e: QGraphicsSceneHoverEvent):
self.hovered = False
self.scene().update(self.sceneBoundingRect())
def mousePressEvent(self, e: QGraphicsSceneMouseEvent):
super().mousePressEvent(e)
def mouseReleaseEvent(self, e: QGraphicsSceneMouseEvent):
if self.mode == 1:
self.click_handler(self.camera)
def mouseDoubleClickEvent(self, event: QGraphicsSceneMouseEvent):
if self.stick_widget_mode == StickMode.EditDelete:
x = event.pos().toPoint().x()
y = event.pos().toPoint().y()
stick = self.camera.create_new_sticks(
[(np.array([[x, y - 50], [x, y + 50]]), 3)],
self.current_image_name)[
0] #self.dataset.create_new_stick(self.camera)
self.sticks_without_width.append(stick)
def set_button_mode(self, click_handler: Callable[[Camera], None],
data: str):
self.mode = 1 # TODO make a proper ENUM
self.click_handler = lambda c: click_handler(c, data)
def set_display_mode(self):
self.mode = 0 # TODO make a proper ENUM
self.click_handler = None
def _remove_stick_widgets(self):
for sw in self.stick_widgets:
sw.setParentItem(None)
self.scene().removeItem(sw)
sw.deleteLater()
self.stick_widgets.clear()
def handle_stick_created(self, stick: Stick):
if stick.camera_id != self.camera.id:
return
sw = StickWidget(stick, self.camera, self)
sw.set_mode(self.stick_widget_mode)
self.connect_stick_widget_signals(sw)
self.stick_widgets.append(sw)
self.stick_widgets_out_of_sync.emit(self)
self.update()
def handle_stick_removed(self, stick: Stick):
if stick.camera_id != self.camera.id:
return
stick_widget = next(
filter(lambda sw: sw.stick.id == stick.id, self.stick_widgets))
self.disconnect_stick_widget_signals(stick_widget)
self.stick_widgets.remove(stick_widget)
stick_widget.setParentItem(None)
self.scene().removeItem(stick_widget)
stick_widget.deleteLater()
self.update()
def handle_sticks_removed(self, sticks: List[Stick]):
if sticks[0].camera_id != self.camera.id:
return
for stick in sticks:
to_remove: StickWidget = None
for sw in self.stick_widgets:
if sw.stick.id == stick.id:
to_remove = sw
break
self.stick_widgets.remove(to_remove)
to_remove.setParentItem(None)
if self.scene() is not None:
self.scene().removeItem(to_remove)
to_remove.deleteLater()
self.update()
def handle_sticks_added(self, sticks: List[Stick]):
if len(sticks) == 0:
return
if sticks[0].camera_id != self.camera.id:
return
for stick in sticks:
sw = StickWidget(stick, self.camera, self)
sw.set_mode(self.stick_widget_mode)
self.connect_stick_widget_signals(sw)
self.stick_widgets.append(sw)
self.update_stick_box()
self.stick_widgets_out_of_sync.emit(self)
self.update()
def connect_stick_widget_signals(self, stick_widget: StickWidget):
stick_widget.delete_clicked.connect(
self.handle_stick_widget_delete_clicked)
stick_widget.stick_changed.connect(self.handle_stick_widget_changed)
stick_widget.link_initiated.connect(self.handle_stick_link_initiated)
stick_widget.right_clicked.connect(
self.handle_stick_widget_context_menu)
def disconnect_stick_widget_signals(self, stick_widget: StickWidget):
stick_widget.delete_clicked.disconnect(
self.handle_stick_widget_delete_clicked)
stick_widget.stick_changed.disconnect(self.handle_stick_widget_changed)
stick_widget.link_initiated.disconnect(
self.handle_stick_link_initiated)
stick_widget.right_clicked.disconnect(
self.handle_stick_widget_context_menu)
def handle_stick_widget_delete_clicked(self, stick: Stick):
self.camera.remove_stick(stick)
def set_stick_widgets_mode(self, mode: StickMode):
self.stick_widget_mode = mode
for sw in self.stick_widgets:
sw.set_mode(mode)
self.set_stick_edit_mode(mode == StickMode.Edit)
def handle_stick_widget_changed(self, stick_widget: StickWidget):
self.camera.stick_changed.emit(stick_widget.stick)
def handle_stick_changed(self, stick: Stick):
if stick.camera_id != self.camera.id:
return
sw = next(
filter(lambda _sw: _sw.stick.id == stick.id, self.stick_widgets))
sw.adjust_line()
sw.update_tooltip()
def handle_stick_link_initiated(self, stick_widget: StickWidget):
self.stick_link_requested.emit(stick_widget)
def get_top_left(self) -> QPointF:
return self.sceneBoundingRect().topLeft()
def get_top_right(self) -> QPointF:
return self.sceneBoundingRect().topRight()
def highlight(self, color: Optional[QColor]):
if color is None:
self.highlight_animation.stop()
self.highlight_rect.setVisible(False)
return
alpha = color.alpha()
color.setAlpha(0)
self.highlight_animation.setStartValue(color)
self.highlight_animation.setEndValue(color)
color.setAlpha(alpha)
self.highlight_animation.setKeyValueAt(0.5, color)
self.highlight_animation.setDuration(2000)
self.highlight_animation.setLoopCount(-1)
self.highlight_rect.setPen(QPen(color))
self.highlight_rect.setVisible(True)
self.highlight_animation.start()
@pyqtProperty(QColor)
def highlight_color(self) -> QColor:
return self.current_highlight_color
@highlight_color.setter
def highlight_color(self, color: QColor):
self.current_highlight_color = color
def handle_highlight_color_changed(self, color: QColor):
self.highlight_rect.setBrush(QBrush(color))
self.update()
def handle_stick_widget_context_menu(self, sender: Dict[str, StickWidget]):
self.stick_context_menu.emit(sender['stick_widget'], self)
def show_overlay_message(self, msg: Optional[str]):
if msg is None:
self.overlay_message.setVisible(False)
self.blur_eff.setEnabled(False)
return
self.overlay_message.setText(msg)
self.overlay_message.setPos(
self.pixmap.boundingRect().center() -
QPointF(0.5 * self.overlay_message.boundingRect().width(), 0.5 *
self.overlay_message.boundingRect().height()))
self.overlay_message.setVisible(True)
self.blur_eff.setEnabled(True)
def show_status_message(self, msg: Optional[str]):
if msg is None:
self.control_widget.set_title_text(self.camera.folder.name)
else:
self.control_widget.set_title_text(msg)
def update_stick_box(self):
left = 9000
right = 0
top = 9000
bottom = -1
for stick in self.camera.sticks:
left = min(left, min(stick.top[0], stick.bottom[0]))
right = max(right, max(stick.top[0], stick.bottom[0]))
top = min(top, min(stick.top[1], stick.bottom[1]))
bottom = max(bottom, max(stick.top[1], stick.bottom[1]))
left -= 100
right += 100
top -= 100
bottom += 100
self.stick_box.setRect(left, top, right - left, bottom - top)
pen = QPen(QColor(0, 100, 200, 200))
pen.setWidth(2)
pen.setStyle(Qt.DashLine)
self.stick_box.setPen(pen)
def set_stick_edit_mode(self, is_edit: bool):
if is_edit:
self.update_stick_box()
self.stick_box_start_pos = self.stick_box.pos()
for sw in self.stick_widgets:
sw.setParentItem(self.stick_box)
else:
offset = self.stick_box.pos() - self.stick_box_start_pos
for sw in self.stick_widgets:
stick = sw.stick
stick.translate(np.array([int(offset.x()), int(offset.y())]))
sw.setParentItem(self)
sw.set_stick(stick)
self.stick_box.setParentItem(None)
self.stick_box = QGraphicsRectItem(self)
self.stick_box.setFlag(QGraphicsItem.ItemIsMovable, True)
self.stick_box.setVisible(False)
self.stick_box.setVisible(is_edit)
def keyPressEvent(self, event: QKeyEvent) -> None:
pass
def keyReleaseEvent(self, event: QKeyEvent) -> None:
if event.key() in [Qt.Key_Right, Qt.Key_Tab, Qt.Key_Space]:
self.control_widget.next_photo_btn.click_button(True)
elif event.key() in [Qt.Key_Left]:
self.control_widget.prev_photo_btn.click_button(True)
elif event.key() == Qt.Key_S:
self.enter_pressed.emit()
class IndicatorIconView(QGraphicsPixmapItem):
def __init__(self,
parent: ViewBox,
icon_path: str,
icon_pos: int,
color: Optional[List[int]] = None,
message: str = ""):
"""An indicator icon for a pyqtgraph ViewBox
The icon loaded from icon_path will be displayed in the low right corner of the ViewBox.
:param parent: ViewBox to place indicator in
:param icon_path: path to icon
:param icon_pos: position index. Counting from 0 in lower right.
"""
super().__init__()
self.parent = parent
self.icon_pos = icon_pos
self.label = QGraphicsSimpleTextItem(message)
self.label.setVisible(False)
self.parent.scene().addItem(self.label)
self.set_icon(icon_path, color)
self.icon_size = [32, 32]
self.parent.scene().addItem(self)
self.position_icon()
self.parent.sigResized.connect(self.position_icon)
self.setVisible(False)
self.setAcceptHoverEvents(True)
self.connected_overlay = None
self.actions: List[QAction] = []
def set_icon(self, icon_path: str, color: Optional[List[int]] = None):
if color is not None:
image_data = skio.imread(icon_path, plugin="imageio")
# Set the RGB part to the red channel multiplied by the requested color
red_channel = image_data[:, :, 0] / 255
image_data[:, :, 0] = red_channel * color[0]
image_data[:, :, 1] = red_channel * color[1]
image_data[:, :, 2] = red_channel * color[2]
h = image_data.shape[0]
w = image_data.shape[1]
image_qi = QImage(image_data.data, w, h, 4 * w,
QImage.Format_RGBA8888)
image_pm = QPixmap.fromImage(image_qi)
self.label.setBrush(QColor(*color))
else:
image_pm = QPixmap(icon_path)
self.setPixmap(image_pm)
def position_icon(self):
# The size of the imageview we are putting the icon ing
scene_size = self.parent.size()
# The position of the image within the scene
scene_pos = self.parent.scenePos()
# Lower right corner in scene pixel coordinates
corner_pos_x = scene_size.width() + scene_pos.x()
corner_pos_y = scene_size.height() + scene_pos.y()
icon_pos_x = corner_pos_x - self.icon_size[0] * (1 +
self.icon_pos) - 10
icon_pos_y = corner_pos_y - self.icon_size[1] - 30
self.setOffset(icon_pos_x, icon_pos_y)
label_width = self.label.boundingRect().width()
self.label.setPos(corner_pos_x - label_width,
icon_pos_y - self.icon_size[0])
def hoverEnterEvent(self, event):
if self.connected_overlay is not None:
self.connected_overlay.setVisible(True)
self.label.setVisible(True)
def hoverLeaveEvent(self, event):
if self.connected_overlay is not None:
self.connected_overlay.setVisible(False)
self.label.setVisible(False)
def add_actions(self, actions: List[Tuple[str, Callable]]):
for text, method in actions:
action = QAction(text)
action.triggered.connect(method)
self.actions.append(action)
def mouseClickEvent(self, event):
event.accept()
if self.actions:
qm = QMenu()
for action in self.actions:
qm.addAction(action)
qm.exec(event.screenPos().toQPoint())
