def mouseMoveEvent(self, event): if (event.buttons() and Qt.LeftButton) and self.drawing: if self.set_mask: self.setMask() self.set_mask = False painter = QPainter(self._mask) if not painter.isActive(): painter.begin(self) painter.setRenderHint(QPainter.Antialiasing, True) if self.drawMode: painter.setPen( QPen(Qt.white, self.brushSlider.value(), Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) else: painter.setPen( QPen(Qt.black, self.brushSlider.value(), Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) painter.drawLine(self.lastPoint, self.mapToScene(event.pos())) painter.end() self.lastPoint = self.mapToScene(event.pos()) img = np.array(self._current_image, dtype=np.float32) mask = rgb_view(self._mask) channel = self.color_index[self.brushColor] ind = np.all(mask != [0, 0, 0], axis=-1) color = np.array([50, 50, 50], dtype=np.float32) color[channel] = 250 img[ind] = img[ind] * 0.45 + color * 0.55 self._photo.setPixmap(QPixmap(array2qimage(img))) # super(Editor, self).mouseMoveEvent(event)
def postDrawPreview(self, canvas: Qg.QPainter): assert canvas.isActive() dashedPen = Qg.QPen(Qc.Qt.DashLine) dashedPen.setWidthF(1 / self.info['magnification']) # draw the base points canvas.save() canvas.setWorldTransform(self.transf.toQTransform(), True) epsilonSize = 6 / self.info['magnification'] if self.info['autoRecompute'] or not self.curveMode: ctrlPtsColor = 'gray' else: ctrlPtsColor = 'red' canvas.setPen(dashedPen) canvas.drawPath(self.asyPath.toQPainterPath()) nodePen = Qg.QPen(Qg.QColor('blue')) nodePen.setWidthF(1 / self.info['magnification']) ctlPtsPen = Qg.QPen(Qg.QColor(ctrlPtsColor)) ctlPtsPen.setWidthF(1 / self.info['magnification']) for index in range(len(self.asyPath.nodeSet)): point = self.asyPath.nodeSet[index] if point != 'cycle': basePoint = Qc.QPointF(point[0], point[1]) canvas.setPen(nodePen) canvas.drawEllipse(basePoint, epsilonSize, epsilonSize) else: point = self.asyPath.nodeSet[0] basePoint = Qc.QPointF(point[0], point[1]) if self.curveMode: if index != 0: canvas.setPen(ctlPtsPen) postCtrolSet = self.asyPath.controlSet[index - 1][1] postCtrlPoint = Qc.QPointF(postCtrolSet[0], postCtrolSet[1]) canvas.drawEllipse(postCtrlPoint, epsilonSize, epsilonSize) canvas.setPen(dashedPen) canvas.drawLine(basePoint, postCtrlPoint) if index != len(self.asyPath.nodeSet) - 1: canvas.setPen(ctlPtsPen) preCtrlSet = self.asyPath.controlSet[index][0] preCtrlPoint = Qc.QPointF(preCtrlSet[0], preCtrlSet[1]) canvas.drawEllipse(preCtrlPoint, epsilonSize, epsilonSize) canvas.setPen(dashedPen) canvas.drawLine(basePoint, preCtrlPoint) canvas.restore()
def paintEvent(self, event): global frameCounter global timeId painter = QPainter(self) rectPainter = QPainter() boxIdPainter = QPainter() if (self.surface.isActive()): self.surface.paint(painter) else: painter.fillRect(event.rect(), self.palette().window()) if len(player.videobox) > 0 and frameCounter < len(player.videobox): for i in xrange(len(player.videobox[frameCounter].box_id)): if player.videobox[frameCounter].box_id[i] != -1: x,y,w,h = player.videobox[frameCounter].box_Param[i] if not rectPainter.isActive(): rectPainter.begin(self) rectPainter.setRenderHint(QPainter.Antialiasing) rectPainter.setPen(QColor(self.getColorBox(player.videobox[frameCounter].annotation[i]))) rectPainter.drawRect(x,y,w,h) rectPainter.end() if not boxIdPainter.isActive(): boxIdPainter.begin(self) boxIdPainter.setPen(QColor(255,0,0)) boxIdPainter.drawText(QRectF(x+2,y,w,h),Qt.AlignLeft,str(player.videobox[frameCounter].box_id[i])) boxIdPainter.end() if self.moved and not event.rect().size().__eq__(self.surface.surfaceFormat().sizeHint()): if not rectPainter.isActive(): rectPainter.begin(self) rectPainter.setRenderHint(QPainter.Antialiasing) rectPainter.setPen(QColor(0,0,255)) rectPainter.drawRect(event.rect()) rectPainter.end()
def makeSnapshot(self): image = QImage(self.display_widget.size(), QImage.Format_ARGB32) painter = QPainter(image) if painter.isActive(): self.render(painter) painter.end() default_dir = path.join(path.expanduser('~')) filename = QFileDialog.getSaveFileName(self, 'Save Snapshot', default_dir) image.save(filename[0])
def _w_canvas_paint_event(self, qpe: QPaintEvent): painter = QPainter(self.w_canvas) texture = self._texture rect = self._rect if not painter.isActive(): painter.begin(self.w_canvas) if texture['pixmap'] is not None: x, y, w, h = texture['x'], texture['y'], texture['w'], texture['h'] if rect['draw']: painter.setPen(QPen(rect['color'])) painter.drawRect(x, y, w, h) painter.setCompositionMode(self._blend) painter.drawPixmap(x, y, w, h, texture['pixmap']) painter.end()
class PixmapCanvas(QWidget): """ Canvas class for PyQt5. Everything is drawn on QPixmap, meaning the content is stable between updates. There is self.frame_counter available that is incremented every timeout. """ def __init__(self, width=500, height=500, anim_period=-1): super().__init__() self.pixmap = QPixmap(width, height) self.setFixedSize(width, height) self.anim_period = anim_period self.p = QPainter() self.timer = QTimer(self) self.timer.timeout.connect(self.timeout) if anim_period >= 0: self.timer.start(anim_period) self.p.begin(self.pixmap) self.init() self.p.end() self.frame_counter = 0 def init(self): pass def redraw(self): raise NotImplementedError("This method is abstract, you need to implement it.") def background_color(self, color_name): """ Deletes content of the canvas and sets background color. """ activated_here = True if self.p.isActive(): activated_here = False else: self.p.begin(self.pixmap) self.p.fillRect(0, 0, self.width(), self.height(), QColor(color_name)) if activated_here: self.p.end() def timeout(self, *args, **kwargs): """ Calls the redraw() and passes the args and kwargs. """ self.frame_counter += 1 activated_here = True if self.p.isActive(): activated_here = False else: self.p.begin(self.pixmap) self.redraw(*args, **kwargs) if activated_here: self.p.end() self.update() def paintEvent(self, event): self.p.begin(self) self.p.drawPixmap(0, 0, self.pixmap) self.p.end() def resize(self, *args): """ Deletes everything on canvas and sets new size. """ stopped_here = False if self.p.isActive(): self.p.end() stopped_here = True self.setFixedSize(*args) self.pixmap = QPixmap(self.width(), self.height()) if stopped_here: self.p.begin(self.pixmap)
class GraphicsWidget(QWidget): def __init__(self, parent=None, event: dict = None, refresh_rate=60, **kwargs): super().__init__(parent, **kwargs) self.setFocusPolicy(Qt.ClickFocus) self.setMouseTracking(True) self._timer = QTimer(self) self._timer.timeout.connect(self._timer_timeout) self._painter = QPainter(self) self._refresh_rate = 0 self._dt = 0 self._fps = 0 self._frame_count = 0 self._frame_count_p = 0 self._frame_time = 0 self._scale = 1 self._antialiasing = False self._event = dict( painter=lambda: self._painter, scale=lambda: self._scale, mouse=lambda: self._mouse, keyboard=lambda: self._keyboard, dt=lambda: self._dt, fps=lambda: self._fps, ) if event is not None: self._event.update(event) self.set_refresh_rate(refresh_rate) self._mouse = Mouse(self._event) self._keyboard = Keyboard(self._event) self.new = Factory(self._event) @property def debug(self): debug = self._event.get('debug') if debug is not None: return debug() return False @property def event_(self): return self._event @property def pause(self): return not self._timer.isActive() def register_event(self, **kwargs): self._event.update(**kwargs) def set_antialiasing(self, b: bool): self._antialiasing = b def set_scale(self, scale: float): self._scale = scale def set_refresh_rate(self, refresh_rate): self._refresh_rate = 1000 / refresh_rate def set_pause(self, b: bool): if self.debug: print(self.__class__.__name__, 'pause: %a' % b) if b and not self.pause: self._timer.stop() elif self.pause: self._timer.start(self._refresh_rate) @property def dt(self): return self._dt @property def fps(self): return self._fps @property def mouse(self): return self._mouse @property def keyboard(self): return self._keyboard @property def scale(self): return self._scale @property def painter(self): return self._painter def callback_update(self): pass def callback_draw(self): pass def callback_focus(self, b: bool): pass def callback_resize(self, w, h): pass def _timer_timeout(self): now = time.time() self.callback_update() self.repaint() self._dt = time.time() - now self._frame_count += 1 if now - self._frame_time > 1: self._frame_time = now self._fps = self._frame_count - self._frame_count_p self._frame_count_p = self._frame_count self._mouse.reset() self._keyboard.reset() pe = self._event.get('process_events') if pe is not None: pe() @_ignore_on_pause def resizeEvent(self, re: QResizeEvent): super().resizeEvent(re) size = re.size() self.callback_resize(size.width(), size.height()) def showEvent(self, *args): self.set_pause(False) super().showEvent(*args) def hideEvent(self, *args): self.set_pause(True) super().hideEvent(*args) def closeEvent(self, *args): self.set_pause(True) super().closeEvent(*args) @_ignore_on_pause def mouseMoveEvent(self, me: QMouseEvent): super().mouseMoveEvent(me) self._mouse.update(me) @_ignore_on_pause def mousePressEvent(self, me: QMouseEvent): super().mousePressEvent(me) self._mouse.update(me, status=Mouse.STAT_PRESS) @_ignore_on_pause def mouseReleaseEvent(self, me: QMouseEvent): super().mouseReleaseEvent(me) self._mouse.update(me, status=Mouse.STAT_RELEASE) @_ignore_on_pause def keyPressEvent(self, ke: QKeyEvent) -> None: super().keyPressEvent(ke) self._keyboard.update(ke, status=Keyboard.STAT_PRESS) @_ignore_on_pause def keyReleaseEvent(self, ke: QKeyEvent) -> None: super().keyReleaseEvent(ke) self._keyboard.update(ke, status=Keyboard.STAT_RELEASE) @_ignore_on_pause def focusInEvent(self, *args): super().focusInEvent(*args) self.callback_focus(True) @_ignore_on_pause def focusOutEvent(self, *args): super().focusOutEvent(*args) self.callback_focus(False) def paintEvent(self, *args): super().paintEvent(*args) self._painter = QPainter(self) if self._antialiasing: self._painter.setRenderHint(QPainter.Antialiasing) if not self._painter.isActive(): self._painter.begin(self) self.callback_draw() self._painter.end()
class PixmapCanvas(QWidget): """ Canvas class for PyQt5. Everything is drawn on QPixmap, meaning the content is stable between updates. """ def __init__(self, width=500, height=500, init_func=None, update_func=None, anim_period=-1): """ Parameters ---------- width : int Width of the canvas height : int Height of the canvas init_func : callable(c: PixmapCanvas) Init function for the canvas, is called once, painter is available (c.p) update_func : callable(c: PixmapCanvas, *args, **kwargs) This is called every time the timeout() method is called. It is called by timer or manually. Painter is available (c.p) anim_period : int animation period in ms, if 0, timer is not initialized """ super().__init__() self.pixmap = QPixmap(width, height) self.setFixedSize(width, height) self.init_func = init_func if init_func else lambda widget: None self.update_func = update_func if update_func else lambda widget: None self.anim_period = anim_period self.p = QPainter() self.timer = None if anim_period >= 0: self.timer = QTimer(self) self.timer.timeout.connect(self.timeout) self.timer.start(anim_period) self.p.begin(self.pixmap) self.init_func(self) self.p.end() def background_color(self, color_name): """ Deletes content of the canvas and sets background color. """ activated_here = True if self.p.isActive(): activated_here = False else: self.p.begin(self.pixmap) self.p.fillRect(0, 0, self.width(), self.height(), QColor(color_name)) if activated_here: self.p.end() def timeout(self, *args, **kwargs): """ Calls the update_func() and passes the args and kwargs. """ activated_here = True if self.p.isActive(): activated_here = False else: self.p.begin(self.pixmap) self.update_func(self, *args, **kwargs) if activated_here: self.p.end() self.update() def paintEvent(self, event): self.p.begin(self) self.p.drawPixmap(0, 0, self.pixmap) self.p.end() def resize(self, *args): """ Deletes everything on canvas and sets new size. """ stopped_here = False if self.p.isActive(): self.p.end() stopped_here = True self.setFixedSize(*args) self.pixmap = QPixmap(self.width(), self.height()) if stopped_here: self.p.begin(self.pixmap)