def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127)))
painter.setPen(QPen(Qt.NoPen))
for i in range(6):
x_pos = self.width() / 2 + 30 * \
math.cos(2 * math.pi * i / 6.0) - 10
y_pos = self.height() / 2 + 30 * \
math.sin(2 * math.pi * i / 6.0) - 10
if (self.counter / 5) % 6 == i:
linear_gradient = QLinearGradient(
x_pos + 10, x_pos, y_pos + 10, y_pos)
linear_gradient.setColorAt(0, QColor(135, 206, 250))
linear_gradient.setColorAt(1, QColor(0, 0, 128))
painter.setBrush(QBrush(linear_gradient))
else:
linear_gradient = QLinearGradient(
x_pos - 10, x_pos, y_pos + 10, y_pos)
linear_gradient.setColorAt(0, QColor(105, 105, 105))
linear_gradient.setColorAt(1, QColor(0, 0, 0))
painter.setBrush(QBrush(linear_gradient))
painter.drawEllipse(
x_pos,
y_pos,
20, 20)
painter.end()
def createImage(self, transform):
scaledRect = transform.mapRect(QRect(0, 0, 25, 25))
image = QImage(scaledRect.width(), scaledRect.height(),
QImage.Format_ARGB32_Premultiplied)
image.fill(0)
painter = QPainter(image)
painter.scale(transform.m11(), transform.m22())
painter.setRenderHints(QPainter.TextAntialiasing | QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
painter.setPen(Qt.NoPen)
if Colors.useEightBitPalette:
painter.setBrush(QColor(102, 175, 54))
painter.drawEllipse(0, 0, 25, 25)
painter.setFont(Colors.tickerFont())
painter.setPen(QColor(255, 255, 255))
painter.drawText(10, 15, self.letter)
else:
brush = QLinearGradient(0, 0, 0, 25)
brush.setSpread(QLinearGradient.PadSpread)
brush.setColorAt(0.0, QColor(102, 175, 54, 200))
brush.setColorAt(1.0, QColor(102, 175, 54, 60))
painter.setBrush(brush)
painter.drawEllipse(0, 0, 25, 25)
painter.setFont(Colors.tickerFont())
painter.setPen(QColor(255, 255, 255, 255))
painter.drawText(10, 15, self.letter)
return image
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, ev):
"""Called when paint is needed, finds out which page to magnify."""
layout = self.parent().surface().pageLayout()
pos = self.geometry().center() - self.parent().surface().pos()
page = layout.pageAt(pos)
if not page:
return
pagePos = pos - page.pos()
max_zoom = self.parent().surface().view().MAX_ZOOM * self.MAX_EXTRA_ZOOM
newPage = Page(page, min(max_zoom, self._scale * page.scale()))
if not newPage.same_page(self._page):
if self._page:
self._page.magnifier = None
self._page = newPage
self._page.magnifier = self
relx = pagePos.x() / float(page.width())
rely = pagePos.y() / float(page.height())
image = cache.image(self._page)
img_rect = QRect(self.rect())
if not image:
cache.generate(self._page)
image = cache.image(self._page, False)
if image:
img_rect.setWidth(self.width() * image.width() / self._page.width())
img_rect.setHeight(self.height() * image.height() / self._page.height())
if image:
img_rect.moveCenter(QPoint(relx * image.width(), rely * image.height()))
p = QPainter(self)
p.drawImage(self.rect(), image, img_rect)
p.setRenderHint(QPainter.Antialiasing, True)
p.setPen(QPen(QColor(192, 192, 192, 128), 6))
p.drawEllipse(self.rect().adjusted(2, 2, -2, -2))
def paintEvent(self, e): qp = QPainter() qp.begin(self) qp.setBrush(QColor(200, 0, 0)) qp.drawEllipse(8,8,15,15) qp.end()
def setNameAndBrush(self, sigma, color=Qt.black):
self.sigma = sigma
self.setText(f'σ{self.column}'.translate(self.sub_trans))
if self.sigma is not None:
total_window = (1 + 2 * int(self.sigma * self.window_size + 0.5))
self.setToolTip(f'sigma = {sigma:.1f} pixels, window diameter = {total_window:.1f}')
font = QFont()
font.setPointSize(10)
# font.setBold(True)
self.setFont(font)
self.setForeground(color)
pixmap = QPixmap(self.pixmapSize)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(color)
brush = QBrush(color)
painter.setBrush(brush)
painter.drawEllipse(QRect(old_div(self.pixmapSize.width(), 2) - old_div(self.brushSize, 2),
old_div(self.pixmapSize.height(), 2) - old_div(self.brushSize, 2),
self.brushSize, self.brushSize))
painter.end()
self.setIcon(QIcon(pixmap))
self.setTextAlignment(Qt.AlignVCenter)
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 updateCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter ellipse 1
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen(Qt.red)
pen.setWidth(3)
painter.setPen(pen)
brush = QBrush(Qt.green)
painter.setBrush(brush)
painter.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setStyle(Qt.DotLine)
pen2.setWidth(3)
painter2.setPen(pen2)
painter2.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
def setupScene(self):
self.m_scene.setSceneRect(-300, -200, 600, 460)
linearGrad = QLinearGradient(QPointF(-100, -100), QPointF(100, 100))
linearGrad.setColorAt(0, Qt.darkGreen)#QColor(255, 255, 255))
linearGrad.setColorAt(1, Qt.green)#QQColor(192, 192, 255))
self.setBackgroundBrush(linearGrad)
radialGrad = QRadialGradient(30, 30, 30)
radialGrad.setColorAt(0, Qt.yellow)
radialGrad.setColorAt(0.2, Qt.yellow)
radialGrad.setColorAt(1, Qt.transparent)
pixmap = QPixmap(60, 60)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setPen(Qt.NoPen)
painter.setBrush(radialGrad)
painter.drawEllipse(0, 0, 60, 60)
painter.end()
self.m_lightSource = self.m_scene.addPixmap(pixmap)
self.m_lightSource.setZValue(2)
self.proto = ProtoObj(0, 0, 50, 50, self)
self.proto.initObj()
#self.m_items.append(self.proto.getObj()[0])
self.m_scene.addItem(self.proto.getObj()[0])
def __paintRound(self):
"""
Private method to paint a round raised LED.
"""
# Initialize coordinates, width and height of the LED
width = self.__getBestRoundSize()
# Calculate the gradient for the LED
wh = width / 2
color = self.__led_on and self.__led_color or self.__offcolor
gradient = QRadialGradient(wh, wh, wh, 0.8 * wh, 0.8 * wh)
gradient.setColorAt(0.0, color.lighter(200))
gradient.setColorAt(0.6, color)
if self.__framedLed:
gradient.setColorAt(0.9, color.darker())
gradient.setColorAt(1.0, self.palette().color(QPalette.Dark))
else:
gradient.setColorAt(1.0, color.darker())
# now do the drawing
paint = QPainter(self)
paint.setRenderHint(QPainter.Antialiasing, True)
paint.setBrush(QBrush(gradient))
paint.setPen(Qt.NoPen)
paint.drawEllipse(1, 1, width, width)
paint.end()
def updateFilledCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter filled ellipse
p = QPalette()
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush(p.link().color())
painter.setBrush(brush)
painter.setOpacity(0.4)
painter.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setWidth(1)
painter2.setPen(pen2)
painter2.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
def paintEvent(self, e): qp = QPainter() qp.begin(self) qp.setBrush(QColor(200, 0, 0)) qp.drawEllipse(0,0,50,50) qp.setPen(QColor(0, 0, 0)) qp.drawText(e.rect(), Qt.AlignVCenter,str(self.node.heuristicValue))
def paintEvent(self, e):
QLabel.paintEvent(self, e)
painter = QPainter()
painter.begin(self)
painter.setBrush(self.brush)
for mark in self.marks:
painter.drawEllipse(mark, constants.ellipsWidth, constants.ellipsHeight)
painter.end()
def paintEvent(self, QPaintEvent):
QWidget.paintEvent(self, QPaintEvent)
qp = QPainter()
qp.begin(self)
qp.setBrush(self.pointer.color)
qp.drawEllipse(0, 0, 10 - 1, 10 - 1)
qp.end()
def getCursor(self):
antialiasing_margin = 1
size = self.pen.width()
pixmap = QPixmap(size + antialiasing_margin * 2,
size + antialiasing_margin * 2)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
painter.drawEllipse(QRectF(QPointF(antialiasing_margin, antialiasing_margin),
QSizeF(size, size)))
painter.end()
return QCursor(pixmap)
def paintEvent(self, event):
qp = QPainter(self)
qp.setPen(QPen(Qt.black, 5, 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
qp.drawEllipse(100, 15, 400, 200)
qp.setBrush(QBrush(Qt.red, Qt.DiagCrossPattern))
qp.drawEllipse(600, 15, 200, 200)
def paint(self, painter: QPainter,
option: QStyleOptionGraphicsItem,
widget: QWidget):
"""Need to override paint so selection appearance is correct.
Args:
painter: Description
option: Description
widget: Description
"""
painter.setPen(self.pen())
painter.setBrush(self.brush())
painter.drawEllipse(self.rect())
def updateImage(self):
if self.fid is not None:
self.readCurrentFrame()
else:
self._normalizeImage()
self.mainImage._canvas.setCursor(Qt.CrossCursor)
if self.h5path in self.eggs:
if self.frame_number in self.eggs[self.h5path]:
current_list = self.eggs[self.h5path][self.frame_number]
painter = QPainter()
painter.begin(self.frame_qimg)
pen = QPen()
pen.setWidth(2)
pen.setColor(Qt.red)
painter.setPen(pen)
painter.setBrush(Qt.red)
for (x,y) in current_list:
#painter.drawEllipse(x,y, 1,1)
painter.drawPoint(x,y)
painter.end()
#set number of eggs eggs
n_eggs_txt = "{} Eggs".format(len(self.eggs[self.h5path][self.frame_number]))
self.ui.number_of_eggs.setText(n_eggs_txt)
else:
self.ui.number_of_eggs.setText("0 Eggs")
prev_frame = self.frame_number-1
if self.ui.show_prev.isChecked() and prev_frame in self.eggs[self.h5path]:
prev_list = self.eggs[self.h5path][prev_frame]
painter = QPainter()
painter.begin(self.frame_qimg)
pen = QPen()
pen.setWidth(1)
pen.setColor(Qt.blue)
painter.setPen(pen)
for (x,y) in prev_list:
painter.drawEllipse(x-3,y-3, 5,5)
#painter.drawPoint(x,y)
painter.end()
self.mainImage.setPixmap(self.frame_qimg)
def updateIcon(self):
self.setText(str(self._size))
w, h = self.ICON_SIZE
pixmap = QPixmap(w, h)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(Qt.black)
preview_size = min(w - 1, self._size)
center = (w - preview_size) / 2.0
painter.drawEllipse(QRect(center, center, preview_size, preview_size))
painter.end()
self.setIcon(QIcon(pixmap))
self.setIconSize(QSize(w, h))
def drawJunctions(doc, painter: QPainter):
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(Layer.color(LayerType.junction)))
nets = doc.objects(objType=NetObj)
juncts = defaultdict(set)
while nets:
n = nets.pop()
# check net against every other net in set
for n2 in nets:
v = n.connVtx(n2)
if v:
juncts[v].add(n)
juncts[v].add(n2)
for pt, nets in juncts.items():
if len(nets) > 2:
painter.drawEllipse(QPoint(pt.x, pt.y), 500, 500)
def paintEvent(self, event):
super().paintEvent(event)
if self.__checkers is None:
return
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
for checker in self.__checkers:
checker_obj, color, _ = checker
lines = checker_obj.checks.keys()
painter.setPen(QColor(color))
painter.setBrush(QColor(color))
for top, block_number, _ in self._editor.visible_blocks:
for marker in lines:
if marker == block_number:
r = self.width() - 9
painter.drawEllipse(5, top + 10, r, r)
def data(self, index, role):
'''
Reimplement, see labelListModel or boxListModel for concrete example
:param index:
:param role:
'''
if role == Qt.EditRole and index.column() == self.ColumnID.Name:
name = self._elements[index.row()].name
return name
elif role == Qt.ToolTipRole and index.column() == self.ColumnID.Delete:
s = "Delete {}".format(self._elements[index.row()].name)
return s
elif role == Qt.ToolTipRole and index.column() == self.ColumnID.Name:
suffix = self._getToolTipSuffix(index.row())
s = "{}\nDouble click to rename {}".format(
self._elements[index.row()].name, suffix)
return s
elif role == Qt.DisplayRole and index.column() == self.ColumnID.Name:
name = self._elements[index.row()].name
return name
if role == Qt.DecorationRole and index.column() == self.ColumnID.Delete:
if index.row() in self.unremovable_rows: return
row = index.row()
pixmap = QPixmap(_NPIXELS, _NPIXELS)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(QColor("red"))
painter.drawEllipse(1, 1, _NPIXELS - 2, _NPIXELS - 2)
pen = QPen(QColor("black"))
pen.setWidth(2)
painter.setPen(pen)
x = _XSTART
y = _NPIXELS - x
painter.drawLine(x, x, y, y)
painter.drawLine(y, x, x, y)
painter.end()
icon = QIcon(pixmap)
return icon
def drawSkel(self, worm_img, worm_qimg, row_data, roi_corner = (0,0)):
if not self.skel_file or not isinstance(self.trajectories_data, pd.DataFrame):
return
c_ratio_y = worm_qimg.width()/worm_img.shape[1];
c_ratio_x = worm_qimg.height()/worm_img.shape[0];
skel_id = int(row_data['skeleton_id'])
qPlg = {}
with tables.File(self.skel_file, 'r') as ske_file_id:
for tt in ['skeleton', 'contour_side1', 'contour_side2']:
dat = ske_file_id.get_node('/' + tt)[skel_id];
dat[:,0] = (dat[:,0]-roi_corner[0])*c_ratio_x
dat[:,1] = (dat[:,1]-roi_corner[1])*c_ratio_y
qPlg[tt] = QPolygonF()
for p in dat:
qPlg[tt].append(QPointF(*p))
if 'is_good_skel' in row_data and row_data['is_good_skel'] == 0:
self.skel_colors = {'skeleton':(102, 0, 0 ),
'contour_side1':(102, 0, 0 ), 'contour_side2':(102, 0, 0 )}
else:
self.skel_colors = {'skeleton':(27, 158, 119 ),
'contour_side1':(217, 95, 2), 'contour_side2':(231, 41, 138)}
pen = QPen()
pen.setWidth(2)
painter = QPainter()
painter.begin(worm_qimg)
for tt, color in self.skel_colors.items():
pen.setColor(QColor(*color))
painter.setPen(pen)
painter.drawPolyline(qPlg[tt])
pen.setColor(Qt.black)
painter.setBrush(Qt.white)
painter.setPen(pen)
radius = 3
painter.drawEllipse(qPlg['skeleton'][0], radius, radius)
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, self.antialiased)
painter.translate(self.width() / 2, self.height() / 2)
for diameter in range(0, 256, 9):
delta = abs((self.frameNo % 128) - diameter / 2)
alpha = 255 - (delta * delta) / 4 - diameter
if alpha > 0:
painter.setPen(QPen(QColor(0, diameter / 2, 127, alpha), 3))
if self.floatBased:
painter.drawEllipse(QRectF(-diameter / 2.0,
-diameter / 2.0, diameter, diameter))
else:
painter.drawEllipse(QRect(-diameter / 2,
-diameter / 2, diameter, diameter))
def paintEvent(self, e):
super().paintEvent(e)
qp = QPainter()
qp.begin(self)
line_numbers = (3,5,6,14)
try:
qp.setBrush(QtGui.QColor("#D0D0D0"))
qp.drawRect(0,0,self.width(), self.height())
qp.setBrush(Qt.red)
x = self.parent().margin / 2
for top, bottom, line_number, block in self.parent().visible_blocks:
if line_number in line_numbers:
mid = (bottom + top)/2
radius = (bottom - top) / 2
qp.drawEllipse(x-0.5*radius, mid-0.5*radius, radius, radius)
finally:
qp.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127)))
painter.setPen(QPen(Qt.NoPen))
for i in range(3):
if (self.counter / 3) % 3 == i:
painter.setBrush(QBrush(QColor(99, 137, 168)))
else:
painter.setBrush(QBrush(QColor(127, 127, 127)))
painter.drawEllipse(self.width() / 2.3 + 50 * i,
self.height() / 2, 35, 35)
painter.end()
def paintEvent(self, event):
# From Peter, thanks !
# http://thecodeinn.blogspot.fr/2015/02/customizing-qdials-in-qt-part-1.html
painter = QPainter(self)
# So that we can use the background color
painter.setBackgroundMode(1)
# Smooth out the circle
painter.setRenderHint(QPainter.Antialiasing)
# Use background color
painter.setBrush(painter.background())
# Store color from stylesheet, pen will be overriden
pointColor = QColor(painter.pen().color())
# No border
painter.setPen(QPen(Qt.NoPen))
# Draw first circle
painter.drawEllipse(0, 0, self.width(), self.height())
# Reset color to pointColor from stylesheet
painter.setBrush(QBrush(pointColor))
# Get ratio between current value and maximum to calculate angle
ratio = self.value() / self.maximum()
# The maximum amount of degrees is 270, offset by 225
angle = ratio * self._degree270 - self._degree225
# Radius of background circle
rx = self.width() / 2
ry = self.height() / 2
# Add r to have (0,0) in center of dial
y = sin(angle) * (ry - self.knobRadius - self.knobMargin) + ry
x = cos(angle) * (rx - self.knobRadius - self.knobMargin) + rx
# Draw the ellipse
painter.drawEllipse(QPointF(x, y),
self.knobRadius,
self.knobRadius)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127)))
painter.setPen(QPen(Qt.NoPen))
for i in range(6):
if (self.counter / 5) % 6 == i:
painter.setBrush(QBrush(QColor(127 + (self.counter % 5)*32, 127, 127)))
else:
painter.setBrush(QBrush(QColor(127, 127, 127)))
painter.drawEllipse(
self.width()/2 + 30 * math.cos(2 * math.pi * i / 6.0) - 10,
self.height()/2 + 30 * math.sin(2 * math.pi * i / 6.0) - 10, 20, 20)
painter.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127)))
painter.setPen(QPen(Qt.NoPen))
for i in range(12):
if self.counter % 12 == i:
painter.setBrush(QBrush(QColor(165, 165, 165, (self.counter % 12)*22)))
else:
painter.setBrush(QBrush(QColor(165, 165, 165)))
painter.drawEllipse(
self.width()/2 + 50 * math.cos(2 * math.pi * i / 12.0) - 5,
self.height()/2 + 50 * math.sin(2 * math.pi * i / 12.0) - 5,
12, 12)
painter.end()
def __grabRect(self):
"""
Private method to grab the selected rectangle (i.e. do the snapshot).
"""
if self.__mode == SnapshotRegionGrabber.Ellipse:
ell = QRegion(self.__selection, QRegion.Ellipse)
if not ell.isEmpty():
self.__grabbing = True
xOffset = self.__pixmap.rect().x() - ell.boundingRect().x()
yOffset = self.__pixmap.rect().y() - ell.boundingRect().y()
translatedEll = ell.translated(xOffset, yOffset)
pixmap2 = QPixmap(ell.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.drawEllipse(translatedEll.boundingRect())
pt.setCompositionMode(QPainter.CompositionMode_SourceIn)
else:
pt.setClipRegion(translatedEll)
pt.setCompositionMode(QPainter.CompositionMode_Source)
pt.drawPixmap(pixmap2.rect(), self.__pixmap,
ell.boundingRect())
pt.end()
self.grabbed.emit(pixmap2)
else:
r = QRect(self.__selection)
if not r.isNull() and r.isValid():
self.__grabbing = True
self.grabbed.emit(self.__pixmap.copy(r))
def paintEvent(self, *args, **kwargs):
painter = QPainter(self)
for x, y, r, color in self.circles:
painter.setPen(QPen(QColor(*color), 8, Qt.SolidLine))
painter.drawEllipse(x - r, y - r, x + r, y + r)
def run(self):
painter = QPainter()
painter.begin(self)
painter.drawEllipse(self, random.randrange(3, 30))
painter.end()
class AniState:
"""Wrapper class around QPainter to ease its usage."""
def __init__(self, widget, frame, time, dt, center=False):
self._painter = QPainter(widget)
self._painter.setRenderHint(QPainter.Antialiasing, True)
if center:
self._painter.translate(widget.width() / 2, widget.height() / 2)
self.width = widget.width()
self.height = widget.height()
self.frame = frame
self.time = time
self.dt = dt
def color(self, value):
"""
Sets the border color. The input value might be ``None`` to use
no border, a tuple consisting of (r, g, b, [a]), a string or an
integer representing the color, or a QColor/QPen itself.
"""
width = self._painter.pen().widthF()
if value is None:
self._painter.setPen(Qt.NoPen)
elif isinstance(value, tuple):
self._painter.setPen(QPen(QColor(*value), width))
elif isinstance(value, (str, int)):
self._painter.setPen(QPen(QColor(value), width))
elif isinstance(value, QColor):
self._painter.setPen(QPen(value, width))
elif isinstance(value, QPen):
self._painter.setPen(value)
return self
def fill(self, value):
"""
Sets the fill color. The input value might be ``None`` to use
no fill, a tuple consisting of (r, g, b, [a]), a string or an
integer representing the color, or a QColor/QBrush itself.
"""
if value is None:
self._painter.setBrush(Qt.NoBrush)
elif isinstance(value, tuple):
self._painter.setBrush(QBrush(QColor(*value)))
elif isinstance(value, (str, int)):
self._painter.setBrush(QBrush(QColor(value)))
elif isinstance(value, QColor):
self._painter.setBrush(QBrush(value))
elif isinstance(value, QBrush):
self._painter.setBrush(value)
return self
def size(self, size):
"""
Sets the size for lines and points.
"""
pen = self._painter.pen()
pen.setWidthF(size)
self._painter.setPen(pen)
return self
def line(self, x1, y1, x2=None, y2=None):
"""
Draws a line between the input positions.
If list/tuples are given as the first two arguments, they should
consist of two elements representing elements in a position vector.
"""
if isinstance(x1, (tuple, list)):
x2 = y1
x1, y1 = x1
if isinstance(x2, (tuple, list)):
x2, y2 = x2
self._painter.drawLine(x1, y1, x2, y2)
return self
def point(self, x, y=None):
"""
Draws a single point.
If a list/tuple is supplied as the first argument, it should
consist of two elements representing elements in a position vector.
"""
if isinstance(x, (tuple, list)):
x, y = x
self._painter.drawPoint(x, y)
return self
def points(self, values):
"""
Draws a series of points. If the first element of the list of
values is a list/tuple, then the following must be the same type.
"""
assert len(values) % 2 == 0
if isinstance(values[0], (tuple, list)):
self._painter.drawPoints(*[QPointF(x, y) for x, y, in values])
else:
self._painter.drawPoints(*[QPointF(values[i], values[i + 1])
for i in range(0, len(values), 2)])
def lines(self, values, closed=False):
"""
Draws a series of connected lines. If the first element of the list
of values is a list/tuple, then the following must be the same type.
If ``closed``, the first point will be connected to the last.
"""
assert len(values) > 4 and len(values) % 2 == 0
if isinstance(values[0], (tuple, list)):
self._painter.drawLines(*[
QLineF(
values[i - 1][0], values[i - 1][1],
values[i][0], values[i][0]
)
for i in range(0 if closed else 1, len(values))
])
else:
self._painter.drawLines(*[
QLineF(
values[i - 2], values[i - 1],
values[i], values[i + 1]
)
for i in range(0 if closed else 2, len(values), 2)
])
return self
def box(self, x, y, width, height):
"""Draws a box at the given position with the given size."""
self._painter.drawRect(x, y, width, height)
def rect(self, x1, y1, x2, y2):
"""Wrapper around anistate.box(x1, y1, x2 - x1, y2 - y1)."""
if x2 < x1:
x1, x2 = x2, x1
if y2 < y1:
y1, y2 = y2, y1
self._painter.drawRect(x1, y1, x2 - x1, y2 - y1)
def circle(self, x, y, radius):
"""Draws a centered circle at the given position and radius."""
self._painter.drawEllipse(QPointF(x, y), radius, radius)
def poly(self, values):
"""Draws a filled polygon with the shape of the input values."""
assert len(values) % 2 == 0
if isinstance(values[0], (tuple, list)):
self._painter.drawPolygon(*[QPointF(x, y) for x, y, in values])
else:
self._painter.drawPolygon(*[QPointF(values[i], values[i + 1])
for i in range(0, len(values), 2)])
return self
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 = 8
radius = 8
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: shouldnt need this
max_out = np.argmax(out)
# Draw 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:
# Is there a value being fed in
if inputs[node, 0] > 0:
painter.setBrush(QtGui.QBrush(Qt.green))
else:
painter.setBrush(QtGui.QBrush(Qt.white))
# Hidden layers
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)))
# Output layer
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))
else:
painter.setBrush(QtGui.QBrush(Qt.white))
painter.drawEllipse(x_loc, y_loc, radius * 2, radius * 2)
h_offset += 150
# Reset horizontal offset for the weights
h_offset = default_offset
# Draw weights
# For each layer starting at 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]
# For each node from the previous layer
for prev_node in range(prev_nodes):
# For all current nodes, check to see what the weights are
for curr_node in range(curr_nodes):
# If there is a positive weight, make the line blue
if weights[curr_node, prev_node] > 0:
painter.setPen(QtGui.QPen(Qt.blue))
# If there is a negative (impeding) weight, make the line red
else:
painter.setPen(QtGui.QPen(Qt.red))
# Grab locations of the nodes
start = self.neuron_locations[(l - 1, prev_node)]
end = self.neuron_locations[(l, curr_node)]
# Offset start[0] by diameter of circle so that the line starts on the right of the circle
painter.drawLine(start[0] + radius * 2, start[1], end[0],
end[1])
def drawInnerBackground(self, p: QPainter, innerRect: QRectF):
if self.m_barStyle == self.BarStyle.DONUT:
p.setBrush(self.palette().alternateBase())
p.drawEllipse(innerRect)
def paintEvent(self, event):
if self.model is None:
return
fm = QFontMetrics(self.font())
timestampWidth = fm.width("9999-99-99 99:99 ")
size = fm.height()
indicatorSize = int(size * 0.8)
offset = int(1.5 * (size - indicatorSize))
minY = event.rect().y()
maxY = minY + event.rect().height() + size
minY -= size
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.TextAntialiasing)
y = 0
for row in range(self.model.rowCount()):
x = 0
if minY <= y <= maxY:
painter.save()
painter.setPen(self.palette().color(QPalette.Text))
if row == self.selectedRow:
painter.fillRect(x, y + (offset * 0.8), self.width(), size,
self.palette().highlight())
painter.setPen(self.palette().color(
QPalette.HighlightedText))
#timestamp = self.model.data(
#self.model.index(row, TIMESTAMP)).toDateTime()
timestamp = self.model.data(self.model.index(row, TIMESTAMP))
painter.drawText(x, y + size,
timestamp.toString(TIMESTAMPFORMAT))
#print(timestamp.toString(TIMESTAMPFORMAT))
x += timestampWidth
temperature = self.model.data(
self.model.index(row, TEMPERATURE))
#temperature = temperature.toDouble()[0]
temperature = float(temperature)
if temperature < 20:
color = QColor(0, 0, int(255 * (20 - temperature) / 20))
elif temperature > 25:
color = QColor(int(255 * temperature / 100), 0, 0)
else:
color = QColor(0, int(255 * temperature / 100), 0)
painter.setPen(Qt.NoPen)
painter.setBrush(color)
painter.drawEllipse(x, y + offset, indicatorSize,
indicatorSize)
x += size
rawPh = self.model.data(self.model.index(row, RAWPH))
#rawPh = rawPh.toDouble()[0]
rawPh = float(rawPh)
if rawPh < 7:
color = QColor(int(255 * rawPh / 10), 0, 0)
elif rawPh >= 8:
color = QColor(0, 0, int(255 * rawPh / 10))
else:
color = QColor(0, int(255 * rawPh / 10), 0)
painter.setBrush(color)
painter.drawEllipse(x, y + offset, indicatorSize,
indicatorSize)
x += size
flocPh = self.model.data(self.model.index(row, FLOCCULATEDPH))
#flocPh = flocPh.toDouble()[0]
flocPh = float(flocPh)
if flocPh < 7:
color = QColor(int(255 * flocPh / 10), 0, 0)
elif flocPh >= 8:
color = QColor(0, 0, int(255 * flocPh / 10))
else:
color = QColor(0, int(255 * flocPh / 10), 0)
painter.setBrush(color)
painter.drawEllipse(x, y + offset, indicatorSize,
indicatorSize)
painter.restore()
painter.save()
x += size
flow = self.model.data(self.model.index(row, INLETFLOW))
#flow = flow.toDouble()[0]
flow = float(flow)
char = None
if flow <= 0:
char = WaterQualityView.FLOWCHARS[0]
elif flow < 3.6:
char = WaterQualityView.FLOWCHARS[1]
elif flow > 4.7:
char = WaterQualityView.FLOWCHARS[2]
if char is not None:
painter.setFont(self.flowfont)
painter.drawText(x, y + size, char)
painter.restore()
y += size
if y > maxY:
break
def paint(self, painter: QPainter, *args, **kwargs):
"""
Paint the domains
"""
r = self.rect
painter.setBrush(self.colour.brush)
painter.setPen(self.colour.pen)
painter.drawRect(r)
is_selected = self.is_selected
# Movement is allowed if we have enabled it
move_enabled = misc_helper.coalesce(
self.options.lego_move_enabled,
self.gene_view.model_view.user_move_enabled)
# Draw the piano roll unless we're moving
if self.options.lego_view_piano_roll is False or move_enabled:
draw_piano_roll = False
elif self.options.lego_view_piano_roll is None:
draw_piano_roll = is_selected
else:
draw_piano_roll = not is_selected
# Draw the selection bars, unless the piano roll is indicative of this already
draw_sel_bars = is_selected and not draw_piano_roll
# Selection bars
# (A blue box inside the gene box)
if draw_sel_bars:
self.__paint_selection_rect(painter)
# Movement bars
# (The same as the selection bars but dotted in red and cyan)
if move_enabled and is_selected:
self.__paint_movement_rect(painter)
# Piano roll
# (A piano roll for genes)
if draw_piano_roll:
lookup_table = self.model_view.lookup_table
letter_size = lookup_table.letter_size
painter.setPen(Qt.NoPen)
painter.setBrush(
DRAWING.PIANO_ROLL_SELECTED_BACKGROUND
if is_selected else DRAWING.PIANO_ROLL_UNSELECTED_BACKGROUND)
OFFSET_X = letter_size
rect_width = self.rect.width()
rect_height = lookup_table.count * letter_size
painter.drawRect(0, OFFSET_X, rect_width, rect_height)
array = self.domain.site_array
if not array:
painter.setPen(Pens.RED)
painter.drawLine(0, 0, rect_width, rect_height)
painter.drawLine(0, rect_height, rect_width, 0)
else:
for i, c in enumerate(array):
pos = lookup_table.letter_order_table.get(c)
if pos is not None:
painter.setPen(
lookup_table.letter_colour_table.get(
c, DRAWING.GENE_DEFAULT_FG))
painter.drawEllipse(i * letter_size,
pos * letter_size + OFFSET_X,
letter_size, letter_size)
# Snap-lines, when moving
if self.mousemove_snapline:
x = self.mousemove_snapline[0] - self.pos().x()
y = self.mousemove_snapline[1] - self.pos().y()
painter.setPen(DRAWING.SNAP_LINE_2)
painter.drawLine(x, self.boundingRect().height() / 2, x, y)
painter.setPen(DRAWING.SNAP_LINE)
painter.drawLine(x, self.boundingRect().height() / 2, x, y)
if not self.mousemove_label.startswith("<"):
x -= QFontMetrics(painter.font()).width(self.mousemove_label)
if y < 0:
y = self.rect.top() - DRAWING.TEXT_MARGIN
else:
y = self.rect.bottom() + DRAWING.TEXT_MARGIN + QFontMetrics(
painter.font()).xHeight()
painter.setPen(DRAWING.TEXT_LINE)
painter.drawText(QPointF(x, y),
self.mousemove_label) # Mouse snapline position
elif self.mousemove_label:
painter.setPen(DRAWING.TEXT_LINE)
painter.drawText(
QPointF(self.rect.left() + DRAWING.TEXT_MARGIN,
self.rect.top() - DRAWING.TEXT_MARGIN),
self.mousemove_label) # Mouse position
if not move_enabled:
# Positions (when not in move mode)
if misc_helper.coalesce(self.options.lego_view_positions,
is_selected):
# Draw position
if self.sibling_previous is None or self.sibling_next is None or self.sibling_previous.rect.width(
) > 32:
self.__draw_position(painter)
# Domains (when not in move mode)
if misc_helper.coalesce(self.options.lego_view_components,
is_selected):
self.__draw_component_name(painter)
def circular_pellet(self, painter: QPainter, pellet_size):
"""A perfectly circular pellet (2nd in logo)."""
painter.drawEllipse(QRectF(0, 0, pellet_size, pellet_size))
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)
painter.setPen(QPen(Qt.black, 1.0, Qt.SolidLine))
horizontal_space = 20 # Space between Nodes within the same layer
layer_nodes = self.mario.network.layer_nodes
default_offset = self.x_offset
h_offset = self.x_offset
v_offset = self.y_offset + 50
inputs = self.mario.inputs_as_array
out = self.mario.network.feed_forward(inputs)
active_outputs = np.where(out > 0.5)[0]
max_n = self.size[0] // (2 * self.neuron_radius + horizontal_space)
# Draw nodes
for layer, num_nodes in enumerate(layer_nodes[1:], 1):
h_offset = (((max_n - num_nodes)) *
(2 * self.neuron_radius + horizontal_space)) / 2
activations = None
if layer > 0:
activations = self.mario.network.params['A' + str(layer)]
for node in range(num_nodes):
x_loc = node * (self.neuron_radius * 2 +
horizontal_space) + h_offset
y_loc = v_offset
t = (layer, node)
if t not in self.neuron_locations:
self.neuron_locations[t] = (x_loc + self.neuron_radius,
y_loc)
painter.setBrush(QtGui.QBrush(Qt.white, Qt.NoBrush))
# Input layer
if layer == 0:
# Is there a value being fed in
if inputs[node, 0] > 0:
painter.setBrush(QtGui.QBrush(Qt.green))
else:
painter.setBrush(QtGui.QBrush(Qt.white))
# Hidden layers
elif layer > 0 and layer < len(layer_nodes) - 1:
saturation = max(min(activations[node, 0], 1.0), 0.0)
painter.setBrush(
QtGui.QBrush(
QtGui.QColor.fromHslF(125 / 239, saturation,
120 / 240)))
# Output layer
elif layer == len(layer_nodes) - 1:
text = ('U', 'D', 'L', 'R', 'A', 'B')[node]
painter.drawText(
h_offset + node *
(self.neuron_radius * 2 + horizontal_space), v_offset +
2 * self.neuron_radius + 2 * self.neuron_radius, text)
if node in active_outputs:
painter.setBrush(QtGui.QBrush(Qt.green))
else:
painter.setBrush(QtGui.QBrush(Qt.white))
painter.drawEllipse(x_loc, y_loc, self.neuron_radius * 2,
self.neuron_radius * 2)
v_offset += 150
# Reset horizontal offset for the weights
h_offset = default_offset
# Draw weights
# For each layer starting at 1
for l in range(2, len(layer_nodes)):
weights = self.mario.network.params['W' + str(l)]
prev_nodes = weights.shape[1]
curr_nodes = weights.shape[0]
# For each node from the previous layer
for prev_node in range(prev_nodes):
# For all current nodes, check to see what the weights are
for curr_node in range(curr_nodes):
# If there is a positive weight, make the line blue
if weights[curr_node, prev_node] > 0:
painter.setPen(QtGui.QPen(Qt.blue))
# If there is a negative (impeding) weight, make the line red
else:
painter.setPen(QtGui.QPen(Qt.red))
# Grab locations of the nodes
start = self.neuron_locations[(l - 1, prev_node)]
end = self.neuron_locations[(l, curr_node)]
# Offset start[0] by diameter of circle so that the line starts on the right of the circle
painter.drawLine(start[0],
start[1] + self.neuron_radius * 2, end[0],
end[1])
# Draw line straight down
color = QColor(255, 0, 217)
painter.setPen(QPen(color, 3.0, Qt.SolidLine))
painter.setBrush(QBrush(Qt.NoBrush))
x_start = 5 + 150 + (16 / 2 * self.tile_size[0])
y_start = 5 + (15 * self.tile_size[1])
x_end = x_start
y_end = y_start + 5 + (2 * self.neuron_radius)
painter.drawLine(x_start, y_start, x_end, y_end)
# Set pen to be smaller and draw pink connections
painter.setPen(QPen(color, 1.0, Qt.SolidLine))
for nid in range(layer_nodes[1]):
start = self.neuron_locations[(1, nid)]
painter.drawLine(start[0], start[1], x_end, y_end)
def run(self):
qp = QPainter()
qp.begin(self)
qp.setBrush(QColor(r(0, 255), r(0, 255), r(0, 255)))
qp.drawEllipse(r(0, 700), r(0, 500), r(10, 400), r(10, 400))
qp.end()
def mousePressEvent(self, click: QtGui.QMouseEvent):
if self.start_point_file != "" and self.end_point_file != "":
x = click.pos().x()
y = click.pos().y()
if self.start_clicked is True and self.end_clicked is True and \
not(x >= 495 and x <= 855 and y >= 50 and y <= 320):
if self.type == 0:
self.type = 2
self.start_clicked = False
self.end_clicked = False
s_pixmap = self.start_normal_pixmap
e_pixmap = self.end_normal_pixmap
# draw on startIM
painter = QPainter()
painter.begin(s_pixmap)
pen = QtGui.QPen(QtGui.QColor(0, 0, 255))
pen.setWidth(10)
painter.setPen(pen)
painter.drawEllipse(self.temp_coord1[0] - 4,
self.temp_coord1[1] - 4, 10, 10)
painter.end()
self.startIm.setPixmap(
s_pixmap.scaled(360, 270, Qt.KeepAspectRatio))
# draw on endIM
painter = QPainter()
painter.begin(e_pixmap)
pen = QtGui.QPen(QtGui.QColor(0, 0, 255))
pen.setWidth(10)
painter.setPen(pen)
painter.drawEllipse(self.temp_coord2[0] - 4,
self.temp_coord2[1] - 4, 10, 10)
painter.end()
self.endIm.setPixmap(
e_pixmap.scaled(360, 270, Qt.KeepAspectRatio))
# write to files
s_x = str(float(self.temp_coord1[0]))
s_y = str(float(self.temp_coord1[1]))
e_x = str(float(self.temp_coord2[0]))
e_y = str(float(self.temp_coord2[1]))
s_str = (8 - len(s_x)) * " " + s_x + (8 - len(s_y)) * " " + s_y
e_str = (8 - len(e_x)) * " " + e_x + (8 - len(e_y)) * " " + e_y
if os.stat(self.start_point_file).st_size != 0:
s_str = '\n' + s_str
if os.stat(self.end_point_file).st_size != 0:
e_str = '\n' + e_str
f = open(self.start_point_file, 'a+')
f.write(s_str)
f.close()
f = open(self.end_point_file, 'a+')
f.write(e_str)
f.close()
self.triangles = loadTriangles(self.start_point_file,
self.end_point_file)
if self.showTri.isChecked():
self.TriangleShow()
y_to_x_ratio = self.start_im_pixels.shape[
0] / self.start_im_pixels.shape[1]
x_l = self.start_im_pixels.shape[1]
y_l = self.start_im_pixels.shape[0]
if y_to_x_ratio <= 3.0 / 4.0:
x_compare = 360
y_compare = y_to_x_ratio * 360.0 # 180 or 90
else:
x_compare = 1.0 / y_to_x_ratio * 270.0
y_compare = 0
if x > 45 and x < 45 + x_compare and y > 50 + y_compare and y < 320 - y_compare: # start image
if y_to_x_ratio <= 3.0 / 4.0:
x_pos = np.round((x - 45.0) * x_l / 360.0)
y_pos = np.round((y - 50 - y_compare))
else:
x_pos = np.round((x - 45.0) * y_l / 270.0)
y_pos = np.round((y - 50.0) * y_l / 270)
if x_pos >= self.start_im_pixels.shape[1]:
x_pos -= 1
if y_pos >= self.start_im_pixels.shape[0]:
y_pos -= 1
if self.start_clicked is False:
self.start_clicked = True
self.temp_coord1 = (x_pos, y_pos)
if self.showTri.isChecked() is True:
s_pixmap = self.start_pixmap.copy()
else:
s_pixmap = self.start_normal_pixmap.copy()
painter = QPainter()
painter.begin(s_pixmap)
pen = QtGui.QPen(QtGui.QColor(0, 255, 0))
pen.setWidth(10)
painter.setPen(pen)
painter.drawEllipse(x_pos - 4, y_pos - 4, 10, 10)
painter.end()
self.startIm.setPixmap(
s_pixmap.scaled(360, 270, Qt.KeepAspectRatio))
if x > 495 and x < 495 + x_compare and y > 50 + y_compare and y < 320 - y_compare: # end image
if y_to_x_ratio <= 3.0 / 4.0:
x_pos = np.round((x - 495.0) * x_l / 360.0)
y_pos = np.round((y - 50 - y_compare))
else:
x_pos = np.round((x - 495.0) * y_l / 270.0)
y_pos = np.round((y - 50.0) * y_l / 270)
if y_pos == self.start_im_pixels.shape[0]:
y_pos -= 1
if x_pos == self.start_im_pixels.shape[1]:
x_pos -= 1
if self.start_clicked is True and self.end_clicked is False:
self.end_clicked = True
self.temp_coord2 = (x_pos, y_pos)
if self.showTri.isChecked() is True:
e_pixmap = self.end_pixmap.copy()
else:
e_pixmap = self.end_normal_pixmap.copy()
painter = QPainter()
painter.begin(e_pixmap)
pen = QtGui.QPen(QtGui.QColor(0, 255, 0))
pen.setWidth(10)
painter.setPen(pen)
painter.drawEllipse(x_pos - 4, y_pos - 4, 10, 10)
painter.end()
self.endIm.setPixmap(
e_pixmap.scaled(360, 270, Qt.KeepAspectRatio))
def paintEvent(self, event):
page_bottom = self.edit.viewport().height()
font_metrics = QFontMetrics(self.edit.document().defaultFont())
current_block = self.edit.document().findBlock(
self.edit.textCursor().position())
pattern = self.pat if self.edit.lang == "python" else self.patNotPython
painter = QPainter(self)
background = resources.CUSTOM_SCHEME.get(
'sidebar-background', resources.COLOR_SCHEME['sidebar-background'])
foreground = resources.CUSTOM_SCHEME.get(
'sidebar-foreground', resources.COLOR_SCHEME['sidebar-foreground'])
background_selected = resources.CUSTOM_SCHEME.get(
'sidebar-selected-background',
resources.COLOR_SCHEME['sidebar-selected-background'])
foreground_selected = resources.CUSTOM_SCHEME.get(
'sidebar-selected-foreground',
resources.COLOR_SCHEME['sidebar-selected-foreground'])
painter.fillRect(self.rect(), QColor(background))
block = self.edit.firstVisibleBlock()
viewport_offset = self.edit.contentOffset()
line_count = block.blockNumber()
painter.setFont(self.edit.document().defaultFont())
xofs = self.width() - self.foldArea
painter.fillRect(
xofs, 0, self.foldArea, self.height(),
QColor(
resources.CUSTOM_SCHEME.get(
'fold-area', resources.COLOR_SCHEME['fold-area'])))
while block.isValid():
line_count += 1
# The top left position of the block in the document
position = self.edit.blockBoundingGeometry(block).topLeft() + \
viewport_offset
# Check if the position of the block is outside of the visible area
if position.y() > page_bottom:
break
# Set the Painter Pen depending on special lines
painter.setPen(QColor(foreground))
error = False
checkers = self._neditable.sorted_checkers
for items in checkers:
checker, color, _ = items
if (line_count - 1) in checker.checks:
painter.setPen(QColor(color))
font = painter.font()
font.setItalic(True)
font.setUnderline(True)
painter.setFont(font)
error = True
break
# We want the line number for the selected line to be bold.
bold = False
if block == current_block:
painter.fillRect(
0,
round(position.y()) + font_metrics.descent(), self.width(),
font_metrics.ascent() + font_metrics.descent(),
QColor(background_selected))
bold = True
font = painter.font()
font.setBold(True)
if not error:
painter.setPen(QColor(foreground_selected))
painter.setFont(font)
# Draw the line number right justified at the y position of the
# line. 3 is a magic padding number. drawText(x, y, text).
if block.isVisible():
painter.drawText(
self.width() - self.foldArea -
font_metrics.width(str(line_count)) - 3,
round(position.y()) + font_metrics.ascent() +
font_metrics.descent() - 1, str(line_count))
# Remove the bold style if it was set previously.
if bold:
font = painter.font()
font.setBold(False)
painter.setFont(font)
if error:
font = painter.font()
font.setItalic(False)
font.setUnderline(False)
painter.setFont(font)
block = block.next()
self.highest_line = line_count
#Code Folding
if self.foldArea != self.rightArrowIcon.width():
polygon = QPolygonF()
self.rightArrowIcon = QPixmap(self.foldArea, self.foldArea)
self.rightArrowIcon.fill(Qt.transparent)
self.downArrowIcon = QPixmap(self.foldArea, self.foldArea)
self.downArrowIcon.fill(Qt.transparent)
polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.25))
polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.75))
polygon.append(QPointF(self.foldArea * 0.8, self.foldArea * 0.5))
iconPainter = QPainter(self.rightArrowIcon)
iconPainter.setRenderHint(QPainter.Antialiasing)
iconPainter.setPen(Qt.NoPen)
iconPainter.setBrush(
QColor(
resources.CUSTOM_SCHEME.get(
'fold-arrow', resources.COLOR_SCHEME['fold-arrow'])))
iconPainter.drawPolygon(polygon)
polygon.clear()
polygon.append(QPointF(self.foldArea * 0.25, self.foldArea * 0.4))
polygon.append(QPointF(self.foldArea * 0.75, self.foldArea * 0.4))
polygon.append(QPointF(self.foldArea * 0.5, self.foldArea * 0.8))
iconPainter = QPainter(self.downArrowIcon)
iconPainter.setRenderHint(QPainter.Antialiasing)
iconPainter.setPen(Qt.NoPen)
iconPainter.setBrush(
QColor(
resources.CUSTOM_SCHEME.get(
'fold-arrow', resources.COLOR_SCHEME['fold-arrow'])))
iconPainter.drawPolygon(polygon)
self.calculate_docstring_block_fold()
block = self.edit.firstVisibleBlock()
while block.isValid():
position = self.edit.blockBoundingGeometry(
block).topLeft() + viewport_offset
#Check if the position of the block is outside of the visible area
if position.y() > page_bottom:
break
if pattern.match(block.text()) and block.isVisible():
can_fold = True
if self.patComment.match(block.text()) and \
(block.blockNumber() in self._endDocstringBlocks):
can_fold = False
if can_fold:
if block.blockNumber() in self.foldedBlocks:
painter.drawPixmap(xofs, round(position.y()),
self.rightArrowIcon)
else:
painter.drawPixmap(xofs, round(position.y()),
self.downArrowIcon)
#Add Bookmarks and Breakpoint
if block.blockNumber() in self.breakpoints:
linear_gradient = QLinearGradient(
xofs, round(position.y()), xofs + self.foldArea,
round(position.y()) + self.foldArea)
linear_gradient.setColorAt(0, QColor(255, 11, 11))
linear_gradient.setColorAt(1, QColor(147, 9, 9))
painter.setRenderHints(QPainter.Antialiasing, True)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(linear_gradient))
painter.drawEllipse(xofs + 1,
round(position.y()) + 6, self.foldArea - 1,
self.foldArea - 1)
elif block.blockNumber() in self.bookmarks:
linear_gradient = QLinearGradient(
xofs, round(position.y()), xofs + self.foldArea,
round(position.y()) + self.foldArea)
linear_gradient.setColorAt(0, QColor(13, 62, 243))
linear_gradient.setColorAt(1, QColor(5, 27, 106))
painter.setRenderHints(QPainter.Antialiasing, True)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(linear_gradient))
painter.drawRoundedRect(xofs + 1,
round(position.y()) + 6,
self.foldArea - 2, self.foldArea - 1,
3, 3)
block = block.next()
painter.end()
super(SidebarWidget, self).paintEvent(event)
def TriangleShow(self):
if self.showTri.isChecked() is True:
self.start_pixmap = self.start_normal_pixmap.copy()
self.end_pixmap = self.end_normal_pixmap.copy()
painter = QPainter()
painter.begin(self.start_pixmap)
if self.type == 0:
pen = QtGui.QPen(QtGui.QColor(255, 0, 0))
elif self.type == 1:
pen = QtGui.QPen(QtGui.QColor(0, 0, 255))
else:
pen = QtGui.QPen(QtGui.QColor(0, 255, 255))
pen.setWidth(4)
painter.setPen(pen)
for tri in self.triangles[0]:
painter.drawLine(tri.vertices[0][0], tri.vertices[0][1],
tri.vertices[1][0], tri.vertices[1][1])
painter.drawLine(tri.vertices[2][0], tri.vertices[2][1],
tri.vertices[1][0], tri.vertices[1][1])
painter.drawLine(tri.vertices[0][0], tri.vertices[0][1],
tri.vertices[2][0], tri.vertices[2][1])
painter.end()
s_pixmap = self.start_pixmap.copy()
if self.start_clicked is True:
painter = QPainter()
painter.begin(s_pixmap)
pen = QtGui.QPen(QtGui.QColor(0, 255, 0))
pen.setWidth(10)
painter.setPen(pen)
painter.drawEllipse(self.temp_coord1[0] - 4,
self.temp_coord1[1] - 4, 10, 10)
painter.end()
painter = QPainter()
painter.begin(self.end_pixmap)
if self.type == 0:
pen = QtGui.QPen(QtGui.QColor(255, 0, 0))
elif self.type == 1:
pen = QtGui.QPen(QtGui.QColor(0, 0, 255))
else:
pen = QtGui.QPen(QtGui.QColor(0, 255, 255))
pen.setWidth(4)
painter.setPen(pen)
for tri in self.triangles[1]:
painter.drawLine(tri.vertices[0][0], tri.vertices[0][1],
tri.vertices[1][0], tri.vertices[1][1])
painter.drawLine(tri.vertices[2][0], tri.vertices[2][1],
tri.vertices[1][0], tri.vertices[1][1])
painter.drawLine(tri.vertices[0][0], tri.vertices[0][1],
tri.vertices[2][0], tri.vertices[2][1])
painter.end()
e_pixmap = self.end_pixmap.copy()
if self.end_clicked is True:
painter = QPainter()
painter.begin(e_pixmap)
pen = QtGui.QPen(QtGui.QColor(0, 255, 0))
pen.setWidth(10)
painter.setPen(pen)
painter.drawEllipse(self.temp_coord2[0] - 4,
self.temp_coord2[1] - 4, 10, 10)
painter.end()
self.startIm.setPixmap(
s_pixmap.scaled(360, 270, Qt.KeepAspectRatio))
self.endIm.setPixmap(e_pixmap.scaled(360, 270, Qt.KeepAspectRatio))
else:
s_pixmap = self.start_normal_pixmap.copy()
if self.start_clicked is True:
painter = QPainter()
painter.begin(s_pixmap)
pen = QtGui.QPen(QtGui.QColor(0, 255, 0))
pen.setWidth(10)
painter.setPen(pen)
painter.drawEllipse(self.temp_coord1[0] - 4,
self.temp_coord1[1] - 4, 10, 10)
painter.end()
e_pixmap = self.end_normal_pixmap.copy()
if self.end_clicked is True:
painter = QPainter()
painter.begin(e_pixmap)
pen = QtGui.QPen(QtGui.QColor(0, 255, 0))
pen.setWidth(10)
painter.setPen(pen)
painter.drawEllipse(self.temp_coord2[0] - 4,
self.temp_coord2[1] - 4, 10, 10)
painter.end()
self.startIm.setPixmap(
s_pixmap.scaled(360, 270, Qt.KeepAspectRatio))
self.endIm.setPixmap(e_pixmap.scaled(360, 270, Qt.KeepAspectRatio))
def paintEvent(self, event):
selections = self.selectionModel()
option = self.viewOptions()
state = option.state
background = option.palette.base()
foreground = QPen(option.palette.color(QPalette.WindowText))
textPen = QPen(option.palette.color(QPalette.Text))
highlightedPen = QPen(option.palette.color(QPalette.HighlightedText))
painter = QPainter(self.viewport())
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), background)
painter.setPen(foreground)
# Viewport rectangles
pieRect = QRect(self.margin, self.margin, self.pieSize, self.pieSize)
keyPoint = QPoint(self.totalSize - self.horizontalScrollBar().value(),
self.margin - self.verticalScrollBar().value())
if self.validItems > 0:
painter.save()
painter.translate(pieRect.x() - self.horizontalScrollBar().value(),
pieRect.y() - self.verticalScrollBar().value())
painter.drawEllipse(0, 0, self.pieSize, self.pieSize)
startAngle = 0.0
for row in range(self.model().rowCount(self.rootIndex())):
index = self.model().index(row, 1, self.rootIndex())
value = self.model().data(index)
if value > 0.0:
angle = 360 * value / self.totalValue
colorIndex = self.model().index(row, 0, self.rootIndex())
color = self.model().data(colorIndex, Qt.DecorationRole)
if self.currentIndex() == index:
painter.setBrush(QBrush(color, Qt.Dense4Pattern))
elif selections.isSelected(index):
painter.setBrush(QBrush(color, Qt.Dense3Pattern))
else:
painter.setBrush(QBrush(color))
painter.drawPie(0, 0, self.pieSize, self.pieSize,
int(startAngle * 16), int(angle * 16))
startAngle += angle
painter.restore()
keyNumber = 0
for row in range(self.model().rowCount(self.rootIndex())):
index = self.model().index(row, 1, self.rootIndex())
value = self.model().data(index)
if value > 0.0:
labelIndex = self.model().index(row, 0, self.rootIndex())
option = self.viewOptions()
option.rect = self.visualRect(labelIndex)
if selections.isSelected(labelIndex):
option.state |= QStyle.State_Selected
if self.currentIndex() == labelIndex:
option.state |= QStyle.State_HasFocus
self.itemDelegate().paint(painter, option, labelIndex)
keyNumber += 1
def paintEvent(
self, e): #Fonction qui va "peindre" la fenetre, c'est l'affichage
painter = QPainter(self)
pen = QPen()
#Un rectangle de la taille de la fenetre pour un fond noir
couleurFond = QColor(0, 0, 0)
painter.fillRect(0, 0, self.width(), self.height(), couleurFond)
colorTour = QColor(0, 150, 255)
pen = QPen()
pen.setColor(colorTour)
painter.setPen(pen)
#conditions pour afficher le cercle décrivant la trajectoire des planètes
if self.zoom <= 8:
painter.drawEllipse(self.pos1x, self.pos1y, self.rayon1,
self.rayon1)
if self.zoom <= 7:
painter.drawEllipse(self.pos2x, self.pos2y, self.rayon2,
self.rayon2)
if self.zoom <= 6:
painter.drawEllipse(self.pos3x, self.pos3y, self.rayon3,
self.rayon3)
if self.zoom <= 5:
painter.drawEllipse(self.pos4x, self.pos4y,
self.rayon4, self.rayon4)
if self.zoom <= 4:
painter.drawEllipse(self.pos5x, self.pos5y,
self.rayon5, self.rayon5)
if self.zoom <= 3:
painter.drawEllipse(self.pos6x, self.pos6y,
self.rayon6, self.rayon6)
if self.zoom <= 2:
painter.drawEllipse(
self.pos7x, self.pos7y, self.rayon7,
self.rayon7)
if self.zoom <= 1:
painter.drawEllipse(
self.pos8x, self.pos8y,
self.rayon8, self.rayon8)
#affichage du soleil au centre
color = QColor(255, 255, 0)
pen.setColor(color)
painter.setPen(pen)
brush = QBrush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawEllipse(self.width() / 2 - self.bd_s / 2,
self.height() / 2 - self.bd_s / 2 + 15, self.bd_s,
self.bd_s)
#un enchainement de conditions ( if ) afin de pouvoir maitriser le zoom en supprimant l'affichage des planètes qui ne sont plus à l'écran
if self.zoom <= 8:
color = QColor(218, 65, 32)
pen.setColor(color)
painter.setPen(pen)
brush = QBrush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawEllipse(
self.width() / 2 - (self.bd_p / 2) +
(self.rayon1 / 2) * math.cos(self.angle1),
self.height() / 2 - (self.bd_p / 2) + 15 +
(self.rayon1 / 2) * math.sin(self.angle1), self.bd_p,
self.bd_p)
if self.zoom <= 7:
color = QColor(0, 255, 255)
pen.setColor(color)
painter.setPen(pen)
brush = QBrush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawEllipse(
self.width() / 2 - (self.bd_p / 2) +
(self.rayon2 / 2) * math.cos(self.angle2),
self.height() / 2 - (self.bd_p / 2) + 15 +
(self.rayon2 / 2) * math.sin(self.angle2), self.bd_p,
self.bd_p)
if self.zoom <= 6:
color = QColor(255, 228, 181)
pen.setColor(color)
painter.setPen(pen)
brush = QBrush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawEllipse(
self.width() / 2 - (self.bd_p / 2) +
(self.rayon3 / 2) * math.cos(self.angle3),
self.height() / 2 - (self.bd_p / 2) + 15 +
(self.rayon3 / 2) * math.sin(self.angle3), self.bd_p,
self.bd_p)
if self.zoom <= 5:
color = QColor(222, 184, 135)
pen.setColor(color)
painter.setPen(pen)
brush = QBrush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawEllipse(
self.width() / 2 - (self.bd_p / 2) +
(self.rayon4 / 2) * math.cos(self.angle4),
self.height() / 2 - (self.bd_p / 2) + 15 +
(self.rayon4 / 2) * math.sin(self.angle4),
self.bd_p, self.bd_p)
if self.zoom <= 4:
color = QColor(178, 34, 34)
pen.setColor(color)
painter.setPen(pen)
brush = QBrush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawEllipse(
self.width() / 2 - (self.bd_p / 2) +
(self.rayon5 / 2) * math.cos(self.angle5),
self.height() / 2 - (self.bd_p / 2) + 15 +
(self.rayon5 / 2) * math.sin(self.angle5),
self.bd_p, self.bd_p)
if self.zoom <= 3:
color = QColor(0, 0, 255)
pen.setColor(color)
painter.setPen(pen)
brush = QBrush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawEllipse(
self.width() / 2 - (self.bd_p / 2) +
(self.rayon6 / 2) * math.cos(self.angle6),
self.height() / 2 - (self.bd_p / 2) + 15 +
(self.rayon6 / 2) * math.sin(self.angle6),
self.bd_p, self.bd_p)
if self.zoom <= 2:
color = QColor(255, 140, 0)
pen.setColor(color)
painter.setPen(pen)
brush = QBrush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawEllipse(
self.width() / 2 - (self.bd_p / 2) +
(self.rayon7 / 2) *
math.cos(self.angle7),
self.height() / 2 - (self.bd_p / 2) +
15 + (self.rayon7 / 2) *
math.sin(self.angle7), self.bd_p,
self.bd_p)
if self.zoom <= 1:
color = QColor(100, 149, 237)
pen.setColor(color)
painter.setPen(pen)
brush = QBrush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawEllipse(
self.width() / 2 -
(self.bd_p / 2) +
(self.rayon8 / 2) *
math.cos(self.angle8),
self.height() / 2 -
(self.bd_p / 2) + 15 +
(self.rayon8 / 2) *
math.sin(self.angle8), self.bd_p,
self.bd_p)
#histoire de dates, pas encore utile
'''
painter.setPen(pen)
font = painter.font()
font.setPointSize(self.width() / 50)
painter.setFont(font)
painter.drawText(self.width()/1.5, self.height() / 12, str(self.dateJour))
painter.drawText(self.width()/1.3 + self.width()/50 * 8, self.height() / 12, str(self.dateAnnée))
if self.dateMois == 10 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'JANVIER')
if self.dateMois == 2 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'FEVRIER')
if self.dateMois == 3 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'MARS')
if self.dateMois == 4 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'AVRIL')
if self.dateMois == 5 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'MAI')
if self.dateMois == 6 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'JUIN')
if self.dateMois == 7 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'JUILLET')
if self.dateMois == 8 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'AOUT')
if self.dateMois == 1 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'SEPTEMBRE')
if self.dateMois == 10 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'OCTOBRE')
if self.dateMois == 11 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'NOVEMBRE')
if self.dateMois == 12 :
painter.drawText(self.width()/1.4 + self.width()/50*2, self.height() / 12, 'DECEMBRE')
'''
if -0.5 < self.angle3 / 2 * pi < 0.5:
self.dateAnnée += 1
def paintEvent(self, event):
painter = QPainter(self)
painter.setBrush(QBrush(self.status_color, Qt.SolidPattern))
painter.drawEllipse(self.width() * 0.5,
self.height() * 0.35, self.diameter, self.diameter)
def get_masked_image(path, size=64, overlay_text=""):
"""
Returns a ``QPixmap`` from an image file masked with a smooth circle.
The returned pixmap will have a size of *size* × *size* pixels.
:param str path: Path to image file.
:param int size: Target size. Will be the diameter of the masked image.
:param overlay_text: Overlay text. This will be shown in white sans-serif on top of
the image.
:return: `QPixmap`` instance.
"""
with open(path, "rb") as f:
imgdata = f.read()
imgtype = path.split(".")[-1]
# Load image and convert to 32-bit ARGB (adds an alpha channel):
image = QImage.fromData(imgdata, imgtype)
image.convertToFormat(QImage.Format_ARGB32)
# Crop image to a square:
imgsize = min(image.width(), image.height())
rect = QRect(
(image.width() - imgsize) / 2,
(image.height() - imgsize) / 2,
imgsize,
imgsize,
)
image = image.copy(rect)
# Create the output image with the same dimensions and an alpha channel
# and make it completely transparent:
out_img = QImage(imgsize, imgsize, QImage.Format_ARGB32)
out_img.fill(Qt.transparent)
# Create a texture brush and paint a circle with the original image onto
# the output image:
brush = QBrush(image) # Create texture brush
painter = QPainter(out_img) # Paint the output image
painter.setBrush(brush) # Use the image texture brush
painter.setPen(Qt.NoPen) # Don't draw an outline
painter.setRenderHint(QPainter.Antialiasing, True) # Use AA
painter.drawEllipse(0, 0, imgsize, imgsize) # Actually draw the circle
if overlay_text:
# draw text
font = QtGui.QFont("Arial Rounded MT Bold")
font.setPointSize(imgsize * 0.4)
painter.setFont(font)
painter.setPen(Qt.white)
painter.drawText(QRect(0, 0, imgsize, imgsize), Qt.AlignCenter,
overlay_text)
painter.end() # We are done (segfault if you forget this)
# Convert the image to a pixmap and rescale it. Take pixel ratio into
# account to get a sharp image on retina displays:
pr = QWindow().devicePixelRatio()
pm = QPixmap.fromImage(out_img)
pm.setDevicePixelRatio(pr)
size *= pr
pm = pm.scaled(size, size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
return pm
def paintEvent(self, event):
self.controller.lock.acquire()
velocity_scale_factor = self.config.getfloat(
"spaceframe.ship.velocity.scale")
star_width = self.config.getint("spaceframe.star.width")
star_height = self.config.getint("spaceframe.star.height")
ship_width = self.config.getint("spaceframe.ship.width")
ship_height = self.config.getint("spaceframe.ship.height")
# print("paint, star count {0}".format(len(self.controller.stars())))
painter = QPainter(self)
painter.setPen(QPen(Qt.black, 1, Qt.SolidLine))
painter.setBrush(QBrush(Qt.green, Qt.SolidPattern))
gui_center_x = self.width() / 2
gui_center_y = self.height() / 2
# we know our space_width_ratio, that's essentially the zoom level, need to map that to a height ratio given
# our gui width/height ratio
space_height_ratio = self.space_width_ratio * self.width(
) / self.height()
# draw a point at the center
painter.drawRect(self.width() / 2 - 2, self.height() / 2 - 2, 4, 4)
# we need to re-compute the rectangles every paint event
self.star_rectangles = []
self.ship_rectangles = []
painter.setPen(QPen(Qt.black, 1, Qt.SolidLine))
painter.setBrush(QBrush(Qt.red, Qt.SolidPattern))
# first draw lines to/from moving ships and their stars
for ship in self.controller.ships:
if (ship.selected
or ship.hovered) and ship.destination_star is not None:
self.brush_and_pen(painter, "spaceframe.ship.destination")
painter.drawLine(
gui_center_x +
((ship.destination_star.location.x - self.space_center_x) /
self.space_width_ratio), gui_center_y +
((ship.destination_star.location.y - self.space_center_y) /
space_height_ratio),
gui_center_x + ((ship.location.x - self.space_center_x) /
self.space_width_ratio),
gui_center_y + ((ship.location.y - self.space_center_y) /
space_height_ratio))
# next draw line between selected star and hovered star
for star in self.controller.stars:
if star.hovered and self.controller.selected_star is not None and self.controller.selected_star.star_id != star.star_id:
self.brush_and_pen(painter, "spaceframe.star.selected_hovered")
s = self.controller.selected_star
painter.drawLine(
gui_center_x + ((star.location.x - self.space_center_x) /
self.space_width_ratio),
gui_center_y + ((star.location.y - self.space_center_y) /
space_height_ratio),
gui_center_x + ((s.location.x - self.space_center_x) /
self.space_width_ratio),
gui_center_y + ((s.location.y - self.space_center_y) /
space_height_ratio))
for star in self.controller.stars:
x = gui_center_x + ((star.location.x - self.space_center_x) /
self.space_width_ratio) - (star_width / 2)
y = gui_center_y + ((star.location.y - self.space_center_y) /
space_height_ratio) - (star_height / 2)
if star.hovered:
self.brush_and_pen(painter, "spaceframe.star.hovered")
elif star.selected:
self.brush_and_pen(painter, "spaceframe.star.selected")
else:
self.brush_and_pen(painter, "spaceframe.star.default")
painter.drawEllipse(x, y, star_width, star_height)
painter.setFont(QFont('Decorative', 10))
painter.drawText(x + 2, y + star_height / 2 + 4,
"{0}".format(star.star_id))
self.star_rectangles.append(
(star, QRect(x, y, star_width, star_height)))
for ship in self.controller.ships:
x = gui_center_x + ((ship.location.x - self.space_center_x) /
self.space_width_ratio) - (ship_width / 2)
y = gui_center_y + ((ship.location.y - self.space_center_y) /
space_height_ratio) - (ship_height / 2)
if ship.hovered:
self.brush_and_pen(painter, "spaceframe.ship.hovered")
elif ship.selected:
self.brush_and_pen(painter, "spaceframe.ship.selected")
else:
self.brush_and_pen(painter, "spaceframe.ship.default")
painter.drawEllipse(x, y, ship_width - 2, ship_height - 2)
# if travelling (not docked) draw a visual indicator of the velocity
if ship.docked_star is None:
self.brush_and_pen(painter, "spaceframe.ship.velocity")
# center of ship (gui coords)
ship_x = x + ship_width / 2
ship_y = y + ship_height / 2
# center of destination star (gui coords)
star_x = gui_center_x + (
(ship.destination_star.location.x - self.space_center_x) /
self.space_width_ratio)
star_y = gui_center_y + (
(ship.destination_star.location.y - self.space_center_y) /
space_height_ratio)
big_h = math.sqrt(
math.pow(star_x - ship_x, 2) +
math.pow(star_y - ship_y, 2))
h = 10
x_prime = (
(star_x - ship_x) * h) / big_h if big_h != 0 else ship_x
y_prime = (
(star_y - ship_y) * h) / big_h if big_h != 0 else ship_y
vel_x = x + (ship_width / 2) + x_prime
vel_y = y + (ship_height / 2) + y_prime
painter.drawLine(
vel_x, vel_y, vel_x + velocity_scale_factor *
(ship.velocity.x / self.space_width_ratio),
vel_y + velocity_scale_factor *
(ship.velocity.y / space_height_ratio))
self.ship_rectangles.append(
(ship, QRect(x, y, ship_width, ship_height)))
painter.end()
self.controller.lock.release()
def paintEvent(self, event):
painter = QPainter(self)
painter.setPen(QPen(choice(self.colors), 8, Qt.SolidLine))
diam = randrange(1, 500)
painter.drawEllipse(0, 0, diam, diam)
def drawChart(self, qp: QtGui.QPainter) -> None:
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 = (height, width, 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 __init__(self, parent=None): # pylint: disable=too-many-statements
super(WatchpointsWidget, self).__init__(parent=parent)
self._app_window = parent
if self._app_window.dwarf is None:
print('WatchpointsWidget created before Dwarf exists')
return
self._uppercase_hex = True
self.setAutoFillBackground(True)
# connect to dwarf
self._app_window.dwarf.onWatchpointAdded.connect(
self._on_watchpoint_added)
self._app_window.dwarf.onWatchpointRemoved.connect(
self._on_watchpoint_removed)
# setup our model
self._watchpoints_model = QStandardItemModel(0, 5)
self._watchpoints_model.setHeaderData(0, Qt.Horizontal, 'Address')
self._watchpoints_model.setHeaderData(1, Qt.Horizontal, 'R')
self._watchpoints_model.setHeaderData(1, Qt.Horizontal, Qt.AlignCenter,
Qt.TextAlignmentRole)
self._watchpoints_model.setHeaderData(2, Qt.Horizontal, 'W')
self._watchpoints_model.setHeaderData(2, Qt.Horizontal, Qt.AlignCenter,
Qt.TextAlignmentRole)
self._watchpoints_model.setHeaderData(3, Qt.Horizontal, 'X')
self._watchpoints_model.setHeaderData(3, Qt.Horizontal, Qt.AlignCenter,
Qt.TextAlignmentRole)
self._watchpoints_model.setHeaderData(4, Qt.Horizontal, 'S')
self._watchpoints_model.setHeaderData(4, Qt.Horizontal, Qt.AlignCenter,
Qt.TextAlignmentRole)
# setup ui
v_box = QVBoxLayout(self)
v_box.setContentsMargins(0, 0, 0, 0)
self.list_view = DwarfListView()
self.list_view.setModel(self._watchpoints_model)
self.list_view.header().setSectionResizeMode(0, QHeaderView.Stretch)
self.list_view.header().setSectionResizeMode(
1, QHeaderView.ResizeToContents | QHeaderView.Fixed)
self.list_view.header().setSectionResizeMode(
2, QHeaderView.ResizeToContents | QHeaderView.Fixed)
self.list_view.header().setSectionResizeMode(
3, QHeaderView.ResizeToContents | QHeaderView.Fixed)
self.list_view.header().setSectionResizeMode(
4, QHeaderView.ResizeToContents | QHeaderView.Fixed)
self.list_view.header().setStretchLastSection(False)
self.list_view.doubleClicked.connect(self._on_item_dblclick)
self.list_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.list_view.customContextMenuRequested.connect(self._on_contextmenu)
v_box.addWidget(self.list_view)
#header = QHeaderView(Qt.Horizontal, self)
h_box = QHBoxLayout()
h_box.setContentsMargins(5, 2, 5, 5)
btn1 = QPushButton(QIcon(utils.resource_path('assets/icons/plus.svg')),
'')
btn1.setFixedSize(20, 20)
btn1.clicked.connect(self._on_additem_clicked)
btn2 = QPushButton(QIcon(utils.resource_path('assets/icons/dash.svg')),
'')
btn2.setFixedSize(20, 20)
btn2.clicked.connect(self.delete_items)
btn3 = QPushButton(
QIcon(utils.resource_path('assets/icons/trashcan.svg')), '')
btn3.setFixedSize(20, 20)
btn3.clicked.connect(self.clear_list)
h_box.addWidget(btn1)
h_box.addWidget(btn2)
h_box.addSpacerItem(
QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Preferred))
h_box.addWidget(btn3)
# header.setLayout(h_box)
# header.setFixedHeight(25)
# v_box.addWidget(header)
v_box.addLayout(h_box)
# create a centered dot icon
_section_width = self.list_view.header().sectionSize(2)
self._new_pixmap = QPixmap(_section_width, 20)
self._new_pixmap.fill(Qt.transparent)
painter = QPainter(self._new_pixmap)
rect = QRect((_section_width * 0.5), 0, 20, 20)
painter.setBrush(QColor('#666'))
painter.setPen(QColor('#666'))
painter.drawEllipse(rect)
self._dot_icon = QIcon(self._new_pixmap)
# shortcuts
shortcut_add = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_W),
self._app_window, self._on_additem_clicked)
shortcut_add.setAutoRepeat(False)
self.setLayout(v_box)
def paintEvent(self, event):
if self.situation:
painter = self.situation
else:
painter = QPainter(self)
painter.setPen(QPen(Qt.darkBlue, 2, Qt.SolidLine))
pages = self.data[0].split(';')
pages.pop()
self.m = int(pages.pop(0)) * 2
for i in range(len(pages)):
pages[i] = eval(pages[i])
levels = set()
for i in pages:
levels.add(i[2])
all_pages = []
for level in levels:
temp = []
for i in pages:
if i[2] == level:
temp.append(i)
if i == pages[-1]:
temp.sort()
for a in temp:
all_pages.append(a)
pages = all_pages
max_values = self.m
lenght_square = 25 * max_values
height_square = 60
height_number = height_square + 30
square_position_x = 580
square_position_y = 100
circle_position_x = square_position_x
circle_position_y = square_position_y + 45
number_position_x = square_position_x
number_position_y = square_position_y + 25
past = pages[0][0]
i = 0
for page in pages:
current = page[-1]
qtd_page_level = self.qtd_pages_for_level(current, pages)
qtd_page_level = qtd_page_level / 2
# Pages
painter.setBrush(QBrush(Qt.white, Qt.SolidPattern))
if i == 0:
# Desenha a primeira página
painter.drawRect(square_position_x, square_position_y,
lenght_square, height_square)
circle_position_x = square_position_x
circle_position_y = square_position_y + height_square - 15
number_position_x = square_position_x
number_position_y = square_position_y + height_square - 35
elif past != current:
i = 1
painter.drawRect(
square_position_x - (lenght_square * qtd_page_level) +
lenght_square / 2,
square_position_y + int(page[-1]) * square_position_y,
lenght_square, height_square)
circle_position_x = square_position_x - (
lenght_square * qtd_page_level) + lenght_square / 2
circle_position_y = square_position_y + page[
-1] * square_position_y + height_square - 15
number_position_x = square_position_x - (
lenght_square * qtd_page_level) + lenght_square / 2
number_position_y = square_position_y + page[
-1] * square_position_y + height_square - 15
past = current
else:
painter.drawRect(
square_position_x - (lenght_square * qtd_page_level) +
(i - 1) * lenght_square + lenght_square / 2,
square_position_y + int(page[-1]) * square_position_y,
lenght_square, height_square)
circle_position_x = square_position_x - (
lenght_square * qtd_page_level
) + (i - 1) * lenght_square + lenght_square / 2 + 8
circle_position_y = square_position_y + page[
-1] * square_position_y + height_square - 15
number_position_x = square_position_x - (
lenght_square * qtd_page_level
) + (i - 1) * lenght_square + lenght_square / 2 + 8
number_position_y = square_position_y + page[
-1] * square_position_y + height_square - 15
positions_circles = list()
for number_of_point in range(max_values + 1):
spaces_beetwen_circle = (lenght_square / max_values) - 5
if number_of_point == 0:
painter.drawEllipse(
circle_position_x +
(number_of_point * spaces_beetwen_circle) + 3,
circle_position_y, 8, 8)
positions_circles.append(
(circle_position_x +
(number_of_point * spaces_beetwen_circle),
circle_position_y))
else:
painter.drawEllipse(
circle_position_x +
(number_of_point * spaces_beetwen_circle),
circle_position_y, 8, 8)
positions_circles.append(
(circle_position_x +
(number_of_point * spaces_beetwen_circle),
circle_position_y))
positions_numbers = []
space_beetwen_number = (lenght_square / max_values) - 5
j = 0
for number in page[1]:
if i == 0:
painter.drawText(
number_position_x + (j * space_beetwen_number) + 10,
number_position_y, str(number))
painter.drawText(number_position_x, number_position_y - 30,
str(page[0]))
positions_numbers.append(
(number_position_x + 30, number_position_y))
j += 1
else:
painter.drawText(
number_position_x + (j * space_beetwen_number) + 10,
number_position_y - 15, str(number))
painter.drawText(number_position_x, number_position_y - 50,
str(page[0]))
positions_numbers.append(
(number_position_x + (i * space_beetwen_number) + 30,
number_position_y))
j += 1
j = 0
i += 1
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
if self.fLabel:
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
painter.setPen(self.fLabelGradientColor2)
painter.setBrush(self.fLabelGradient)
painter.drawRect(self.fLabelGradientRect)
painter.setFont(self.fLabelFont)
painter.setPen(self.fLabelGradientColorT[0 if self.isEnabled() else 1])
painter.drawText(self.fLabelPos, self.fLabel)
if self.isEnabled():
normValue = float(self.fRealValue - self.fMinimum) / float(self.fMaximum - self.fMinimum)
target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)
curLayer = int((self.fPixmapLayersCount - 1) * normValue)
if self.fPixmapOrientation == self.HORIZONTAL:
xpos = self.fPixmapBaseSize * curLayer
ypos = 0.0
else:
xpos = 0.0
ypos = self.fPixmapBaseSize * curLayer
source = QRectF(xpos, ypos, self.fPixmapBaseSize, self.fPixmapBaseSize)
painter.drawPixmap(target, self.fPixmap, source)
# Custom knobs (Dry/Wet and Volume)
if self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_WET, self.CUSTOM_PAINT_MODE_CARLA_VOL):
# knob color
colorGreen = QColor(0x5D, 0xE7, 0x3D).lighter(100 + self.fHoverStep*6)
colorBlue = QColor(0x3E, 0xB8, 0xBE).lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252*16*normValue
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_WET:
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
gradient = QConicalGradient(15.5, 15.5, -45)
gradient.setColorAt(0.0, colorBlue)
gradient.setColorAt(0.125, colorBlue)
gradient.setColorAt(0.625, colorGreen)
gradient.setColorAt(0.75, colorGreen)
gradient.setColorAt(0.76, colorGreen)
gradient.setColorAt(1.0, colorGreen)
painter.setBrush(gradient)
painter.setPen(QPen(gradient, 3))
else:
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 3))
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)
# Custom knobs (L and R)
elif self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_L, self.CUSTOM_PAINT_MODE_CARLA_R):
# knob color
color = QColor(0xAD, 0xD5, 0x48).lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(7.0, 8.0, 11.0, 12.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
painter.setBrush(color)
painter.setPen(QPen(color, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.0, 2.0))
# draw arc
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_L:
startAngle = 216*16
spanAngle = -252.0*16*normValue
else:
startAngle = 324.0*16
spanAngle = 252.0*16*(1.0-normValue)
painter.setPen(QPen(color, 2))
painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)
# Custom knobs (Color)
elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_COLOR:
# knob color
color = self.fCustomPaintColor.lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252*16*normValue
painter.setBrush(color)
painter.setPen(QPen(color, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
painter.setBrush(color)
painter.setPen(QPen(color, 3))
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)
# Custom knobs (Zita)
elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_ZITA:
a = normValue * pi * 1.5 - 2.35
r = 10.0
x = 10.5
y = 10.5
x += r * sin(a)
y -= r * cos(a)
painter.setBrush(Qt.black)
painter.setPen(QPen(Qt.black, 2))
painter.drawLine(QPointF(11.0, 11.0), QPointF(x, y))
# Custom knobs
else:
painter.restore()
return
if self.HOVER_MIN < self.fHoverStep < self.HOVER_MAX:
self.fHoverStep += 1 if self.fIsHovered else -1
QTimer.singleShot(20, self.update)
else: # isEnabled()
target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)
painter.drawPixmap(target, self.fPixmap, target)
painter.restore()
def paintEvent(self, event): painter = QPainter(self) painter.setPen(self.pen) painter.setBrush(self.brush) if self.antialiased: painter.setRenderHint(QPainter.Antialiasing) angle_step = 360 / self.n_states painter.save() #Save_1. Save the state of the system (push matrix) painter.translate(self.dist_center.x(), self.dist_center.y()) # go to the center of the render area painter.rotate(-180) #to start painting from the left side of the circle (clockwise) #center of the circumference where through we are going to paint our states x = self.dist_radius * math.cos(0) y = self.dist_radius * math.sin(0) for h in range(self.n_states): rot = angle_step * h # each state is equidistant from the others. We paint them in circles painter.save() #Save_2 painter.rotate(rot) #now our system is pointing to the next state to be drawn painter.translate(x,y) #now our origin is in the center of the next state to be drawn #if the state is active, fill it green if self.machine.getState(h).isActive(): painter.setBrush(self.greenGradientBrush) painter.drawEllipse(QPoint(0,0), self.state_radius, self.state_radius) #draw the new state #global position of transformed coordinates (before any transformation, origin at top-left corner) gx = painter.worldTransform().map(QPoint(0,0)).x() gy = painter.worldTransform().map(QPoint(0,0)).y() self.machine.getState(h).setPos(gx, gy) #store the center of the state without any transformation applied # text transformation. Our origin is still in the center of the current state painter.save() #Save_3 painter.rotate(180) #making the text go vertical painter.rotate(-rot) #undoing the rotation made for painting the state. No the text is horizontal font = painter.font(); font.setPixelSize(self.state_radius*.4); painter.setFont(font); rect = QRect(-self.state_radius, -self.state_radius, self.state_radius*2, self.state_radius*2) painter.drawText(rect, Qt.AlignCenter, self.machine.getState(h).getName()); painter.restore() #Restore_3 #end text transformation painter.restore() #Restore_2 painter.restore() #Restore_1. Restore the state of the system (pop matrix) #drawing transitions. Line between states painter.save() # Save_4 pptv = QTransform() #Define a new transformation. Needed to rotate the system along other axis than Z pptv.translate(0, self.height()) #We are now at the bottom-left corner of the screen pptv.rotate(-180, Qt.XAxis) #Rotate along the X-axis so now we are in a typical cartesian system. painter.setTransform(pptv) #Apply the transformation states = self.machine.getStates() for state in states: transitions = state.getTransitions() for transition in transitions: #get the center of the origin and destination states in our current system state orig = QPoint(state.getPos()[0], state.getPos()[1]) end = QPoint(self.machine.getState(transition.getStateEnd()).getPos()[0], self.machine.getState(transition.getStateEnd()).getPos()[1]) # get those coordinates without transformation orig2 = QPoint(painter.worldTransform().map(orig)) end2 = QPoint(painter.worldTransform().map(end)) #get the angle between states centers and the horizon angle = math.atan2(end2.y() - orig2.y(), end2.x() - orig2.x()) #get the coordinates of the starting point of the transition (it starts in the bound of the state, not in the center) newX = self.state_radius * math.cos(angle) + orig2.x() newY = self.state_radius * math.sin(angle) + orig2.y() #now the transition starts at the border, not in the center orig2.setX(newX) orig2.setY(newY) #same for the destination state angle2 = math.atan2(orig2.y() - end2.y(), orig2.x() - end2.x()) newX2 = self.state_radius * math.cos(angle2) + end2.x() newY2 = self.state_radius * math.sin(angle2) + end2.y() end2.setX(newX2) end2.setY(newY2) #draw the line between the origin and destination states painter.drawLine(orig2, end2) #get the start and the end of the transition untransformed init = QPoint(painter.worldTransform().map(orig2)) end = QPoint(painter.worldTransform().map(end2)) #store that info transition.setOrig(init.x(), init.y()) transition.setDest(end.x(), end.y()) transition.setAngle(angle) painter.restore() #Restore_4 #Appliying style to the transitions painter.setPen(QPen(QColor(Qt.gray), 3)) for state in self.machine.getStates(): for transition in state.getTransitions(): #get the start and end coordinates of the transition i = QPoint(transition.getOrig()[0], transition.getOrig()[1]) o = QPoint(transition.getDest()[0], transition.getDest()[1]) painter.drawPolyline(i, o) #Drawing the arrow at the end of the transition painter.save() #Save_5 painter.setPen(QPen(QColor(Qt.gray), 2)) painter.translate(transition.getDest()[0],transition.getDest()[1]) #Go to the end of the transition painter.rotate(90 - transition.getAngle()*180/math.pi) #Rotate to point in the direction of the transition #coordinates of the arrow (triangle) a = QPoint(0,0) b = QPoint(-5,10) c = QPoint(5,10) #coordinates of the arrow untransformed a1 = painter.worldTransform().map(a) b1 = painter.worldTransform().map(b) c1 = painter.worldTransform().map(c) #Drawin the actual arrow pointer = QPolygon([a,b,c]) painter.drawPolygon(pointer) painter.restore() #Restore_5 #For the animation of the transition painter.save() #Save_6 if transition.isActive(): #if the current transition is the active one the wave function will be running, so it's updating the canvas painter.setPen(QPen(QColor(Qt.green), 3)) painter.drawPolyline(i,o) painter.setPen(QPen(QColor(Qt.gray), 3)) painter.drawPolyline(self.poly(self.pts)) #Draw the arrow in the active state (red arrow) painter.setBrush(QBrush(QColor(255, 0, 0))) painter.setPen(QPen(QColor(Qt.red), 2)) pointer = QPolygon([a1,b1,c1]) painter.drawPolygon(pointer) #Ball that follows the line animation for x, y in self.pts: painter.drawEllipse(QRectF(self.pts[0][0] - 4, self.pts[0][1] - 4, 8, 8)) painter.restore() #Restore_6 #Painting the text of the transition painter.save() #Save_7 pptv = QTransform() painter.setPen(QPen(QColor(Qt.black), 3)) #get the middle point of the transition middleX = (transition.getOrig()[0] + transition.getDest()[0]) /2 middleY = (transition.getOrig()[1] + transition.getDest()[1]) /2 pptv.translate(middleX, middleY) #translate to that point painter.setTransform(pptv) #apply the transformation font = painter.font(); font.setPixelSize(self.state_radius*.2); painter.setFont(font); rect = QRect(-self.state_radius, -self.state_radius, self.state_radius*2, self.state_radius*2) name = str(transition.getId())+ '. ' + transition.getName() painter.drawText(rect, Qt.AlignCenter, name) painter.restore() #Restore_7 #paint the actual canvas painter.setPen(self.palette().dark().color()) painter.setBrush(Qt.NoBrush) painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def onMakeError(self):
# 该错误可以直接被python层捕捉
QPainter.drawEllipse(self.rect())
def paintEvent(self, ev):
painter = QPainter(self)
painter.setPen(QColor.fromRgb(0,0,0))
painter.drawRect( 0, 0, self.width()-1, self.height()-1 )
drawTraceY = 0.0
drawTraceX = 0.0
FoundY = False
FoundX = False
# Рисуем вертикальную левую шкалу, проходим по значениям заголовка столбцов
for colum_i in range(len(self.Columns)):
if (self.CurCell_col == -1) and (self.CurCell_row == colum_i):
if self.inEdit: self.drawCell( painter, 0, colum_i, self.editText, True)
else: self.drawCell( painter, 0, colum_i, self.Columns[colum_i], True)
else: self.drawCell( painter, 0, colum_i, self.Columns[colum_i], False)
painter.setPen(QColor.fromRgb(0,0,0))
#if row_i == len(self.Rows) - 1:
#prev = self.Rows[row_i-1]
#curr = self.Rows[row_i]
#nnext = curr + ((curr - prev) / 2.0)
if self.TracingEnabled is True:
if self.TracingColumn < self.Columns[colum_i]:
if colum_i == len(self.Columns) - 1:
curr = self.Columns[colum_i]
nnext = 0
FoundY = True
if self.TracingColumn < nnext:
drawTraceY = colum_i*self.itH+self.itH
else:
percent = ( nnext-self.TracingColumn ) / ( nnext-curr )
drawTraceY = ((colum_i * self.itH)+self.itH) - (percent * (self.itH/2.0))
elif not FoundY:
if colum_i == 0:
# Значение находится между верхним и нулевым значениями
prev = self.Columns[colum_i] - ((self.Columns[colum_i+1]-self.Columns[colum_i])/2.0)
lastY = 0
else:
prev = self.Columns[colum_i-1]
lastY = (colum_i-1)*self.itH + (self.itH/2.0)-2
diff = prev - self.Columns[colum_i]
percent =( prev - self.TracingColumn ) / diff
currentY = colum_i*self.itH + (self.itH/2.0)-2
drawTraceY = (lastY + (percent * (currentY - lastY)))
if (drawTraceY < 0):
# Cap it at 0
drawTraceY = 0
FoundY = True
# Рисуем горизонтальную шкалу внизу, проходим по значениям заголовка строки
for row_i in range(len(self.Rows)):
if (self.CurCell_row == -1) and (self.CurCell_col == row_i):
if self.inEdit: self.drawCell( painter, row_i+1, len(self.Rows), self.editText, True)
else: self.drawCell( painter, row_i+1, len(self.Rows), self.Rows[row_i], True)
else: self.drawCell( painter, row_i+1, len(self.Rows), self.Rows[row_i], False)
painter.setPen(QColor.fromRgb(0,0,0))
if self.TracingEnabled:
if self.TracingRow > self.Rows[row_i]:
if row_i == len(self.Rows) - 1:
prev = self.Rows[row_i-1]
curr = self.Rows[row_i]
nnext = curr + ((curr - prev) / 2.0)
FoundX = True
if (self.TracingRow > nnext):
drawTraceX = self.itW + (row_i * self.itW) + (self.itW)
else:
percent = (self.TracingRow - curr) / (nnext - curr)
drawTraceX = (((row_i+1) * self.itW) + (self.itW / 2.0)) + (percent * (self.itW/2.0))
elif not FoundX:
if row_i == 0:
prev = self.Rows[row_i] - ((self.Rows[row_i+1] - self.Rows[row_i]))
lastx = self.itW
else:
prev = self.Rows[row_i-1]
lastx = self.itW + ((row_i-1) * self.itW) + (self.itW / 2.0)
diff = self.Rows[row_i] - prev
#if diff == 0: diff = 0.1
percent = (self.TracingRow - prev) / diff
currentX = self.itW + ((row_i)*self.itW) + ((self.itW/2.0))
drawTraceX = (lastx + (percent * (currentX - lastx)))
if drawTraceX < self.itW:
drawTraceX = self.itW
FoundX = True
for row_i in range(len(self.Rows)):
for colum_i in range(len(self.Columns)):
if (self.CurCell_row == row_i ) and (self.CurCell_col == colum_i ):
if self.inEdit: self.drawCell( painter, colum_i+1, row_i, self.editText, True)
else: self.drawCell( painter, colum_i+1, row_i, self.values[row_i, colum_i], True)
else: self.drawCell( painter, colum_i+1, row_i, self.values[row_i, colum_i], False)
if FoundY and FoundX and self.TracingEnabled:
pen = painter.pen()
pen.setWidth(5)
pen.setColor(QColor.fromRgb(255,255,0))
painter.setPen(pen)
painter.drawLine(0,drawTraceY,4,drawTraceY)
painter.drawEllipse(drawTraceX-2, drawTraceY-1, 4, 2)
pen.setColor(QColor.fromRgb(0,0,0))
pen.setWidth(2)
painter.setPen(pen)
painter.drawEllipse(drawTraceX-6, drawTraceY-4, 12, 8)
class QtRenderer(Renderer):
"""An implementation of :class:`~renderer.Renderer` for PyQt5.
This renderer will draw on any `QPaintDevice`
"""
def __init__(self, paint_device):
"""Creates a new renderer based on a QPaintDevice pd"""
self._grid_pen = QPen(QColor(0x808080))
self._grid_pen.setStyle(Qt.DashLine)
self._painter = None
Renderer.__init__(self, paint_device)
def set_canvas(self, canvas):
"""Tell the renderer to draw on canvas
The type of canvas is implementation-dependent"""
if self._painter is not None:
self._painter.restore()
self._painter.restore()
self._painter.end()
self._paintdevice = canvas
self._painter = QPainter(canvas)
self._painter.setRenderHint(QPainter.Antialiasing)
# invert the y axis
self._painter.scale(1,-1)
self._painter.translate(0,-canvas.height())
Renderer.set_canvas(self,canvas)
def _get_canvas_size(self,pd):
"""Get the canvas size tuple (width,height)"""
return (pd.width(), pd.height())
def push_state(self):
"""Store the current state on the stack.
Current state includes default pose, pen and brush"""
### FIXME store things
self._painter.save()
def pop_state(self):
"""Restore the last saved state from the stack
The state includes default pose, pen and brush"""
### FIXME store things
self._painter.restore()
def _calculate_bounds(self):
transform = self._painter.worldTransform().inverted()[0]
xs,ys = zip(
transform.map(0.0,0.0),
transform.map(0.0,float(self.size[1])),
transform.map(float(self.size[0]),float(self.size[1])),
transform.map(float(self.size[0]),0.0)
)
self._bounds = (min(xs), min(ys), max(xs), max(ys))
def _draw_grid(self):
self.reset_pose()
self._painter.setPen(self._grid_pen)
xmin, ymin, xmax, ymax = self._bounds
# Determine min/max x & y line indices:
x_ticks = (int(xmin//self._grid_spacing), int(xmax//self._grid_spacing + 1))
y_ticks = (int(ymin//self._grid_spacing), int(ymax//self._grid_spacing + 1))
self._painter.drawLines(
[QLineF(xmin, i * self._grid_spacing,
xmax, i * self._grid_spacing)
for i in range(*y_ticks)])
self._painter.drawLines(
[QLineF(i * self._grid_spacing, ymin,
i * self._grid_spacing, ymax)
for i in range(*x_ticks)])
def scale(self, factor):
"""Scale drawing operations by factor
To be implemented in subclasses."""
self._painter.scale(factor,factor)
def rotate(self, angle):
"""Rotate canvas by angle (in radians)
To be implemented in subclasses."""
self._painter.rotate(degrees(angle))
def translate(self, dx, dy):
"""Translate canvas by dx, dy
To be implemented in subclasses."""
self._painter.translate(dx,dy)
def clear_screen(self):
"""Erases the current screen with a white brush"""
self._painter.save()
self._painter.resetTransform()
self.set_pen(0xFFFFFF)
self.set_brush(0xFFFFFF)
self.draw_rectangle(0,0,self.size[0],self.size[1])
self._painter.restore()
Renderer.clear_screen(self)
@staticmethod
def __qcolor(color):
"""Returns qcolor for a given ARGB color"""
c = QColor(color)
if color > 0xFFFFFF:
c.setAlpha((color >> 24) & 0xFF)
return c
def set_pen(self,color=0, thickness=0):
"""Sets the line color and thickness.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setPen(Qt.NoPen)
else:
self._painter.setPen(QPen(self.__qcolor(color),thickness))
def set_brush(self,color):
"""Sets the fill color.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setBrush(Qt.NoBrush)
else:
self._painter.setBrush(self.__qcolor(color))
def draw_polygon(self,points):
"""Draws a polygon.
Expects a list of points as a list of tuples or as a numpy array."""
self._painter.drawPolygon(QPolygonF([QPointF(*point[:2]) for point in points]))
def draw_ellipse(self, cx, cy, ra, rb = None):
"""Draws an ellipse."""
if rb is None:
rb = ra
self._painter.drawEllipse(QRectF(cx-ra,cy-ra,2*ra,2*rb))
def draw_rectangle(self, x, y, w, h):
"""Draws a rectangle."""
self._painter.drawRect(QRectF(x,y,w,h))
def draw_text(self, text, x, y, bgcolor = 0):
"""Draws a text string at the defined position."""
pass
def draw_line(self, x1, y1, x2, y2):
"""Draws a line using the current pen from (x1,y1) to (x2,y2)"""
self._painter.drawLine(QLineF(x1,y1,x2,y2))
def draw_point(self,x,y):
"""Draw a single point using the current pen at (x,y)"""
self._painter.drawPoint(QPointF(x,y))
def draw_points(self,points):
"""Draw a set of points, given as [(x,y)], using the current pen"""
self._painter.drawPoints(QPolygonF([QPointF(x,y) for x,y in points]))
def browseImageClicked(self):
file_name = QFileDialog.getOpenFileName(
None, 'Choose an image', '', 'Image files (*.jpg *.png *.bmp)')
if file_name[0]:
self.gui.imgDir.setText(file_name[0])
# imageData = open("C:/Adi/Projects/Face Recognition/testing_data/cats/cat.1000.jpg", 'rb').read()
imgsize = 160
imageData = open(file_name[0], 'rb').read()
image = QImage.fromData(imageData, "jpg")
image.convertToFormat(QImage.Format_ARGB32)
image = image.scaled(imgsize, imgsize, Qt.IgnoreAspectRatio)
print(image.width())
print(image.height())
# Crop image to a square:
#
# rect = QRect(
# # (image.width() - imgsize) / 2,
# # (image.height() - imgsize) / 2,
# 0,
# 0,
# imgsize,
# imgsize,
# )
# image = image.copy(rect)
# Create the output image with the same dimensions and an alpha channel
# and make it completely transparent:
out_img = QImage(imgsize, imgsize, QImage.Format_ARGB32)
out_img.fill(Qt.transparent)
# Create a texture brush and paint a circle with the original image onto
# the output image:
brush = QBrush(image) # Create texture brush
painter = QPainter(out_img) # Paint the output image
painter.setBrush(brush) # Use the image texture brush
pen = QPen(QColor(255, 255, 255), 2)
painter.setPen(pen)
# painter.setPen(Qt.NoPen) # Don't draw an outline
painter.setRenderHint(QPainter.Antialiasing, True) # Use AA
painter.drawEllipse(2, 2, imgsize - 4,
imgsize - 4) # Actually draw the circle
painter.end() # We are done (segfault if you forget this)
# Convert the image to a pixmap and rescale it. Take pixel ratio into
# account to get a sharp image on retina displays:
pr = QWindow().devicePixelRatio()
pm = QPixmap.fromImage(out_img)
pm.setDevicePixelRatio(pr)
size = 200 * pr
# pm = pm.scaled(100, 100, Qt.KeepAspectRatio, Qt.SmoothTransformation)
pm = pm.scaled(self.gui.chosenImg.width(),
self.gui.chosenImg.height(), Qt.KeepAspectRatio,
Qt.SmoothTransformation)
# pm = pm.scaled(size, self.gui.label_2.height(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
self.gui.chosenImg.setPixmap(pm)
def paintEvent(self, event):
p = QPainter()
p.begin(self)
self._normalMap.render(p, event.rect())
p.setPen(Qt.black)
p.drawText(self.rect(), Qt.AlignBottom | Qt.TextWordWrap,
"Map data CCBYSA 2009 OpenStreetMap.org contributors")
p.end()
if self.zoomed:
dim = min(self.width(), self.height())
magnifierSize = min(MAX_MAGNIFIER, dim * 2 / 3)
radius = magnifierSize / 2
ring = radius - 15
box = QSize(magnifierSize, magnifierSize)
# reupdate our mask
if self.maskPixmap.size() != box:
self.maskPixmap = QPixmap(box)
self.maskPixmap.fill(Qt.transparent)
g = QRadialGradient()
g.setCenter(radius, radius)
g.setFocalPoint(radius, radius)
g.setRadius(radius)
g.setColorAt(1.0, QColor(255, 255, 255, 0))
g.setColorAt(0.5, QColor(128, 128, 128, 255))
mask = QPainter(self.maskPixmap)
mask.setRenderHint(QPainter.Antialiasing)
mask.setCompositionMode(QPainter.CompositionMode_Source)
mask.setBrush(g)
mask.setPen(Qt.NoPen)
mask.drawRect(self.maskPixmap.rect())
mask.setBrush(QColor(Qt.transparent))
mask.drawEllipse(g.center(), ring, ring)
mask.end()
center = self.dragPos - QPoint(0, radius)
center += QPoint(0, radius / 2)
corner = center - QPoint(radius, radius)
xy = center * 2 - QPoint(radius, radius)
# only set the dimension to the magnified portion
if self.zoomPixmap.size() != box:
self.zoomPixmap = QPixmap(box)
self.zoomPixmap.fill(Qt.lightGray)
if True:
p = QPainter(self.zoomPixmap)
p.translate(-xy)
self._largeMap.render(p, QRect(xy, box))
p.end()
clipPath = QPainterPath()
clipPath.addEllipse(QPointF(center), ring, ring)
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
p.setClipPath(clipPath)
p.drawPixmap(corner, self.zoomPixmap)
p.setClipping(False)
p.drawPixmap(corner, self.maskPixmap)
p.setPen(Qt.gray)
p.drawPath(clipPath)
if self.invert:
p = QPainter(self)
p.setCompositionMode(QPainter.CompositionMode_Difference)
p.fillRect(event.rect(), Qt.white)
p.end()
