def nextFrame(self):
mouse_pos = self.mapFromGlobal(QCursor.pos())
mouse_x = mouse_pos.x()
mouse_y = mouse_pos.y()
self.x1 = mouse_x
self.y1 = mouse_y
self.radius1 = self.radius1 + math.sin(self.frame_count / 8) * 4
delay = 20
self.x2 += (mouse_x - self.x2) / delay
self.y2 += (mouse_y - self.y2) / delay
self.frame_count += 1
if self.paint_image.width() != self.width() or self.paint_image.height() != self.height():
self.paint_image = QPixmap(self.width(), self.height())
self.paint_image.fill(self.background_color)
p = QPainter()
p.begin(self.paint_image) # auf das paint_image malen
p.setBackground(self.background_color) # color when stuff is erased
# Hintergrund löschen, wenn Rechteck bei der Maus angekommen ist
# print("{0}, {1}".format(self.x2, mouse_x))
if round(self.x2) == mouse_x and round(self.y2) == mouse_y:
p.eraseRect(0, 0, self.paint_image.width(), self.paint_image.height())
self.drawFrame(p)
p.end()
self.repaint()
def paintEvent(self, event):
side = min(self.width(), self.height())
stime = QTime.currentTime().msec()
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
#painter.translate(self.width() / 2, self.height() / 2)
#painter.scale(side / 200.0, side / 200.0)
painter.eraseRect( self.rect())
painter.save()
#New Pen, because we want to set multiple properties : color and width
p = QPen(self.TimerColor)
p.setWidth(10)
# Use our pen
painter.setPen( p )
# Angle specified in 1/16th of a degree, so scale it up
painter.drawArc(0, 0, 40, 40, 16.0 * 360 * stime / 1000, 120 * 16.0)
painter.restore()
#This be where object rendering happens, iter through obj collection
self.lockShapes.acquire()
try:
for s in self.shapes:
s.Render(painter, self.scale )
finally:
self.lockShapes.release()
def paintEvent(self, ev):
super(TagsLabelWidget, self).paintEvent(ev)
painter = QPainter(self)
painter.save()
try:
painter.setBackground(self.palette().brush(self.backgroundRole()))
painter.eraseRect(ev.rect())
painter.setClipRect(ev.rect())
fm = QFontMetrics(self.font()) # TODO use style
x = self.xmargin
for sz, tag in self._positions(self.tags):
fg, bg = tag_to_colors(tag)
painter.setPen(fg.color())
painter.fillRect(x, self.ymargin,
sz.width() + 2 * self.xpadding, fm.height(),
bg.color())
painter.drawText(x + self.xpadding, self.ymargin + fm.ascent(),
tag)
x += sz.width() + self.xmargin + 2 * self.xpadding
finally:
painter.restore()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.HighQualityAntialiasing, False)
painter.eraseRect(0, 0, self.viewPort.getWidth(),
self.viewPort.getHeight())
painter.fillRect(event.rect(), Qt.white)
pen = QPen()
pen.setColor(QColor(128, 128, 128))
painter.setPen(pen)
painter.drawRect(0, 0, self.viewPort.getWidth(),
self.viewPort.getHeight())
if self.model is not None:
ao = self.model.getObservedAgent()
if ao is not None:
self.updateViewPort(ao)
self.drawEnvironment(painter, self.model.environment)
self.drawAgents(painter, self.model.agents)
self.drawGradient(painter, self.model.environment)
painter.end()
def drawAxisLines(self):
if self.pixmap is None:
painter = QPainter()
else:
painter = QPainter(self.pixmap)
painter.eraseRect(self.frame)
painter.setPen(Qt.darkGray)
# Draw box outline.
painter.drawRect(self.frame)
# Draw horizonal zero voltage line.
painter.drawLine(self.frame.left(),
self.frame.center().y(), self.frame.right(),
self.frame.center().y())
# Draw vertical lines at 0 ms and 1 ms.
painter.drawLine(
self.frame.left() + (1.0 / 3.0) *
(self.frame.right() - self.frame.left()) + 1, self.frame.top(),
self.frame.left() + (1.0 / 3.0) *
(self.frame.right() - self.frame.left()) + 1, self.frame.bottom())
painter.drawLine(
self.frame.left() + (2.0 / 3.0) *
(self.frame.right() - self.frame.left()) + 1, self.frame.top(),
self.frame.left() + (2.0 / 3.0) *
(self.frame.right() - self.frame.left()) + 1, self.frame.bottom())
self.update()
class DigitImage(QLabel):
def __init__(self, *args):
super().__init__(*args)
self.setFixedSize(200, 200)
self.setStyleSheet('border: 3px solid grey;')
@pyqtSlot(int)
def drawDigit(self, digit):
print(digit)
self.painter = QPainter(self.pixmap())
self.painter.begin(self.pixmap())
font = self.painter.font()
font.setPointSize(60)
self.painter.setFont(font)
self.painter.drawText(self.rect(), QtCore.Qt.AlignCenter, str(digit))
self.painter.end()
self.repaint()
@pyqtSlot()
def clear(self):
self.painter.begin(self.pixmap())
self.painter.eraseRect(self.rect())
self.painter.end()
self.repaint()
def from_svg_bytes(self, svg_bytes):
"""Paints an svg from a bytes object"""
renderer = QSvgRenderer(svg_bytes)
painter = QPainter(self)
painter.eraseRect(self.rect())
renderer.render(painter)
painter.end()
def load_svg_sized_pixmap(path, w=100, h=100):
svg_renderer = QSvgRenderer(path)
image = QImage(w, h, QImage.Format_ARGB32)
painter = QPainter(image)
painter.eraseRect(0, 0, w, h)
svg_renderer.render(painter)
painter.end()
return QPixmap.fromImage(image)
def paintEvent(self, event):
painter = QPainter(self)
if self.layer is not None:
painter.resetTransform()
painter.drawImage(self.rect(), self.qImage)
self.drawShapes(painter)
else:
painter.eraseRect(self.rect())
def clearCanvas(self):
self.last_click = None
self.first_click = None
self.lineCount = 0
painter = QPainter(self.pixmap())
painter.eraseRect(0, 0, self.canvas_size, self.canvas_size)
painter.drawPixmap(0, 0, self.OGpixmap)
painter.end()
self.update()
def clear(self):
self.last_click = None
self.first_click = None
self.lineCount = 0
self.array = np.zeros((512,512,3), dtype=np.uint8)
painter = QPainter(self.pixmap())
painter.eraseRect(0,0,512,512)
painter.drawPixmap(0,0,self.OGpixmap)
painter.end()
self.update()
def paintEvent(self, event):
q = QPainter(self)
p = QPen()
p.setStyle(Qt.SolidLine)
p.setWidth(5)
q.setPen(p)
if (self.isErase):
q.eraseRect(self.rect())
self.isErase = False
for pos in self.chosen_points:
q.drawPoint(pos)
def paintEvent(self, event: QPaintEvent) -> None:
qp = QPainter()
qp.begin(self)
if self.mouse_start_pos is not None and self.mouse_curr_pos is not None:
qp.drawRect(
QRect(self.mouse_start_pos.x(), self.mouse_start_pos.y(),
self.mouse_curr_pos.x() - self.mouse_start_pos.x(),
self.mouse_curr_pos.y() - self.mouse_start_pos.y()))
# print('start:', (self.mouse_start_pos.x(), self.mouse_start_pos.y()),
# '\tend:', (self.mouse_curr_pos.x(), self.mouse_curr_pos.y()))
else:
qp.eraseRect(0, 0, self.screenHeight, self.screenWidth)
qp.end()
def click_del(self):
if len(self.selectedTop) != 0:
for x in self.selectedTop:
self.brushColor = Qt.white
painter = QPainter(self.image)
self.pen(painter)
#clear deleting top
painter.drawEllipse(x.x() - Constant.rad / 2,
x.y() - Constant.rad / 2, Constant.rad,
Constant.rad)
# clear conection lines
for rib in x.list:
painter.drawLine(rib.to.x(), rib.to.y(), x.x(), x.y())
for k in range(self.countParam):
painter.eraseRect(
QRectF((x.x() + rib.to.x()) / 2 + 5,
(x.y() + rib.to.y()) / 2 - 15, 50,
10 * self.countParam))
painter.eraseRect(
QRectF(x.x() - 15,
x.y() - 15, Constant.rad * 2, Constant.rad * 2))
# restore adjacent circles
self.brushColor = Qt.blue
self.pen(painter)
for rib in x.list:
painter.drawEllipse(rib.to.x() - Constant.rad / 2,
rib.to.y() - Constant.rad / 2,
Constant.rad, Constant.rad)
self.brushColor = Qt.black
self.pen(painter)
painter.drawText(QPointF(rib.to.x(), rib.to.y()),
str(rib.to.getNumber()))
self.graph.delete(x)
self.selectedTop.clear()
else:
self.graph.deleteAll()
self.image.fill(Qt.white)
self.countCom = 0
self.countCity = 0
self.initNeed()
self.update()
def mouseReleaseEvent(self, event):
X = 1920 - 2 * event.y()
Y = 2 * event.x()
print("(%s, %s) %s" % (X, Y, datetime.now()))
print("release")
message = json.dumps({
"x": X,
"y": Y,
"time": time.time(),
"mouse": "release"
})
self.sock.sendto(message.encode(), self.udpaddr)
painter = QPainter(self.image)
painter.eraseRect(self.rect())
self.drawing = False
def screenshot(self):
self.scene.clearSelection()
image = QImage(self.centralWidget().size(),
QtGui.QImage.Format_ARGB32_Premultiplied)
painter = QPainter()
painter.begin(image)
painter.eraseRect(self.centralWidget().rect())
painter.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.centralWidget().render(painter)
painter.end()
(file_path,
file_format) = QFileDialog.getSaveFileName(self, 'Save file',
self.drawer.label + '.png',
".png")
if (file_path != ''):
if (image.save(file_path, "PNG", 100)):
message = QMessageBox.about(self, self.drawer.label,
"Screenshot saved")
def paintEvent(self, event: QPaintEvent):
height = self.height()
painter = QPainter(self)
pen: QPen = painter.pen()
blockColor = QColor(0, 0, 0, 255)
painter.eraseRect(0, 0, self.width(), height)
self.renderBegin.emit(painter)
for poly in reversed(self.polygonFactory):
if len(poly.points) > 0:
r, g, b, a = poly.fillColor
if poly.has_cache and a != 0:
col = QColor(r, g, b, a)
pen.setColor(blockColor)
painter.setPen(pen)
for y, x1, x2 in poly.cachedLines:
y = height - y
painter.fillRect(
x1,
y,
x2 - x1,
1,
col
)
r, g, b, a = poly.outlineColor
if poly.outlineThickness > 0 and a != 0:
pen.setColor(QColor(r, g, b, a))
pen.setWidth(poly.outlineThickness)
painter.setPen(pen)
points = [QPoint(i.x, height - i.y) for i in poly.points]
painter.drawPolygon(points[0], *points[1:])
self.renderEnd.emit(painter)
def draw_on_canvas(self):
current_pos = QPoint(self.mouse_x, self.mouse_y)
if self.current_canvas_name == 'sketch':
if self.line_mode == 'straight' and self.mode == 'inputSketch':
self.sketch_canvas = self.tmp_sketch_canvas.copy()
painter = QPainter(self.sketch_canvas)
painter.setPen(
QPen(self.color, self.brushSize, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
elif self.current_canvas_name == 'detail':
if self.line_mode == 'straight' and self.mode == 'inputDetail':
self.detail_canvas = self.tmp_detail_canvas.copy()
painter = QPainter(self.detail_canvas)
painter.setPen(
QPen(self.color, self.brushSize, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
if self.mode == 'inputErase':
r = QRect(QPoint(), self._clear_size * QSize())
r.moveCenter(current_pos)
painter.save()
painter.setCompositionMode(QPainter.CompositionMode_Clear)
painter.eraseRect(r)
painter.restore()
elif self.line_mode == 'straight':
painter.drawLine(self.start_pos, current_pos)
elif self.line_mode == 'free':
painter.drawLine(self.last_pos, current_pos)
else:
pass
painter.end()
self.last_pos = QPoint(self.mouse_x, self.mouse_y)
def drawGradients(self, painter: QPainter):
painter.setBackground(QBrush(Qt.cyan))
painter.eraseRect(0, 0, self.width(), self.height())
grad1 = QLinearGradient(0, 20, 0, 110)
grad1.setColorAt(0.1, Qt.black)
grad1.setColorAt(0.5, Qt.yellow)
grad1.setColorAt(0.9, Qt.black)
painter.fillRect(20, 20, 300, 90, grad1)
grad2 = QLinearGradient(0, 55, 250, 0)
grad2.setColorAt(0.2, Qt.black)
grad2.setColorAt(0.5, Qt.red)
grad2.setColorAt(0.8, Qt.black)
painter.fillRect(20, 140, 300, 100, grad2)
grad3 = QLinearGradient(0, 280, 0, 380)
grad3.setColorAt(0.1, QColor(0xcc, 0xcc, 0xcc, 156))
grad3.setColorAt(0.8, QColor(0xcc, 0xcc, 0xcc, 0))
painter.fillRect(20, 280, 300, 100, grad3)
def paintEvent(self, event):
painter = QPainter(self)
# erase background
painter.setBackground(QBrush(Layer.color(LayerType.background)))
painter.setClipping(True)
painter.eraseRect(self.rect())
# draw document
if self._ctrl is not None:
# draw grid
painter.setRenderHint(QPainter.Antialiasing, False)
pen = QPen(Layer.color(LayerType.grid))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setTransform(self._transform)
painter.setPen(pen)
self._drawGrid(painter)
# draw drawables
# painter.setRenderHint(QPainter.Antialiasing)
for d in self._ctrl.getDrawables():
d.draw(painter)
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
# erase background
painter.setBackground(QBrush(Layer.color(LayerType.background)))
painter.setClipping(True)
painter.eraseRect(self.rect())
# draw document
if self._ctrl is not None:
# draw grid
painter.setRenderHint(QPainter.Antialiasing, False)
pen = QPen(Layer.color(LayerType.grid))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setTransform(self._transform)
painter.setPen(pen)
self._drawGrid(painter)
# draw drawables
# painter.setRenderHint(QPainter.Antialiasing)
for d in self._ctrl.getDrawables():
d.draw(painter)
painter.end()
def paintEvent(self, e):
tabOverlap = QStyleOptionTab()
tabOverlap.shape = QTabBar.RoundedNorth
optTabBase = QStyleOptionTabBarBase()
optTabBase.initFrom(self)
optTabBase.shape = QTabBar.RoundedNorth
optTabBase.tabBarRect = QRect()
painter = QPainter(self)
selected = (0, 0)
for i in range(len(self.__tabList)):
for j in range(len(self.__tabList[i])):
tab = self.__getStyleOption(i, j)
if not (tab.state & QStyle.State_Enabled):
tab.palette.setCurrentColorGroup(QPalette.Disabled)
optTabBase.tabBarRect |= tab.rect
if (i, j) == self.__selectedIndex:
selected = (i, j)
optTabBase.selectedTabRect = tab.rect
continue
self.style().drawControl(QStyle.CE_TabBarTab, tab, painter,
self)
if selected != (-1, -1):
for j in range(len(self.__tabList[selected[0]])):
tab = self.__getStyleOption(selected[0], j)
self.style().drawControl(QStyle.CE_TabBarTab, tab, painter,
self)
tab = self.__getStyleOption(selected[0], selected[1])
painter.eraseRect(tab.rect)
self.style().drawControl(QStyle.CE_TabBarTab, tab, painter, self)
def drawOnCanvas(self, points):
"""
Performs drawing on canvas.
"""
painter = QPainter(self.pixmap())
if self.antialiasing_status:
painter.setRenderHint(QPainter.Antialiasing)
if self.eraser_selected == False:
pen = QPen(QColor(self.pen_color), self.pen_width)
painter.setPen(pen)
painter.drawLine(self.last_mouse_pos, points)
# Update the mouse's position for next movement
self.last_mouse_pos = points
elif self.eraser_selected == True:
# Use the eraser
eraser = QRect(points.x(), points.y(), 12, 12)
painter.eraseRect(eraser)
painter.end()
self.update()
def refreshPixmap(self):
# Pixel map used for double buffering.
self.pixmap = QPixmap(self.size())
self.pixmap.fill()
painter = QPainter(self.pixmap)
# Clear old display.
painter.eraseRect(self.rect())
# Draw box around entire display.
painter.setPen(Qt.darkGray)
r = QRect(self.rect())
r.adjust(0, 0, -1, -1)
painter.drawRect(r)
# Plot all frames.
for i in range(
len(self.frameList[self.numFramesIndex[self.selectedPort]])):
self.drawAxes(painter, i)
self.tPosition = 0
self.update()
class dibujito(QtWidgets.QMainWindow, Ui_MainWindow):
def __init__(self):
super().__init__()
self.setupUi(self)
self.mapa = QPixmap(700, 700)
self.mapa.fill(QColor('WHITE'))
self.label.setPixmap(self.mapa)
self.painter = QPainter(self.label.pixmap())
pen = QPen()
pen.setWidth(3)
pen.setColor(QColor('#7584F3'))
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.setPen(pen)
cordenada = threading.Thread(daemon=True, target=union_puntos)
cordenada.start()
self.pushButton.clicked.connect(self.apachado)
def paint(self, suma_x, suma_y):
global x, y
try:
self.painter.drawLine(x, y, x + suma_x, y + suma_y)
self.update()
x = suma_x + x
if x < 10:
x = 700
elif x >= 700:
x = 10
y = y + suma_y
if y < 10:
y = 700
elif y >= 700:
y = 10
except:
print('error pintar')
def apachado(self):
self.painter.eraseRect(0, 0, 700, 700)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBackground(QColor(52, 170, 253))
painter.eraseRect(painter.viewport())
painter.drawPixmap(QPoint(0, 0), self.__background)
qfont = QFont("Arial")
qfont.setPixelSize(72)
qfont.setBold(QFont.Bold)
self.__paint_outlined_text(painter, QPoint(150, 110), qfont, "UML")
qfont.setPixelSize(45)
self.__paint_outlined_text(painter, QPoint(330, 110), qfont, ".FRI")
self.__paint_outlined_text(painter, QPoint(450, 110), qfont, Application().about.version.major_minor_string)
painter.end()
super().paintEvent(event)
def paintEvent(self, event):
width = self.width()
height = self.height()
center = QPoint((width + 1) / 2, (height + 1) / 2)
diameterBpm = width - 2
if (height < width):
diameterBpm = height - 2
widthBeam = diameterBpm * (self.beamWidth / self.bpmDiameter)
heightBeam = diameterBpm * (self.beamHeight / self.bpmDiameter)
horizontalGapWidth = diameterBpm * (self.bpmHorizontalGap /
self.bpmDiameter)
horizontalGap = QRect(center.x() + 1 - horizontalGapWidth / 2,
center.y() - diameterBpm / 2, horizontalGapWidth,
diameterBpm + 2)
verticalGapWidth = diameterBpm * (self.bpmVerticalGap /
self.bpmDiameter)
verticalGap = QRect(center.x() - 1 - diameterBpm / 2,
center.y() + 1 - verticalGapWidth / 2,
diameterBpm + 2, verticalGapWidth)
posX = center.x() + self.beamPosX * center.x() / 2
posY = center.y() + self.beamPosY * center.y() / 2
painter = QPainter()
painter.begin(self)
painter.setPen(QPen(Qt.white))
painter.setBrush(Qt.white)
painter.drawEllipse(center, diameterBpm / 2, diameterBpm / 2)
painter.eraseRect(horizontalGap)
painter.eraseRect(verticalGap)
if (abs(self.beamPosX) <= 1 and abs(self.beamPosY) <= 1):
painter.setPen(QPen(Qt.red))
painter.setBrush(Qt.transparent)
painter.drawEllipse(posX + 1 - widthBeam / 2,
posY + 1 - heightBeam / 2, widthBeam,
heightBeam)
painter.end()
def drawWaveforms(self):
painter = QPainter(self.pixmap)
length = Rhd2000DataBlock.getSamplesPerDataBlock(
) * self.numUsbBlocksToPlot
polyline = [0] * (length + 1)
# Assume all frames are the same size.
yAxisLength = (self.frameList[self.numFramesIndex[self.selectedPort]]
[0].height() - 2) / 2.0
tAxisLength = self.frameList[self.numFramesIndex[
self.selectedPort]][0].width() - 1
for j in range(
len(self.frameList[self.numFramesIndex[self.selectedPort]])):
stream = self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).boardStream
channel = self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).chipChannel
stype = self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).signalType
if self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).enabled:
xOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].left() + 1
xOffset += self.tPosition * tAxisLength / self.tScale
# Set clipping region
adjustedFrame = copy(
self.frameList[self.numFramesIndex[self.selectedPort]][j])
adjustedFrame.adjust(0, 1, 0, 0)
painter.setClipRect(adjustedFrame)
# Erase segment of old wavefrom
eraseBlock = copy(adjustedFrame)
eraseBlock.setLeft(xOffset)
eraseBlock.setRight(
(tAxisLength * (1000.0 / self.sampleRate) / self.tScale) *
(length - 1) + xOffset)
painter.eraseRect(eraseBlock)
# Redraw y = 0 axis
self.drawAxisLines(painter, j)
if stype == constants.AmplifierSignal:
# Plot RHD2000 amplifier waveform
tStepMsec = 1000.0 / self.sampleRate
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -yAxisLength / self.yScale
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].center().y()
# build waveform
for i in range(length):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset,
yScaleFactor * self.signalProcessor.
amplifierPostFilter[stream][channel][i] + yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.
selectedPort]] = self.signalProcessor.amplifierPostFilter[
stream][channel][length - 1]
# draw waveform
painter.setPen(Qt.blue)
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.AuxInputSignal:
# Plot RHD2000 auxiliary input signal
tStepMsec = 1000.0 / (self.sampleRate / 4)
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 2.5
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom()
# build waveform
for i in range(length / 4):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset, yScaleFactor *
self.signalProcessor.auxChannel[stream][channel][i]
+ yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] = self.signalProcessor.auxChannel[
stream][channel][(length / 4) - 1]
# draw waveform
pen = QPen()
pen.setColor(QColor(200, 50, 50))
painter.setPen(pen)
polyline = polyline[:(length // 4) + 1]
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.SupplyVoltageSignal:
# Plot RHD2000 supply voltage signal
tStepMsec = 1000.0 / (self.sampleRate / 60.0)
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 1.5
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom()
voltageLow = False
voltageOutOfRange = False
# build waveform
for i in range(length / 60):
voltage = self.signalProcessor.supplyVoltage[stream][i]
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset,
yScaleFactor * (voltage - 2.5) + yOffset)
if voltage < 2.9 or voltage > 3.6:
voltageOutOfRange = True
elif voltage < 3.2:
voltageLow = True
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor *
(self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] - 2.5) + yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.
selectedPort]] = self.signalProcessor.supplyVoltage[
stream][(length / 60) - 1]
# draw waveform
painter.setPen(Qt.green)
if voltageLow:
painter.setPen(Qt.yellow)
if voltageOutOfRange:
painter.setPen(Qt.red)
polyline = polyline[:(length // 60) + 1]
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.BoardAdcSignal:
# Plot USB interface board ADC input signal
tStepMsec = 1000.0 / self.sampleRate
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 3.3
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom()
# build waveform
for i in range(length):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset, yScaleFactor *
self.signalProcessor.boardAdc[channel][i] +
yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] = self.signalProcessor.boardAdc[
channel][length - 1]
# draw waveform
painter.setPen(Qt.darkGreen)
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.BoardDigInSignal:
# Plot USB interface board digital input signal
tStepMsec = 1000.0 / self.sampleRate
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 2.0
yOffset = (self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom() +
self.frameList[self.numFramesIndex[
self.selectedPort]][j].center().y()) / 2.0
# build waveform
for i in range(length):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset, yScaleFactor *
self.signalProcessor.boardDigIn[channel][i] +
yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] = self.signalProcessor.boardDigIn[
channel][length - 1]
# draw waveform
pen = QPen()
pen.setColor(QColor(200, 50, 200))
painter.setPen(pen)
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
painter.setClipping(False)
tStepMsec = 1000.0 / self.sampleRate
self.tPosition += length * tStepMsec
if self.tPosition >= self.tScale:
self.tPosition = 0.0
class MorphingApp(QMainWindow, Ui_Dialog):
img1=None
img2=None
def __init__(self, parent=None):
super(MorphingApp, self).__init__(parent)
self.setupUi(self)
self.slidervalue=0
# self.loadimg1()
self.load_start.clicked.connect(self.loadimg1)
self.load_end.clicked.connect(self.loadimg2)
self.alpha.setMaximum(100)
self.alpha.setMinimum(0)
self.alpha.setSingleStep(5)
slidervalue=self.alpha.value()/100.0
self.alpha_value.setText('%.2f'%slidervalue)
self.alpha.valueChanged.connect(self.valChangeHandler)
self.start_image.mousePressEvent=self.image1ClickHandler
self.end_image.mousePressEvent=self.image2ClickHandler
self.blending.clicked.connect(self.blendingBtnHandler)
self.show_triangles.toggled.connect(self.checkboxChangeHandler)
self.MarkLeft=1
self.numPoints=0
self.comfirmedLen=0
self.fromfileLen=0
self.leftPoints=[]
self.rightPoints = []
self.qp= QPainter()
self.keyPressEvent=self.backspaceHandler
self.leftPath=''
self.rightPath=''
self.allowbland=0
self.itemArr=[]
self.previndex=0
def checkboxChangeHandler(self):
try:
self.draw1()
self.draw2()
except Exception as e:
pass
def mousePressEvent(self,event):
if self.img1 == None or self.img2 == None:
# self.leftPoints = []
self.MarkLeft = 233
return
self.comfirmedLen=min(len(self.rightPoints),len(self.leftPoints))
self.writePoints()
try:
self.draw1()
self.draw2()
except Exception as e:
pass
def image1ClickHandler(self,event):
print('%d %d' % (self.fromfileLen, self.comfirmedLen))
if os.path.exists(self.leftPath + '.png.txt') and os.path.exists(
self.rightPath + '.png.txt') and self.img1 != None and self.img2 != None:
self.allowbland = 1
self.comfirmedLen = len(self.leftPoints)
if self.MarkLeft==1:
# save point info
print('click detect1')
print(event.localPos())
print(self.img1)
if self.img1==None or self.img2 ==None:
self.leftPoints=[]
self.MarkLeft = 233
return
self.leftPoints.append(event.localPos())
self.MarkLeft=0
self.writePoints()
try:
self.draw1()
self.draw2()
except Exception as e:
pass
else:
pass
def image2ClickHandler(self,event):
print('%d %d' % (self.fromfileLen,self.comfirmedLen))
if os.path.exists(self.leftPath + '.png.txt') and os.path.exists(
self.rightPath + '.png.txt') and self.img1 != None and self.img2 != None:
self.allowbland = 1
self.comfirmedLen=max(len(self.rightPoints),len(self.leftPoints))-1
if self.MarkLeft ==0:
print('click detect2')
print(event.localPos())
if self.img1==None or self.img2 ==None:
self.rightPoints=[]
self.MarkLeft = 233
return
self.rightPoints.append(event.localPos())
self.MarkLeft=1
self.writePoints()
try:
self.draw1()
self.draw2()
except Exception as e:
pass
else:
pass
def backspaceHandler(self,event):
if self.img1 == None or self.img2 == None:
return
print('%d %d'%(len(self.leftPoints),len(self.rightPoints)))
if not event.key() ==Qt.Key_Backspace:
return
print('backspace pressed')
if self.comfirmedLen==max(len(self.rightPoints),len(self.leftPoints)):
return
if len(self.leftPoints)==len(self.rightPoints):
self.rightPoints=self.rightPoints[0:len(self.rightPoints)-1]
self.draw2()
self.MarkLeft=0
return
if len(self.leftPoints)>len(self.rightPoints):
self.leftPoints=self.leftPoints[0:len(self.leftPoints)-1]
self.draw1()
self.MarkLeft = 1
return
def valChangeHandler(self):
self.slidervalue=self.alpha.value()/100.0
index=int(self.slidervalue/0.05)
if index==self.previndex:
return
self.alpha_value.setText('%.2f'%self.slidervalue)
if len(self.itemArr)!=21:
return
self.qp.eraseRect(QRectF(QPointF(0, 0), QPointF(480, 360)))
newImg=self.itemArr[index]
# print(index)
self.imabland = QImage.fromData(newImg)
self.imabland= QImage(newImg.data, newImg.shape[1], newImg.shape[0], newImg.strides[0], QImage.Format_RGB888);
self.imabland=self.imabland.scaledToWidth(480-2)
self.imabland=self.imabland.scaledToHeight(360-2)
self.imabland=QPixmap.fromImage(self.imabland)
self.MarkLeft=1
self.blend_image.scene = QGraphicsScene() # ???????????
item = QGraphicsPixmapItem(self.imabland) # ????????????????
self.blend_image.scene.addItem(item) # ??????????scene??
self.blend_image.setScene(self.blend_image.scene)
def loadimg1(self):
self.image1 = QPixmap()
sz = QSize(720, 540)
path, _ = QFileDialog.getOpenFileName(self, 'choose image', None, 'Image files(*.jpg *.gif *.png)')
self.leftPath=path[0:len(path)-4]
# leftImage = imageio.imread(self.leftPath + '.png')
# print(leftImage)
print(self.leftPath)
with open(path,'rb') as fp:
img=fp.read()
self.imageee1 = QImage.fromData(img)
self.imageee1=self.imageee1.scaledToWidth(480-2)
self.imageee1=self.imageee1.scaledToHeight(360-2)
self.img1=self.imageee1
self.image1=QPixmap.fromImage(self.imageee1)
self.MarkLeft=1
self.start_image.scene = QGraphicsScene() # ???????????
item = QGraphicsPixmapItem(self.image1) # ????????????????
self.start_image.scene.addItem(item) # ??????????scene??
self.start_image.setScene(self.start_image.scene)
if self.img1!=None and self.img2!=None:
self.loadPoints()
def loadimg2(self):
self.image2 = QPixmap()
path, _ = QFileDialog.getOpenFileName(self, 'choose image', None, 'Image files(*.jpg *.gif *.png)')
self.rightPath=path[0:len(path)-4]
with open(path,'rb') as fp:
img=fp.read()
self.imageee2 = QImage.fromData(img)
self.imageee2=self.imageee2.scaledToWidth(480-2)
self.imageee2=self.imageee2.scaledToHeight(360-2)
self.img2 = self.imageee2
self.image2=QPixmap.fromImage(self.imageee2)
self.end_image.scene = QGraphicsScene() # ???????????
item = QGraphicsPixmapItem(self.image2) # ????????????????
self.end_image.scene.addItem(item) # ??????????scene??
self.MarkLeft=1
self.end_image.setScene(self.end_image.scene)
if self.img1!=None and self.img2!=None:
self.loadPoints()
# def operatePointsFile(self):
# self.numPoints=min(len(self.rightPoints),len(self.leftPoints))
# if os.path.exists(self.leftPath+'.txt') and os.path.exists(self.rightPath+'.txt'):
# # tris=loadTriangles(self.leftPath+'.txt',self.rightPath+'.txt')
# pointL = np.loadtxt(self.leftPath+'.txt', dtype=np.float64)
# pointR = np.loadtxt(self.rightPath+'.txt', dtype=np.float64)
# self.rightPoints=[]
# self.leftPoints=[]
# for lp in pointL:
# self.leftPoints.append(QPointF(lp[0]/3,lp[1]/3))
# for rp in pointR:
# self.rightPoints.append(QPointF(rp[0]/3,rp[1]/3))
# self.draw1()
# self.draw2()
# print(self.numPoints)
# print(self.rightPoints)
# else:
# self.writePoints()
def draw1(self):
self.qp.eraseRect(QRectF(QPointF(0, 0), QPointF(480, 360)))
with open(self.leftPath+'.png', 'rb') as fp:
img = fp.read()
self.imageee1 = QImage.fromData(img)
self.imageee1=self.imageee1.scaledToWidth(480-2)
self.imageee1=self.imageee1.scaledToHeight(360-2)
self.img1=self.imageee1
self.qp.begin(self.img1)
self.qp.setPen(Qt.red)
# self.qp.eraseRect(QRectF(QPointF(0, 0), QPointF(480, 360)))
for i in range(0,len(self.leftPoints)):
if i<self.fromfileLen:
self.qp.setPen(Qt.red)
elif i < self.comfirmedLen:
self.qp.setPen(Qt.blue)
else:
self.qp.setPen(Qt.green)
self.qp.drawEllipse(self.leftPoints[i], 2, 2)
# self.qp.drawPoint(point)
if self.show_triangles.isChecked()==True:
self.qp.setPen(Qt.yellow)
try:
tris=loadTrianglesResize(self.leftPath+'.png.txt', self.rightPath+'.png.txt')
except Exception as e:
return
print(len(tris[0]))
print(self.comfirmedLen)
for tri in tris[0]:
tri=tri.vertices
# print(tri)
self.qp.drawLine(tri[0][0],tri[0][1],tri[1][0],tri[1][1])
self.qp.drawLine(tri[0][0], tri[0][1], tri[2][0], tri[2][1])
self.qp.drawLine(tri[1][0], tri[1][1], tri[2][0], tri[2][1])
self.qp.end()
item = QGraphicsPixmapItem(self.image1) # ????????????????
self.start_image.scene.addItem(item) # ??????????scene??
self.start_image.scene.addPixmap(QPixmap.fromImage(self.img1))
self.start_image.setScene(self.start_image.scene)
self.update()
if os.path.exists(self.leftPath + '.png.txt') and os.path.exists(
self.rightPath + '.png.txt') and self.img1 != None and self.img2 != None:
self.allowbland = 1
# QGraphicsScene.removeItem()
def draw2(self):
with open(self.rightPath + '.png', 'rb') as fp:
img = fp.read()
self.imageee2 = QImage.fromData(img)
self.imageee2 = self.imageee2.scaledToWidth(480 - 2)
self.imageee2 = self.imageee2.scaledToHeight(360 - 2)
self.img2=self.imageee2
self.qp.begin(self.img2)
self.qp.setPen(Qt.green)
for i in range(0,len(self.rightPoints)):
if i<self.fromfileLen:
self.qp.setPen(Qt.red)
elif i < self.comfirmedLen:
self.qp.setPen(Qt.blue)
else:
self.qp.setPen(Qt.green)
self.qp.drawEllipse(self.rightPoints[i], 2, 2)
if self.show_triangles.isChecked() == True:
self.qp.setPen(Qt.yellow)
try:
tris = loadTrianglesResize(self.leftPath + '.png.txt', self.rightPath + '.png.txt')
except Exception as e:
return
for tri in tris[1]:
tri = tri.vertices
# print(tri)
self.qp.drawLine(tri[0][0], tri[0][1], tri[1][0], tri[1][1])
self.qp.drawLine(tri[0][0], tri[0][1], tri[2][0], tri[2][1])
self.qp.drawLine(tri[1][0], tri[1][1], tri[2][0], tri[2][1])
self.qp.end()
item = QGraphicsPixmapItem(self.image2) # ????????????????
self.end_image.scene.addItem(item) # ??????????scene??
self.end_image.scene.addPixmap(QPixmap.fromImage(self.img2))
self.end_image.setScene(self.end_image.scene)
self.update()
if os.path.exists(self.leftPath + '.png.txt') and os.path.exists(
self.rightPath + '.png.txt') and self.img1 != None and self.img2 != None:
self.allowbland = 1
def loadPoints(self):
self.fromfileLen=0
if os.path.exists(self.leftPath+'.png.txt') and os.path.exists(self.rightPath+'.png.txt'):
# tris=loadTriangles(self.leftPath+'.txt',self.rightPath+'.txt')
pointL = np.loadtxt(self.leftPath+'.png.txt', dtype=np.float64)
pointR = np.loadtxt(self.rightPath+'.png.txt', dtype=np.float64)
self.rightPoints=[]
self.leftPoints=[]
for lp in pointL:
self.leftPoints.append(QPointF(lp[0]/3,lp[1]/3))
self.fromfileLen+=1
for rp in pointR:
self.rightPoints.append(QPointF(rp[0]/3,rp[1]/3))
self.comfirmedLen=self.fromfileLen
print(self.leftPoints)
print(self.fromfileLen)
try:
self.draw1()
self.draw2()
except Exception as e:
pass
# print(self.numPoints)
# print(self.rightPoints)
def writePoints(self):
self.numPoints=min(len(self.leftPoints),len(self.rightPoints))
fp1=open(self.leftPath+'.png.txt','w')
fp2=open(self.rightPath+'.png.txt','w')
# fp1=open('temp1.txt','w')
# fp2=open('temp2.txt','w')
for i in range(0,self.comfirmedLen):
fp1.write('%.1f %.1f\n'%(self.leftPoints[i].x()*3,self.leftPoints[i].y()*3))
fp2.write('%.1f %.1f\n' % (self.rightPoints[i].x()*3, self.rightPoints[i].y()*3))
fp1.close()
fp2.close()
def blendingBtnHandler(self):
t1=time.time()
# for i in range(5):
# p.apply_async(long_time_task, args=(i,))
# print('Waiting for all subprocesses done...')
# p.close()
# p.join()
print('All subprocesses done.')
# if os.path.exists(self.leftPath+'.png.txt') and os.path.exists(self.rightPath+'.png.txt') and self.img1!=None and self.img2!=None:
# self.allowbland=1
if self.allowbland==0:
return
self.allowbland = 0
# self.operatePointsFile()
processPoll = Pool(8)
resultlist=[]
self.itemArr=[]
path1=self.leftPath
path2=self.rightPath
for i in range (0,101,5):
res=processPoll.apply_async(MorphImgxx,args=(path1,path2,i/100.0,))
# res=self.MorphImg(alpha=i/100.0)
resultlist.append(res)
# print(i)
processPoll.close()
# print('xxx')
processPoll.join()
# print('yyy')
self.allowbland=0
for r in resultlist:
# print(type(r))
# print(r.get())
self.itemArr.append(r.get())
t2=time.time()
print(t2-t1)
self.previndex=-1
self.valChangeHandler()
# self.MorphImg(alpha=self.slidervalue)
# def showTriangle(self):
def MorphImg(self,alpha):
# self.leftPath='TestData/LeftColor'
# self.rightPath='TestData/RightColor'
t1 = time.time()
out = loadTrianglesResize(self.leftPath+'.png.txt', self.rightPath+'.png.txt')
t3 = time.time()
# out = loadTrianglesResize('temp1.txt','temp2.txt')
# leftImage = imageio.imread(self.leftPath+'.png')
leftImage = Image.open(self.leftPath + '.png')
leftImage=leftImage.resize([480,360])
# leftImage.show()
leftImage=np.array(leftImage.getdata()).reshape(leftImage.size[1], leftImage.size[0], 3)
rightImage = Image.open(self.rightPath+'.png')
rightImage=rightImage.resize([480,360])
# rightImage.show()
rightImage=np.array(rightImage.getdata()).reshape(rightImage.size[1], rightImage.size[0], 3)
morpher = MyMorpher(leftImage, out[0], rightImage, out[1])
newImg=morpher.getImageAtAlpha(alpha)
# self.imabland = QImage.fromData(newImg)
# self.imabland= QImage(newImg.data, newImg.shape[1], newImg.shape[0], newImg.strides[0], QImage.Format_RGB888);
# self.imabland=self.imabland.scaledToWidth(480-2)
# self.imabland=self.imabland.scaledToHeight(360-2)
# self.imabland=QPixmap.fromImage(self.imabland)
# self.MarkLeft=1
# self.blend_image.scene = QGraphicsScene() # ???????????
# item = QGraphicsPixmapItem(self.imabland) # ????????????????
# self.blend_image.scene.addItem(item) # ??????????scene??
# self.blend_image.setScene(self.blend_image.scene)
t2 = time.time()
print(t2-t1)
return newImg
class App(QMainWindow):
def __init__(self):
super(App, self).__init__()
# set main window attributes
self.title = 'PROJECTION AR'
self.left = 300
self.top = 100
self.camera = 2
# offsets
self.pointerOffsetX = 123
self.pointerOffsetY = 63
self.imageOffsetX = 250
self.imageOffsetY = 200
self.is_secondWindow = True
self.secondTransparncy = True
self.sizeObject = QtWidgets.QDesktopWidget().screenGeometry(-1)
self.bold_font = QtGui.QFont("Times", 10, QtGui.QFont.Bold)
self.secondaryWindow = ProjectorWindow(None)
self.secondaryWindow_final = ProjectorWindow(self.secondTransparncy)
self.preProcessingTool = PreProcessImages()
self.PreProcessImagesV2Tool = PreProcessImagesV2()
# Flags
self.video_started = False
self.pencil_started = False
self.erase_flag = False
# extra parameters
self.timer = QTimer()
self.cap = None
self.filePath = None
self.cursor = None
# variable for annotation
self.draw_pixmap = QPixmap(self.sizeObject.width() - self.imageOffsetX,
self.sizeObject.height() - self.imageOffsetY)
self.draw_pixmap.fill(Qt.transparent)
self.painter = QPainter(self.draw_pixmap)
self.annotation_label = QLabel(self)
self.videoLabel = QLabel("Start Video", self)
# custom drawing variables
self.drawing = False
self.brushSize = 6
self.clear_size = 20
self.brushColor = Qt.green
self.lastPoint = QPoint()
# cursor setting
self.editCursor = QCursor(QPixmap("./assets/icons/cursor/icons8-edit-24.png"))
self.eraseCursor = QCursor(QPixmap("./assets/icons/cursor/icons8-erase-28.png"))
# side Button
self.sideStartButton = QtWidgets.QToolButton(self)
self.sideDrawButton = QtWidgets.QToolButton(self)
self.sideEraseButton = QtWidgets.QToolButton(self)
self.sidePauseButton = QtWidgets.QToolButton(self)
self.sideExitButton = QtWidgets.QToolButton(self)
# menu bar for file
self.createMenu()
# Build UI
self.buildUI()
def buildUI(self):
"""
"""
# window location and title
self.setWindowTitle(self.title)
# self.setGeometry(self.left, self.top, self.width(), self.height())
self.setWindowIcon(QIcon("./assets/icons/icon-green.png"))
self.showMaximized()
sideButtonSize = QtCore.QSize(85, 55)
# side Button process
self.sideStartButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.sideStartButton.setIcon(QIcon('./assets/icons/SideButton/sidePlayIcon.png'))
self.sideStartButton.released.connect(self.startVideo)
self.sideStartButton.setIconSize(sideButtonSize)
self.sideDrawButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.sideDrawButton.setIcon(QIcon('./assets/icons/SideButton/sideEditIcon.png'))
self.sideDrawButton.released.connect(self.drawUsingPencil)
self.sideDrawButton.setIconSize(sideButtonSize)
self.sideEraseButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.sideEraseButton.setIcon(QIcon('./assets/icons/SideButton/sideEraseIcon.png'))
self.sideEraseButton.released.connect(self.eraseDrawing)
self.sideEraseButton.setIconSize(sideButtonSize)
self.sidePauseButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.sidePauseButton.setIcon(QIcon('./assets/icons/SideButton/sidePauseIcon.png'))
self.sidePauseButton.released.connect(self.pauseDrawing)
self.sidePauseButton.setIconSize(sideButtonSize)
self.sideExitButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.sideExitButton.setIcon(QIcon('./assets/icons/SideButton/sideExitIcon.png'))
self.sideExitButton.released.connect(self.exitApp)
self.sideExitButton.setIconSize(sideButtonSize)
# group the UI components
buttonGroup = self.groupcomponents()
# final layout.. all components together
self.finalUi(buttonGroup)
# show the UI
self.show()
# create projector window
self.secondaryWindow.show()
def createMenu(self):
""" Create and add menu items into menu bar
"""
# list of menu bars
self.fileMenuBar = self.menuBar().addMenu("&File")
self.editMenuBar = self.menuBar().addMenu("&Edit")
self.brushSizeBar = self.menuBar().addMenu("&Pencil Size")
self.eraserSizeBar = self.menuBar().addMenu("&Eraser Size")
# file menu Bar components
self.startVideoButton = self.fileMenuBar.addAction("Strat Video")
self.actionExit = self.fileMenuBar.addAction("Exit")
self.actionOpen = self.fileMenuBar.addAction("Open File")
# edit menu bar components
self.pencilButton = self.editMenuBar.addAction("Draw")
self.stopVideoButton = self.editMenuBar.addAction("Pause")
self.eraseButton = self.editMenuBar.addAction("Erase")
self.lassoButton = self.editMenuBar.addAction("Lasso")
self.rectangleButton = self.editMenuBar.addAction("Select")
# Pencil tool
self.pencilButton.setIcon(QIcon("./assets/icons/icons8-pencil-50.png"))
self.pencilButton.triggered.connect(self.drawUsingPencil)
# rectangle tool
self.rectangleButton.setIcon(QIcon("./assets/icons/icons8-rectangle-50.png"))
# Erase tool
self.eraseButton.setShortcut("Ctrl+X")
self.eraseButton.setIcon(QIcon("./assets/icons/icons8-eraser.png"))
self.eraseButton.triggered.connect(self.eraseDrawing)
# lasso tool
self.lassoButton.setShortcut("Ctrl+L")
self.lassoButton.setIcon(QIcon("./assets/icons/icons8-lasso-tool-48.png"))
# Stop Video button
self.stopVideoButton.setShortcut('Ctrl+P')
self.stopVideoButton.setIcon(QIcon("./assets/icons/icons8-stop-squared-50.png"))
self.stopVideoButton.triggered.connect(self.pauseDrawing)
# start button
self.startVideoButton.setShortcut('Ctrl+S')
self.startVideoButton.setIcon(QIcon("./assets/icons/icons8-start-50.png"))
self.startVideoButton.triggered.connect(self.startVideo)
# create menu bar to put some menu Options
self.actionOpen.setShortcut('Ctrl+O')
self.actionOpen.setIcon(QIcon("./assets/icons/open_file_icon.png"))
self.actionOpen.triggered.connect(self.openFileNamesDialog)
# add exit option to exit the program(keyboard shortcut ctrl+q)
self.actionExit.setShortcut('Ctrl+Q')
self.actionExit.setIcon(QIcon("./assets/icons/icons8-exit-50.png"))
self.actionExit.triggered.connect(self.exitApp)
# Pencil size menu
self.threepxActionSize = self.brushSizeBar.addAction("3px")
self.threepxActionSize.triggered.connect(lambda: self.changePencilSize(3))
self.threepxActionSize.setIcon(QIcon("./assets/icons/penSize/px3.png"))
self.fivepxActionSize = self.brushSizeBar.addAction("5px")
self.fivepxActionSize.triggered.connect(lambda: self.changePencilSize(5))
self.fivepxActionSize.setIcon(QIcon("./assets/icons/penSize/px5.png"))
self.sevenpxActionSize = self.brushSizeBar.addAction("7px")
self.sevenpxActionSize.triggered.connect(lambda: self.changePencilSize(7))
self.sevenpxActionSize.setIcon(QIcon("./assets/icons/penSize/px7.png"))
self.ninepxActionSize = self.brushSizeBar.addAction("9px")
self.ninepxActionSize.triggered.connect(lambda: self.changePencilSize(9))
self.ninepxActionSize.setIcon(QIcon("./assets/icons/penSize/px9.png"))
# Eraser size menu
self.erase10ActionSize = self.eraserSizeBar.addAction("10px")
self.erase10ActionSize.triggered.connect(lambda: self.changeEraserSize(10))
self.erase10ActionSize.setIcon(QIcon("./assets/icons/penSize/px3.png"))
self.erase20ActionSize = self.eraserSizeBar.addAction("20px")
self.erase20ActionSize.triggered.connect(lambda: self.changeEraserSize(20))
self.erase20ActionSize.setIcon(QIcon("./assets/icons/penSize/px5.png"))
self.erase30ActionSize = self.eraserSizeBar.addAction("30px")
self.erase30ActionSize.triggered.connect(lambda: self.changeEraserSize(30))
self.erase30ActionSize.setIcon(QIcon("./assets/icons/penSize/px7.png"))
self.erase40ActionSize = self.eraserSizeBar.addAction("40px")
self.erase40ActionSize.triggered.connect(lambda: self.changeEraserSize(40))
self.erase40ActionSize.setIcon(QIcon("./assets/icons/penSize/px9.png"))
def groupcomponents(self):
"""
"""
# button group box
toolsButtonGroupBox = QGroupBox("Tools")
toolsButtonGroupBox.setFixedWidth(100)
toolsButtonGroupBox.setMaximumHeight(450)
# vertical layout
vLayout = QVBoxLayout()
vLayout.setSpacing(0)
vLayout.setContentsMargins(1, 0, 0, 1)
vLayout.addWidget(self.sideStartButton)
vLayout.addWidget(self.sideDrawButton)
vLayout.addWidget(self.sideEraseButton)
vLayout.addWidget(self.sidePauseButton)
vLayout.addWidget(self.sideExitButton)
# set the layout to the button group
toolsButtonGroupBox.setLayout(vLayout)
return toolsButtonGroupBox
def finalUi(self, buttonGroup):
"""
"""
# button group box
colorVBox = QGroupBox("Colors")
colorVBox.setFixedWidth(45)
colorVBox.setMaximumHeight(1000)
# vertical layout
colorVLayout = QVBoxLayout()
colorVLayout.setSpacing(0)
colorVLayout.setContentsMargins(0, 0, 0, 0)
self.add_palette_buttons(colorVLayout)
# set the layout to the button group
colorVBox.setLayout(colorVLayout)
gridLayout = QGridLayout()
# add widgets to the layout
gridLayout.addWidget(buttonGroup, 0, 0)
gridLayout.addWidget(self.videoLabel, 0, 1)
gridLayout.addWidget(self.annotation_label, 0, 1)
gridLayout.addWidget(colorVBox, 0, 2)
# widget for the general layout
wid = QtWidgets.QWidget(self)
self.setCentralWidget(wid)
wid.setLayout(gridLayout)
def add_palette_buttons(self, layout):
for c in COLORS:
b = QPaletteButton(c)
b.pressed.connect(lambda c=c: self.set_pen_color(c))
layout.addWidget(b)
def set_pen_color(self, c):
self.brushColor = QtGui.QColor(c)
def startVideo(self):
""" This will start the camera feed """
try:
# if timer is stopped
if not self.timer.isActive():
# create video capture and start timer
self.cap = cv2.VideoCapture(self.camera)
self.videoLabel.setText("Connecting to camera")
self.video_started = True
# self.change_button_status()
# set timer timeout callback function
self.timer.timeout.connect(self.displayImage)
self.timer.start(100)
except Exception as ex:
print(ex)
def pauseDrawing(self):
""" stop both plotting and erasing """
if self.timer.isActive():
self.drawing = False
self.erase_flag = False
QApplication.setOverrideCursor(Qt.UpArrowCursor)
else:
self.videoLabel.setText('Camera is not started')
def displayImage(self):
""" This function read the camera and display the image
"""
try:
# read form camera
ret, image = self.cap.read()
raw_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
wrapped = self.preProcessingTool.fourPointTransform(raw_image)
# recreate the second window
if self.is_secondWindow:
self.secondaryWindow.close()
self.secondaryWindow_final.show()
self.is_secondWindow = False
wrapped = cv2.resize(wrapped, (
self.sizeObject.width() - self.imageOffsetX, self.sizeObject.height() - self.imageOffsetY))
# get image info
height, width, channel = wrapped.shape
step = channel * width
# create QImage and show it onto the label
qImg = QImage(wrapped.data, width, height, step, QImage.Format_RGB888)
self.videoLabel.setPixmap(QPixmap.fromImage(qImg))
except Exception as exc:
print(exc)
def drawUsingPencil(self):
# change the cursor to pencil
if self.video_started:
self.startVideoButton.setEnabled(False)
QApplication.setOverrideCursor(self.editCursor)
self.drawing = True
def eraseDrawing(self):
if self.video_started:
self.erase_flag = True
QApplication.setOverrideCursor(self.eraseCursor)
self.drawing = False
# pencil size
def changePencilSize(self, penSize):
self.brushSize = penSize
# Eraser Size
def changeEraserSize(self, brushSize):
self.clear_size = brushSize
# open file to load image
def openFileNamesDialog(self):
options = QtWidgets.QFileDialog.Options()
options |= QtWidgets.QFileDialog.DontUseNativeDialog
files, _ = QtWidgets.QFileDialog.getOpenFileNames(
self, "QtWidgets.QFileDialog.getOpenFileNames()",
"", "png Files (*.png)", options=options)
if files:
self.filePath = files[0]
# go ahead and read the file if necessary
def pixmapToArray(self, pixmap):
# Get the size of the current pixmap
size = pixmap.size()
h = size.width()
w = size.height()
channels_count = 4
# Get the QImage Item and convert it to a byte string
qimg = pixmap.toImage()
s = qimg.bits().asstring(w * h * channels_count)
img = np.fromstring(s, dtype=np.uint8).reshape((w, h, channels_count))
return img
# compute homography
def getHomography(self):
K_cam = np.array([[1198.370216, 0.0000, 558.550289],
[0, 1217.432399, 303.112548],
[0, 0, 1]])
K_proj = np.array([[1682.580944, 0.0000, 377.944090],
[0, 1592.522801, 259.182582],
[0, 0, 1]])
T = np.array([-100.121874, -35.443266, 86.250559])
R = np.array([[9.9753117267249736e-001, 2.4600138893772598e-002, 6.5775319938706903e-002],
[-2.5830952403295852e-002, 9.9950555626341375e-001, 1.7927768865717380e-002],
[-6.5301772139589140e-002, -1.9582547458668855e-002, 9.9767339464899940e-001]])
H = K_proj * R * (np.linalg.inv(K_cam))
return H
# apply image transform
def getHomographyTransform(self, H, image):
width = image.shape[0]
height = image.shape[1]
transformedImage = cv2.warpPerspective(image, H, (height, width))
return transformedImage
# normal application exit
def exitApp(self):
if self.timer.isActive():
self.cap.release()
sys.exit(0)
# add different events
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton and self.video_started:
self.lastPoint = event.pos()
self.lastPoint.setX(self.lastPoint.x() - self.pointerOffsetX)
self.lastPoint.setY(self.lastPoint.y() - self.pointerOffsetY)
# mouseMoveEvent(sefl, event)
# Works: yes
# TODO:
# - rise the annotation image as size(secondScreen.width, secondScreen.height)
# - resize secondary image to fit the screen
def mouseMoveEvent(self, event):
if (event.buttons() & Qt.LeftButton) and self.rect().contains(event.pos()):
self.painter.setOpacity(0.9)
currentPoint = event.pos()
currentPoint.setX(currentPoint.x() - self.pointerOffsetX)
currentPoint.setY(currentPoint.y() - self.pointerOffsetY)
# drawing annotation
if self.drawing:
self.painter.setPen(QPen(self.brushColor, self.brushSize, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
self.painter.drawLine(self.lastPoint, currentPoint)
# erasing the annotation
elif self.erase_flag:
r = QRect(QPoint(), self.clear_size * QSize())
r.moveCenter(currentPoint)
self.painter.save()
self.painter.setCompositionMode(QtGui.QPainter.CompositionMode_Clear)
self.painter.eraseRect(r)
self.painter.restore()
# set drawn annotation to the label and save last point
self.annotation_label.setPixmap(self.draw_pixmap)
self.lastPoint = currentPoint
# update the paint in both screens
scaled_pixmap = self.draw_pixmap.scaled(self.secondaryWindow_final.secWidth,
self.secondaryWindow_final.secHeight,
Qt.IgnoreAspectRatio, Qt.FastTransformation)
# apply homography transform
# numpyImage = self.pixmapToArray(QPixmap(scaled_pixmap))
# H = self.getHomography()
# hImage = self.getHomographyTransform(H, numpyImage)
#
# # display the image
# # secImage = QPixmap.fromImage(hTransformed)
# image = QtGui.QImage(hImage, hImage.shape[1], hImage.shape[0], hImage.shape[1] * 3,QtGui.QImage.Format_RGB888)
# pix = QtGui.QPixmap(image)
self.secondaryWindow_final.label.setPixmap(scaled_pixmap)
# self.secondaryWindow_final.label.resize(self.secondaryWindow_final.width(), self.secondaryWindow_final.height())
self.update()
# highlight
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton and self.video_started:
# self.drawing = False
self.save()
def save(self):
try:
filePath = 'annotation.png'
self.draw_pixmap.save(filePath)
except Exception as ex:
print(ex)
def paintEvent(self, event):
p = QPainter(self)
p.eraseRect(event.rect())
for i in range(0, 10):
self.drawDisplaySlot888(p, i)
p.end()
