def drawNeedle(self, painter):
"""
Aguja, (fondo y punta)
"""
painter.save()
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self._angle)
scale = min((self.width() - self._margins) / 120.0,
(self.height() - self._margins) / 120.0)
painter.scale(scale, scale)
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(self.palette().brush(QPalette.Shadow))
painter.drawPolygon(
QPolygon([
QPoint(-10, 0),
QPoint(0, -45),
QPoint(10, 0),
QPoint(0, 45),
QPoint(-10, 0)
]))
# painter.setBrush(self.palette().brush(QPalette.Highlight))
painter.setBrush(self.colorMarcasCompass)
painter.drawPolygon(
# QPolygon([QPoint(-5, -25), QPoint(0, -45), QPoint(5, -25),
# QPoint(0, -30), QPoint(-5, -25)])
QPolygon([
QPoint(-10, 0),
QPoint(0, -45),
QPoint(10, 0),
QPoint(-10, 0)
]))
painter.restore()
def drawNeedle(self, painter):
painter.save()
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self.angle)
scale = min((self.width() - self.margins) / 120,
(self.height() - self.margins) / 120)
painter.scale(scale, scale)
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QColor(Qt.black))
painter.drawPolygon(
QPolygon([
QPoint(-10, 0),
QPoint(0, -45),
QPoint(10, 0),
QPoint(0, 45),
QPoint(-10, 0)
]))
painter.setBrush(QColor(Qt.red))
painter.drawPolygon(
QPolygon([
QPoint(-5, -25),
QPoint(0, -45),
QPoint(5, -25),
QPoint(0, -30),
QPoint(-5, -25)
]))
painter.restore()
def _drawIcon(self, color=Qt.black):
self.setForeground(QBrush(color))
if self.isRootNode:
pixmap = QPixmap(20, 20)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
pen = QPen(color)
pen.setWidth(1)
painter.setPen(pen)
painter.setBrush(color)
painter.setRenderHint(QPainter.Antialiasing)
if not self.isExpanded:
arrowRightPolygon = [
QPoint(6, 6), QPoint(6, 14),
QPoint(14, 10)
]
painter.drawPolygon(QPolygon(arrowRightPolygon))
else:
arrowDownPolygon = [
QPoint(6, 6), QPoint(15, 6),
QPoint(10, 14)
]
painter.drawPolygon(QPolygon(arrowDownPolygon))
painter.end()
self.setIcon(QIcon(pixmap))
def __init__(self, title='', image=''):
super().__init__()
self.title = title
self.desktop = QDesktopWidget()
self.screen = self.desktop.availableGeometry()
self.logger = logging.getLogger(self.__class__.__name__)
# drawing setting
self._drawing = False
self._image = image
self._w, self._h, self._c = (1280, 720, 3)
self._pen_measure = QPen(Qt.black, 3, cap=Qt.RoundCap)
self._pen_measure_line = QPen(Qt.black, 1, style=Qt.SolidLine)
self._pen_predict = QPen(Qt.blue, 3, cap=Qt.RoundCap)
self._pen_predict_line = QPen(Qt.blue, 1, style=Qt.SolidLine)
self._pen_correct = QPen(Qt.red, 5, cap=Qt.RoundCap)
self._pen_correct_line = QPen(Qt.red, 1, style=Qt.SolidLine)
self._measure_points = QPolygon()
self._predict_points = QPolygon()
self._correct_points = QPolygon()
self._measure_text = f"Mouse measurement - ()"
self._predict_text = f"Kalman Filter predict - ()"
self._correct_text = f"Kalman Filter correct - ()"
# init
self.init_ui()
def draw(self, gp):
gp.setPen(QPen(Qt.black, 1, Qt.SolidLine))
L = int(self.line.text())
k = float(self.line1.text())
N = int(self.line2.text())
A1 = QPoint(0, 0)
B1 = QPoint(L, 0)
C1 = QPoint(L, L)
D1 = QPoint(0, L)
# for (i = 0; i < n; i++) {
# printf("%f %f\n", x + r * Math.cos(2 * Math.PI * i / n), y + r * Math.sin(2 * Math.PI * i / n));
# }
points = QPolygon([A1, B1, C1, D1])
gp.drawPolygon(points)
for i in range(N):
A2 = QPoint(k * A1.x() + (1 - k) * B1.x(),
k * A1.y() + (1 - k) * B1.y())
B2 = QPoint(k * B1.x() + (1 - k) * C1.x(),
k * B1.y() + (1 - k) * C1.y())
C2 = QPoint(k * C1.x() + (1 - k) * D1.x(),
k * C1.y() + (1 - k) * D1.y())
D2 = QPoint(k * D1.x() + (1 - k) * A1.x(),
k * D1.y() + (1 - k) * A1.y())
points = QPolygon([A2, B2, C2, D2])
gp.drawPolygon(points)
A1, B1, C1, D1 = A2, B2, C2, D2
def __init__(self, parent=None):
super(PyAnalogClock, self).__init__(parent)
self.timeZoneOffset = 0
timer = QTimer(self)
timer.timeout.connect(self.update)
timer.timeout.connect(self.updateTime)
timer.start(1000)
self.setWindowTitle("Analog Clock")
self.resize(200, 200)
self.hourHand = QPolygon([
QPoint(7, 8),
QPoint(-7, 8),
QPoint(0, -40)
])
self.minuteHand = QPolygon([
QPoint(7, 8),
QPoint(-7, 8),
QPoint(0, -70)
])
self.hourColor = QColor(0, 127, 0)
self.minuteColor = QColor(0, 127, 127, 191)
def drawing(self, qp):
if self.k == 0:
qp.setBrush(QColor(choice(self.colors)))
points = QPolygon([QPoint(randint(1, 300), randint(1, 300)),
QPoint(randint(1, 300), randint(1, 300)),
QPoint(randint(1, 300), randint(1, 300)),
QPoint(randint(1, 300), randint(1, 300))])
qp.drawPolygon(points)
elif self.x > -1 and self.y > -1 and self.k == 1:
qp.setBrush(QColor(choice(self.colors)))
qp.drawRect(self.x, self.y, randint(1, 100), randint(1, 100))
ex.show()
elif self.x > -1 and self.y > -1 and self.k == -1:
qp.setBrush(QColor(choice(self.colors)))
a = randint(1, 100)
qp.drawEllipse(self.x, self.y, a, a)
elif self.x > -1 and self.y > -1 and self.k == 2:
qp.setBrush(QColor(choice(self.colors)))
points = QPolygon([QPoint((self.x + self.x // 2) + randint(1, self.x),
(self.y - self.y // 2) + randint(1, self.y)),
QPoint(self.x, self.y),
QPoint(self.x // 2, self.y * 2)])
qp.drawPolygon(points)
def draw_needle(self, painter):
painter.save()
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self._angle)
scale = min((self.width() - self._margins) / 120.0,
(self.height() - self._margins) / 120.0)
painter.scale(scale, scale)
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(self.palette().brush(QPalette.WindowText))
painter.drawPolygon(
QPolygon([
QPoint(-10, 0),
QPoint(0, -45),
QPoint(10, 0),
QPoint(0, 45),
QPoint(-10, 0)
]))
painter.setBrush(Qt.red)
painter.drawPolygon(
QPolygon([
QPoint(-5, -25),
QPoint(0, -45),
QPoint(5, -25),
QPoint(0, -30),
QPoint(-5, -25)
]))
painter.restore()
def __init__(self):
"""
Constructor
"""
super(SnapshotFreehandGrabber, self).__init__(
None,
Qt.X11BypassWindowManagerHint | Qt.WindowStaysOnTopHint |
Qt.FramelessWindowHint | Qt.Tool)
self.__selection = QPolygon()
self.__mouseDown = False
self.__newSelection = False
self.__handleSize = 10
self.__showHelp = True
self.__grabbing = False
self.__dragStartPoint = QPoint()
self.__selectionBeforeDrag = QPolygon()
self.__locale = QLocale()
self.__helpTextRect = QRect()
self.__helpText = self.tr(
"Select a region using the mouse. To take the snapshot,"
" press the Enter key or double click. Press Esc to quit.")
self.__pixmap = QPixmap()
self.__pBefore = QPoint()
self.setMouseTracking(True)
QTimer.singleShot(200, self.__initialize)
def paintEvent(self, event):
qp = QtGui.QPainter(self)
for r in self.rect_list:
qp.setBrush(QtGui.QBrush(QtGui.QColor(100, 10, 10,
40))) # module color
qp.drawRect(QtCore.QRect(r.rect_begin,
r.rect_end)) # Draw module rectangle
qp.drawText((r.rect_begin + r.rect_end) / 2,
r.center_text) # Write the name of module rectangle
in_order = 0
out_order = 0
inout_order = 0
# Draw input ports and their names
for i in r.in_port_list:
# Write the port name
qp.drawText(
r.rect_begin + QtCore.QPoint(
5, int(r.Tri_In_F / 2 + r.Tri_In_F * in_order)),
i.text)
in_order = in_order + 1
polygon = QPolygon(i.points)
qp.setBrush(QtGui.QBrush(QtGui.QColor(
0, 0, 255, 127))) # input port color
qp.drawPolygon(polygon)
# Draw output ports and their names
for i in r.out_port_list:
# Write the port name
qp.drawText(
r.rect_end + QtCore.QPoint(
int(r.Tri_In_H + 5),
int(-(r.rect_end.y() - r.rect_begin.y()) +
r.Tri_In_F / 2 + r.Tri_In_F * out_order)), i.text)
out_order = out_order + 1
polygon = QPolygon(i.points)
qp.setBrush(QtGui.QBrush(QtGui.QColor(
0, 0, 255, 127))) # output port color
qp.drawPolygon(polygon)
# Draw inout ports and their names
for i in r.inout_port_list:
# Write the port name
qp.drawText(
QtCore.QPoint(
int(r.rect_begin.x() + 5),
int(r.rect_end.y() - r.Tri_In_F / 2 -
r.Tri_In_F * inout_order)), i.text)
inout_order = inout_order + 1
polygon = QPolygon(i.points)
qp.setBrush(QtGui.QBrush(QtGui.QColor(
0, 0, 255, 127))) # inout port color
qp.drawPolygon(polygon)
def initUI(self):
self.paths = []
self.current = QPolygon()
self.select = QPolygon()
self.ctrl = False
self.color = QColor("black")
self.width = 1
self.buttonpressed = -1
self.selected_poly = []
def draw(self, image):
qp = QPainter(image)
qp.setPen(QPen(self.drawContext.stroke, self.drawContext.width))
qp.drawPolyline(QPolygon(self.points))
qp.setPen(QPen(Qt.transparent, 0))
qp.setBrush(self.drawContext.fill)
qp.drawPolygon(QPolygon(self.points))
class AnalogClock(QWidget):
hourHand = QPolygon([QPoint(7, 8), QPoint(-7, 8), QPoint(0, -40)])
minuteHand = QPolygon([QPoint(7, 8), QPoint(-7, 8), QPoint(0, -70)])
hourColor = QColor(127, 0, 127)
minuteColor = QColor(0, 127, 127, 191)
def __init__(self, parent=None):
super(AnalogClock, self).__init__(parent)
timer = QTimer(self)
timer.timeout.connect(self.update)
timer.start(1000)
self.setWindowTitle("Analog Clock")
self.resize(200, 200)
def paintEvent(self, event):
side = min(self.width(), self.height())
time = QTime.currentTime()
painter = QPainter(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(AnalogClock.hourColor)
painter.save()
painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)))
painter.drawConvexPolygon(AnalogClock.hourHand)
painter.restore()
painter.setPen(AnalogClock.hourColor)
for i in range(12):
painter.drawLine(88, 0, 96, 0)
painter.rotate(30.0)
painter.setPen(Qt.NoPen)
painter.setBrush(AnalogClock.minuteColor)
painter.save()
painter.rotate(6.0 * (time.minute() + time.second() / 60.0))
painter.drawConvexPolygon(AnalogClock.minuteHand)
painter.restore()
painter.setPen(AnalogClock.minuteColor)
for j in range(60):
if (j % 5) != 0:
painter.drawLine(92, 0, 96, 0)
painter.rotate(6.0)
def drawNeedle(self, painter):
painter.save()
# Set up painter
painter.translate(self.width() / 2, self.height() / 2)
scale = min((self.width() - self._margins) / 120.0,
(self.height() - self._margins) / 120.0)
painter.scale(scale, scale)
painter.setPen(QPen(Qtc.NoPen))
# Rotate surface for painting
intAngle = int(round(self._angle))
painter.rotate(intAngle)
# Draw the full black needle first if needed
if self.needleType == NeedleFull:
needleTailBrush = self.palette().brush(QPalette.Shadow)
needleTailColor = QColor(self.needleBodyColor)
needleTailBrush.setColor(needleTailColor)
painter.setBrush(needleTailBrush)
painter.drawPolygon(QPolygon([QPoint(-6, 0), QPoint(0, -45), QPoint(6, 0),
QPoint(0, 45), QPoint(-6, 0)]))
# Now draw the red tip (on top of the black needle)
needleTipBrush = self.palette().brush(QPalette.Highlight)
needleTipColor = QColor(self.needleTipColor)
needleTipBrush.setColor(needleTipColor)
painter.setBrush(needleTipBrush)
# First QPoint is the center bottom apex of the needle
painter.drawPolygon(QPolygon([QPoint(-3, -24), QPoint(0, -45), QPoint(3, -23),
QPoint(0, -30), QPoint(-3, -23)]))
if self.needleType == NeedleMirrored:
# Rotate
# Need to account for the initial rotation to see how much more to rotate it.
if (intAngle == 90 or intAngle == -90 or intAngle == 270):
mirrorRotation = 180
else:
mirrorRotation = 180 - intAngle - intAngle
painter.rotate(mirrorRotation)
# Paint shadowed indicator
needleTipBrush = self.palette().brush(QPalette.Highlight)
needleTipColor = Qtc.gray
needleTipBrush.setColor(needleTipColor)
painter.setBrush(needleTipBrush)
painter.drawPolygon(
QPolygon([QPoint(-3, -25), QPoint(0, -45), QPoint(3, -25),
QPoint(0, -30), QPoint(-3, -25)])
)
painter.restore()
def mousePressEvent(self, event):
self.select = QPolygon()
self.selected_poly = []
self.buttonpressed = event.button()
if self.buttonpressed == Qt.RightButton:
self.selected = QPolygon()
self.select.append(event.pos())
else:
self.current = QPolygon()
self.current.append(event.pos())
self.update()
def paintEvent(self, event):
painter = QPainter(self)
# complete graph ratio
scale, translation = self._get_scale_translation()
if self.need_draw_grid:
self.draw_grid(scale, translation)
painter.drawPixmap(QPoint(), self.pixmap)
############ EXTERIOR #################################
painter.setPen(self.external_contour_pen)
exterior_coords_on_screen = [
QPoint(*tuple(p * scale + translation))
for p in self.current_polygon_exterior
]
painter.drawPolyline(QPolygon(exterior_coords_on_screen))
############ INTERIOR #################################
painter.setPen(self.internal_contour_pen)
interior_coords_list = []
for current_polygon_interior in self.current_polygon_interiors:
interior_coords_on_screen = [
QPoint(*tuple(p * scale + translation))
for p in current_polygon_interior
]
painter.drawPolyline(QPolygon(interior_coords_on_screen))
interior_coords_list.append(interior_coords_on_screen)
####################### Points of each point ##########
# Draw selected Point in different color
if self.current_selected_tuple is not None and self.current_selected_tuple[
0] == 'exterior':
exterior_coords_on_screen = self.draw_exterior_selected_point(
exterior_coords_on_screen, painter)
if self.current_selected_tuple is not None and self.current_selected_tuple[
0] == 'interior':
interior_coords_list = self.draw_interior_selected_point(
interior_coords_list, painter)
painter.setPen(self.external_point_pen)
painter.drawPoints(QPolygon(exterior_coords_on_screen))
painter.setPen(self.internal_point_pen)
for interior_coord in interior_coords_list:
painter.drawPoints(QPolygon(interior_coord))
###################### Each tile in the solution ###############
if self.current_best_solution is not None:
self.draw_solution(painter)
def paintRadarChart(self,
scores,
scoresValue,
x=255,
y=270,
r=160,
n=6,
m=5):
# (x, y)为中心画雷达图，r为大小，n为边数，m为几等分
# scoresValue在0到1之间，展示雷达图用
painter = QPainter(self)
angle_0 = 0 # 起始位置弧度，向上为0，顺时针为正
scoresName = ['Ce/s', '3BV/s', 'RTime', 'STNC', 'IOE', 'RQP']
painter.setPen(self.pen1)
painter.setFont(QFont('Arial', 16)) # 设置字体和大小
for j in range(1, m + 1):
points = []
for i in range(n):
angle_s = angle_0 + i * 6.2831853 / n
angle_t = angle_0 + (i + 1) * 6.2831853 / n
r0 = j / m * r
x_s = int(x + r0 * math.cos(angle_s))
y_s = int(y - r0 * math.sin(angle_s))
points.append(QtCore.QPoint(x_s, y_s))
painter.drawPolygon(QPolygon(points))
points = []
for i in range(n):
angle_s = angle_0 + i * 6.2831853 / n
angle_t = angle_0 + (i + 1) * 6.2831853 / n
x_s = int(x + r * math.cos(angle_s))
y_s = int(y - r * math.sin(angle_s))
painter.setPen(self.pen1)
painter.drawLine(x, y, x_s, y_s)
x_s = int(x + r0 * 1.23 * math.cos(angle_s))
y_s = int(y - r0 * 1.23 * math.sin(angle_s))
painter.setPen(self.pen3)
painter.drawText(QtCore.QRectF(x_s - 65, y_s - 30, 120,
60), QtCore.Qt.AlignCenter,
scoresName[i] + "\n" + scores[scoresName[i]])
# painter.drawText(QtCore.QRectF(50,70,100,130), QtCore.Qt.AlignCenter, "abcdefg\nhijklmn")
x_s = int(x + scoresValue[i] * r * math.cos(angle_s))
y_s = int(y - scoresValue[i] * r * math.sin(angle_s))
points.append(QtCore.QPoint(x_s, y_s))
painter.setPen(self.pen2)
painter.setBrush(self.brush)
painter.drawPolygon(QPolygon(points))
def widgetQuadrant(rect, point):
center = rect.center()
if QPolygon([rect.topLeft(), rect.topRight(),
center]).containsPoint(point, 0):
return consts.UP
if QPolygon([rect.bottomLeft(),
rect.bottomRight(), center]).containsPoint(point, 0):
return consts.DOWN
if QPolygon([rect.topLeft(), rect.bottomLeft(),
center]).containsPoint(point, 0):
return consts.LEFT
if QPolygon([rect.bottomRight(),
rect.topRight(), center]).containsPoint(point, 0):
return consts.RIGHT
def paintEvent(self, QPaintEvent):
painter = QPainter()
painter.begin(self)
painter.setPen(Qt.blue)
#绘制弧
#左上角位置，宽度，高度
rect = QRect(0, 10, 100, 100)
#alen:1 alen=1/16度 45*16=720
painter.drawArc(rect, 0, 50 * 16)
#绘制圆
painter.setPen(Qt.red)
painter.drawArc(120, 10, 100, 100, 0, 360 * 16)
#绘制带弦的弧
painter.drawChord(10, 120, 100, 100, 12, 130 * 16)
#绘制扇形
painter.drawPie(10, 240, 100, 100, 12, 130 * 16)
#绘制椭圆
painter.drawEllipse(120, 120, 150, 100)
#5边形
point1 = QPoint(140, 380)
point2 = QPoint(270, 420)
point3 = QPoint(219, 512)
point4 = QPoint(290, 588)
point5 = QPoint(120, 533)
polygon = QPolygon([point1, point2, point3, point4, point5])
painter.drawPolygon(polygon)
#绘制图像
image = QImage('./school.jpg')
rect = QRect(300, 200, image.width() / 2, image.height() / 2)
painter.drawImage(rect, image)
# image.save('./school1.png')
painter.end()
def __grabRegion(self):
"""
Private method to grab the selected region (i.e. do the snapshot).
"""
pol = QPolygon(self.__selection)
if not pol.isEmpty():
self.__grabbing = True
xOffset = self.__pixmap.rect().x() - pol.boundingRect().x()
yOffset = self.__pixmap.rect().y() - pol.boundingRect().y()
translatedPol = pol.translated(xOffset, yOffset)
pixmap2 = QPixmap(pol.boundingRect().size())
pixmap2.fill(Qt.transparent)
pt = QPainter()
pt.begin(pixmap2)
if pt.paintEngine().hasFeature(QPaintEngine.PorterDuff):
pt.setRenderHints(
QPainter.Antialiasing |
QPainter.HighQualityAntialiasing |
QPainter.SmoothPixmapTransform,
True)
pt.setBrush(Qt.black)
pt.setPen(QPen(QBrush(Qt.black), 0.5))
pt.drawPolygon(translatedPol)
pt.setCompositionMode(QPainter.CompositionMode_SourceIn)
else:
pt.setClipRegion(QRegion(translatedPol))
pt.setCompositionMode(QPainter.CompositionMode_Source)
pt.drawPixmap(pixmap2.rect(), self.__pixmap, pol.boundingRect())
pt.end()
self.grabbed.emit(pixmap2)
def initUI(self):
self.setGeometry(self.left, self.top, self._width, self._height)
# Create widget
self.label = QLabel(self)
self.pointer = QPolygon([
QtCore.QPoint(2, 0),
QtCore.QPoint(-2, 0),
QtCore.QPoint(0, -(self._sidelength / 2))
])
timer = QtCore.QTimer(self)
timer.timeout.connect(self.update)
timer.timeout.connect(self.showmini)
timer.start(self.refreshrate)
# This is the part to make the application act as an overlay
self.setAttribute(QtCore.Qt.WA_NoSystemBackground, True)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
self.setWindowFlags(QtCore.Qt.Window | QtCore.Qt.CustomizeWindowHint
| QtCore.Qt.FramelessWindowHint
| QtCore.Qt.WindowStaysOnBottomHint
| QtCore.Qt.SplashScreen)
self.show()
self.setContextMenuPolicy(QtCore.Qt.ActionsContextMenu)
quitAction = QAction("Quit", self)
quitAction.triggered.connect(sys.exit)
self.addAction(quitAction)
def selectpoly_copy(self):
"""
Copy a polygon region from the current image, returning it.
Create a mask for the selected area, and use it to blank
out non-selected regions. Then get the bounding rect of the
selection and crop to produce the smallest possible image.
:return: QPixmap of the copied region.
"""
self.timer_cleanup()
pixmap = self.pixmap().copy()
bitmap = QBitmap(*CANVAS_DIMENSIONS)
bitmap.clear() # Starts with random data visible.
p = QPainter(bitmap)
# Construct a mask where the user selected area will be kept,
# the rest removed from the image is transparent.
userpoly = QPolygon(self.history_pos + [self.current_pos])
p.setPen(QPen(Qt.color1))
p.setBrush(QBrush(Qt.color1)) # Solid color, Qt.color1 == bit on.
p.drawPolygon(userpoly)
p.end()
# Set our created mask on the image.
pixmap.setMask(bitmap)
# Calculate the bounding rect and return a copy of that region.
return pixmap.copy(userpoly.boundingRect())
def draw_third_cond(self, qp, amount, diameter):
target = random.randrange(0, amount)
for i in range(amount):
color = random.choice(self.colors)
form = random.choice(self.forms)
x = random.randrange(100, 1800, 20)
y = random.randrange(100, 800, 20)
self.forms_list.append((x, y))
qp.setPen(Qt.SolidLine)
if i == target:
self.target_x = x
self.target_y = y
qp.setBrush(QtGui.QColor(54, 50, 168))
qp.drawEllipse(x - diameter, y - diameter, diameter, diameter)
else:
qp.setBrush(QtGui.QColor(color[0], color[1], color[2]))
if form == 'rect':
qp.drawRect(x - diameter, y - diameter, diameter, diameter)
elif form == 'triangle':
points = [
QPoint(x - diameter, y - diameter),
QPoint(x - diameter * 2, y - diameter),
QPoint(x - diameter, y - diameter * 2),
]
poly = QPolygon(points)
qp.drawPolygon(poly)
elif form == 'circle':
qp.drawEllipse(x - diameter, y - diameter, diameter, diameter)
def draw_block(self, p, point, w, h):
# Painting settings:
p.setPen(Qt.NoPen)
p.setRenderHint(QPainter.Antialiasing)
# Here for changing black with another color (to be debugged)
# p.setBrush(QBrush(QColor(*self.color_2)))
# # p.drawRect(QRect(-1, -1, (w + 2)*1.5, (h + 2)*1.5))
p.setBrush(QBrush(QColor(*self.color)))
# To draw a windmill, a set of consecutive triangles will be painted:
mid_x = int(w / 2) # calculate image center
mid_y = int(h / 2)
# calculate angles for each triangle:
angles = np.arange(0, np.pi * 2, (np.pi * 2) / self.n_arms)
angles += np.pi / 2 + np.pi / (2 * self.n_arms)
# angular width of the white arms, by default equal to dark ones
size = np.pi / self.n_arms
# radius of triangles (much larger than frame)
rad = (w**2 + h**2)**(1 / 2)
# loop over angles and draw consecutive triangles
for deg in np.array(angles):
polyg_points = [
QPoint(mid_x, mid_y),
QPoint(int(mid_x + rad * np.cos(deg)),
int(mid_y + rad * np.sin(deg))),
QPoint(
int(mid_x + rad * np.cos(deg + size)),
int(mid_y + rad * np.sin(deg + size)),
),
]
polygon = QPolygon(polyg_points)
p.drawPolygon(polygon)
def rescale_method(self):
# print("slotMethod")
if self.width() <= self.height():
self.widget_diameter = self.width()
else:
self.widget_diameter = self.height()
self.change_value_needle_style([
QPolygon([
QPoint(4, 30),
QPoint(-4, 30),
QPoint(-2,
-self.widget_diameter / 2 * self.needle_scale_factor),
QPoint(
0,
-self.widget_diameter / 2 * self.needle_scale_factor - 6),
QPoint(2, -self.widget_diameter / 2 * self.needle_scale_factor)
])
])
# needle = [QPolygon([
# QPoint(4, 4),
# QPoint(-4, 4),
# QPoint(-3, -120),
# QPoint(0, -126),
# QPoint(3, -120)])]
# print(str(type(needle)).split("'")[1])
#
# needle = [2]
# print(str(type(needle[0])).split("'")[1])
self.scale_fontsize = self.initial_scale_fontsize * self.widget_diameter / 400
self.value_fontsize = self.initial_value_fontsize * self.widget_diameter / 400
# print("slotMethod end")
pass
def enableMask(self, enable):
if not enable or Colors.noWindowMask:
self.clearMask()
else:
region = QPolygon([
# North side.
0, 0,
800, 0,
# East side.
# 800, 70,
# 790, 90,
# 790, 480,
# 800, 500,
800, 600,
# South side.
700, 600,
670, 590,
130, 590,
100, 600,
0, 600,
# West side.
# 0, 550,
# 10, 530,
# 10, 520,
# 0, 520,
0, 0])
self.setMask(QRegion(region))
def drawAltitudeIndicator(self, event, painter):
boxWidth = self.width * 0.13
boxHeight = self.height * 0.6
brush = QtGui.QBrush(QColor(100, 100, 100, 200))
painter.setPen(QPen(QBrush(Qt.yellow), 2, Qt.SolidLine))
painter.fillRect(
QRectF(self.width - boxWidth, (self.height - boxHeight) / 2,
boxWidth, boxHeight), brush)
scale = 0.01
for i in range(self.altitude - 29, self.altitude + 29):
if i % 10 == 0:
x = self.width - boxWidth
y = self.height * 0.5 + (
(self.altitude - i) * scale * self.height)
text = str(i)
painter.drawLine(x, y, x + 5, y)
painter.drawText(QPoint(x + 10, y + 5), text)
painter.setBrush(Qt.black)
p1 = QPoint(self.width, self.height * (0.46))
p2 = QPoint(self.width - boxWidth * 0.9, self.height * (0.46))
p3 = QPoint(self.width - boxWidth, self.height * (0.5))
p4 = QPoint(self.width - boxWidth * 0.9, self.height * (0.54))
p5 = QPoint(self.width, self.height * (0.54))
poly = QPolygon([p1, p2, p3, p4, p5])
painter.setPen(QPen(QBrush(QColor(0, 0, 0, 0)), 2, Qt.SolidLine))
painter.drawPolygon(poly)
painter.setPen(QPen(QBrush(QColor(255, 255, 0)), 2, Qt.SolidLine))
text = str(self.altitude) + " m"
rect = QRectF(p1, p4)
painter.drawText(rect, QtCore.Qt.AlignCenter, text)
painter.drawText(
QPoint(self.width - boxWidth + 5,
(self.height - boxHeight) / 2 - 5), "Altitude")
def drawAirspeedIndicator(self, event, painter):
boxWidth = self.width * 0.13
boxHeight = self.height * 0.6
brush = QtGui.QBrush(QColor(100, 100, 100, 200))
painter.setPen(QPen(QBrush(Qt.yellow), 2, Qt.SolidLine))
painter.fillRect(
QRectF(0, (self.height - boxHeight) / 2, boxWidth, boxHeight),
brush)
scale = 0.01
for i in range(self.speed - 29, self.speed + 29):
if i % 10 == 0 and i >= 0:
x = boxWidth
y = self.height * 0.5 + (
(self.speed - i) * scale * self.height)
text = str(i)
painter.drawLine(x - 5, y, x, y)
painter.drawText(QPoint(x - 10 - 8 * len(text), y + 5), text)
painter.setBrush(Qt.black)
p1 = QPoint(0, self.height * (0.46))
p2 = QPoint(boxWidth * 0.9, self.height * (0.46))
p3 = QPoint(boxWidth, self.height * (0.5))
p4 = QPoint(boxWidth * 0.9, self.height * (0.54))
p5 = QPoint(0, self.height * (0.54))
poly = QPolygon([p1, p2, p3, p4, p5])
painter.setPen(
QPen(QBrush(QColor(0, 0, 0, 0)), 2, Qt.SolidLine, Qt.RoundCap))
painter.drawPolygon(poly)
painter.setPen(
QPen(QBrush(QColor(255, 255, 0)), 2, Qt.SolidLine, Qt.RoundCap))
rect = QRectF(p1, p4)
painter.drawText(rect, QtCore.Qt.AlignCenter, str(self.speed) + " kt")
painter.drawText(QPoint(5, (self.height - boxHeight) / 2 - 5),
"Airspeed (KIAS)")
def paint_event_bar_vertical(qp: QPainter, index_rect: QRect,
back_ground: QColor, align: int):
if align == ALIGN_RIGHT:
rect = index_rect
rect.setLeft(rect.left() + 10)
arrow_points = [
QPoint(rect.left() - 10,
rect.center().y()),
rect.topLeft(),
rect.topRight(),
rect.bottomRight(),
rect.bottomLeft()
]
else:
rect = index_rect
rect.setRight(rect.right() - 10)
arrow_points = [
QPoint(rect.right() + 10,
rect.center().y()),
rect.bottomRight(),
rect.bottomLeft(),
rect.topLeft(),
rect.topRight()
]
qp.setBrush(back_ground)
qp.drawPolygon(QPolygon(arrow_points))
def draw_needle(self, painter):
""" draw needle"""
painter.save()
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self._roll)
scale = min((self.width() - self._margins) / 120.0,
(self.height() - self._margins) / 120.0)
painter.scale(scale, scale)
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QColor(231, 116, 113))
painter.drawPolygon(
QPolygon([
QPoint(-5, 0),
QPoint(0, -48),
QPoint(5, 0),
QPoint(0, 48),
QPoint(-5, 0)
]))
# painter.setBrush(self.palette().brush(QPalette.Highlight))
# painter.drawPolygon(
# QPolygon([QPoint(-5, -25), QPoint(0, -45), QPoint(5, -25),
# QPoint(0, -30), QPoint(-5, -25)])
# )
painter.restore()
