def draw(self, painter: QPainter):
pen = QPen(Layer.color(LayerType.annotate))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setPen(pen)
painter.drawLine(self.pt1, self.pt2)
def paintEvent(self, event):
"""This method draws a left sidebar
:param event: QEvent
"""
painter = QPainter(self)
painter.fillRect(event.rect(), Qt.white)
width = self.width() - 8
height = self.editor.fontMetrics().height()
font = self.editor.font()
font_bold = self.editor.font()
font_bold.setBold(True)
painter.setFont(font)
pen = QPen(Qt.gray)
painter.setPen(QPen(QColor("#e9e9e9")))
painter.drawLine(width + 7, 0, width + 7, event.rect().height())
painter.setPen(pen)
current_line = self.editor.textCursor().blockNumber()
for top, line, block in self.editor.visible_blocks:
if current_line == line:
painter.setFont(font_bold)
else:
painter.setFont(font)
painter.drawText(5, top, width, height,
Qt.AlignRight, str(line + 1))
def image(cls, **kwargs):
"""
Returns an image suitable for the palette.
:rtype: QPixmap
"""
# INITIALIZATION
pixmap = QPixmap(kwargs['w'], kwargs['h'])
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
# INITIALIZE EDGE LINE
pp1 = QPointF(((kwargs['w'] - 52) / 2), kwargs['h'] / 2)
pp2 = QPointF(((kwargs['w'] - 52) / 2) + 52 - 2, kwargs['h'] / 2)
line = QLineF(pp1, pp2)
# CALCULATE HEAD COORDINATES
angle = radians(line.angle())
p1 = QPointF(line.p2().x() + 2, line.p2().y())
p2 = p1 - QPointF(sin(angle + M_PI / 3.0) * 8, cos(angle + M_PI / 3.0) * 8)
p3 = p1 - QPointF(sin(angle + M_PI - M_PI / 3.0) * 8, cos(angle + M_PI - M_PI / 3.0) * 8)
# INITIALIZE EDGE HEAD
head = QPolygonF([p1, p2, p3])
# DRAW THE POLYGON
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QPen(QColor(0, 0, 0), 1.1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(line)
# DRAW HEAD
painter.setPen(QPen(QColor(0, 0, 0), 1.1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.setBrush(QColor(0, 0, 0))
painter.drawPolygon(head)
# DRAW THE TEXT ON TOP OF THE EDGE
space = 2 if Platform.identify() is Platform.Darwin else 0
painter.setFont(Font('Arial', 9, Font.Light))
painter.drawText(pp1.x() + space, (kwargs['h'] / 2) - 4, 'instanceOf')
return pixmap
def drawLine(line: GridLine, painter: QtGui.QPainter):
""" Draw line in QPainter """
pen = QtGui.QPen()
pen.setColor(line.color)
pen.setWidth(line.width)
painter.setPen(pen)
painter.drawLine(line.start, line.end)
def lineNumberAreaPaintEvent(self, event):
painter = QPainter(self.lineNumbers)
painter.fillRect(event.rect(), QColor(230, 230, 230))
d = event.rect().topRight()
a = event.rect().bottomRight()
painter.setPen(Qt.darkGray)
painter.drawLine(d.x(), d.y(), a.x(), a.y())
painter.setPen(QColor(100, 100, 100))
painter.setFont(self.font())
block = self.firstVisibleBlock()
blockNumber = block.blockNumber()
top = int(
self.blockBoundingGeometry(block).translated(
self.contentOffset()).top())
bottom = top + int(self.blockBoundingRect(block).height())
while block.isValid() and top <= event.rect().bottom():
if block.isVisible() and bottom >= event.rect().top():
number = str(blockNumber + 1)
painter.drawText(4, top, self.lineNumbers.width() - 8,
self.fontMetrics().height(), Qt.AlignRight,
number)
block = block.next()
top = bottom
bottom = top + int(self.blockBoundingRect(block).height())
blockNumber += 1
def paintEvent(self,event=None):
painter = QPainter(self)
pixmap=QPixmap(":/images/wheelfinal.png")
#painter.begin(self)
#painter.drawPixmap(QtCore.QRect(self.left, self.top, self.width, self.height), self.pixmap)
painter.drawPixmap(self.rect(), pixmap)
self.resize(pixmap.width(),pixmap.height())
pen = QPen(Qt.red, 3)
painter.setPen(pen)
painter.drawArc (self.disc_center-int(self.distance_from_center(self.points[0])) ,
self.disc_center - int(self.distance_from_center (self.points[0])) ,
2*int(self.distance_from_center(self.points[0])) ,
2*int(self.distance_from_center(self.points[0])) ,
int(16*self.hue_min) ,
int(16*(self.hue_max-self.hue_min)))#arc joining point 0 and point 1
painter.drawLine(int(self.points[0][0]),int(self.points[0][1]),int(self.points[3][0]),int(self.points[3][1]))#line joining point 0 and point 3
painter.drawArc(self.disc_center-int(self.distance_from_center(self.points[2])) ,
self.disc_center - int(self.distance_from_center (self.points[2])) ,
2*int(self.distance_from_center(self.points[2])) ,
2*int(self.distance_from_center(self.points[2])) ,
int(16*self.hue_min) ,
int(16*(self.hue_max-self.hue_min)))#arc joining point 2 and 3
painter.drawLine(int(self.points[1][0]),int(self.points[1][1]),int(self.points[2][0]),int(self.points[2][1]))#line joining point 1 and 2
self.update()
def image(cls, **kwargs):
"""
Returns an image suitable for the palette.
:rtype: QPixmap
"""
# INITIALIZATION
pixmap = QPixmap(kwargs['w'], kwargs['h'])
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
# INIT THE LINE
p1 = QPointF(((kwargs['w'] - 54) / 2), kwargs['h'] / 2)
p2 = QPointF(((kwargs['w'] - 54) / 2) + 54 - 2, kwargs['h'] / 2)
line = QLineF(p1, p2)
# CLACULATE HEAD COORDS
angle = line.angle()
p1 = QPointF(line.p2().x() + 2, line.p2().y())
p2 = p1 - QPointF(sin(angle + M_PI / 3.0) * 8, cos(angle + M_PI / 3.0) * 8)
p3 = p1 - QPointF(sin(angle + M_PI - M_PI / 3.0) * 8, cos(angle + M_PI - M_PI / 3.0) * 8)
# INITIALIZE HEAD
head = QPolygonF([p1, p2, p3])
# DRAW EDGE LINE
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QPen(QColor(0, 0, 0), 1.1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(line)
# DRAW EDGE HEAD
painter.setPen(QPen(QColor(0, 0, 0), 1.1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.setBrush(QColor(0, 0, 0))
painter.drawPolygon(head)
return pixmap
def drawData(self, points=[], color=Qt.black):
painter = QPainter(self.image)
painter.setPen(QPen(color, self.myPenWidth, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
for n in range(len(points) - 1):
painter.drawLine(points[n][0], points[n][1], points[n + 1][0], points[n + 1][1])
self.update()
def paintEvent(self, event):
painter = QPainter(self)
icon = self.icon_pressed if self.isDown() else self.icon
if icon is not None:
x = (self.width() - icon.width()) / 2
y = (self.height() - icon.height()) / 2
painter.drawPixmap(x, y, icon)
else:
width = self.width()
height = self.height()
padding = width / 5
radius = width - 2*padding
palette = self.palette()
# Mid is darker than Dark. Go figure... -Dan
bg_color = palette.color(QPalette.Mid) if self.isDown() else palette.color(QPalette.Dark)
fg_color = palette.color(QPalette.Window) # or QPalette.Base for white
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setBrush(bg_color)
painter.setPen(bg_color)
painter.drawEllipse(padding, padding, radius, radius)
padding = padding * 2
painter.setPen(fg_color)
painter.drawLine(padding, padding, width-padding, height-padding)
painter.drawLine(padding, height-padding, width-padding, padding)
def paintEvent(self, event):
rect = QRect(10, 20, 80, 60)
path = QPainterPath()
path.moveTo(20, 80)
path.lineTo(20, 30)
path.cubicTo(80, 0, 50, 50, 80, 80)
startAngle = 30 * 16
arcLength = 120 * 16
painter = QPainter(self)
painter.setPen(self.pen)
painter.setBrush(self.brush)
if self.antialiased:
painter.setRenderHint(QPainter.Antialiasing)
for x in range(0, self.width(), 100):
for y in range(0, self.height(), 100):
painter.save()
painter.translate(x, y)
if self.transformed:
painter.translate(50, 50)
painter.rotate(60.0)
painter.scale(0.6, 0.9)
painter.translate(-50, -50)
if self.shape == RenderArea.Line:
painter.drawLine(rect.bottomLeft(), rect.topRight())
elif self.shape == RenderArea.Points:
painter.drawPoints(RenderArea.points)
elif self.shape == RenderArea.Polyline:
painter.drawPolyline(RenderArea.points)
elif self.shape == RenderArea.Polygon:
painter.drawPolygon(RenderArea.points)
elif self.shape == RenderArea.Rect:
painter.drawRect(rect)
elif self.shape == RenderArea.RoundedRect:
painter.drawRoundedRect(rect, 25, 25, Qt.RelativeSize)
elif self.shape == RenderArea.Ellipse:
painter.drawEllipse(rect)
elif self.shape == RenderArea.Arc:
painter.drawArc(rect, startAngle, arcLength)
elif self.shape == RenderArea.Chord:
painter.drawChord(rect, startAngle, arcLength)
elif self.shape == RenderArea.Pie:
painter.drawPie(rect, startAngle, arcLength)
elif self.shape == RenderArea.Path:
painter.drawPath(path)
elif self.shape == RenderArea.Text:
painter.drawText(rect, Qt.AlignCenter,
"PyQt by\nRiverbank Computing")
elif self.shape == RenderArea.Pixmap:
painter.drawPixmap(10, 10, self.pixmap)
painter.restore()
painter.setPen(self.palette().dark().color())
painter.setBrush(Qt.NoBrush)
painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def drawLineTo(self, endPoint):
painter = QPainter(self.image)
painter.setPen(QPen(self.myPenColor, self.myPenWidth, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(self.lastPoint, endPoint)
rad = self.myPenWidth / 2 + 2
self.update(QRect(self.lastPoint, endPoint).normalized().adjusted(-rad, -rad, +rad, +rad))
self.lastPoint = QPoint(endPoint)
def paintEvent(self, event):
QLabel.paintEvent(self, event)
painter = QPainter(self)
painter.setPen(Qt.blue)
#painter.setBrush(Qt.yellow)
#painter.drawRect(10, 10, 100, 100)
x,y,w,h = self.geometry
painter.drawLine(x,y+self.perspective[0]*h//1000,x+w,y+self.perspective[1]*h//1000)
painter.drawLine(x,y+self.perspective[2]*h//1000,x+w,y+self.perspective[3]*h//1000)
def paintEvent(self, event): if not globalSettings.rightMargin: return QTextEdit.paintEvent(self, event) painter = QPainter(self.viewport()) painter.setPen(colorValues['marginLine']) y1 = self.rect().topLeft().y() y2 = self.rect().bottomLeft().y() painter.drawLine(self.marginx, y1, self.marginx, y2) QTextEdit.paintEvent(self, event)
def paintEvent(self,event): pp = QPainter( self.pix) # 根据鼠标指针前后两个位置绘制直线 pp.drawLine( self.lastPoint, self.endPoint) # 让前一个坐标值等于后一个坐标值， # 这样就能实现画出连续的线 self.lastPoint = self.endPoint painter = QPainter(self) painter.drawPixmap(0, 0, self.pix)
def paintEvent(self, event):
QWidget.paintEvent(self, event)
width, height = self.width(), self.height()
polygon = QPolygon()
for i, rate in enumerate(self.loads):
x = width - i * self.pointDistance
y = height - rate * height
if x < self.boxWidth:
break
polygon.append(QPoint(x, y))
painter = QPainter(self)
pen = QPen()
pen.setColor(Qt.darkGreen)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
#画网格
painter.setOpacity(0.5)
gridSize = self.pointDistance * 4
deltaX = (width - self.boxWidth) % gridSize + self.boxWidth
deltaY = height % gridSize
for i in range(int(width / gridSize)):
x = deltaX + gridSize * i
painter.drawLine(x, 0, x, height)
for j in range(int(height / gridSize)):
y = j * gridSize + deltaY
painter.drawLine(self.boxWidth, y, width, y)
#画折线
pen.setColor(Qt.darkCyan)
pen.setWidth(2)
painter.setPen(pen)
painter.setOpacity(1)
painter.drawPolyline(polygon)
#画展示框
if len(self.loads) > 0:
rate = self.loads[0]
else:
rate = 1.0
rect1 = QRect(4, height * 0.05, self.boxWidth - 9, height * 0.7)
rect2 = QRect(4, height * 0.8, self.boxWidth - 9, height * 0.2)
centerX = int(rect1.width() / 2) + 1
pen.setWidth(1)
for i in range(rect1.height()):
if i % 4 == 0:
continue
if (rect1.height() - i) / rect1.height() > rate:
pen.setColor(Qt.darkGreen)
else:
pen.setColor(Qt.green)
painter.setPen(pen)
for j in range(rect1.width()):
if centerX - 1 <= j <= centerX + 1:
continue
painter.drawPoint(rect1.x() + j, rect1.y() + i)
pen.setColor(Qt.black)
painter.setPen(pen)
painter.drawText(rect2, Qt.AlignHCenter | Qt.AlignVCenter, str(int(rate * 100)) + "%")
def paintEvent(self, event):
# Draw rectangle
qp = QPainter()
qp.begin(self)
x, y, w, h = self.geometry().x(), self.geometry().y(), self.geometry().width(), self.geometry().height()
qp.drawLine(0, 0, 0, h)
qp.drawLine(0, h-1, w-1, h-1)
qp.drawLine(w-1, h-1, w-1, 0)
qp.end()
def paintEvent(self, event):
super(MyLabel, self).paintEvent(event)
painter = QPainter(self)
if not self.cross:
if self.mouse_pos != None:
painter.drawLine(QPoint(self.mouse_pos.x(), 0) , QPoint(self.mouse_pos.x(), self.height()))
painter.drawLine(QPoint(0,self.mouse_pos.y()) , QPoint(self.width(),self.mouse_pos.y()))
else :
self.paintCross(painter)
def draw_line_to(self, end_point):
painter = QPainter(self.image)
painter.setPen(QPen(self.foreground_color if self.scribbling == 1 else self.background_color,
self.pen_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(QPoint(self.last_point.x()//self.scaling_factor, self.last_point.y()//self.scaling_factor),
QPoint(end_point.x()//self.scaling_factor, end_point.y()//self.scaling_factor))
self.update()
self.last_point = QPoint(end_point)
def draw_line(self, line, value, painter=None, update=False):
if painter == None:
painter = QPainter(self.image)
painter.setPen(Qt.black)
painter.drawLine(QPoint(line, 31 - value // 8), QPoint(line, 31))
painter.setPen(Qt.white)
painter.drawLine(QPoint(line, 0), QPoint(line, 31 - value // 8))
if update:
self.update()
def paintEvent(self, event):
painter = QPainter(self.viewport())
if self.highlight_line:
r = self.cursorRect()
r.setX(0)
r.setWidth(self.viewport().width())
painter.fillRect(r, self.highlight_brush)
if self.draw_line:
painter.setPen(self.line_pen)
painter.drawLine(self.line)
painter.end()
QPlainTextEdit.paintEvent(self, event)
def paint(self, painter: QPainter,
option: QStyleOptionGraphicsItem,
widget: QWidget):
"""Paint this strand
Args:
painter:
option
widget:
"""
painter.setPen(self.pen())
painter.drawLine(self.line())
def paintEvent(self, _event):
qp = QPainter(self)
g = QLinearGradient(0.0, 0.0, 0.0, self.height())
g.setColorAt(0, Qt.white)
g.setColorAt(1, Qt.black)
y = self.height() - self.reflectivity * self.height() / 4095.0
qp.fillRect(0, 0, self.width(), self.height(), g)
qp.setPen(Qt.red)
qp.drawLine(0, y, self.width(), y)
def draw(self):
painter = QPainter(self._neditor.viewport())
painter.setPen(self.__color)
metrics = QFontMetricsF(self._neditor.font())
doc_margin = self._neditor.document().documentMargin()
offset = self._neditor.contentOffset().x() + doc_margin
x = round(metrics.width(' ') * self.__position) + offset
if self.__background:
width = self._neditor.viewport().width() - x
rect = QRect(x, 0, width, self._neditor.height())
painter.fillRect(rect, self.__background_color)
painter.drawLine(x, 0, x, self._neditor.height())
def paintEvent(self,e):
painter = QPainter(self)
#painter.setRenderHint(QPainter.Antialiasing, True)
#painter.setPen(QPen(self.color, 6, Qt.SolidLine))
#painter.setBrush(QBrush(Qt.green, Qt.SolidPattern))
self.i+=1
#print(self.i)
for a in self.demet:
c, self.x0,self.y0,self.x1,self.y1=a
a0,a1,a2,a3=c
color=QColor.fromHsv(a0,a1,a2,a3)
painter.setPen(QPen(color, 5, Qt.SolidLine))
painter.drawLine(self.x0,self.y0,self.x1,self.y1) #20, 40, 250, 40
def __draw_collapsed_line(self):
viewport = self._neditor.viewport()
painter = QPainter(viewport)
painter.setPen(self.__line_fold_color)
for top, _, block in self._neditor.visible_blocks:
if not block.next().isVisible():
layout = block.layout()
line = layout.lineAt(layout.lineCount() - 1)
offset = self._neditor.contentOffset()
line_rect = line.naturalTextRect().translated(offset.x(), top)
bottom = line_rect.bottom()
painter.drawLine(
line_rect.x(), bottom, line_rect.width(), bottom)
def paintEvent(self, event):
logger.debug("paintEvent: {0} - {1}".format(self, event.rect()))
qp = QPainter()
qp.begin(self)
width = self.size().width() - 1
height = self.size().height() - 1
#draw border
qp.setPen(self.border_color)
qp.drawLine(0, 0, width, 0)
qp.drawLine(0, 0, 0, height)
qp.drawLine(width, 0, width, height)
qp.drawLine(0, height, width, height)
#draw bar
width -= 2
height -= 2
value = orig_value = self.data_source()
value = min(self.max_range, value)
value = max(self.min_range, value)
qp.setPen(self.bar_color)
qp.setBrush(self.bar_color)
if self.orientation == 'horizontal':
qp.drawRect(1, 1,
width / self.max_range * value, height)
else:
qp.drawRect(1, height - (height / self.max_range * value), width, height)
qp.setPen(self.border_color)
qp.drawText(event.rect(), Qt.AlignCenter, str(orig_value))
qp.end()
logger.debug("paintEvent End: {0}".format(self))
def paintEvent(self, event):
painter = QPainter(self)
# Background
painter.setBrush(self.brush)
painter.setPen(self.pen)
rect = self.rect()
painter.drawRect(rect)
# Line along bottom
tab_bar_rect = self.findChild(QTabBar).rect()
rect.moveBottom(tab_bar_rect.bottom())
painter.setPen(self.bottom_margin)
painter.drawLine(rect.bottomLeft(), rect.bottomRight())
def paintEvent(self, event):
side = min(self.width(), self.height())
time = QTime.currentTime()
time = time.addSecs(self.timeZoneOffset * 3600)
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(self.hourColor))
painter.save()
painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)))
painter.drawConvexPolygon(self.hourHand)
painter.restore()
painter.setPen(self.hourColor)
for i in range(0, 12):
painter.drawLine(84, 0, 96, 0)
painter.rotate(30.0)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(self.minuteColor))
painter.save()
painter.rotate(6.0 * (time.minute() + time.second() / 60.0))
painter.drawConvexPolygon(self.minuteHand)
painter.restore()
painter.setPen(QPen(self.minuteColor))
for j in range(0, 60):
if (j % 5) != 0:
painter.drawLine(90, 0, 96, 0)
painter.rotate(6.0)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(self.secondColor))
painter.save()
painter.rotate(6.0 * time.second())
painter.drawConvexPolygon(self.secondHand)
painter.restore()
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.drawImage(QRect(0, 0, super().width(), super().height()), self.image)
if self.grid_enabled:
painter.setPen(QPen(self.grid_color))
for x in range(1, self.width):
painter.drawLine(x * self.scaling_factor, 0, x * self.scaling_factor, super().height())
for y in range(1, self.height):
painter.drawLine(0, y * self.scaling_factor, super().width(), y * self.scaling_factor)
self.parent.paint_overlay(event, painter)
def paintEvent(self, event):
logger.debug("paintEvent: {0} - {1}".format(self, event.rect()))
qp = QPainter()
qp.begin(self)
width = self.size().width() - 1
height = self.size().height() - 1
#draw border
qp.setPen(self.border_color)
qp.drawLine(0, 0, width, 0)
qp.drawLine(0, 0, 0, height)
qp.drawLine(width, 0, width, height)
qp.drawLine(0, height, width, height)
#draw plot
width -= 1
height -= 1
if len(self.data):
qp.setPen(self.plot_color)
max_val = max(self.data)
points = list();
for index in range(len(self.data)-1, 1, -1):
points.append(QPoint((width / 100 * index), height - (height / max_val * self.data[index])))
points.append(QPoint(1, height))
points.append(QPoint(width, height))
qp.setBrush(self.plot_color)
qp.drawPolygon(*points)
qp.end()
logger.debug("paintEvent End: {0}".format(self))
def paintEvent(self, event):
dst = self.imgRect()
qp = QPainter()
qp.begin(self)
# draw background
brush = QBrush(Qt.SolidPattern)
# brush.setColor(Qt.white)
brush.setColor(Qt.black)
qp.setBrush(brush)
qp.drawRect(dst)
# brush = QBrush(Qt.DiagCrossPattern)
# brush.setColor(Qt.black)
# qp.setBrush(brush)
# qp.drawRect(dst)
self.state.paintImage(qp, dst)
# draw orientation lines
qp.setPen(QColor(255,255,255,150))
qp.drawLine(dst.x()+dst.width()/3,dst.y()+0,
dst.x()+dst.width()/3,dst.y()+dst.height())
qp.drawLine(dst.x()+dst.width()/2,dst.y()+0,
dst.x()+dst.width()/2,dst.y()+dst.height())
qp.drawLine(dst.x()+dst.width()*2/3,dst.y()+0,
dst.x()+dst.width()*2/3,dst.y()+dst.height())
qp.drawLine(dst.x()+0,dst.y()+dst.height()/3,
dst.x()+dst.width(),dst.y()+dst.height()/3)
qp.drawLine(dst.x()+0,dst.y()+dst.height()/2,
dst.x()+dst.width(),dst.y()+dst.height()/2)
qp.drawLine(dst.x()+0,dst.y()+dst.height()*2/3,
dst.x()+dst.width(),dst.y()+dst.height()*2/3)
qp.end()
def drawSmithChart(self, qp: QtGui.QPainter):
centerX = int(self.width() / 2)
centerY = int(self.height() / 2)
qp.setPen(QtGui.QPen(Chart.color.text))
qp.drawText(3, 15, self.name)
qp.setPen(QtGui.QPen(Chart.color.foreground))
qp.drawEllipse(QtCore.QPoint(centerX, centerY),
int(self.dim.width / 2), int(self.dim.height / 2))
qp.drawLine(centerX - int(self.dim.width / 2), centerY,
centerX + int(self.dim.width / 2), centerY)
qp.drawEllipse(
QtCore.QPoint(centerX + int(self.dim.width / 4), centerY),
int(self.dim.width / 4), int(self.dim.height / 4)) # Re(Z) = 1
qp.drawEllipse(
QtCore.QPoint(centerX + int(2 / 3 * self.dim.width / 2), centerY),
int(self.dim.width / 6), int(self.dim.height / 6)) # Re(Z) = 2
qp.drawEllipse(
QtCore.QPoint(centerX + int(3 / 4 * self.dim.width / 2), centerY),
int(self.dim.width / 8), int(self.dim.height / 8)) # Re(Z) = 3
qp.drawEllipse(
QtCore.QPoint(centerX + int(5 / 6 * self.dim.width / 2), centerY),
int(self.dim.width / 12), int(self.dim.height / 12)) # Re(Z) = 5
qp.drawEllipse(
QtCore.QPoint(centerX + int(1 / 3 * self.dim.width / 2), centerY),
int(self.dim.width / 3), int(self.dim.height / 3)) # Re(Z) = 0.5
qp.drawEllipse(
QtCore.QPoint(centerX + int(1 / 6 * self.dim.width / 2), centerY),
int(self.dim.width / 2.4),
int(self.dim.height / 2.4)) # Re(Z) = 0.2
qp.drawArc(centerX + int(3 / 8 * self.dim.width), centerY,
int(self.dim.width / 4), int(self.dim.width / 4), 90 * 16,
152 * 16) # Im(Z) = -5
qp.drawArc(centerX + int(3 / 8 * self.dim.width), centerY,
int(self.dim.width / 4), -int(self.dim.width / 4), -90 * 16,
-152 * 16) # Im(Z) = 5
qp.drawArc(centerX + int(self.dim.width / 4), centerY,
int(self.dim.width / 2), int(self.dim.height / 2), 90 * 16,
127 * 16) # Im(Z) = -2
qp.drawArc(centerX + int(self.dim.width / 4), centerY,
int(self.dim.width / 2), -int(self.dim.height / 2),
-90 * 16, -127 * 16) # Im(Z) = 2
qp.drawArc(centerX, centerY, self.dim.width, self.dim.height, 90 * 16,
90 * 16) # Im(Z) = -1
qp.drawArc(centerX, centerY, self.dim.width, -self.dim.height,
-90 * 16, -90 * 16) # Im(Z) = 1
qp.drawArc(centerX - int(self.dim.width / 2), centerY,
self.dim.width * 2, self.dim.height * 2, int(99.5 * 16),
int(43.5 * 16)) # Im(Z) = -0.5
qp.drawArc(centerX - int(self.dim.width / 2), centerY,
self.dim.width * 2, -self.dim.height * 2, int(-99.5 * 16),
int(-43.5 * 16)) # Im(Z) = 0.5
qp.drawArc(centerX - self.dim.width * 2, centerY,
self.dim.width * 5, self.dim.height * 5, int(93.85 * 16),
int(18.85 * 16)) # Im(Z) = -0.2
qp.drawArc(centerX - self.dim.width * 2, centerY,
self.dim.width * 5, -self.dim.height * 5, int(-93.85 * 16),
int(-18.85 * 16)) # Im(Z) = 0.2
self.drawTitle(qp)
qp.setPen(Chart.color.swr)
for swr in self.swrMarkers:
if swr <= 1:
continue
gamma = (swr - 1) / (swr + 1)
r = round(gamma * self.dim.width / 2)
qp.drawEllipse(QtCore.QPoint(centerX, centerY), r, r)
qp.drawText(QtCore.QRect(centerX - 50, centerY - 4 + r, 100, 20),
QtCore.Qt.AlignCenter, str(swr))
class Renderer:
def __init__(self, width, height, ownWindow=False):
self.width = width
self.height = height
self.img = QImage(width, height, QImage.Format_RGB888)
self.painter = QPainter()
self.window = None
if ownWindow:
self.app = QApplication([])
self.window = Window()
def close(self):
"""
Deallocate resources used
"""
pass
def beginFrame(self):
self.painter.begin(self.img)
self.painter.setRenderHint(QPainter.Antialiasing, False)
# Clear the background
self.painter.setBrush(QColor(0, 0, 0))
self.painter.drawRect(0, 0, self.width - 1, self.height - 1)
def endFrame(self):
self.painter.end()
if self.window:
if self.window.closed:
self.window = None
else:
self.window.setPixmap(self.getPixmap())
self.app.processEvents()
def getPixmap(self):
return QPixmap.fromImage(self.img)
def getArray(self):
"""
Get a numpy array of RGB pixel values.
The size argument should be (3,w,h)
"""
width = self.width
height = self.height
shape = (width, height, 3)
numBytes = self.width * self.height * 3
buf = self.img.bits().asstring(numBytes)
output = np.frombuffer(buf, dtype='uint8')
output = output.reshape(shape)
return output
def push(self):
self.painter.save()
def pop(self):
self.painter.restore()
def rotate(self, degrees):
self.painter.rotate(degrees)
def translate(self, x, y):
self.painter.translate(x, y)
def scale(self, x, y):
self.painter.scale(x, y)
def setLineColor(self, r, g, b, a=255):
self.painter.setPen(QColor(r, g, b, a))
def setColor(self, r, g, b, a=255):
self.painter.setBrush(QColor(r, g, b, a))
def setLineWidth(self, width):
pen = self.painter.pen()
pen.setWidthF(width)
self.painter.setPen(pen)
def drawLine(self, x0, y0, x1, y1):
self.painter.drawLine(x0, y0, x1, y1)
def drawCircle(self, x, y, r):
center = QPoint(x, y)
self.painter.drawEllipse(center, r, r)
def drawPolygon(self, points):
"""Takes a list of points (tuples) as input"""
points = map(lambda p: QPoint(p[0], p[1]), points)
self.painter.drawPolygon(QPolygon(points))
def drawPolyline(self, points):
"""Takes a list of points (tuples) as input"""
points = map(lambda p: QPoint(p[0], p[1]), points)
self.painter.drawPolyline(QPolygon(points))
def fillRect(self, x, y, width, height, r, g, b, a=255):
self.painter.fillRect(QRect(x, y, width, height), QColor(r, g, b, a))
def paintEvent(self, event):
# INITIALISATION painter, etat etc
# etat joueur True = tir, False = deplacement
etat = self.model.player.etat
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(self.style_base)
poly = self.model.map.polygone
points = [
QPoint(poly[0, i], poly[1, i]) for i in range(0, poly.shape[1])
]
# OPTIONS D'AFFICHAGE
#painter.drawPixmap(100, 100, self.drop)
# affichage polygone
if self.show_polygon:
Qpoly = QPolygon(points)
painter.setPen(self.style_gris)
painter.drawPolygon(Qpoly)
painter.setPen(self.style_base)
if self.show_numbers:
for i in range(len(points)):
painter.drawText(points[i], str(i))
if self.show_impact:
painter.setPen(self.style_rouge)
painter.drawEllipse(QPoint(self.pt_col[0], self.pt_col[1]), 10, 10)
painter.setPen(self.style_base)
# affichage arretes découvertes
if self.show_taches:
taches = self.model.map.taches
for tache in taches:
A = QPoint(tache[0][0], tache[0][1])
B = QPoint(tache[1][0], tache[1][1])
painter.drawLine(A, B)
else:
arretes = self.model.map.arretes
for arrete in arretes:
A = QPoint(poly[0, arrete[0]], poly[1, arrete[0]])
B = QPoint(poly[0, arrete[1]], poly[1, arrete[1]])
painter.drawLine(A, B)
# affichage joueur
xy = self.model.player.coords
###### affichage selon les differents état de jeu #####
if self.game_over:
title_font = QtGui.QFont()
title_font.setFamily("Cooper Black")
title_font.setPointSize(14)
self.show_polygon = True
painter.drawEllipse(QPoint(xy[0], xy[1]), self.r_player,
self.r_player)
painter.drawText(self.size[0] / 2, self.size[1] / 2, 'GameOver')
elif len(self.model.map.arretes) == len(points) and etat != 4:
title_font = QtGui.QFont()
title_font.setFamily("Cooper Black")
title_font.setPointSize(14)
self.show_polygon = True
painter.drawEllipse(QPoint(xy[0], xy[1]), self.r_player,
self.r_player)
painter.drawText(self.size[0] / 2, self.size[1] / 2, 'Bravo !')
# Demande de tir : 0
elif etat == 0:
self.demande_tir(painter)
# Animation tir
elif etat == 1:
self.animation_tir(painter)
elif etat == 4:
self.animation_tache(painter)
# Demande de déplacement
elif etat == 2:
self.demande_deplacement(painter)
# Animation déplacement
elif etat == 3:
self.animation_deplacement(painter)
# Si il y a eu une erreur...
else:
self.model.player.etat = 0
def paintEvent(self, event):
if self.pos:
q = QPainter(self)
q.drawLine(0, 0, self.pos.x(), self.pos.y())
def paintEvent(self, event):
linePen = QPen(Qt.black)
linePen.setWidth(3)
width = self.width() / self.scale
def paintLineMarks(painter):
painter.save()
painter.scale(self.scale, yDirection * self.scale)
painter.setPen(linePen)
painter.drawLine(0, self.ascender, width, self.ascender)
painter.drawLine(0, 0, width, 0)
painter.drawLine(0, self.descender, width, self.descender)
painter.restore()
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(0, 0, self.width(), self.height(), Qt.white)
if self._verticalFlip:
baselineShift = -self.descender
yDirection = 1
else:
baselineShift = self.ascender
yDirection = -1
painter.translate(
self.padding,
self.padding + baselineShift * self.scale * self._lineHeight)
# TODO: scale painter here to avoid g*scale everywhere below
cur_width = 0
if self._showMetrics:
paintLineMarks(painter)
for index, glyph in enumerate(self.glyphs):
# line wrapping
gWidth = glyph.width * self.scale
doKern = index > 0 and self._showKerning and cur_width > 0
if doKern:
kern = self.lookupKerningValue(self.glyphs[index - 1].name,
glyph.name) * self.scale
else:
kern = 0
if (self._wrapLines and cur_width + gWidth + kern +
2 * self.padding > self.width()) or glyph.unicode == 2029:
painter.translate(-cur_width, self.ptSize * self._lineHeight)
if self._showMetrics:
paintLineMarks(painter)
cur_width = gWidth
else:
if doKern:
painter.translate(kern, 0)
cur_width += gWidth + kern
glyphPath = glyph.getRepresentation("defconQt.QPainterPath")
painter.save()
painter.scale(self.scale, yDirection * self.scale)
if self._showMetrics:
halfDescent = self.descender / 2
painter.drawLine(0, 0, 0, halfDescent)
painter.drawLine(glyph.width, 0, glyph.width, halfDescent)
if self._selected is not None and index == self._selected:
painter.fillRect(0, self.descender, glyph.width, self.upm,
glyphSelectionColor)
painter.fillPath(glyphPath, Qt.black)
painter.restore()
painter.translate(gWidth, 0)
def draw_lines(self, painter: QtGui.QPainter) -> None:
# переключаем кисть
painter.setPen(self.label_pen)
painter.setBackground(QtCore.Qt.white)
# из TY1 в T1
painter.drawLine(self.points["TY1"], self.points["T1"])
# из T1 в TX
painter.drawLine(self.points["T1"], self.points["TX"])
# из TX в T2
painter.drawLine(self.points["TX"], self.points["T2"])
# из T2 в TZ
painter.drawLine(self.points["T2"], self.points["TZ"])
# из TZ в T3
painter.drawLine(self.points["TZ"], self.points["T3"])
# Из T3 в TY3
painter.drawLine(self.points["T3"], self.points["TY3"])
# рисуем сектор
self.draw_arc(painter)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Tree Viewer")
self.setFixedHeight(600)
self.setFixedWidth(800)
self.actionUp = QAction()
self.actionUp.triggered.connect(self.selecUp)
self.actionUp.setShortcut('Z')
self.actionDown = QAction()
self.actionDown.triggered.connect(self.selecDown)
self.actionDown.setShortcut('S')
self.actionLeft = QAction()
self.actionLeft.triggered.connect(self.selecLeft)
self.actionLeft.setShortcut('Q')
self.actionRight = QAction()
self.actionRight.triggered.connect(self.selecRight)
self.actionRight.setShortcut('D')
self.actionAddKnot = QAction()
self.actionAddKnot.triggered.connect(self.addKnot)
self.actionAddKnot.setShortcut('A')
self.actionRemoveKnot = QAction()
self.actionRemoveKnot.triggered.connect(self.removeKnot)
self.actionRemoveKnot.setShortcut('R')
self.addAction(self.actionUp)
self.addAction(self.actionDown)
self.addAction(self.actionLeft)
self.addAction(self.actionRight)
self.addAction(self.actionAddKnot)
self.addAction(self.actionRemoveKnot)
self.tree = Knot('A',
left=Knot('B', left=Knot('D'), right=Knot('E')),
right=Knot('C', left=Knot('F'), right=Knot('G')))
self.setUI()
def setUI(self):
self.frameInfos = QFrame(self)
self.frameInfos.setGeometry(600, 0, 200, 600)
self.frameInfos.setStyleSheet(
".QFrame{border: 2px solid rgb(144,144,144);\nborder-radius: 10px;}"
)
self.frameTree = QFrame(self)
self.frameTree.setGeometry(0, 0, 600, 600)
self.frameTree.setStyleSheet(
".QFrame{border: 2px solid rgb(144,144,144);\nborder-radius: 10px;}"
)
self.updateTree()
self.windowAddKnot = QDialog(self, Qt.Drawer)
self.windowAddKnot.setFixedWidth(400)
self.windowAddKnot.setFixedHeight(200)
self.windowAddKnot.labelKnotName = QLabel(
f'Knot Name: {self.selected.name}', self.windowAddKnot)
self.windowAddKnot.labelKnotName.setAlignment(Qt.AlignCenter)
self.windowAddKnot.labelKnotName.setGeometry(110, 10, 180, 20)
self.windowAddKnot.labelSide = QLabel('Choose which child side:',
self.windowAddKnot)
self.windowAddKnot.labelSide.setGeometry(10, 40, 180, 20)
self.windowAddKnot.comboSide = QComboBox(self.windowAddKnot)
self.windowAddKnot.comboSide.addItems(
['left', 'right'] if not self.selected.left and not self.selected.
right else ['left'] if self.selected.right else ['right'])
self.windowAddKnot.comboSide.setGeometry(210, 40, 180, 20)
self.windowAddKnot.labelKnot = QLabel('Choose Knot\'s name:',
self.windowAddKnot)
self.windowAddKnot.labelKnot.setGeometry(10, 70, 180, 20)
self.windowAddKnot.entryKnot = QLineEdit(self.windowAddKnot)
self.windowAddKnot.entryKnot.setGeometry(210, 70, 180, 20)
self.windowAddKnot.buttonValidate = QPushButton(
'Add Knot', self.windowAddKnot)
self.windowAddKnot.buttonValidate.setGeometry(110, 130, 180, 20)
self.windowAddKnot.buttonValidate.clicked.connect(
lambda: self.verifyAddition(
self.windowAddKnot.comboSide.currentText(),
self.windowAddKnot.entryKnot.text()))
self.windowError = QMessageBox()
self.windowError.setIcon(QMessageBox.Information)
self.labelKnotName = QLabel(f'Knot Name: {self.selected.name}',
self.frameInfos)
self.labelKnotName.setStyleSheet(
'border: 2px solid rgb(144,144,144);\nborder-radius: 15px;')
self.labelKnotName.setGeometry(10, 10, 180, 30)
self.labelKnotName.setAlignment(Qt.AlignCenter)
self.labelKnotLeaf = QLabel(f'Knot is leaf: {self.selected.isLeaf()}',
self.frameInfos)
self.labelKnotLeaf.setGeometry(10, 40, 180, 20)
self.labelKnotAlt = QLabel(f'Knot Altitude: {self.selected.i}',
self.frameInfos)
self.labelKnotAlt.setGeometry(10, 70, 180, 20)
self.labelKnotRank = QLabel(f'Knot Rank: {self.selected.r}',
self.frameInfos)
self.labelKnotRank.setGeometry(10, 100, 180, 20)
self.labelKnotParent = QLabel(
f'Parent Name: {self.selected.parentKnot.name}'
if self.selected.parentKnot else 'Root Knot', self.frameInfos)
self.labelKnotParent.setGeometry(10, 150, 180, 20)
self.labelKnotChildLeft = QLabel(
f'Left Child Name: {self.selected.left.name}'
if self.selected.left else 'No Left Child', self.frameInfos)
self.labelKnotChildLeft.setGeometry(10, 180, 180, 20)
self.labelKnotChildRight = QLabel(
f'Right Child Name: {self.selected.right.name}'
if self.selected.right else 'No Right Child', self.frameInfos)
self.labelKnotChildRight.setGeometry(10, 210, 180, 20)
self.buttonRemoveKnot = QPushButton('Remove Knot', self.frameInfos)
self.buttonRemoveKnot.setFocusPolicy(Qt.NoFocus)
self.buttonRemoveKnot.setGeometry(10, 240, 180, 20)
self.buttonRemoveKnot.clicked.connect(self.removeKnot)
self.buttonAddKnot = QPushButton('Add Child', self.frameInfos)
self.buttonAddKnot.setFocusPolicy(Qt.NoFocus)
self.buttonAddKnot.setGeometry(10, 270, 180, 20)
self.buttonAddKnot.clicked.connect(self.addKnot)
def removeKnot(self):
if self.selected == self.tree:
self.showError('Cannot remove root knot', 'Root Error')
else:
self.knotCoordinates = []
self.tree.removeKnot(self.selected.name)
self.tree.traceTree()
self.selected = self.tree
self.selectKnot()
self.frameTree.update()
def addKnot(self):
if self.selected.left and self.selected.right:
self.showError('Knot has already two children', 'Children Error')
else:
self.windowAddKnot.comboSide.clear()
self.windowAddKnot.comboSide.addItems(['left', 'right'] if (
not self.selected.left and not self.selected.right
) else ['left'] if self.selected.right else ['right'])
self.windowAddKnot.labelKnotName.setText(
f'Knot Name: {self.selected.name}')
self.windowAddKnot.setWindowModality(Qt.ApplicationModal)
self.windowAddKnot.setFocusPolicy(Qt.StrongFocus)
self.windowAddKnot.activateWindow()
self.windowAddKnot.setFocus(True)
self.windowAddKnot.raise_()
self.windowAddKnot.show()
def verifyAddition(self, side, name):
if name:
s = self.tree.search(name)
if not s[0]:
if side == 'left': self.selected.left = Knot(name)
else: self.selected.right = Knot(name)
self.windowAddKnot.hide()
elif s[1] != self.tree:
buttonReply = QMessageBox.question(
self.windowAddKnot, f'{name} is already in use',
f"Do you want to transfer children to {self.selected.name} ?\n{name} wille be the {side} child of {self.selected.name}",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if buttonReply == QMessageBox.Yes:
if side == 'left':
if s[1].parentKnot.left:
if s[1].parentKnot.left.name == name:
self.selected.left = s[1].parentKnot.left
s[1].parentKnot.left = None
if s[1].parentKnot.right:
if s[1].parentKnot.right.name == name:
self.selected.left = s[1].parentKnot.right
s[1].parentKnot.right = None
self.selected.left.parent = self.selected
else:
if s[1].parentKnot.left and s[
1].parentKnot.left.name == name:
self.selected.right = s[1].parentKnot.left
s[1].parentKnot.left = None
elif s[1].parentKnot.right and s[
1].parentKnot.right.name == name:
self.selected.right = s[1].parentKnot.right
s[1].parentKnot.right = None
self.selected.right.parent = self.selected
self.windowAddKnot.hide()
else:
self.showError('You can\'t modify tree root', 'Root Error')
self.activateWindow()
self.updateTree()
self.selectKnot()
def updateTree(self):
self.knotCoordinates = []
self.selected = self.tree
self.tree.alt = self.tree.getAlt() - 1
self.tree.setInfos(self)
self.tree.setLabel()
self.tree.traceTree()
self.frameTree.update()
self.tree.label.setStyleSheet(
"border: 2px solid rgb(0,0,144);\nborder-radius:10px;")
def paintEvent(self, e):
self.painter = QPainter(self)
for cos in self.knotCoordinates:
if self.selected.x == cos[0] and self.selected.y + 30 == cos[1]:
self.painter.setPen(
QPen(QColor(144, 0, 0), 3, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
elif self.selected.x == cos[2] and self.selected.y + 10 == cos[3]:
self.painter.setPen(
QPen(QColor(0, 144, 0), 3, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
else:
self.painter.setPen(
QPen(QColor(0, 0, 144), 3, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
self.painter.drawLine(cos[0], cos[1], cos[2], cos[3])
self.painter.end()
def mousePressEvent(self, event):
pos = QCursor.pos()
w = app.widgetAt(pos)
if w != self.frameTree and w is not self.selected.label and 0 <= pos.x(
) <= 600 and 0 <= pos.y() <= 600:
self.selected.label.setStyleSheet(
"border: 2px solid rgb(144,144,144);\nborder-radius:10px;")
s = self.tree.search(w.text())
self.selected = s[1]
self.selectKnot()
def selectKnot(self):
self.selected.label.setStyleSheet(
"border: 2px solid rgb(0,0,144);\nborder-radius:10px;")
self.labelKnotName.setText(f"Knot Name: {self.selected.name}")
self.labelKnotLeaf.setText(f"Knot is Leaf: {self.selected.isLeaf()}")
self.labelKnotAlt.setText(f"Knot Altitude: {self.selected.i}")
self.labelKnotRank.setText(f"Knot Rank: {self.selected.r}")
self.labelKnotParent.setText(
f'Parent Name: {self.selected.parentKnot.name}' if self.selected.
parentKnot else 'Root Knot')
self.labelKnotChildLeft.setText(
f"Left Child Name: {self.selected.left.name}" if self.selected.
left else f"No Left Child")
self.labelKnotChildRight.setText(
f"Right Child Name: {self.selected.right.name}" if self.selected.
right else f"No Right Child")
self.update()
def selecUp(self):
if self.selected.parentKnot:
self.selected.label.setStyleSheet(
"border: 2px solid rgb(144,144,144);\nborder-radius:10px;")
self.selected = self.selected.parentKnot
self.selectKnot()
def selecLeft(self):
if self.selected.parentKnot and self.selected.r != 1:
k = self.selected.parentKnot
checked = [self.selected.name]
while self.selected.i != k.i:
last = k
if k.right and (k.right.name not in checked
and k.right.r < self.selected.r):
checked.append(k.name)
k = k.right
elif k.left and (k.left.name not in checked):
checked.append(k.name)
k = k.left
elif k.parentKnot and (k.parentKnot.name not in checked):
checked.append(k.name)
k = k.parentKnot
elif last == k:
k = self.selected
self.selected.label.setStyleSheet(
"border: 2px solid rgb(144,144,144);\nborder-radius:10px;")
self.selected = k
self.selectKnot()
def selecRight(self):
if self.selected.parentKnot and self.selected.r != 2**self.selected.i:
k = self.selected.parentKnot
checked = [self.selected.name]
while self.selected.i != k.i:
last = k
if k.left and (k.left.name not in checked
and k.left.r > self.selected.r):
checked.append(k.name)
k = k.left
elif k.right and (k.right.name not in checked):
checked.append(k.name)
k = k.right
elif k.parentKnot and (k.parentKnot.name not in checked):
checked.append(k.name)
k = k.parentKnot
elif last == k:
k = self.selected
self.selected.label.setStyleSheet(
"border: 2px solid rgb(144,144,144);\nborder-radius:10px;")
self.selected = k
self.selectKnot()
def selecDown(self):
if self.selected.left:
self.selected.label.setStyleSheet(
"border: 2px solid rgb(144,144,144);\nborder-radius:10px;")
self.selected = self.selected.left
self.selectKnot()
elif self.selected.right:
self.selected.label.setStyleSheet(
"border: 2px solid rgb(144,144,144);\nborder-radius:10px;")
self.selected = self.selected.right
self.selectKnot()
def showError(self, text, title):
self.windowError.setText(text)
self.windowError.setWindowTitle(title)
self.windowError.show()
def paintEvent(self, event):
qp = QPainter(self)
qp.setRenderHint(
QPainter.Antialiasing
) # <- Set anti-aliasing See https://wiki.python.org/moin/PyQt/Painting%20and%20clipping%20demonstration
size = self.size()
widget_width, widget_height = size.width(), size.height()
# Make fonts
time_label_font = qp.font()
time_label_font.setPointSize(self.time_label_font_size)
task_label_font = qp.font()
task_label_font.setPointSize(self.task_label_font_size)
# Frame
qp.setPen(QPen(Qt.black, self.border_size, Qt.SolidLine))
qp.setBrush(QBrush(Qt.white, Qt.SolidPattern))
qp.drawRect(
self.margin_size + self.time_label_margin, # x_start
self.margin_size, # y_start
widget_width - 2 * self.margin_size -
self.time_label_margin, # x_size
widget_height - 2 * self.margin_size) # y_size
## Starting time label
#qp.setFont(time_label_font)
#qp.drawText(0, #self.margin_size, # x_start
# self.margin_size - int(self.time_label_font_size/2), # y_start
# self.time_label_margin, # x_size
# self.time_label_font_size, # y_size
# Qt.AlignCenter,
# self.starting_time_str)
## Ending time label
#qp.setFont(time_label_font)
#qp.drawText(0, #self.margin_size, # x_start
# widget_height - self.margin_size - int(self.time_label_font_size/2), # y_start
# self.time_label_margin, # x_size
# self.time_label_font_size, # y_size
# Qt.AlignCenter,
# self.ending_time_str)
# Draw a line for each hour
qp.setPen(QPen(Qt.gray, 1, Qt.SolidLine))
qp.setFont(time_label_font)
if self.starting_time.minute == 0:
i = 0
else:
i = 1
marker_time = datetime.datetime(year=self.starting_time.year,
month=self.starting_time.month,
day=self.starting_time.day,
hour=self.starting_time.hour + i)
while marker_time.hour <= self.ending_time.hour:
time_marker_str = marker_time.strftime("%H:%M")
marker_time_y_pos = self.timeCoordinateMapper(time_marker_str)
qp.drawLine(
self.margin_size + self.time_label_margin, # x_start
marker_time_y_pos, # y_start
widget_width - self.margin_size, # x_end
marker_time_y_pos) # y_end
qp.drawText(
0, #self.margin_size, # x_start
marker_time_y_pos -
int(self.time_label_font_size / 2), # y_start
self.time_label_margin, # x_size
self.time_label_font_size, # y_size
Qt.AlignCenter,
time_marker_str)
if marker_time.hour == 23:
break
i += 1
marker_time = datetime.datetime(year=self.starting_time.year,
month=self.starting_time.month,
day=self.starting_time.day,
hour=self.starting_time.hour + i)
# Tasks
qp.setPen(QPen(Qt.black, self.border_size, Qt.SolidLine))
#qp.setBrush(QBrush(Qt.yellow, Qt.SolidPattern))
#qp.setBrush(QBrush(QColor("#fcaf3e88"), Qt.SolidPattern))
qp.setBrush(QBrush(QColor(194, 135, 0, 128), Qt.SolidPattern))
qp.setFont(task_label_font)
for task in self.data:
y_start = self.timeCoordinateMapper(task["start"])
y_end = self.timeCoordinateMapper(task["end"])
qp.drawRect(
self.margin_size + self.time_label_margin, # x_start
y_start, # y_start
widget_width - 2 * self.margin_size -
self.time_label_margin, # x_size
y_end - y_start) # y_size
qp.drawText(
self.margin_size + self.time_label_margin, # x_start
y_start, # y_start
widget_width - 2 * self.margin_size -
self.time_label_margin, # x_size
y_end - y_start, # y_size
Qt.AlignCenter,
task["label"])
# Draw a line to show the current time
current_time_str = datetime.datetime.now().strftime("%H:%M")
current_time_y_pos = self.timeCoordinateMapper(current_time_str)
qp.setPen(QPen(Qt.red, self.border_size, Qt.SolidLine))
qp.setBrush(QBrush(Qt.red, Qt.SolidPattern))
qp.drawLine(
self.margin_size + self.time_label_margin, # x_start
current_time_y_pos, # y_start
widget_width - self.margin_size, # x_end
current_time_y_pos) # y_end
# Current time bullet
bullet_border = 5
qp.setPen(QPen(Qt.red, bullet_border, Qt.SolidLine))
qp.setBrush(QBrush(Qt.red, Qt.SolidPattern))
qp.setRenderHint(
QPainter.Antialiasing
) # <- Set anti-aliasing See https://wiki.python.org/moin/PyQt/Painting%20and%20clipping%20demonstration
bullet_radius = 3
qp.drawEllipse(
self.margin_size + self.time_label_margin -
bullet_radius, # x_start,
current_time_y_pos - bullet_radius, # y_start,
2 * bullet_radius,
2 * bullet_radius)
def drawBackground(self):
side = min(self.width(), self.height())
''' Keep side size an even number by trunkating odd pixel '''
side &= ~0x01
gradient = QRadialGradient()
painter = QPainter(self)
pen = QPen(Qt.black)
pen.setWidth(1)
''' Initialize painter '''
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 256.0, side / 256.0)
painter.setPen(pen)
''' Draw external circle '''
gradient = QRadialGradient(QPointF(-128, -128), 384,
QPointF(-128, -128))
gradient.setColorAt(0, QColor(224, 224, 224))
gradient.setColorAt(1, QColor(28, 28, 28))
painter.setPen(pen)
painter.setBrush(QBrush(gradient))
painter.drawEllipse(QPoint(0, 0), 125, 125)
''' Draw inner circle '''
gradient = QRadialGradient(QPointF(128, 128), 384, QPointF(128, 128))
gradient.setColorAt(0, QColor(224, 224, 224))
gradient.setColorAt(1, QColor(28, 28, 28))
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(gradient))
painter.drawEllipse(QPoint(0, 0), 118, 118)
''' Draw inner shield '''
gradient = QRadialGradient(QPointF(-128, -128), 384,
QPointF(-128, -128))
gradient.setColorAt(0, QColor(255, 255, 255))
gradient.setColorAt(1, QColor(224, 224, 224))
painter.setBrush(gradient)
painter.setPen(Qt.NoPen)
painter.drawEllipse(QPoint(0, 0), 115, 115)
painter.setPen(pen)
painter.setBrush(Qt.black)
painter.drawPoint(0, 0)
line = 10
''' Draw scale majorTicks using coords rotation '''
painter.save()
painter.setBrush(Qt.black)
painter.rotate(self.start_angle)
# ''' initial angle (first tick) '''
painter.setBrush(QBrush(Qt.black))
t_rot = self.stop_angle / (self.minorTicks *
(self.majorTicks - 1) + self.majorTicks - 1)
for i in range(
int((self.minorTicks) * (self.majorTicks - 1) +
self.majorTicks)):
if self.minorTicks:
if (self.minorTicks + 1) == 0:
painter.drawLine(QPoint(105, 0), QPoint(105 - line, 0))
else:
painter.drawLine(QPoint(105, 0), QPoint(105 - line / 3, 0))
else:
painter.drawLine(QPoint(105, 0), QPoint(105 - line, 0))
painter.rotate(t_rot)
painter.restore()
''' Draw scale numbers using vector rotation '''
''' x' = xcos(a)-ysin(a) '''
''' y' = xsin(a)-ycos(a) '''
painter.save()
rotation = (self.start_angle /
360) * 2 * pi # ''' Initial rotation '''
painter.setFont(self.digitFont)
for i in range(int(self.majorTicks)):
point = QPointF((70 * cos(rotation)), 70 * sin(rotation))
value = self.scaleFormat.format(self.wmin + i * self.step)
size = painter.fontMetrics().size(Qt.TextSingleLine, value)
point.setX(point.x() - size.width() / 2) # += int()
point.setY(point.y() + size.height() / 4)
painter.drawText(point, value)
rotation += self.rot_rad
painter.restore()
labela = self.labelFormat.format(self.value)
painter.setFont(self.labelFont)
point = QPointF()
size = painter.fontMetrics().size(Qt.TextSingleLine, labela)
point.setX(point.x() - size.width() / 2)
point.setY(point.y() + size.height() / 4 + self.labelOffset)
painter.drawText(point, labela)
if len(self.label) > 0: # Draw meter label
painter.setFont(self.labelFont)
point = QPointF()
size = painter.fontMetrics().size(Qt.TextSingleLine, self.label)
point.setX(point.x() - size.width() / 2)
point.setY(point.y() + size.height() / 4 + self.labelOffset + 24)
painter.drawText(point, self.label)
def overlay_marks(self, img, is_cseed=False, calibration_sheet=False):
border_color = Qt.white
base_img = QImage(self.f_size.width(),self.f_size.height(), QImage.Format_ARGB32)
base_img.fill(border_color)
img = QImage(img)
painter = QPainter()
painter.begin(base_img)
total_distance_h = round(base_img.width() / self.abstand_v)
dist_v = round(total_distance_h) / 2
dist_h = round(total_distance_h) / 2
img = img.scaledToWidth(base_img.width() - (2 * (total_distance_h)))
painter.drawImage(total_distance_h,
total_distance_h,
img)
#frame around image
pen = QPen(Qt.black, 2)
painter.setPen(pen)
#horz
painter.drawLine(0, total_distance_h, base_img.width(), total_distance_h)
painter.drawLine(0, base_img.height()-(total_distance_h), base_img.width(), base_img.height()-(total_distance_h))
#vert
painter.drawLine(total_distance_h, 0, total_distance_h, base_img.height())
painter.drawLine(base_img.width()-(total_distance_h), 0, base_img.width()-(total_distance_h), base_img.height())
#border around img
border_thick = 6
Rpath = QPainterPath()
Rpath.addRect(QRectF((total_distance_h)+(border_thick/2),
(total_distance_h)+(border_thick/2),
base_img.width()-((total_distance_h)*2)-((border_thick)-1),
(base_img.height()-((total_distance_h))*2)-((border_thick)-1)))
pen = QPen(Qt.black, border_thick)
pen.setJoinStyle (Qt.MiterJoin)
painter.setPen(pen)
painter.drawPath(Rpath)
Bpath = QPainterPath()
Bpath.addRect(QRectF((total_distance_h), (total_distance_h),
base_img.width()-((total_distance_h)*2), (base_img.height()-((total_distance_h))*2)))
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawPath(Bpath)
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawLine(0, base_img.height()/2, total_distance_h, base_img.height()/2)
painter.drawLine(base_img.width()/2, 0, base_img.width()/2, total_distance_h)
painter.drawLine(base_img.width()-total_distance_h, base_img.height()/2, base_img.width(), base_img.height()/2)
painter.drawLine(base_img.width()/2, base_img.height(), base_img.width()/2, base_img.height() - total_distance_h)
#print code
f_size = 37
QFontDatabase.addApplicationFont(os.path.join(os.path.dirname(__file__), 'DejaVuSansMono-Bold.ttf'))
font = QFont("DejaVu Sans Mono", f_size-11, QFont.Bold)
font.setPixelSize(35)
painter.setFont(font)
if not calibration_sheet:
if is_cseed: #its a secret
painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0, base_img.height()-dist_v, base_img.width(), base_img.height()-(dist_v))
painter.drawLine(base_img.width()-(dist_h), 0, base_img.width()-(dist_h), base_img.height())
painter.drawImage(((total_distance_h))+11, ((total_distance_h))+11,
QImage(icon_path('electrumb.png')).scaledToWidth(2.1*(total_distance_h), Qt.SmoothTransformation))
painter.setPen(QPen(Qt.white, border_thick*8))
painter.drawLine(base_img.width()-((total_distance_h))-(border_thick*8)/2-(border_thick/2)-2,
(base_img.height()-((total_distance_h)))-((border_thick*8)/2)-(border_thick/2)-2,
base_img.width()-((total_distance_h))-(border_thick*8)/2-(border_thick/2)-2 - 77,
(base_img.height()-((total_distance_h)))-((border_thick*8)/2)-(border_thick/2)-2)
painter.setPen(QColor(0,0,0,255))
painter.drawText(QRect(0, base_img.height()-107, base_img.width()-total_distance_h - border_thick - 11,
base_img.height()-total_distance_h - border_thick), Qt.AlignRight,
self.versioned_seed.version + '_'+self.versioned_seed.checksum)
painter.end()
else: # revealer
painter.setPen(QPen(border_color, 17))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0, base_img.height()-dist_v, base_img.width(), base_img.height()-(dist_v))
painter.drawLine(base_img.width()-(dist_h), 0, base_img.width()-(dist_h), base_img.height())
painter.setPen(QPen(Qt.black, 2))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0, base_img.height()-dist_v, base_img.width(), base_img.height()-(dist_v))
painter.drawLine(base_img.width()-(dist_h), 0, base_img.width()-(dist_h), base_img.height())
logo = QImage(icon_path('revealer_c.png')).scaledToWidth(1.3*(total_distance_h))
painter.drawImage((total_distance_h)+ (border_thick), ((total_distance_h))+ (border_thick), logo, Qt.SmoothTransformation)
#frame around logo
painter.setPen(QPen(Qt.black, border_thick))
painter.drawLine(total_distance_h+border_thick, total_distance_h+logo.height()+3*(border_thick/2),
total_distance_h+logo.width()+border_thick, total_distance_h+logo.height()+3*(border_thick/2))
painter.drawLine(logo.width()+total_distance_h+3*(border_thick/2), total_distance_h+(border_thick),
total_distance_h+logo.width()+3*(border_thick/2), total_distance_h+logo.height()+(border_thick))
#frame around code/qr
qr_size = 179
painter.drawLine((base_img.width()-((total_distance_h))-(border_thick/2)-2)-qr_size,
(base_img.height()-((total_distance_h)))-((border_thick*8))-(border_thick/2)-2,
(base_img.width()/2+(total_distance_h/2)-border_thick-(border_thick*8)/2)-qr_size,
(base_img.height()-((total_distance_h)))-((border_thick*8))-(border_thick/2)-2)
painter.drawLine((base_img.width()/2+(total_distance_h/2)-border_thick-(border_thick*8)/2)-qr_size,
(base_img.height()-((total_distance_h)))-((border_thick*8))-(border_thick/2)-2,
base_img.width()/2 + (total_distance_h/2)-border_thick-(border_thick*8)/2-qr_size,
((base_img.height()-((total_distance_h)))-(border_thick/2)-2))
painter.setPen(QPen(Qt.white, border_thick * 8))
painter.drawLine(
base_img.width() - ((total_distance_h)) - (border_thick * 8) / 2 - (border_thick / 2) - 2,
(base_img.height() - ((total_distance_h))) - ((border_thick * 8) / 2) - (border_thick / 2) - 2,
base_img.width() / 2 + (total_distance_h / 2) - border_thick - qr_size,
(base_img.height() - ((total_distance_h))) - ((border_thick * 8) / 2) - (border_thick / 2) - 2)
painter.setPen(QColor(0,0,0,255))
painter.drawText(QRect(((base_img.width()/2) +21)-qr_size, base_img.height()-107,
base_img.width()-total_distance_h - border_thick -93,
base_img.height()-total_distance_h - border_thick), Qt.AlignLeft, self.versioned_seed.get_ui_string_version_plus_seed())
painter.drawText(QRect(0, base_img.height()-107, base_img.width()-total_distance_h - border_thick -3 -qr_size,
base_img.height()-total_distance_h - border_thick), Qt.AlignRight, self.versioned_seed.checksum)
# draw qr code
qr_qt = self.paintQR(self.versioned_seed.get_ui_string_version_plus_seed()
+ self.versioned_seed.checksum)
target = QRectF(base_img.width()-65-qr_size,
base_img.height()-65-qr_size,
qr_size, qr_size )
painter.drawImage(target, qr_qt)
painter.setPen(QPen(Qt.black, 4))
painter.drawLine(base_img.width()-65-qr_size,
base_img.height()-65-qr_size,
base_img.width() - 65 - qr_size,
(base_img.height() - ((total_distance_h))) - ((border_thick * 8)) - (border_thick / 2) - 4
)
painter.drawLine(base_img.width()-65-qr_size,
base_img.height()-65-qr_size,
base_img.width() - 65,
base_img.height()-65-qr_size
)
painter.end()
else: # calibration only
painter.end()
cal_img = QImage(self.f_size.width() + 100, self.f_size.height() + 100,
QImage.Format_ARGB32)
cal_img.fill(Qt.white)
cal_painter = QPainter()
cal_painter.begin(cal_img)
cal_painter.drawImage(0,0, base_img)
#black lines in the middle of border top left only
cal_painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
cal_painter.drawLine(0, dist_v, base_img.width(), dist_v)
cal_painter.drawLine(dist_h, 0, dist_h, base_img.height())
pen = QPen(Qt.black, 2, Qt.DashDotDotLine)
cal_painter.setPen(pen)
n=15
cal_painter.setFont(QFont("DejaVu Sans Mono", 21, QFont.Bold))
for x in range(-n,n):
#lines on bottom (vertical calibration)
cal_painter.drawLine((((base_img.width())/(n*2)) *(x))+ (base_img.width()/2)-13,
x+2+base_img.height()-(dist_v),
(((base_img.width())/(n*2)) *(x))+ (base_img.width()/2)+13,
x+2+base_img.height()-(dist_v))
num_pos = 9
if x > 9 : num_pos = 17
if x < 0 : num_pos = 20
if x < -9: num_pos = 27
cal_painter.drawText((((base_img.width())/(n*2)) *(x))+ (base_img.width()/2)-num_pos,
50+base_img.height()-(dist_v),
str(x))
#lines on the right (horizontal calibrations)
cal_painter.drawLine(x+2+(base_img.width()-(dist_h)),
((base_img.height()/(2*n)) *(x))+ (base_img.height()/n)+(base_img.height()/2)-13,
x+2+(base_img.width()-(dist_h)),
((base_img.height()/(2*n)) *(x))+ (base_img.height()/n)+(base_img.height()/2)+13)
cal_painter.drawText(30+(base_img.width()-(dist_h)),
((base_img.height()/(2*n)) *(x))+ (base_img.height()/2)+13, str(x))
cal_painter.end()
base_img = cal_img
return base_img
def paintEvent(self, *_):
"""
This is called on self.update() and on resize - makes resizes a bit ugly.
This method draws every frame and forms the core of the program.
"""
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.translate(self.width() / 2,
self.height() / 2) # Make (0,0) centre
if self.draw_axes:
painter.setPen(QPen(QColor(0, 0, 0, 64), 1))
# Line(x1,y2,x2,y2)
painter.drawLine(
QLineF(0,
self.height() / 2, 0, -self.height() / 2))
painter.drawLine(QLineF(self.width() / 2, 0, -self.width() / 2, 0))
colours = interpolate_hsv(self.col1, self.col2, self.num_dots - 2)
# self.num_dots slider minimum is 2, so middle num minimum 0 which is ok
last = None
for cur_dot_num in range(self.num_dots):
if self.join_end_dots:
angle_off = radians(self.angle_factor /
(self.num_dots - 1)) * cur_dot_num
frame_no = self.frame_no + cur_dot_num * (
180 / (self.num_dots - 1)) / self.speedmult
else:
angle_off = radians(
self.angle_factor / self.num_dots) * cur_dot_num
frame_no = self.frame_no + cur_dot_num * (
180 / self.num_dots) / self.speedmult
# green = (240/self.num_dots) * (self.num_dots - cur_dot_num)
# blue = (240/self.num_dots) * cur_dot_num
# colour = QColor(0, green, blue)
colour = next(colours).toRgb()
painter.setPen(QPen(colour))
painter.setBrush(QBrush(colour))
# progress = (cos(radians(SPEED_MULT * frame_no)) + 1)/2 * 180
progress = abs((frame_no * self.speedmult) % (2 * self.halfmax) -
self.halfmax)
# Progress oscillates every 360/speed_mult frames
# Progress dictates the range of values of x later fed into cos(x)
# frame_no multiplier dictates frequency of oscillations
# Progress ranges between 0 and 180 which later gives us a
# cos(progress) ranging between # 1 and -1, which combines with
# sometimes-neg wid * hei to give a full range
# print(self.frame_no,progress)
height = sin(angle_off) * (self.height() - 100)
width = cos(angle_off) * (self.width() - 100)
# (0,0) is the centre
x = cos(radians(self.x_multiplier * progress)) * width / 2
y = cos(radians(self.y_multiplier * progress)) * height / 2
if self.draw_lines:
painter.setPen(QPen(colour, self.dot_size))
painter.drawLine(QPointF(x, y), QPointF(0, 0))
if self.connect_lines:
if last:
painter.drawLine(QPointF(x, y), last)
last = QPointF(x, y)
else:
painter.drawEllipse(QPointF(x, y), self.dot_size,
self.dot_size)
def paintEvent(self, event):
# 时钟指针坐标点
hourPoint = [QPoint(7, 8), QPoint(-7, 8), QPoint(0, -30)]
minPoint = [QPoint(7, 8), QPoint(-7, 8), QPoint(0, -65)]
secPoint = [QPoint(7, 8), QPoint(-7, 8), QPoint(0, -80)]
# 时钟指针颜色
hourColor = QColor(200, 100, 0, 200)
minColor = QColor(0, 127, 127, 150)
secColor = QColor(0, 160, 230, 150)
side = min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2,
self.height() / 2) # painter坐标系原点移至widget中央
painter.scale(side / 200,
side / 200) # 缩放painterwidget坐标系，使绘制的时钟位于widge中央,即钟表支持缩放
# 绘制小时和分钟刻度线
painter.save()
for i in range(0, 60):
if (i % 5) != 0:
painter.setPen(minColor)
painter.drawLine(92, 0, 96, 0) # 绘制分钟刻度线
else:
painter.setPen(hourColor)
painter.drawLine(88, 0, 96, 0) # 绘制小时刻度线
painter.rotate(360 / 60)
painter.restore()
# 绘制小时数字
painter.save()
font = painter.font()
font.setBold(True)
painter.setFont(font)
pointSize = font.pointSize()
painter.setPen(hourColor)
nhour = 0
radius = 100
for i in range(0, 12):
nhour = i + 3 # 按QT-Qpainter的坐标系换算，3小时的刻度线对应坐标轴0度
if nhour > 12:
nhour = nhour - 12
x = radius * 0.8 * cos(i * 30 * pi / 180.0) - pointSize
y = radius * 0.8 * sin(i * 30 * pi / 180.0) - pointSize / 2.0
width = pointSize * 2
height = pointSize
painter.drawText(QRectF(x, y, width, height), Qt.AlignCenter,
str(nhour))
painter.restore()
time = QTime.currentTime()
# 绘制小时指针
painter.save()
painter.setPen(Qt.NoPen) # 无轮廓线
painter.setBrush(hourColor) # 填充色
painter.rotate(30 *
(time.hour() +
time.minute() / 60)) # 每圈360° = 12h 即：旋转角度 = 小时数 * 30°
print(time.hour())
painter.drawConvexPolygon(QPolygonF(hourPoint))
painter.restore()
# 绘制分钟指针
painter.save()
painter.setPen(Qt.NoPen) # 无轮廓线
painter.setBrush(minColor) # 填充色
painter.rotate(6 *
(time.minute() +
time.second() / 60)) # 每圈360° = 60m 即：旋转角度 = 分钟数 * 6°
painter.drawConvexPolygon(QPolygonF(minPoint))
painter.restore()
# 绘制秒钟指针
painter.save()
painter.setPen(Qt.NoPen) # 无轮廓线
painter.setBrush(secColor) # 填充色
painter.rotate(6 * time.second())
painter.drawConvexPolygon(
QPolygonF(secPoint)) # 每圈360° = 60s 即：旋转角度 = 秒数 * 6°
painter.restore()
class Example(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 600, 600)
self.setWindowTitle('Drawing home')
self.width = 175 #default settings
self.height = 100
self.roofHeight = 50
self.mainColor1 = QColor(255, 255, 127)
self.mainColor2 = QColor(255, 85, 0)
self.roofColor = QColor(199, 250, 252)
self.doorColor = QColor(255, 255, 255)
self.lightColor = QColor(255, 219, 41)
self.windowStyle = "Round window"
self.roomNumber = 1
drawButton = QPushButton(
"Move cursor here to update the object, if it was not happened",
self)
drawButton.setFont(QFont("Comic Sans MS", 11, QFont.Normal))
drawButton.move(40, 60)
drawButton.adjustSize()
#sliders etc.
self.changeWidth = QSlider(Qt.Horizontal, self)
self.changeWidth.setFocusPolicy(Qt.NoFocus)
self.changeWidth.setStyleSheet(sldStyle) #use our own style!
self.changeWidth.setGeometry(30, 150, 100, 30)
self.changeWidth.valueChanged[int].connect(self.changeWidthF)
self.changeHeight = QSlider(Qt.Horizontal, self)
self.changeHeight.setFocusPolicy(Qt.NoFocus)
self.changeHeight.setStyleSheet(sldStyle)
self.changeHeight.setGeometry(30, 220, 100, 30)
self.changeHeight.valueChanged[int].connect(self.changeHeightF)
self.changeRoofHeight = QSlider(Qt.Horizontal, self)
self.changeRoofHeight.setFocusPolicy(Qt.NoFocus)
self.changeRoofHeight.setStyleSheet(sldStyle)
self.changeRoofHeight.setGeometry(30, 290, 100, 30)
self.changeRoofHeight.valueChanged[int].connect(self.changeRoofHeightF)
changeWindowStyle = QComboBox(self)
changeWindowStyle.addItem("Round window")
changeWindowStyle.addItem("2-part window")
changeWindowStyle.addItem("No window")
changeWindowStyle.move(30, 365)
changeWindowStyle.setFont(QFont("Tahoma", 10, QFont.Normal))
changeWindowStyle.activated[str].connect(self.changeWindowStyle)
changeWindowStyle.adjustSize()
changeIllumination = QCheckBox('Neon Light', self)
changeIllumination.move(30, 410)
changeIllumination.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeIllumination.adjustSize()
changeIllumination.stateChanged.connect(self.changeIllumination)
changeRoomNumber = QComboBox(self)
changeRoomNumber.addItem("1")
changeRoomNumber.addItem("2")
changeRoomNumber.move(30, 505)
changeRoomNumber.setFont(QFont("Tahoma", 10, QFont.Normal))
changeRoomNumber.activated[int].connect(self.changeRoomNumber)
#labels
changeW = QLabel("Width", self)
changeW.move(30, 120)
changeW.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeH = QLabel("Height", self)
changeH.move(30, 190)
changeH.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeRH = QLabel("Roof level", self)
changeRH.move(30, 260)
changeRH.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeWS = QLabel("Window style", self)
changeWS.move(30, 330)
changeWS.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeWS.adjustSize()
changeRN = QLabel("Number of rooms", self)
changeRN.move(30, 450)
changeRN.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeRN.adjustSize()
changeRN1 = QLabel("on the 2nd floor", self)
changeRN1.move(30, 470)
changeRN1.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeRN1.adjustSize()
#toolbar actions
roofColorAction = QAction(QIcon('colorR.png'),
'Change color of the roof', self)
roofColorAction.triggered.connect(self.changeRoofColor)
color1Action = QAction(QIcon('color2.png'),
'Change color of the upper part', self)
color1Action.triggered.connect(self.changeColor1)
color2Action = QAction(QIcon('color1.png'),
'Change color of the lower part', self)
color2Action.triggered.connect(self.changeColor2)
doorColorAction = QAction(QIcon('colorD.png'),
'Change color of the door', self)
doorColorAction.triggered.connect(self.changeDoorColor)
randomizeAction = QAction(QIcon('random.png'), 'Randonize your house',
self)
randomizeAction.triggered.connect(self.randomize)
toolbar = self.addToolBar('Menu')
toolbar.setIconSize(QSize(45, 45))
toolbar.addAction(roofColorAction)
toolbar.addAction(color2Action)
toolbar.addAction(color1Action)
toolbar.addAction(doorColorAction)
toolbar.addAction(randomizeAction)
self.show()
def paintEvent(self, e):
#print("paint")
self.qp = QPainter(self)
#self.qp.setPen(QColor(245, 245, 245)) #if you need no black circuit
triangle = QPolygonF([
QPointF(200, 200),
QPointF(200 + self.width, 200),
QPointF(200 + self.width / 2, 200 - self.roofHeight)
])
self.qp.setBrush(QBrush(self.roofColor, Qt.SolidPattern))
self.qp.drawPolygon(triangle) #roof
self.qp.setBrush(QBrush(self.mainColor1, Qt.SolidPattern))
self.qp.drawRect(200, 200, self.width, self.height) #upper part
self.qp.setBrush(QBrush(self.mainColor2, Qt.SolidPattern))
self.qp.drawRect(200, 200 + self.height, self.width,
self.height) #lower part
#details
self.qp.setBrush(QBrush(self.doorColor, Qt.SolidPattern))
self.qp.drawRect(130 + self.width, 115 + 2 * self.height, 50,
80) #calculate door
self.qp.setBrush(QBrush(self.lightColor, Qt.SolidPattern))
self.qp.drawRect(140 + self.width, 125 + 2 * self.height, 30,
40) #window on the door
self.qp.setBrush(QBrush(QColor(173, 98, 23), Qt.SolidPattern))
self.qp.drawEllipse(173 + self.width, 160 + 2 * self.height, 4,
4) #door handle
#variants of the window on the third floor
self.qp.setBrush(QBrush(self.lightColor, Qt.SolidPattern))
if self.windowStyle == "Round window":
diameter = 30 * (self.roofHeight / 50) #calculate proportion
if diameter > 45:
diameter = 45 #limit for normal design
self.qp.drawEllipse(200 - diameter / 2 + self.width / 2,
200 - diameter / 2 - self.roofHeight * 0.45,
diameter, diameter)
self.qp.setPen(QPen(QColor(173, 98, 23), 3,
Qt.SolidLine)) #window planks
self.qp.drawLine(202 - diameter / 2 + self.width / 2,
200 - self.roofHeight * 0.45,
198 + diameter / 2 + self.width / 2,
200 - self.roofHeight * 0.45)
self.qp.drawLine(200 + self.width / 2,
198 + diameter / 2 - self.roofHeight * 0.45,
200 + self.width / 2,
202 - diameter / 2 - self.roofHeight * 0.45)
if self.windowStyle == "2-part window":
left = QPolygonF([
QPointF(200 + self.width / 3, 195),
QPointF(197 + self.width / 2, 195),
QPointF(197 + self.width / 2, 210 - self.roofHeight / 1.04),
QPointF(200 + self.width / 3, 210 - self.roofHeight / 1.5)
])
self.qp.drawPolygon(left)
right = QPolygonF([
QPointF(200 + self.width * 2 / 3, 195),
QPointF(203 + self.width / 2, 195),
QPointF(203 + self.width / 2, 210 - self.roofHeight / 1.04),
QPointF(200 + self.width * 2 / 3, 210 - self.roofHeight / 1.5)
])
self.qp.drawPolygon(right)
#window on the first floor
self.qp.setPen(QPen(Qt.black, 1, Qt.SolidLine))
self.qp.drawRect(210 + 2 / 5 * (self.width - 175),
110 + 2 * self.height - 1 / 5 * (self.height - 100),
75 + 2 / 5 * (self.width - 175),
65 + 1 / 5 * (self.height - 100))
xc = 210 + 2 / 5 * (self.width - 175) + (75 + 2 / 5 *
(self.width - 175)) / 2
yc = 110 + 2 * self.height - 1 / 5 * (self.height -
100) + (65 + 1 / 5 *
(self.height - 100)) / 2
xr = 208 + 2 / 5 * (self.width - 175) + 75 + 2 / 5 * (self.width - 175)
yd = 108 + 2 * self.height - 1 / 5 * (
self.height - 100) + 65 + 1 / 5 * (self.height - 100)
self.qp.setPen(QPen(QColor(173, 98, 23), 3, Qt.SolidLine))
self.qp.drawLine(212 + 2 / 5 * (self.width - 175), yc, xr, yc)
self.qp.drawLine(xc,
112 + 2 * self.height - 1 / 5 * (self.height - 100),
xc, yd)
#windows on the second floor
self.qp.setPen(QPen(Qt.black, 1, Qt.SolidLine))
yc = 110 + self.height - 1 / 5 * (self.height - 100)
yd = 65 + 1 / 5 * (
self.height - 100
) #use our previous variables to make arguments shorter
if self.roomNumber == 1:
self.qp.drawRect(200 + self.width * 0.2, yc, self.width * 0.6, yd)
self.qp.setPen(QPen(QColor(173, 98, 23), 3, Qt.SolidLine))
self.qp.drawLine(200 + self.width * 0.4, yc + 2,
200 + self.width * 0.4, yc + yd - 2)
self.qp.drawLine(200 + self.width * 0.6, yc + 2,
200 + self.width * 0.6, yc + yd - 2)
if self.roomNumber == 2:
self.qp.drawRect(200 + self.width * 0.1, yc, self.width * 0.35, yd)
self.qp.drawRect(200 + self.width * 0.55, yc, self.width * 0.35,
yd)
self.qp.setPen(QPen(QColor(173, 98, 23), 3, Qt.SolidLine))
self.qp.drawLine(200 + self.width * 0.275, yc + 2,
200 + self.width * 0.275, yc + yd - 2)
self.qp.drawLine(200 + self.width * 0.725, yc + 2,
200 + self.width * 0.725, yc + yd - 2)
self.qp.end()
self.update() #need to draw again our image
def changeRoofColor(self):
roofColor = QColorDialog.getColor()
if roofColor.isValid():
self.roofColor = roofColor
def changeColor1(self):
mainColor1 = QColorDialog.getColor()
if mainColor1.isValid():
self.mainColor1 = mainColor1
def changeColor2(self):
mainColor2 = QColorDialog.getColor()
if mainColor2.isValid():
self.mainColor2 = mainColor2
def changeDoorColor(self):
doorColor = QColorDialog.getColor()
if doorColor.isValid():
self.doorColor = doorColor
def changeWidthF(self, value):
#print("changed to " + str(value + 150))
self.width = value + 175
def changeHeightF(self, value):
self.height = value / 2 + 100 #keep in mind max and min value of each characteristic
def changeRoofHeightF(self, value):
self.roofHeight = value / 2 + 50
def changeWindowStyle(self, text):
self.windowStyle = text
def changeIllumination(self, state):
if state == Qt.Checked:
self.lightColor = QColor(229, 101, 157) #purple
else:
self.lightColor = QColor(255, 219, 41) #orange
def changeRoomNumber(self, text):
self.roomNumber = int(text) + 1
def randomize(self):
self.width = r.randint(175, 275)
self.changeWidth.setValue(self.width - 175)
self.height = r.randint(100, 150)
self.changeHeight.setValue(self.height - 100)
self.roofHeight = r.randint(50, 100)
self.changeRoofHeight.setValue(self.roofHeight - 50)
self.mainColor1 = QColor(r.randint(0, 255), r.randint(0, 255),
r.randint(0, 255))
self.mainColor2 = QColor(r.randint(0, 255), r.randint(0, 255),
r.randint(0, 255))
self.roofColor = QColor(r.randint(0, 255), r.randint(0, 255),
r.randint(0, 255))
self.doorColor = QColor(r.randint(0, 255), r.randint(0, 255),
r.randint(0, 255))
def show_network(self, painter: QtGui.QPainter):
painter.setRenderHints(QtGui.QPainter.Antialiasing)
painter.setRenderHints(QtGui.QPainter.HighQualityAntialiasing)
painter.setRenderHint(QtGui.QPainter.TextAntialiasing)
painter.setRenderHint(QtGui.QPainter.SmoothPixmapTransform)
vertical_space = 4.5 ################ chỉnh đồ hoạ mạng noron
radius = 4.5
height = self.frameGeometry().height()
width = self.frameGeometry().width()
layer_nodes = self.snake.network.layer_nodes
default_offset = 30
h_offset = default_offset
inputs = self.snake.vision_as_array
out = self.snake.network.feed_forward(
inputs) # @TODO: không cần điều này
max_out = np.argmax(out)
# Vẽ nodes
for layer, num_nodes in enumerate(layer_nodes):
v_offset = (height -
((2 * radius + vertical_space) * num_nodes)) / 2
activations = None
if layer > 0:
activations = self.snake.network.params['A' + str(layer)]
for node in range(num_nodes):
x_loc = h_offset
y_loc = node * (radius * 2 + vertical_space) + v_offset
t = (layer, node)
if t not in self.neuron_locations:
self.neuron_locations[t] = (x_loc, y_loc + radius)
painter.setBrush(QtGui.QBrush(Qt.white, Qt.NoBrush))
# Input layer
if layer == 0:
# Có một giá trị được cho nuôi trong
if inputs[node, 0] > 0:
painter.setBrush(QtGui.QBrush(
Qt.black)) ########### mới sửa từ màu blue
else:
painter.setBrush(QtGui.QBrush(Qt.white))
# Lớp giữa
elif layer > 0 and layer < len(layer_nodes) - 1:
try:
saturation = max(min(activations[node, 0], 1.0), 0.0)
except:
print(self.snake.network.params)
import sys
sys.exit(-1)
painter.setBrush(
QtGui.QBrush(
QtGui.QColor.fromHslF(125 / 239, saturation,
120 / 240)))
# Lớp ra
elif layer == len(layer_nodes) - 1:
text = ('U', 'D', 'L', 'R')[node]
painter.drawText(
h_offset + 30,
node * (radius * 2 + vertical_space) + v_offset +
1.5 * radius, text)
if node == max_out:
painter.setBrush(QtGui.QBrush(
Qt.green)) ########### đúng ra là blue
else:
painter.setBrush(QtGui.QBrush(Qt.white))
painter.drawEllipse(x_loc, y_loc, radius * 2, radius * 2)
h_offset += 150
# Đặt lại bù ngang cho các trọng số
h_offset = default_offset
# Vẽ trọng lượng
# Đối với mỗi lớp bắt đầu từ 1
for l in range(1, len(layer_nodes)):
weights = self.snake.network.params['W' + str(l)]
prev_nodes = weights.shape[1]
curr_nodes = weights.shape[0]
# Đối với mỗi nút từ lớp trước
for prev_node in range(prev_nodes):
# Đối với tất cả các nút hiện tại, hãy kiểm tra xem trọng số là gì
for curr_node in range(curr_nodes):
# Nếu có trọng lượng dương, làm cho đường màu xanh lá cây
if weights[curr_node, prev_node] > 0:
painter.setPen(QtGui.QPen(Qt.green))
# Nếu có trọng lượng âm (cản trở), làm cho đường màu đỏ
else:
painter.setPen(QtGui.QPen(Qt.red))
# Lấy vị trí của các nút
start = self.neuron_locations[(l - 1, prev_node)]
end = self.neuron_locations[(l, curr_node)]
# Offset bắt đầu [0] theo đường kính của vòng tròn để đường bắt đầu ở bên phải của vòng tròn
painter.drawLine(start[0] + radius * 2, start[1], end[0],
end[1])
def drawValues(self, qp: QtGui.QPainter):
if len(self.data) == 0 and len(self.reference) == 0:
return
pen = QtGui.QPen(self.sweepColor)
pen.setWidth(self.pointSize)
line_pen = QtGui.QPen(self.sweepColor)
line_pen.setWidth(self.lineThickness)
highlighter = QtGui.QPen(QtGui.QColor(20, 0, 255))
highlighter.setWidth(1)
if not self.fixedSpan:
if len(self.data) > 0:
fstart = self.data[0].freq
fstop = self.data[len(self.data)-1].freq
else:
fstart = self.reference[0].freq
fstop = self.reference[len(self.reference) - 1].freq
self.fstart = fstart
self.fstop = fstop
else:
fstart = self.fstart = self.minFrequency
fstop = self.fstop = self.maxFrequency
# Draw bands if required
if self.bands.enabled:
self.drawBands(qp, fstart, fstop)
if self.fixedValues:
maxValue = self.maxDisplayValue / 10e11
minValue = self.minDisplayValue / 10e11
self.maxValue = maxValue
self.minValue = minValue
else:
# Find scaling
minValue = 1
maxValue = -1
for d in self.data:
val = d.capacitiveEquivalent()
if val > maxValue:
maxValue = val
if val < minValue:
minValue = val
for d in self.reference: # Also check min/max for the reference sweep
if d.freq < self.fstart or d.freq > self.fstop:
continue
val = d.capacitiveEquivalent()
if val > maxValue:
maxValue = val
if val < minValue:
minValue = val
self.maxValue = maxValue
self.minValue = minValue
span = maxValue - minValue
if span == 0:
logger.info("Span is zero for CapacitanceChart, setting to a small value.")
span = 1e-15
self.span = span
target_ticks = math.floor(self.chartHeight / 60)
fmt = Format(max_nr_digits=1)
for i in range(target_ticks):
val = minValue + (i / target_ticks) * span
y = self.topMargin + round((self.maxValue - val) / self.span * self.chartHeight)
qp.setPen(self.textColor)
if val != minValue:
valstr = str(Value(val, fmt=fmt))
qp.drawText(3, y + 3, valstr)
qp.setPen(QtGui.QPen(self.foregroundColor))
qp.drawLine(self.leftMargin - 5, y, self.leftMargin + self.chartWidth, y)
qp.setPen(QtGui.QPen(self.foregroundColor))
qp.drawLine(self.leftMargin - 5, self.topMargin,
self.leftMargin + self.chartWidth, self.topMargin)
qp.setPen(self.textColor)
qp.drawText(3, self.topMargin + 4, str(Value(maxValue, fmt=fmt)))
qp.drawText(3, self.chartHeight+self.topMargin, str(Value(minValue, fmt=fmt)))
self.drawFrequencyTicks(qp)
self.drawData(qp, self.data, self.sweepColor)
self.drawData(qp, self.reference, self.referenceColor)
self.drawMarkers(qp)
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
qp.drawLine(self.pos1[0], self.pos1[1], self.pos2[0], self.pos2[1])
qp.end()
def paintEvent(self, event):
self.topLabel.setText(self.text)
qp = QPainter()
qp.begin(self)
qp.setPen(QPen(QBrush(Qt.black), 5))
qp.setFont(QFont('Times', 16))
if self.settingScreen == False:
qp.drawLine(
QLine(self.rod_Xcoord, self.rod_Ycoord,
self.circle_Xcoord + 25, self.circle_Ycoord + 25))
qp.setBrush(QBrush(Qt.black, Qt.SolidPattern))
qp.drawEllipse(self.circle_Xcoord, self.circle_Ycoord, 50, 50)
for item in buttonList:
item.draw(qp)
if self.settingScreen == False:
if self.massScreen == True:
qp.setPen(QPen(QBrush(Qt.blue), 2))
qp.setBrush(QBrush(Qt.blue))
qp.drawRect(75, W_HEIGHT - 70, 100, 10)
qp.setPen(QPen(QBrush(Qt.black), 2))
qp.drawRect(75, W_HEIGHT - 70, 100, 10)
drawNextMassY = W_HEIGHT - 70
for item in self.massArray:
qp.setBrush(QBrush(Qt.gray))
if item == 1:
height = 6
elif item == 10:
height = 15
elif item == 20:
height = 30
else:
height = 45
qp.drawRect(85, drawNextMassY - (height), 80, height)
drawNextMassY = drawNextMassY - (height)
qp.drawText(90, W_HEIGHT - 30,
'Mass: ' + str(self.mass) + ' g')
else:
qp.setPen(QPen(QBrush(Qt.black), 3))
qp.drawText(150, 400, 'Period: ' + str(self.period) + ' s')
if self.calc != None:
qp.drawText(200, 150, str(self.calc))
if self.displayResults == True:
qp.setPen(QPen(QBrush(Qt.black), 2))
if self.force == 0:
qp.drawText(125, 250, 'Calculating...')
else:
if isinstance(self.force, str) == False:
qp.drawText(
125, 250, 'Centripetal Force: ' +
str(round(self.force, 2)) + ' N')
qp.drawText(125, 300, 'Mass: ' + str(self.mass) + ' g')
qp.drawText(125, 350, 'Period: ' + str(self.period) + ' s')
else:
qp.drawText(125, 250, 'Centripetal Force: ' + self.force)
qp.drawText(125, 300, 'Mass: ' + str(self.mass) + ' g')
class Example(QWidget):
def __init__(self):
super().__init__()
self.n = 1
self.filename = QFileDialog.getOpenFileName(self,
'Выбрать файл L-системы',
'/')[0]
self.initUI()
def initUI(self):
self.setGeometry(500, 500, *SCREEN_SIZE)
self.setWindowTitle('L - системы')
self.flag = False
self.slider = QSlider(Qt.Horizontal, self)
self.slider.move(25, 480)
self.slider.valueChanged.connect(self.draw)
self.slider.setMinimum(1)
self.slider.setMaximum(10)
self.slider.setFixedWidth(450)
self.show()
def draw(self, value):
self.flag = True
self.n = value
qp = QPainter()
qp.begin(self)
self.qp = QPainter()
self.qp.begin(self)
self.drawL()
self.qp.end()
qp.end()
self.update()
self.show()
def paintEvent(self, e):
if self.flag:
qp = QPainter()
qp.begin(self)
self.qp = QPainter()
self.qp.begin(self)
self.drawL()
self.qp.end()
qp.end()
def moveto(self, x, y):
self.graph_pos[0] = x
self.graph_pos[1] = y
def lineto(self, x, y):
self.qp.drawLine(*self.graph_pos, int(x), int(y))
self.graph_pos[0] = int(x)
self.graph_pos[1] = int(y)
# Построение L-системы по L-строке
def plotlsystem(self, lstring):
for ch in lstring:
if ch == "F":
self.POSITION[0] += self.step * cos(radians(self.POSITION[2]))
self.POSITION[1] += self.step * sin(radians(self.POSITION[2]))
self.lineto(xs(self.POSITION[0]), ys(self.POSITION[1]))
elif ch == "f":
self.POSITION[0] += self.step * cos(radians(self.POSITION[2]))
self.POSITION[1] += self.step * sin(radians(self.POSITION[2]))
self.lineto(xs(self.POSITION[0]), ys(self.POSITION[1]))
elif ch == "-":
self.POSITION[2] += LSystem["ANGLE"]
elif ch == "+":
self.POSITION[2] -= LSystem["ANGLE"]
elif ch == "[":
STACK.append(self.POSITION[:])
elif ch == "]":
if STACK:
self.POSITION[0], self.POSITION[1], self.POSITION[
2] = STACK.pop(-1)
self.moveto(xs(self.POSITION[0]), ys(self.POSITION[1]))
def drawL(self):
readlsystem(self.filename)
x, y = 0, 0
self.step = 20
self.POSITION = [x, y, 0]
self.graph_pos = [xs(x), xs(y)]
self.plotlsystem(buildlsystem(self.n))
class _ContentGame(QWidget):
def __init__(self, app, parent=None):
super().__init__(parent=parent)
self.app = app
self.game = app.game
self.cellsize = min(app.width() // self.game.width,
app.height() // self.game.height)
self.cellsize3 = self.cellsize // 3
self.cellsize4 = self.cellsize // 4
self.setFixedSize(self.cellsize * self.game.width,
self.cellsize * self.game.height)
self.cellsize6 = self.cellsize // 6
self.cellsize23 = self.cellsize3 * 2
self.cellsize34 = self.cellsize4 * 3
self.qp = QPainter()
def paint_cell(self, i, j):
self.qp.drawRect(j * self.cellsize, i * self.cellsize, self.cellsize,
self.cellsize)
def paint_flag(self, i, j):
self.qp.drawRect(j * self.cellsize + self.cellsize3,
i * self.cellsize + self.cellsize3, self.cellsize3,
self.cellsize3)
def paint_winning_cell(self, i, j):
self.qp.drawRect(j * self.cellsize,
(i + 1) * self.cellsize - self.cellsize4,
self.cellsize, self.cellsize4)
def paint_grid(self):
self.qp.setPen(Qt.black)
for i in range(self.game.height):
self.qp.drawLine(0, i * self.cellsize, self.height(),
i * self.cellsize)
for i in range(self.game.width):
self.qp.drawLine(i * self.cellsize, 0, i * self.cellsize,
self.width())
def set_cell_color(self, i, j):
celltype = self.game.map[i][j]
if celltype == game.EMPTY:
self.qp.setBrush(Qt.lightGray)
elif celltype == game.BLOCK:
self.qp.setBrush(Qt.darkGray)
elif celltype in game.TYPE1:
self.qp.setBrush(Qt.green)
elif celltype in game.TYPE2:
self.qp.setBrush(Qt.blue)
elif celltype in game.TYPE3:
self.qp.setBrush(Qt.yellow)
elif celltype in game.TYPE4:
self.qp.setBrush(Qt.red)
def paint_field(self):
self.qp.setPen(Qt.black)
for i in range(self.game.height):
for j in range(self.game.width):
self.set_cell_color(i, j)
self.paint_cell(i, j)
def paint_flags(self):
for i in range(self.game.height):
for j in range(self.game.width):
if self.game.map[i][j] in game.WHITE_FIGURES:
self.qp.setBrush(Qt.white)
self.paint_flag(i, j)
if self.game.map[i][j] in game.BLACK_FIGURES:
self.qp.setBrush(Qt.black)
self.paint_flag(i, j)
def paint_winning_position(self):
self.qp.setBrush(Qt.white)
for i, j in self.game.white_winning_position:
self.paint_winning_cell(i, j)
self.qp.setBrush(Qt.black)
for i, j in self.game.black_winning_position:
self.paint_winning_cell(i, j)
def mousePressEvent(self, event):
i, j = self.pressed_cell(event)
result = self.game.press_cell(i, j)
self.repaint()
self.app.handle_press_cell(result)
def pressed_cell(self, event):
pos = event.pos()
return pos.y() // self.cellsize, pos.x() // self.cellsize
def paint_selected_cell(self):
i, j = self.game.selected_cell
self.set_cell_color(i, j)
self.qp.drawRect(j * self.cellsize - self.cellsize6,
i * self.cellsize - self.cellsize6,
self.cellsize + self.cellsize3,
self.cellsize + self.cellsize3)
def paint_available_move(self, i, j):
self.qp.drawRect(j * self.cellsize + self.cellsize6,
i * self.cellsize + self.cellsize6, self.cellsize23,
self.cellsize23)
def paint_available_moves(self):
for i, j in self.game.available_moves:
self.paint_available_move(i, j)
def paintEvent(self, event):
self.qp.begin(self)
self.paint_grid()
self.paint_field()
self.paint_winning_position()
if self.game.selected_cell:
self.paint_selected_cell()
self.paint_available_moves()
self.paint_flags()
self.qp.end()
def drawValues(self, qp: QtGui.QPainter):
if len(self.data) == 0 and len(self.reference) == 0:
return
pen = QtGui.QPen(self.sweepColor)
pen.setWidth(self.pointSize)
line_pen = QtGui.QPen(self.sweepColor)
line_pen.setWidth(self.lineThickness)
highlighter = QtGui.QPen(QtGui.QColor(20, 0, 255))
highlighter.setWidth(1)
if self.fixedSpan:
fstart = self.minFrequency
fstop = self.maxFrequency
else:
if len(self.data) > 0:
fstart = self.data[0].freq
fstop = self.data[len(self.data) - 1].freq
else:
fstart = self.reference[0].freq
fstop = self.reference[len(self.reference) - 1].freq
self.fstart = fstart
self.fstop = fstop
# Draw bands if required
if self.bands.enabled:
self.drawBands(qp, fstart, fstop)
# Find scaling
if self.fixedValues:
min_real = self.minDisplayReal
max_real = self.maxDisplayReal
min_imag = self.minDisplayImag
max_imag = self.maxDisplayImag
else:
min_real = 1000
min_imag = 1000
max_real = 0
max_imag = -1000
for d in self.data:
imp = d.impedance()
re, im = imp.real, imp.imag
if re > max_real:
max_real = re
if re < min_real:
min_real = re
if im > max_imag:
max_imag = im
if im < min_imag:
min_imag = im
for d in self.reference: # Also check min/max for the reference sweep
if d.freq < fstart or d.freq > fstop:
continue
imp = d.impedance()
re, im = imp.real, imp.imag
if re > max_real:
max_real = re
if re < min_real:
min_real = re
if im > max_imag:
max_imag = im
if im < min_imag:
min_imag = im
# Always have at least 8 numbered horizontal lines
max_real = max(8, math.ceil(max_real))
min_real = max(
0, math.floor(min_real)) # Negative real resistance? No.
max_imag = math.ceil(max_imag)
min_imag = math.floor(min_imag)
if max_imag - min_imag < 8:
missing = 8 - (max_imag - min_imag)
max_imag += math.ceil(missing / 2)
min_imag -= math.floor(missing / 2)
if 0 > max_imag > -2:
max_imag = 0
if 0 < min_imag < 2:
min_imag = 0
if (max_imag - min_imag) > 8 and min_imag < 0 < max_imag:
# We should show a "0" line for the reactive part
span = max_imag - min_imag
step_size = span / 8
if max_imag < step_size:
# The 0 line is the first step after the top. Scale accordingly.
max_imag = -min_imag / 7
elif -min_imag < step_size:
# The 0 line is the last step before the bottom. Scale accordingly.
min_imag = -max_imag / 7
else:
# Scale max_imag to be a whole factor of min_imag
num_min = math.floor(min_imag / step_size * -1)
num_max = 8 - num_min
max_imag = num_max * (min_imag / num_min) * -1
self.max_real = max_real
self.max_imag = max_imag
span_real = max_real - min_real
if span_real == 0:
span_real = 0.01
self.span_real = span_real
span_imag = max_imag - min_imag
if span_imag == 0:
span_imag = 0.01
self.span_imag = span_imag
# We want one horizontal tick per 50 pixels, at most
horizontal_ticks = math.floor(self.chartHeight / 50)
for i in range(horizontal_ticks):
y = self.topMargin + round(i * self.chartHeight / horizontal_ticks)
qp.setPen(QtGui.QPen(self.foregroundColor))
qp.drawLine(self.leftMargin - 5, y,
self.leftMargin + self.chartWidth + 5, y)
qp.setPen(QtGui.QPen(self.textColor))
re = max_real - i * span_real / horizontal_ticks
im = max_imag - i * span_imag / horizontal_ticks
qp.drawText(3, y + 4, str(round(re, 1)))
qp.drawText(self.leftMargin + self.chartWidth + 8, y + 4,
str(round(im, 1)))
qp.drawText(3, self.chartHeight + self.topMargin,
str(round(min_real, 1)))
qp.drawText(self.leftMargin + self.chartWidth + 8,
self.chartHeight + self.topMargin, str(round(min_imag, 1)))
self.drawFrequencyTicks(qp)
primary_pen = pen
secondary_pen = QtGui.QPen(self.secondarySweepColor)
if len(self.data) > 0:
c = QtGui.QColor(self.sweepColor)
c.setAlpha(255)
pen = QtGui.QPen(c)
pen.setWidth(2)
qp.setPen(pen)
qp.drawLine(20, 9, 25, 9)
c = QtGui.QColor(self.secondarySweepColor)
c.setAlpha(255)
pen.setColor(c)
qp.setPen(pen)
qp.drawLine(self.leftMargin + self.chartWidth, 9,
self.leftMargin + self.chartWidth + 5, 9)
primary_pen.setWidth(self.pointSize)
secondary_pen.setWidth(self.pointSize)
line_pen.setWidth(self.lineThickness)
for i in range(len(self.data)):
x = self.getXPosition(self.data[i])
y_re = self.getReYPosition(self.data[i])
y_im = self.getImYPosition(self.data[i])
qp.setPen(primary_pen)
if self.isPlotable(x, y_re):
qp.drawPoint(x, y_re)
qp.setPen(secondary_pen)
if self.isPlotable(x, y_im):
qp.drawPoint(x, y_im)
if self.drawLines and i > 0:
prev_x = self.getXPosition(self.data[i - 1])
prev_y_re = self.getReYPosition(self.data[i - 1])
prev_y_im = self.getImYPosition(self.data[i - 1])
# Real part first
line_pen.setColor(self.sweepColor)
qp.setPen(line_pen)
if self.isPlotable(x, y_re) and self.isPlotable(
prev_x, prev_y_re):
qp.drawLine(x, y_re, prev_x, prev_y_re)
elif self.isPlotable(
x, y_re) and not self.isPlotable(prev_x, prev_y_re):
new_x, new_y = self.getPlotable(x, y_re, prev_x, prev_y_re)
qp.drawLine(x, y_re, new_x, new_y)
elif not self.isPlotable(x, y_re) and self.isPlotable(
prev_x, prev_y_re):
new_x, new_y = self.getPlotable(prev_x, prev_y_re, x, y_re)
qp.drawLine(prev_x, prev_y_re, new_x, new_y)
# Imag part second
line_pen.setColor(self.secondarySweepColor)
qp.setPen(line_pen)
if self.isPlotable(x, y_im) and self.isPlotable(
prev_x, prev_y_im):
qp.drawLine(x, y_im, prev_x, prev_y_im)
elif self.isPlotable(
x, y_im) and not self.isPlotable(prev_x, prev_y_im):
new_x, new_y = self.getPlotable(x, y_im, prev_x, prev_y_im)
qp.drawLine(x, y_im, new_x, new_y)
elif not self.isPlotable(x, y_im) and self.isPlotable(
prev_x, prev_y_im):
new_x, new_y = self.getPlotable(prev_x, prev_y_im, x, y_im)
qp.drawLine(prev_x, prev_y_im, new_x, new_y)
primary_pen.setColor(self.referenceColor)
line_pen.setColor(self.referenceColor)
secondary_pen.setColor(self.secondaryReferenceColor)
qp.setPen(primary_pen)
if len(self.reference) > 0:
c = QtGui.QColor(self.referenceColor)
c.setAlpha(255)
pen = QtGui.QPen(c)
pen.setWidth(2)
qp.setPen(pen)
qp.drawLine(20, 14, 25, 14)
c = QtGui.QColor(self.secondaryReferenceColor)
c.setAlpha(255)
pen = QtGui.QPen(c)
pen.setWidth(2)
qp.setPen(pen)
qp.drawLine(self.leftMargin + self.chartWidth, 14,
self.leftMargin + self.chartWidth + 5, 14)
for i in range(len(self.reference)):
if self.reference[i].freq < fstart or self.reference[
i].freq > fstop:
continue
x = self.getXPosition(self.reference[i])
y_re = self.getReYPosition(self.reference[i])
y_im = self.getImYPosition(self.reference[i])
qp.setPen(primary_pen)
if self.isPlotable(x, y_re):
qp.drawPoint(x, y_re)
qp.setPen(secondary_pen)
if self.isPlotable(x, y_im):
qp.drawPoint(x, y_im)
if self.drawLines and i > 0:
prev_x = self.getXPosition(self.reference[i - 1])
prev_y_re = self.getReYPosition(self.reference[i - 1])
prev_y_im = self.getImYPosition(self.reference[i - 1])
line_pen.setColor(self.referenceColor)
qp.setPen(line_pen)
# Real part first
if self.isPlotable(x, y_re) and self.isPlotable(
prev_x, prev_y_re):
qp.drawLine(x, y_re, prev_x, prev_y_re)
elif self.isPlotable(
x, y_re) and not self.isPlotable(prev_x, prev_y_re):
new_x, new_y = self.getPlotable(x, y_re, prev_x, prev_y_re)
qp.drawLine(x, y_re, new_x, new_y)
elif not self.isPlotable(x, y_re) and self.isPlotable(
prev_x, prev_y_re):
new_x, new_y = self.getPlotable(prev_x, prev_y_re, x, y_re)
qp.drawLine(prev_x, prev_y_re, new_x, new_y)
line_pen.setColor(self.secondaryReferenceColor)
qp.setPen(line_pen)
# Imag part second
if self.isPlotable(x, y_im) and self.isPlotable(
prev_x, prev_y_im):
qp.drawLine(x, y_im, prev_x, prev_y_im)
elif self.isPlotable(
x, y_im) and not self.isPlotable(prev_x, prev_y_im):
new_x, new_y = self.getPlotable(x, y_im, prev_x, prev_y_im)
qp.drawLine(x, y_im, new_x, new_y)
elif not self.isPlotable(x, y_im) and self.isPlotable(
prev_x, prev_y_im):
new_x, new_y = self.getPlotable(prev_x, prev_y_im, x, y_im)
qp.drawLine(prev_x, prev_y_im, new_x, new_y)
# Now draw the markers
for m in self.markers:
if m.location != -1:
x = self.getXPosition(self.data[m.location])
y_re = self.getReYPosition(self.data[m.location])
y_im = self.getImYPosition(self.data[m.location])
self.drawMarker(x, y_re, qp, m.color,
self.markers.index(m) + 1)
self.drawMarker(x, y_im, qp, m.color,
self.markers.index(m) + 1)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
pen = QPen(Qt.black, 5, Qt.SolidLine)
painter.setPen(pen)
if len(self.pos_xy) > 1:
point_start = self.pos_xy[0]
for pos_tmp in self.pos_xy:
point_end = pos_tmp
if point_end == (-1, -1):
point_start = (-1, -1)
continue
if point_start == (-1, -1):
point_start = point_end
continue
painter.drawLine(point_start[0], point_start[1], point_end[0],
point_end[1])
point_start = point_end
pen = QPen(Qt.blue, 2, Qt.DotLine)
painter.setPen(pen)
strokeLength = 0
if len(self.pos_xy_future) > 1:
point_start = self.pos_xy_future[0]
for pos_tmp in self.pos_xy_future:
point_end = pos_tmp
if point_end[0] == -1:
point_start = (-1, -1)
continue
if point_start[0] == -1:
point_start = point_end
continue
if point_end[0] == 0 or point_start[0] == 0:
continue
painter.drawLine(point_start[0], point_start[1], point_end[0],
point_end[1])
strokeLength += np.sqrt((point_start[0] - point_end[0])**2 +
(point_start[1] - point_end[1])**2)
if (self.config_limitRNNStroke
and strokeLength > self.config_RNNStrokeLimit):
break
point_start = point_end
pen = QPen(Qt.black, 5, Qt.SolidLine)
painter.setPen(pen)
if len(self.pos_xy) > 1:
point_start = self.pos_xy[0]
for pos_tmp in self.pos_xy:
point_end = pos_tmp
if point_end == (-1, -1):
point_start = (-1, -1)
continue
if point_start == (-1, -1):
point_start = point_end
continue
painter.drawLine(point_start[0], point_start[1], point_end[0],
point_end[1])
point_start = point_end
painter.end()
def delauney_triangulation(self):
# result delaunay array and keypoints for intermediate (adjustment) image
self.delaunay = []
self.keypoints3 = []
# ensure keypoints have been filled, and have the same number between images
if len(self.keypoint1) != len(self.keypoint2) or len(self.keypoint1) <= 3:
warning = QWidget()
QMessageBox.warning(warning, "Message", "Must have same number of key points and at least four!")
else:
# generate average points between two, and the delaunay triangle for the result
for i in range(len(self.keypoint1)):
x = int((self.keypoint1[i][0] + self.keypoint2[i][0]) / 2)
y = int((self.keypoint1[i][1] + self.keypoint2[i][1]) / 2)
# add the resulting keypoints to the intermediate array
self.keypoint3.append([x, y])
# generate the delaunay triangles based on the new keypoints (library functions using generated keypoints)
tri = Delaunay(self.keypoint3, False, False, qhull_options = "QJ")
self.delaunay = tri.simplices
# draw lines for the triangulation on image 1
self.image1.setPixmap(QPixmap.fromImage(self.outFeed1))
self.image1.setAlignment(Qt.AlignCenter)
painterInstance = QPainter(self.outFeed1)
penRectangle = QPen(Qt.red)
painterInstance.setPen(penRectangle)
for i in range(len(self.delaunay)):
painterInstance.drawLine(self.keypoint1[self.delaunay[i][0]][0], self.keypoint1[self.delaunay[i][0]][1],
self.keypoint1[self.delaunay[i][1]][0], self.keypoint1[self.delaunay[i][1]][1])
painterInstance.drawLine(self.keypoint1[self.delaunay[i][1]][0], self.keypoint1[self.delaunay[i][1]][1],
self.keypoint1[self.delaunay[i][2]][0], self.keypoint1[self.delaunay[i][2]][1])
painterInstance.drawLine(self.keypoint1[self.delaunay[i][2]][0], self.keypoint1[self.delaunay[i][2]][1],
self.keypoint1[self.delaunay[i][0]][0], self.keypoint1[self.delaunay[i][0]][1])
# display the triangles in image 1
self.image1.setPixmap(QPixmap.fromImage(self.outFeed1))
# draw lines for the triangulation on image 2
self.image2.setPixmap(QPixmap.fromImage(self.outFeed2))
self.image2.setAlignment(Qt.AlignCenter)
painterInstance = QPainter(self.outFeed2)
penRectangle = QPen(Qt.red)
painterInstance.setPen(penRectangle)
for i in range(len(self.delaunay)):
painterInstance.drawLine(self.keypoint2[self.delaunay[i][0]][0], self.keypoint2[self.delaunay[i][0]][1],
self.keypoint2[self.delaunay[i][1]][0], self.keypoint2[self.delaunay[i][1]][1])
painterInstance.drawLine(self.keypoint2[self.delaunay[i][1]][0], self.keypoint2[self.delaunay[i][1]][1],
self.keypoint2[self.delaunay[i][2]][0], self.keypoint2[self.delaunay[i][2]][1])
painterInstance.drawLine(self.keypoint2[self.delaunay[i][2]][0], self.keypoint2[self.delaunay[i][2]][1],
self.keypoint2[self.delaunay[i][0]][0], self.keypoint2[self.delaunay[i][0]][1])
# display the triangles in image 2
self.image2.setPixmap(QPixmap.fromImage(self.outFeed2))
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: QWidget=None):
fillColor = self.color.darker(150) if (option.state & QStyle.State_Selected) else self.color
if option.state & QStyle.State_MouseOver:
fillColor = fillColor.lighter(125)
lod = option.levelOfDetailFromTransform(painter.worldTransform())
if lod < 0.2:
if lod < 0.125:
painter.fillRect(QRectF(0, 0, 110, 70), fillColor)
return
b = painter.brush()
painter.setBrush(fillColor)
painter.drawRect(13, 13, 97, 57)
painter.setBrush(b)
return
oldPen = painter.pen()
pen = oldPen
width = 0
if option.state & QStyle.State_Selected:
width += 2
pen.setWidth(width)
b = painter.brush()
f = 120 if option.state & QStyle.State_Sunken else 100
painter.setBrush(QBrush(fillColor.darker(f)))
painter.drawRect(QRect(14, 14, 79, 39))
painter.setBrush(b)
if lod >= 1:
painter.setPen(QPen(Qt.gray, 1))
painter.drawLine(15, 54, 94, 54)
painter.drawLine(94, 53, 94, 15)
painter.setPen(QPen(Qt.black, 0))
if lod >= 2:
font = QFont("Times", 10)
font.setStyleStrategy(QFont.ForceOutline)
painter.setFont(font)
painter.save()
painter.scale(0.1, 0.1)
painter.drawText(170, 180, "Model: VSC-2000 (Very Small Chip) at {}x{}".format(self.x, self.y))
painter.drawText(170, 200, "Serial number: DLWR-WEER-123L-ZZ33-SDSJ")
painter.drawText(170, 220, "Manufacturer: Chip Manufacturer")
lines = []
if lod >= 0.5:
for i in np.arange(0, 10, 1 if lod > 0.5 else 2):
lines.append(QLineF(18 + 7 * i, 13, 18 + 7 * i, 5))
lines.append(QLineF(18 + 7 * i, 54, 18 + 7 * i, 62))
for i in np.arange(0, 6, 1 if lod > 0.5 else 2):
lines.append(QLineF(5,18 + 5 * i, 13, 18 + 5 * i))
lines.append(QLineF(94, 18 + 5 * i, 102, 18 + 5 * i))
if lod >= 0.4:
lineData = [
QLineF(25, 35, 35, 35),
QLineF(35, 30, 35, 40),
QLineF(35, 30, 45, 35),
QLineF(35, 40, 45, 35),
QLineF(45, 30, 45, 40),
QLineF(45, 35, 55, 35),
]
lines.extend(lineData)
painter.drawLines(lines)
if len(self.stuff) > 1:
p = painter.pen()
painter.setPen(QPen(Qt.red, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.setBrush(Qt.NoBrush)
path = QPainterPath()
path.moveTo(self.stuff[0])
for i in np.arange(len(self.stuff)):
path.lineTo(self.stuff[i])
painter.drawPath(path)
painter.setPen(p)
def drawValues(self, qp: QtGui.QPainter):
if len(self.data) == 0 and len(self.reference) == 0:
return
pen = QtGui.QPen(self.sweepColor)
pen.setWidth(self.pointSize)
line_pen = QtGui.QPen(self.sweepColor)
line_pen.setWidth(self.lineThickness)
highlighter = QtGui.QPen(QtGui.QColor(20, 0, 255))
highlighter.setWidth(1)
if not self.fixedSpan:
if len(self.data) > 0:
fstart = self.data[0].freq
fstop = self.data[len(self.data) - 1].freq
else:
fstart = self.reference[0].freq
fstop = self.reference[len(self.reference) - 1].freq
self.fstart = fstart
self.fstop = fstop
else:
fstart = self.fstart = self.minFrequency
fstop = self.fstop = self.maxFrequency
# Draw bands if required
if self.bands.enabled:
self.drawBands(qp, fstart, fstop)
if self.fixedValues:
maxValue = self.maxDisplayValue
minValue = self.minDisplayValue
self.maxValue = maxValue
self.minValue = minValue
else:
# Find scaling
minValue = -1
maxValue = 1
self.maxValue = maxValue
self.minValue = minValue
# for d in self.data:
# val = d.re
# if val > maxValue:
# maxValue = val
# if val < minValue:
# minValue = val
# for d in self.reference: # Also check min/max for the reference sweep
# if d.freq < self.fstart or d.freq > self.fstop:
# continue
# logmag = self.logMag(d)
# if logmag > maxValue:
# maxValue = logmag
# if logmag < minValue:
# minValue = logmag
# minValue = 10*math.floor(minValue/10)
# self.minValue = minValue
# maxValue = 10*math.ceil(maxValue/10)
# self.maxValue = maxValue
span = maxValue - minValue
if span == 0:
span = 0.01
self.span = span
tick_count = math.floor(self.chartHeight / 60)
tick_step = self.span / tick_count
for i in range(tick_count):
val = minValue + i * tick_step
y = self.topMargin + round(
(maxValue - val) / span * self.chartHeight)
qp.setPen(QtGui.QPen(self.foregroundColor))
qp.drawLine(self.leftMargin - 5, y,
self.leftMargin + self.chartWidth, y)
if val > minValue and val != maxValue:
qp.setPen(QtGui.QPen(self.textColor))
qp.drawText(3, y + 4, str(round(val, 2)))
qp.setPen(QtGui.QPen(self.foregroundColor))
qp.drawLine(self.leftMargin - 5, self.topMargin,
self.leftMargin + self.chartWidth, self.topMargin)
qp.setPen(self.textColor)
qp.drawText(3, self.topMargin + 4, str(maxValue))
qp.drawText(3, self.chartHeight + self.topMargin, str(minValue))
self.drawFrequencyTicks(qp)
self.drawData(qp, self.data, self.sweepColor, self.getReYPosition)
self.drawData(qp, self.reference, self.referenceColor,
self.getReYPosition)
self.drawData(qp, self.data, self.secondarySweepColor,
self.getImYPosition)
self.drawData(qp, self.reference, self.secondaryReferenceColor,
self.getImYPosition)
self.drawMarkers(qp, y_function=self.getReYPosition)
self.drawMarkers(qp, y_function=self.getImYPosition)
def paintEvent(self, event):
locker = QMutexLocker(self.thread.mutex)
img = self.thread.image
dst = self.imgRect()
qp = QPainter()
qp.begin(self)
# draw background
brush = QBrush(Qt.SolidPattern)
# brush.setColor(Qt.white)
brush.setColor(Qt.black)
qp.setBrush(brush)
qp.drawRect(QRect(0,0,self.width(),self.height()))
qp.save()
qp.translate(dst.x()+dst.width()/2, dst.y()+dst.height()/2)
qp.scale(dst.width()/img.width(), dst.width()/img.width())
qp.translate(-img.width()/2, -img.height()/2)
qp.drawImage(0,0,img)
qp.restore()
# draw orientation lines
qp.setPen(QColor(255,255,255,150))
qp.drawLine(dst.x()+dst.width()/3,dst.y()+0,
dst.x()+dst.width()/3,dst.y()+dst.height())
qp.drawLine(dst.x()+dst.width()/2,dst.y()+0,
dst.x()+dst.width()/2,dst.y()+dst.height())
qp.drawLine(dst.x()+dst.width()*2/3,dst.y()+0,
dst.x()+dst.width()*2/3,dst.y()+dst.height())
qp.drawLine(dst.x()+0,dst.y()+dst.height()/3,
dst.x()+dst.width(),dst.y()+dst.height()/3)
qp.drawLine(dst.x()+0,dst.y()+dst.height()/2,
dst.x()+dst.width(),dst.y()+dst.height()/2)
qp.drawLine(dst.x()+0,dst.y()+dst.height()*2/3,
dst.x()+dst.width(),dst.y()+dst.height()*2/3)
qp.end()
def drawLine(self, painter: QPainter, a: Point, b: Point):
painter.drawLine(self.to_qpoint(a), self.to_qpoint(b))
def paintEvent(self, _event: QPaintEvent):
if not self.crop or not self.resolution:
return
painter = QPainter(self)
# Keep a backup of the transform and create a new one
transform = painter.worldTransform()
# Set scaling transform
transform = transform.scale(self.width() / self.resolution.width(),
self.height() / self.resolution.height())
# Compute the transform to flip the coordinate system on the x axis
transform_flip = QTransform()
if self.flip_x:
transform_flip = transform_flip.translate(self.resolution.width(), 0.0)
transform_flip = transform_flip.scale(-1.0, 1.0)
# Small helper for tuple to QPoint
def toqp(point):
return QPoint(point[0], point[1])
# Starting from here we care about AA
painter.setRenderHint(QPainter.Antialiasing)
# Draw all the QR code results
for res in self.results:
painter.setWorldTransform(transform_flip * transform, False)
# Draw lines between all of the QR code points
pen = QPen(self.qr_outline_pen)
if res in self.validator_results.result_colors:
pen.setColor(self.validator_results.result_colors[res])
painter.setPen(pen)
num_points = len(res.points)
for i in range(0, num_points):
i_n = i + 1
line_from = toqp(res.points[i])
line_from += self.crop.topLeft()
line_to = toqp(res.points[i_n] if i_n < num_points else res.points[0])
line_to += self.crop.topLeft()
painter.drawLine(line_from, line_to)
# Draw the QR code data
# Note that we reset the world transform to only the scaled transform
# because otherwise the text could be flipped. We only use transform_flip
# to map the center point of the result.
painter.setWorldTransform(transform, False)
font_metrics = painter.fontMetrics()
data_metrics = QSize(font_metrics.horizontalAdvance(res.data), font_metrics.capHeight())
center_pos = toqp(res.center)
center_pos += self.crop.topLeft()
center_pos = transform_flip.map(center_pos)
text_offset = QPoint(data_metrics.width(), data_metrics.height())
text_offset = text_offset / 2
text_offset.setX(-text_offset.x())
center_pos += text_offset
padding = self.BG_RECT_PADDING
bg_rect_pos = center_pos - QPoint(padding, data_metrics.height() + padding)
bg_rect_size = data_metrics + (QSize(padding, padding) * 2)
bg_rect = QRect(bg_rect_pos, bg_rect_size)
bg_rect_path = QPainterPath()
radius = self.BG_RECT_CORNER_RADIUS
bg_rect_path.addRoundedRect(QRectF(bg_rect), radius, radius, Qt.AbsoluteSize)
painter.setPen(self.bg_rect_pen)
painter.fillPath(bg_rect_path, self.bg_rect_fill)
painter.drawPath(bg_rect_path)
painter.setPen(self.text_pen)
painter.drawText(center_pos, res.data)
def paintEvent(self, _event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
width = self.width()
height = self.height()
if self.dynamic_resize:
knob_radius = self.dynamic_knob_radius
else:
knob_radius = self.knob_radius
# ensure that the center point is in the middle of a pixel to ensure
# that exact vertial and horizantal ticks are drawn exactly 1px wide
x = math.floor(width / 2.0) + 0.5
y = math.floor(height / 2.0) + 0.5
if DEBUG:
painter.fillRect(0, 0, width, height, Qt.yellow)
painter.translate(x, y)
if self.knob_style == KnobWidget.STYLE_NEEDLE:
r = min(x, y) - 1
painter.setPen(Qt.white)
painter.setBrush(Qt.white)
painter.drawEllipse(QPoint(0, 0), r, r)
angle = self.value_factor * self.total_angle - (self.total_angle / 2.0)
# draw base knob or needle spike
if self.knob_style == KnobWidget.STYLE_ROUND:
painter.setPen(self.border_color)
if self.pressed:
gradient = QRadialGradient(0, 0, knob_radius)
gradient.setColorAt(0, self.base_color_pressed)
gradient.setColorAt(0.85, self.base_color)
gradient.setColorAt(1, self.base_color)
painter.setBrush(gradient)
else:
painter.setBrush(self.base_color)
painter.drawEllipse(QPoint(0, 0), knob_radius, knob_radius)
elif self.knob_style == KnobWidget.STYLE_NEEDLE:
painter.save()
painter.rotate(angle)
painter.setPen(self.needle_color)
painter.setBrush(self.needle_color)
needle = QPolygonF()
needle.append(QPointF(self.needle_base_radius * 0.6, 0))
needle.append(QPointF(0, -knob_radius))
needle.append(QPointF(-self.needle_base_radius * 0.6, 0))
painter.drawPolygon(needle)
painter.restore()
# draw knob mark or needle base
if self.knob_style == KnobWidget.STYLE_ROUND:
painter.save()
painter.rotate(angle)
painter.setPen(QPen(self.mark_color, 2))
painter.drawLine(0, -knob_radius * 0.4, 0, -knob_radius * 0.8)
painter.restore()
elif self.knob_style == KnobWidget.STYLE_NEEDLE:
painter.setPen(self.border_color)
painter.setBrush(self.base_color)
painter.drawEllipse(QPoint(0, 0), self.needle_base_radius,
self.needle_base_radius)
if self.scale_visible:
painter.setPen(Qt.black)
# draw scale arc
if self.scale_arc_visible:
painter.drawArc(-knob_radius - self.knob_to_scale,
-knob_radius - self.knob_to_scale,
knob_radius * 2 + self.knob_to_scale * 2,
knob_radius * 2 + self.knob_to_scale * 2,
(90 + self.total_angle / 2) * 16,
-self.total_angle * 16)
# draw scale ticks
def value_to_angle(value):
return (float(value - self.minimum_value) / self.value_range
) * self.total_angle - (self.total_angle / 2.0)
value = self.minimum_value
while value <= self.maximum_value:
angle = value_to_angle(value)
painter.save()
painter.rotate(value_to_angle(value))
painter.drawLine(
0, -knob_radius - self.knob_to_scale, 0,
-knob_radius - self.knob_to_scale - self.tick_size_large)
if self.scale_text_visible:
p = painter.worldTransform().map(QPoint(0, -knob_radius - \
self.knob_to_scale - \
self.tick_size_large - \
self.tick_to_text - \
self.text_radius))
painter.restore()
if self.scale_text_visible:
if DEBUG:
painter.save()
painter.setPen(QColor(255, 0, 0, 50))
painter.setBrush(QColor(255, 0, 0, 50))
painter.drawEllipse(QPoint(p.x() - x,
p.y() - y),
self.text_radius, self.text_radius)
painter.restore()
painter.drawText(
p.x() - x - 30,
p.y() - y - 30, 60, 60,
Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter,
str(value))
for i in range(1, self.scale_step_divisions):
sub_value = value + (float(self.scale_step_size) *
i) / self.scale_step_divisions
if sub_value > self.maximum_value:
break
painter.save()
painter.rotate(value_to_angle(sub_value))
painter.drawLine(
0, -knob_radius - self.knob_to_scale, 0, -knob_radius -
self.knob_to_scale - self.tick_size_small)
painter.restore()
value += self.scale_step_size
if self.title_text != None:
painter.drawText(
-knob_radius, knob_radius - 30, knob_radius * 2, 60,
Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter,
self.title_text)
def printDiagram(self, printer, diagramName=""):
"""
Public method to print the diagram.
@param printer reference to a ready configured printer object
(QPrinter)
@param diagramName name of the diagram (string)
"""
painter = QPainter()
painter.begin(printer)
offsetX = 0
offsetY = 0
widthX = 0
heightY = 0
font = QFont("times", 10)
painter.setFont(font)
fm = painter.fontMetrics()
fontHeight = fm.lineSpacing()
marginX = printer.pageRect().x() - printer.paperRect().x()
marginX = (Preferences.getPrinter("LeftMargin") *
int(printer.resolution() / 2.54) - marginX)
marginY = printer.pageRect().y() - printer.paperRect().y()
marginY = (Preferences.getPrinter("TopMargin") *
int(printer.resolution() / 2.54) - marginY)
width = (printer.width() - marginX -
Preferences.getPrinter("RightMargin") *
int(printer.resolution() / 2.54))
height = (printer.height() - fontHeight - 4 - marginY -
Preferences.getPrinter("BottomMargin") *
int(printer.resolution() / 2.54))
border = self.border == 0 and 5 or self.border
rect = self._getDiagramRect(border)
diagram = self.__getDiagram(rect)
finishX = False
finishY = False
page = 0
pageX = 0
pageY = 1
while not finishX or not finishY:
if not finishX:
offsetX = pageX * width
pageX += 1
elif not finishY:
offsetY = pageY * height
offsetX = 0
pageY += 1
finishX = False
pageX = 1
if (width + offsetX) > diagram.width():
finishX = True
widthX = diagram.width() - offsetX
else:
widthX = width
if diagram.width() < width:
widthX = diagram.width()
finishX = True
offsetX = 0
if (height + offsetY) > diagram.height():
finishY = True
heightY = diagram.height() - offsetY
else:
heightY = height
if diagram.height() < height:
finishY = True
heightY = diagram.height()
offsetY = 0
painter.drawPixmap(marginX, marginY, diagram, offsetX, offsetY,
widthX, heightY)
# write a foot note
s = self.tr("{0}, Page {1}").format(diagramName, page + 1)
tc = QColor(50, 50, 50)
painter.setPen(tc)
painter.drawRect(marginX, marginY, width, height)
painter.drawLine(marginX, marginY + height + 2, marginX + width,
marginY + height + 2)
painter.setFont(font)
painter.drawText(marginX, marginY + height + 4, width, fontHeight,
Qt.AlignRight, s)
if not finishX or not finishY:
printer.newPage()
page += 1
painter.end()
