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)
