def render(self, painter: QPainter) -> None:
if self._item_style == FileItemStyle.SMALLICON:
self.paint_smallicon_view(painter)
elif self._item_style == FileItemStyle.DETAIL:
self.paint_detail_view(painter)
else:
self.paint(painter)
if self.is_selected:
painter.save()
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.setOpacity(0.5)
painter.fillRect(self.tile_rect, QColor(127, 192, 255))
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.setOpacity(1.0)
painter.setPen(QColor(96, 127, 255))
painter.setBrush(Qt.NoBrush)
painter.drawRect(self.tile_rect)
painter.restore()
if self.is_cursor:
painter.setOpacity(1.0)
painter.setPen(QColor(0, 0, 0))
painter.setBrush(QColor(255, 255, 255, 96))
painter.drawRect(self.tile_rect)
def paintEvent(self, event):
logger.debug("paintEvent: {0} - {1}".format(self, event.rect()))
qp = QPainter()
qp.begin(self)
width = self.size().width() - 1
height = self.size().height() - 1
#draw border
qp.setPen(self.border_color)
qp.drawLine(0, 0, width, 0)
qp.drawLine(0, 0, 0, height)
qp.drawLine(width, 0, width, height)
qp.drawLine(0, height, width, height)
#draw bar
width -= 2
height -= 2
value = orig_value = self.data_source()
value = min(self.max_range, value)
value = max(self.min_range, value)
qp.setPen(self.bar_color)
qp.setBrush(self.bar_color)
if self.orientation == 'horizontal':
qp.drawRect(1, 1,
width / self.max_range * value, height)
else:
qp.drawRect(1, height - (height / self.max_range * value), width, height)
qp.setPen(self.border_color)
qp.drawText(event.rect(), Qt.AlignCenter, str(orig_value))
qp.end()
logger.debug("paintEvent End: {0}".format(self))
def paintEvent(self, event):
QWidget.paintEvent(self, event)
painter = QPainter(self)
painter.setBrush(QBrush(QColor(Qt.black)))
painter.setPen(QPen())
painter.setOpacity(self.value)
painter.drawRect(self.rect())
def buildCharPreview(self):
char = self.selectedChar - self.charFrom.value()
if char < 0:
char = 0
if char >= len(self.charSizes):
char = len(self.charSizes) - 1
k = 5
s_x = self.charSizes[char][0]
w = self.charSizes[char][1]
charPix = self.chars.pixmap()
charImage = charPix.toImage()
self.charPreview.resize(w * k + 1, charPix.height() * k + 1)
pix = QPixmap(w * k, charPix.height() * k)
p = QPainter()
p.begin(pix)
p.setBrush(QBrush(QColor(0xffffff), Qt.SolidPattern))
p.drawRect(0, 0, pix.width() - 1, pix.height() - 1)
p.setBrush(QBrush(QColor(0x0), Qt.SolidPattern))
for x in range(w):
for y in range(charPix.height()):
if QColor(charImage.pixel(s_x + x, y)).lightness() == 0x0:
p.drawRect(x * k, y * k, k, k)
p.end()
self.charPreview.setPixmap(pix)
def paintEvent(self, QPaintEvent):
self.updatePosition()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self._currentCounter >= self._numberOfLines:
self._currentCounter = 0
painter.setPen(Qt.NoPen)
for i in range(0, self._numberOfLines):
painter.save()
painter.translate(self._innerRadius + self._lineLength,
self._innerRadius + self._lineLength)
rotateAngle = float(360 * i) / float(self._numberOfLines)
painter.rotate(rotateAngle)
painter.translate(self._innerRadius, 0)
distance = self.lineCountDistanceFromPrimary(
i, self._currentCounter, self._numberOfLines)
color = self.currentLineColor(distance, self._numberOfLines,
self._trailFadePercentage,
self._minimumTrailOpacity,
self._color)
painter.setBrush(color)
rect = QRect(0, -self._lineWidth/2,
self._lineLength, self._lineWidth)
painter.drawRoundedRect(
rect, self._roundness, self._roundness, Qt.RelativeSize)
painter.restore()
def paintEvent(self, event):
radius = 50
treeSize = QSizeF(2 * radius, 2 * radius)
bounds = QRectF( (self.width() - treeSize.height()) / 2,
(self.height() - treeSize.width()) / 2,
treeSize.width(),
treeSize.height())
painter = QPainter(self)
# draw the shadow
painter.setBrush(Qt.black)
painter.setPen(Qt.NoPen)
painter.setOpacity(0.5)
xrad = 95
yrad = self.shadowLength * 20
rect = QRectF(-xrad, -yrad, xrad, yrad)
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self.angle)
painter.translate(xrad/2, yrad/2)
painter.drawChord(rect, 0, 180*16)
painter.resetTransform()
# draw the tree
painter.setOpacity(1)
self.tree.render(painter, bounds)
# draw the compass
bounds = QRectF( 10, 10, 50, 50)
self.compass.render(painter, bounds)
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 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 __grabRegion(self):
"""
Private method to grab the selected region (i.e. do the snapshot).
"""
pol = QPolygon(self.__selection)
if not pol.isEmpty():
self.__grabbing = True
xOffset = self.__pixmap.rect().x() - pol.boundingRect().x()
yOffset = self.__pixmap.rect().y() - pol.boundingRect().y()
translatedPol = pol.translated(xOffset, yOffset)
pixmap2 = QPixmap(pol.boundingRect().size())
pixmap2.fill(Qt.transparent)
pt = QPainter()
pt.begin(pixmap2)
if pt.paintEngine().hasFeature(QPaintEngine.PorterDuff):
pt.setRenderHints(
QPainter.Antialiasing |
QPainter.HighQualityAntialiasing |
QPainter.SmoothPixmapTransform,
True)
pt.setBrush(Qt.black)
pt.setPen(QPen(QBrush(Qt.black), 0.5))
pt.drawPolygon(translatedPol)
pt.setCompositionMode(QPainter.CompositionMode_SourceIn)
else:
pt.setClipRegion(QRegion(translatedPol))
pt.setCompositionMode(QPainter.CompositionMode_Source)
pt.drawPixmap(pixmap2.rect(), self.__pixmap, pol.boundingRect())
pt.end()
self.grabbed.emit(pixmap2)
class ModCrossButton(QPushButton):
def __init__(self,parent,path=None):
QPushButton.__init__(self,parent)
self.parent=parent
#self.setAttribute(Qt.WA_TranslucentBackground, True)
self.backgroundColor = QPalette().light().color()
self.backgroundColor.setRgb(157,157,157) #(220,203,231)
#self.backgroundColor.setAlpha(100)
self.brush=QBrush(Qt.SolidPattern)
def paintEvent(self,event):
self.wide=self.width()
self.high=self.height()
self.xdis=self.wide/7
self.ydis=self.xdis
self.path=QPainterPath()
self.path.setFillRule(Qt.OddEvenFill)
self.path.moveTo(self.wide/2, self.high/2-self.xdis)
self.path.arcTo(0,0, self.wide, self.high,0,360)
#self.path.closeSubpath()
self.path.moveTo(self.wide/2-self.xdis/2, self.ydis)
self.path.lineTo(self.wide/2-self.xdis/2, self.high/2-self.xdis/2)
self.path.lineTo(self.ydis, self.high/2-self.xdis/2)
self.path.lineTo(self.ydis, self.high/2+self.xdis/2)
self.path.lineTo(self.wide/2-self.xdis/2, self.high/2+self.xdis/2)
self.path.lineTo(self.wide/2-self.xdis/2, self.high-self.ydis)
self.path.lineTo(self.wide/2+self.xdis/2, self.high-self.ydis)
self.path.lineTo(self.wide/2+self.xdis/2, self.high/2+self.xdis/2)
self.path.lineTo(self.wide-self.ydis, self.high/2+self.xdis/2)
self.path.lineTo(self.wide-self.ydis, self.high/2-self.xdis/2)
self.path.lineTo(self.wide/2+self.xdis/2, self.high/2-self.xdis/2)
self.path.lineTo(self.wide/2+self.xdis/2, self.ydis)
self.path.closeSubpath()
self.brush.setColor(self.backgroundColor)
self.painter=QPainter(self)
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.setPen(Qt.NoPen)
self.painter.setBrush(self.brush)
self.painter.drawPath(self.path)
self.painter.end()
#def mousePressEvent(self,ev):
# self.parent.close()
def enterEvent(self,ev):
self.backgroundColor.setRgb(242,146,52)
self.update()
def leaveEvent(self,ev):
self.backgroundColor.setRgb(157,157,157)
self.update()
def __redrawColorLabel(self, label, lc, uc):
pixmap = QPixmap(101, 26)
painter = QPainter(pixmap)
lowerColorRect = QRect(0, 0, 50, 25)
upperColorRect = QRect(50, 0, 50, 25)
font = QFont("Times", 11)
painter.setFont(font)
painter.setPen(Qt.black)
painter.setBrush(lc)
painter.drawRect(lowerColorRect)
lgray = lc.red() + lc.green() + lc.blue()
painter.setPen(self.invert(lc))
painter.drawText(lowerColorRect.translated(8, 2), 0, str(lgray))
painter.setPen(Qt.black)
painter.setBrush(uc)
painter.drawRect(upperColorRect)
ugray = uc.red() + uc.green() + uc.blue()
painter.setPen(self.invert(uc))
painter.drawText(upperColorRect.translated(8, 2), 0, str(ugray))
del painter
label.setPixmap(pixmap)
def paintEvent(self, event):
_size = self.size() - QSize(2, 2)
if (_size.isEmpty()):
return
origX = (_size.width() - self.mNewSize.width() * self.mScale) / 2 + 0.5
origY = (_size.height() - self.mNewSize.height() * self.mScale) / 2 + 0.5
oldRect = QRect(self.mOffset, self.mOldSize)
painter = QPainter(self)
painter.translate(origX, origY)
painter.scale(self.mScale, self.mScale)
pen = QPen(Qt.black)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(QRect(QPoint(0, 0), self.mNewSize))
pen.setColor(Qt.white)
painter.setPen(pen)
painter.setBrush(Qt.white)
painter.setOpacity(0.5)
painter.drawRect(oldRect)
pen.setColor(Qt.black)
pen.setStyle(Qt.DashLine)
painter.setOpacity(1.0)
painter.setBrush(Qt.NoBrush)
painter.setPen(pen)
painter.drawRect(oldRect)
painter.end()
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 paintEvent(self, event):
if not self.isDisplayedWhenStopped() and not self.isRunning():
return
width = min(self.width(), self.height())
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
outerRadius = (width-1) * 0.5
innerRadius = (width-1) * 0.5 * 0.38
capsuleHeight = outerRadius - innerRadius
capsuleWidth = capsuleHeight * 0.23 if width > 32 else capsuleHeight * 0.35
capsuleRadius = capsuleWidth / 2
for i in range(12):
color = QColor(self.color)
color.setAlphaF(float(1.0 - float(i / 12.0)))
p.setPen(Qt.NoPen)
p.setBrush(color)
p.save()
p.translate(self.rect().center())
p.rotate(self._angle - float(i * 30.0))
p.drawRoundedRect(-capsuleWidth * 0.5,
-(innerRadius + capsuleHeight),
capsuleWidth,
capsuleHeight,
capsuleRadius,
capsuleRadius)
p.restore()
class RoundedPushButton1(QPushButton):
def __init__(self,parent, default_wide, default_high,text=''):
QPushButton.__init__(self, parent)
#self.resize(100,80)
self.default_high=default_high
self.default_wide=default_wide
self.xrd=self.default_wide/10
#self.yrd=self.default_high/10
self.yrd=self.xrd
#self.resize(self.default_wide,self.default_high)
self.backgroundColor = QPalette().light().color()
self.backgroundColor.setRgb(157,157,157) #(220,203,231)
#self.backgroundColor.setAlpha(0)
self.brush=QBrush(Qt.SolidPattern)
self.textlabel=textQLabel(self,text)
def paintEvent(self,event):
#brush.setStyle(Qt.Dense1Pattern)
self.brush.setColor(self.backgroundColor)
self.painter=QPainter(self)
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.setPen(Qt.NoPen)
self.painter.setBrush(self.brush)
self.painter.drawRoundedRect(QRect(0,0,self.default_wide,self.default_high), self.xrd, self.yrd)
#self.painter.drawPixmap(self.imgx, self.imgy, self.piximg)
self.painter.end()
def paintEvent(self, event):
# Check whether this orb is enhanced
if type(self.parent) == Board:
enh = self.parent.enhanced[self.position]
else:
enh = False
painter = QPainter(self)
painter.drawPixmap(event.rect().adjusted(2,2,-2,-2), self.pixmap())
w = event.rect().width()
if enh:
path = QPainterPath()
pen = QPen()
pen.setWidth(1);
pen.setBrush(Qt.white)
brush = QBrush(Qt.yellow)
font = QFont()
font.setPointSize(20)
font.setWeight(QFont.Black)
path.addText(event.rect().x()+w-15,event.rect().y()+w-5,font,'+')
painter.setPen(pen)
painter.setBrush(brush)
painter.setFont(font)
painter.drawPath(path)
def __init__(self, text, parent):
super(DragLabel, self).__init__(parent)
metric = QFontMetrics(self.font())
size = metric.size(Qt.TextSingleLine, text)
image = QImage(size.width() + 12, size.height() + 12, QImage.Format_ARGB32_Premultiplied)
image.fill(qRgba(0, 0, 0, 0))
font = QFont()
font.setStyleStrategy(QFont.ForceOutline)
painter = QPainter()
painter.begin(image)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(Qt.white)
painter.drawRoundedRect(QRectF(0.5, 0.5, image.width() - 1, image.height() - 1), 25, 25, Qt.RelativeSize)
painter.setFont(font)
painter.setBrush(Qt.black)
painter.drawText(QRect(QPoint(6, 6), size), Qt.AlignCenter, text)
painter.end()
self.setPixmap(QPixmap.fromImage(image))
self.labelText = text
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 image(cls, **kwargs):
"""
Returns an image suitable for the palette.
:rtype: QPixmap
"""
# INITIALIZATION
pixmap = QPixmap(kwargs['w'], kwargs['h'])
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
# INIT THE LINE
p1 = QPointF(((kwargs['w'] - 54) / 2), kwargs['h'] / 2)
p2 = QPointF(((kwargs['w'] - 54) / 2) + 54 - 2, kwargs['h'] / 2)
line = QLineF(p1, p2)
# CLACULATE HEAD COORDS
angle = line.angle()
p1 = QPointF(line.p2().x() + 2, line.p2().y())
p2 = p1 - QPointF(sin(angle + M_PI / 3.0) * 8, cos(angle + M_PI / 3.0) * 8)
p3 = p1 - QPointF(sin(angle + M_PI - M_PI / 3.0) * 8, cos(angle + M_PI - M_PI / 3.0) * 8)
# INITIALIZE HEAD
head = QPolygonF([p1, p2, p3])
# DRAW EDGE LINE
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QPen(QColor(0, 0, 0), 1.1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(line)
# DRAW EDGE HEAD
painter.setPen(QPen(QColor(0, 0, 0), 1.1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.setBrush(QColor(0, 0, 0))
painter.drawPolygon(head)
return pixmap
def 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, event):
painter = QPainter(self)
pixmap = None
if self.status == STATUS_NORMAL:
pixmap = self.normalPix
elif self.status == STATUS_HOVER:
pixmap = self.hoverPix
elif self.status == STATUS_PRESS:
pixmap = self.pressPix
if not pixmap:
return
if not self._enable:
if self.disablePix:
painter.drawPixmap(0, 0, self.disablePix)
else:
image = pixmap.toImage()
grayImg = convertToGray(image)
painter.drawImage(0, 0, grayImg)
elif self.autoRenderMask and self.status != STATUS_NORMAL:
if self.status == STATUS_PRESS:
painter.drawPixmap(1, 1, pixmap)
else:
painter.drawPixmap(0, 0, pixmap)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(QColor(250, 250, 250, 100)))
painter.drawRoundedRect(self.rect(), 2, 2)
else:
painter.drawPixmap(0, 0, pixmap)
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 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 _redrawColorLabel(self, labelIndex, lc, uc, lValue, uValue) :
if labelIndex >= len(self.__colorLabels) :
return
label = self.__colorLabels[labelIndex]
pixmap = QPixmap(101, 26)
painter = QPainter(pixmap)
lowerColorRect = QRect(0, 0, 50, 25)
upperColorRect = QRect(50, 0, 50, 25)
font = QFont('Times', 11)
painter.setFont(font)
painter.setPen(Qt.black);
painter.setBrush(lc);
painter.drawRect(lowerColorRect);
painter.setPen(self.invert(lc));
painter.drawText(lowerColorRect.translated(8, 2), 0, str(lValue));
painter.setPen(Qt.black);
painter.setBrush(uc);
painter.drawRect(upperColorRect);
painter.setPen(self.invert(uc));
painter.drawText(upperColorRect.translated(8, 2), 0, str(uValue));
del painter
label.setPixmap(pixmap);
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 image(cls, **kwargs):
"""
Returns an image suitable for the palette.
:rtype: QPixmap
"""
# INITIALIZATION
pixmap = QPixmap(kwargs['w'], kwargs['h'])
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
# INITIALIZE EDGE LINE
pp1 = QPointF(((kwargs['w'] - 52) / 2), kwargs['h'] / 2)
pp2 = QPointF(((kwargs['w'] - 52) / 2) + 52 - 2, kwargs['h'] / 2)
line = QLineF(pp1, pp2)
# CALCULATE HEAD COORDINATES
angle = radians(line.angle())
p1 = QPointF(line.p2().x() + 2, line.p2().y())
p2 = p1 - QPointF(sin(angle + M_PI / 3.0) * 8, cos(angle + M_PI / 3.0) * 8)
p3 = p1 - QPointF(sin(angle + M_PI - M_PI / 3.0) * 8, cos(angle + M_PI - M_PI / 3.0) * 8)
# INITIALIZE EDGE HEAD
head = QPolygonF([p1, p2, p3])
# DRAW THE POLYGON
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QPen(QColor(0, 0, 0), 1.1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(line)
# DRAW HEAD
painter.setPen(QPen(QColor(0, 0, 0), 1.1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.setBrush(QColor(0, 0, 0))
painter.drawPolygon(head)
# DRAW THE TEXT ON TOP OF THE EDGE
space = 2 if Platform.identify() is Platform.Darwin else 0
painter.setFont(Font('Arial', 9, Font.Light))
painter.drawText(pp1.x() + space, (kwargs['h'] / 2) - 4, 'instanceOf')
return pixmap
def drawPixmapFor3d(self):
self.pixmap3d = QPixmap(self.itemWidth, self.itemHeight)
self.pixmap3d.fill(Qt.transparent)
painter = QPainter()
painter.begin(self.pixmap3d)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
painter.setBrush(QBrush(QColor(220, 220, 220)))
top = [QPoint(5, 10),
QPoint(self.itemWidth - 10, 10),
QPoint(self.itemWidth - 5, 5),
QPoint(10, 5),
QPoint(5, 10)]
painter.drawConvexPolygon(*top)
left = [QPoint(self.itemWidth - 10, 10),
QPoint(self.itemWidth - 10, self.itemHeight - 5),
QPoint(self.itemWidth - 5, self.itemHeight - 10),
QPoint(self.itemWidth - 5, 5),
QPoint(self.itemWidth - 10, 10)]
painter.drawConvexPolygon(*left)
painter.setBrush(QBrush())
painter.drawRect(QRect(5, 10, self.itemWidth - 15, self.itemHeight - 15))
painter.drawText(QRect(5, 10, self.itemWidth - 15, self.itemHeight - 15), Qt.AlignCenter, '3D')
painter.end()
def paintQR(self, data):
if not data:
return
qr = qrcode.QRCode()
qr.add_data(data)
matrix = qr.get_matrix()
k = len(matrix)
border_color = Qt.white
base_img = QImage(k * 5, k * 5, QImage.Format_ARGB32)
base_img.fill(border_color)
qrpainter = QPainter()
qrpainter.begin(base_img)
boxsize = 5
size = k * boxsize
left = (base_img.width() - size)/2
top = (base_img.height() - size)/2
qrpainter.setBrush(Qt.black)
qrpainter.setPen(Qt.black)
for r in range(k):
for c in range(k):
if matrix[r][c]:
qrpainter.drawRect(left+c*boxsize, top+r*boxsize, boxsize - 1, boxsize - 1)
qrpainter.end()
return base_img
def paintEvent(self, pe):
super().paintEvent(pe)
if (self.mRedrawMapImage):
self.renderMapToImage()
self.mRedrawMapImage = False
if (self.mMapImage.isNull() or self.mImageRect.isEmpty()):
return
p = QPainter(self)
p.setRenderHints(QPainter.SmoothPixmapTransform)
backgroundColor = QColor(Qt.darkGray)
if (self.mMapDocument and self.mMapDocument.map().backgroundColor().isValid()):
backgroundColor = self.mMapDocument.map().backgroundColor()
p.setBrush(backgroundColor)
p.setPen(Qt.NoPen)
p.drawRect(self.contentsRect())
p.drawImage(self.mImageRect, self.mMapImage)
viewRect = self.viewportRect()
p.setBrush(Qt.NoBrush)
p.setPen(QColor(0, 0, 0, 128))
p.translate(1, 1)
p.drawRect(viewRect)
outLinePen = QPen(QColor(255, 0, 0), 2)
outLinePen.setJoinStyle(Qt.MiterJoin)
p.translate(-1, -1)
p.setPen(outLinePen)
p.drawRect(viewRect)
p.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):
qp = QPainter(self)
qp.setPen(Qt.black)
size = self.size()
# Colored rectangles
qp.setBrush(QColor(200, 0, 0))
qp.drawRect(0, 0, 100, 100)
qp.setBrush(QColor(0, 200, 0))
qp.drawRect(100, 0, 100, 100)
qp.setBrush(QColor(0, 0, 200))
qp.drawRect(200, 0, 100, 100)
# Color Effect
for i in range(0, 100):
qp.setBrush(QColor(i * 10, 0, 0))
qp.drawRect(10 * i, 100, 10, 32)
qp.setBrush(QColor(i * 10, i * 10, 0))
qp.drawRect(10 * i, 100 + 32, 10, 32)
qp.setBrush(QColor(i * 2, i * 10, i * 1))
qp.drawRect(10 * i, 100 + 64, 10, 32)
def paintEvent(self, event):
if (self.segment_status == True):
print("segment")
painter = QPainter(self)
painter.begin(self)
pen = QPen(Qt.red, 2, Qt.SolidLine)
pp = QPainter(self.pix)
pp.setPen(pen)
pos_size = len(self.pos_xy)
if (pos_size >= 3):
for i in range(0, pos_size - 1):
#print(i,"i")
point_start = self.pos_xy[i]
point_end = self.pos_xy[i + 1]
if point_end == (-1, -1) and i == pos_size - 2:
break
elif point_end == (-1, -1) and i != pos_size - 2:
i += 1 # no use
elif point_start == (-1, -1):
continue
else:
print(point_start, "start")
print(point_end, "end")
pp.drawLine(point_start[0], point_start[1],
point_end[0], point_end[1])
painter.drawPixmap(0, 0, self.pix)
painter.end()
elif (self.dir_status == True):
print("dir")
painter = QPainter(self)
painter.begin(self)
# draw the direction with arrow
pp = QPainter(self.pix)
pen = QPen(Qt.green, 2, Qt.SolidLine)
pp.setPen(pen)
brush = QBrush(Qt.green, Qt.SolidPattern)
pp.setBrush(brush)
line = QLineF(QPointF(self.lastPoint.x(), self.lastPoint.y()),
QPointF(self.endPoint.x(), self.endPoint.y()))
v = line.unitVector()
v.setLength(8)
v.translate(QPointF(line.dx(), line.dy()))
n = v.normalVector()
n.setLength(n.length() * 0.5)
n2 = n.normalVector().normalVector()
p1 = v.p2()
p2 = n.p2()
p3 = n2.p2()
pp.drawLine(self.lastPoint.x(), self.lastPoint.y(),
self.endPoint.x(), self.endPoint.y())
pp.drawPolygon(p1, p2, p3)
painter.drawPixmap(0, 0, self.pix)
painter.end()
else:
painter = QPainter(self)
painter.begin(self)
painter.drawPixmap(0, 0, self.pix)
painter.end()
'''
def __init__(self, parent=None):
super(ThemePage, self).__init__(parent)
self.parent = parent
self.setObjectName('settingsthemepage')
mainLayout = QVBoxLayout()
mainLayout.setSpacing(15)
pen = QPen(
QColor('#4D5355' if self.parent.theme == 'dark' else '#B9B9B9'))
pen.setWidth(2)
theme_light = QPixmap(':/images/theme-light.png', 'PNG')
painter = QPainter(theme_light)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawRect(0, 0, theme_light.width(), theme_light.height())
theme_dark = QPixmap(':/images/theme-dark.png', 'PNG')
painter = QPainter(theme_dark)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawRect(0, 0, theme_dark.width(), theme_dark.height())
self.lightRadio = QRadioButton(self)
self.lightRadio.setIcon(QIcon(theme_light))
self.lightRadio.setIconSize(QSize(165, 121))
self.lightRadio.setCursor(Qt.PointingHandCursor)
self.lightRadio.clicked.connect(self.switchTheme)
self.lightRadio.setChecked(self.parent.theme == 'light')
self.darkRadio = QRadioButton(self)
self.darkRadio.setIcon(QIcon(theme_dark))
self.darkRadio.setIconSize(QSize(165, 121))
self.darkRadio.setCursor(Qt.PointingHandCursor)
self.darkRadio.clicked.connect(self.switchTheme)
self.darkRadio.setChecked(self.parent.theme == 'dark')
themeLayout = QGridLayout()
themeLayout.setColumnStretch(0, 1)
themeLayout.addWidget(self.lightRadio, 0, 1)
themeLayout.addWidget(self.darkRadio, 0, 3)
themeLayout.addWidget(QLabel('Light', self), 1, 1, Qt.AlignHCenter)
themeLayout.setColumnStretch(2, 1)
themeLayout.addWidget(QLabel('Dark', self), 1, 3, Qt.AlignHCenter)
themeLayout.setColumnStretch(4, 1)
themeGroup = QGroupBox('Theme')
themeGroup.setLayout(themeLayout)
mainLayout.addWidget(themeGroup)
index_leftRadio = QRadioButton('Clips on left')
index_leftRadio.setToolTip('Display Clip Index on the left hand side')
index_leftRadio.setCursor(Qt.PointingHandCursor)
index_leftRadio.setChecked(self.parent.parent.indexLayout == 'left')
index_rightRadio = QRadioButton('Clips on right')
index_rightRadio.setToolTip(
'Display Clip Index on the right hand side')
index_rightRadio.setCursor(Qt.PointingHandCursor)
index_rightRadio.setChecked(self.parent.parent.indexLayout == 'right')
index_buttonGroup = QButtonGroup(self)
index_buttonGroup.addButton(index_leftRadio, 1)
index_buttonGroup.addButton(index_rightRadio, 2)
# noinspection PyUnresolvedReferences
index_buttonGroup.buttonClicked[int].connect(
self.parent.parent.setClipIndexLayout)
indexLayout = QHBoxLayout()
indexLayout.addWidget(index_leftRadio)
indexLayout.addWidget(index_rightRadio)
layoutGroup = QGroupBox('Layout')
layoutGroup.setLayout(indexLayout)
mainLayout.addWidget(layoutGroup)
toolbar_labels = self.parent.settings.value('toolbarLabels',
'beside',
type=str)
toolbar_notextRadio = QRadioButton('No text (buttons only)', self)
toolbar_notextRadio.setToolTip('No text (buttons only)')
toolbar_notextRadio.setCursor(Qt.PointingHandCursor)
toolbar_notextRadio.setChecked(toolbar_labels == 'none')
toolbar_underRadio = QRadioButton('Text under buttons', self)
toolbar_underRadio.setToolTip('Text under buttons')
toolbar_underRadio.setCursor(Qt.PointingHandCursor)
toolbar_underRadio.setChecked(toolbar_labels == 'under')
toolbar_besideRadio = QRadioButton('Text beside buttons', self)
toolbar_besideRadio.setToolTip('Text beside buttons')
toolbar_besideRadio.setCursor(Qt.PointingHandCursor)
toolbar_besideRadio.setChecked(toolbar_labels == 'beside')
toolbar_buttonGroup = QButtonGroup(self)
toolbar_buttonGroup.addButton(toolbar_besideRadio, 1)
toolbar_buttonGroup.addButton(toolbar_underRadio, 2)
toolbar_buttonGroup.addButton(toolbar_notextRadio, 3)
# noinspection PyUnresolvedReferences
toolbar_buttonGroup.buttonClicked[int].connect(self.setLabelStyle)
toolbarLayout = QGridLayout()
toolbarLayout.addWidget(toolbar_besideRadio, 0, 0)
toolbarLayout.addWidget(toolbar_underRadio, 0, 1)
toolbarLayout.addWidget(toolbar_notextRadio, 1, 0)
toolbarGroup = QGroupBox('Toolbar')
toolbarGroup.setLayout(toolbarLayout)
mainLayout.addWidget(toolbarGroup)
nativeDialogsCheckbox = QCheckBox('Use native dialogs', self)
nativeDialogsCheckbox.setToolTip('Use native file dialogs')
nativeDialogsCheckbox.setCursor(Qt.PointingHandCursor)
nativeDialogsCheckbox.setChecked(self.parent.parent.nativeDialogs)
nativeDialogsCheckbox.stateChanged.connect(self.setNativeDialogs)
nativeDialogsLabel = QLabel(
'''
<b>ON:</b> use native dialog widgets as provided by your operating system
<br/>
<b>OFF:</b> use a generic file open & save dialog widget provided by the Qt toolkit
<br/><br/>
<b>NOTE:</b> native dialogs should always be used if working
''', self)
nativeDialogsLabel.setObjectName('nativedialogslabel')
nativeDialogsLabel.setTextFormat(Qt.RichText)
nativeDialogsLabel.setWordWrap(True)
advancedLayout = QVBoxLayout()
advancedLayout.addWidget(nativeDialogsCheckbox)
advancedLayout.addWidget(nativeDialogsLabel)
advancedGroup = QGroupBox('Advanced')
advancedGroup.setLayout(advancedLayout)
mainLayout.addWidget(advancedGroup)
mainLayout.addStretch(1)
self.setLayout(mainLayout)
def paint(self, painter: QPainter, options, widget=None):
painter.setBrush(self.fill_brush)
painter.setPen(self.outline_pen)
painter.drawRoundedRect(self.rect, 5, 5)
class Canvas(QWidget):
def __init__(self, size: int = 10,
parent: Optional[QWidget] = None,
*args, **kwargs) -> None:
super(Canvas, self).__init__(*args, **kwargs)
self._qp = QPainter()
self._timer = QTimer()
self._timer.timeout.connect(self.redraw)
self._colors = {
0: {
'cells': QColor('green'),
'background': QColor('white'),
'grid': QColor('black')
}, 1: {
'cells': QColor('black'),
'background': QColor('white'),
'grid': QColor('black')
}}
self.next_generation_signal = GenerationUpdateSignal()
self.game = Game()
self.size = size
self._color_scheme = self._colors[0]
self._grid = []
self._rects = []
@property
def color_scheme(self) -> Dict[str, QColor]:
return self._color_scheme
@color_scheme.setter
def color_scheme(self, color_index: int) -> None:
self._color_scheme = self._colors[color_index]
def start(self) -> None:
self.game.width = self.width() // self.size
self.game.height = self.height() // self.size
self._grid.clear()
self.clear()
self.spawn()
def continue_game(self, upd_time: int) -> None:
self._timer.start(upd_time)
def pause(self) -> None:
self._timer.stop()
def clear(self) -> None:
self.game.reset()
self.redraw(next_generation=False)
def redraw(self, next_generation: bool = True) -> None:
self.draw_grid()
if next_generation:
self.game.next_generation()
self.draw_rects()
self.update()
self.next_generation_signal.generation_update.emit(
self.game.generation)
def spawn(self) -> None:
self.game.random_generate(count=1000)
self.redraw(next_generation=False)
def draw_grid(self) -> None:
if not self._grid:
for x in range(0, self.width() + self.size, self.size):
self._grid.append(QLine(x, 0, x, self.height()))
for y in range(0, self.height() + self.size, self.size):
self._grid.append(QLine(0, y, self.width(), y))
def draw_rects(self) -> None:
self._rects.clear()
for x in range(self.game.width):
for y in range(self.game.height):
if self.game.area[y][x]:
rect = QRect(x * self.size, y * self.size,
self.size, self.size)
value = self.game.area[y][x]
self._rects.append((rect, value))
def draw_rect(self, x: int, y: int) -> None:
x, y = x // self.size, y // self.size
self.game.spawn_or_destroy(x, y)
self.redraw(next_generation=False)
def set_aging(self, mode: bool,
max_age: int, end_breeding_age: int) -> None:
self.clear()
self.game.aging = mode
self.game.max_age = max_age
self.game.end_breeding_age = end_breeding_age
def paintEvent(self, event: QEvent) -> None:
import copy
self._qp.begin(self)
self._qp.setBrush(QBrush(self._color_scheme['background']))
self._qp.drawRect(QRectF(0, 0, self.width(), self.height()))
self._qp.setPen(QPen(self._color_scheme['grid']))
for line in self._grid:
self._qp.drawLine(line)
for rect, value in self._rects:
color = copy.copy(self._color_scheme['cells'])
if self.game.aging:
color.setAlpha(value * self.game.alpha)
self._qp.setBrush(QBrush(color))
self._qp.drawRect(rect)
self._qp.end()
def mousePressEvent(self, event: QEvent) -> None:
self.draw_rect(event.x(), event.y())
def draw_model(self, qp: QPainter):
qp.setBrush(Qt.black)
qp.drawRect(0, 0, self.width, self.height)
qp.setBrush(Qt.red)
qp.setPen(Qt.red)
graphics.draw_model(self.model, qp)
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setBrush(Qt.red)
pen = QPen(Qt.blue)
pen.setWidth(3)
qp.setPen(pen)
for a in self.aristas:
pen = QPen(Qt.blue)
pen.setWidth(3)
qp.setPen(pen)
points = []
ct = 0
while (ct < len(a)):
points.append(QPoint(a[ct][0], a[ct][1]))
ct = ct + 1
poly = QPolygon(points)
qp.drawPolyline(poly)
foo = self.arrow(a[1][0], a[1][1], a[0][0], a[0][1], 25)
fod = self.arrow(a[ct - 2][0], a[ct - 2][1], a[ct - 1][0],
a[ct - 1][1], 25)
pen = QPen(Qt.red)
pen.setWidth(3)
qp.setPen(pen)
qp.setBrush(Qt.red)
if (foo != None):
poly = QPolygon([
QPoint(foo[0], foo[1]),
QPoint(foo[2], foo[3]),
QPoint(foo[4], foo[5])
])
qp.drawPolygon(poly)
if (fod != None):
poly = QPolygon([
QPoint(fod[0], fod[1]),
QPoint(fod[2], fod[3]),
QPoint(fod[4], fod[5])
])
qp.drawPolygon(poly)
qp.setBrush(Qt.green)
pen = QPen(Qt.black)
pen.setWidth(1)
qp.setPen(pen)
for a in self.aristas:
ct = 1
while (ct < len(a) - 1):
qp.drawEllipse(a[ct][0] - 5, a[ct][1] - 5, 10, 10)
if (len(a[ct]) == 3):
fb = QFont('Linux Libertine Mono O', 10)
fm = QFontMetrics(fb)
qp.setFont(fb)
w = fm.width(a[ct][2])
qp.setBrush(Qt.white)
qp.drawRect(a[ct][0] - (w / 2) - 10, a[ct][1], w + 20, 20)
qp.setBrush(Qt.green)
pen = QPen(Qt.black)
pen.setWidth(1)
qp.setPen(pen)
qp.drawText(a[ct][0] - (w / 2), a[ct][1] + 15, a[ct][2])
ct = ct + 1
qp.setPen(Qt.green)
qp.setBrush(Qt.red)
qp.setFont(QFont('Linux Libertine Mono O', 30))
for n in self.nodos:
qp.drawEllipse(n[0] - 25, n[1] - 25, 50, 50)
qp.drawText(n[0] - 12, n[1] + 12, n[2])
def paintEvent(self, QPaintEvent):
painter = QPainter(self)
painter.setBrush(Qt.white)
painter.drawRect(self.rect())
def paint(
self,
painter: QtGui.QPainter,
option: QStyleOptionGraphicsItem,
widget: Optional[QWidget],
) -> None:
# * title
titlePath = QtGui.QPainterPath()
titlePath.setFillRule(QtCore.Qt.WindingFill)
titlePath.addRoundedRect(
0,
0,
self._nodeWidth,
self._nodeTitleHeight,
self._nodeEdgeSize,
self._nodeEdgeSize,
)
titlePath.addRect(
0,
self._nodeTitleHeight - self._nodeEdgeSize,
self._nodeEdgeSize,
self._nodeEdgeSize,
)
titlePath.addRect(
self._nodeWidth - self._nodeEdgeSize,
self._nodeTitleHeight - self._nodeEdgeSize,
self._nodeEdgeSize,
self._nodeEdgeSize,
)
painter.setPen(QtCore.Qt.NoPen)
painter.setBrush(self._nodeTitleBrush)
painter.drawPath(titlePath.simplified())
# ? content
ContentPath = QtGui.QPainterPath()
ContentPath.setFillRule(QtCore.Qt.WindingFill)
ContentPath.addRoundedRect(
0,
self._nodeTitleHeight,
self._nodeWidth,
self._nodeHeight - self._nodeTitleHeight,
self._nodeEdgeSize,
self._nodeEdgeSize,
)
ContentPath.addRect(
0, self._nodeTitleHeight, self._nodeEdgeSize, self._nodeEdgeSize
)
ContentPath.addRect(
self._nodeWidth - self._nodeEdgeSize,
self._nodeTitleHeight,
self._nodeEdgeSize,
self._nodeEdgeSize,
)
painter.setPen(QtCore.Qt.NoPen)
painter.setBrush(self._nodeBrushBackground)
painter.drawPath(ContentPath.simplified())
# ? outline
outline = QtGui.QPainterPath()
outline.addRoundedRect(
0,
0,
self._nodeWidth,
self._nodeHeight,
self._nodeEdgeSize,
self._nodeEdgeSize,
)
painter.setPen(
self._nodePenDefault if not self.isSelected() else self._nodePenSelected
)
painter.setBrush(QtCore.Qt.NoBrush)
painter.drawPath(outline.simplified())
def drawBgCurrent(self, painter: QtGui.QPainter, color: QtGui.QColor):
painter.save()
painter.setPen(QtCore.Qt.NoPen)
painter.setBrush(color)
painter.drawRect(self.rect())
painter.restore()
def mouseReleaseEvent(self, event):
self.end = event.pos()
self.update()
if self.toolkit.switch == 0 and self.sel_rect \
and event.buttons() == QtCore.Qt.LeftButton:
self.scene_sel.setRect(self.begin.x(), self.begin.y(),
self.end.x() - self.begin.x(),
self.end.y() - self.begin.y())
self.paint_allowed = False
elif self.toolkit.switch == 0:
self.paint_allowed = False
if not self.paint_allowed:
return
self.paint_allowed = False
if self.begin == self.end:
return
if self.toolkit.switch == 6:
self.scene_sel.setRect(self.begin.x(), self.begin.y(),
self.end.x() - self.begin.x(),
self.end.y() - self.begin.y())
rectwidth, rectheight, rectx, recty = (self.sel_rect.width(),
self.sel_rect.height(),
self.sel_rect.x(),
self.sel_rect.y())
if "-" in str(rectwidth):
rectx = rectx + rectwidth
rectwidth = abs(rectwidth)
if "-" in str(rectheight):
recty = recty + rectheight
rectheight = abs(rectheight)
tmp = self.crop(self.pixmap().toImage())
blurred = QtGui.QImage(tmp.size(),
QtGui.QImage.Format_ARGB32_Premultiplied)
blurred.fill(QtGui.QColor('transparent'))
painter = QPainter(blurred)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
ctypes_blur(painter, tmp, 45, True, False)
painter.end()
dest = QtGui.QPixmap().fromImage(blurred)
painter = QPainter(self.pixmap())
painter.setRenderHint(QPainter.HighQualityAntialiasing)
self.history.sequence += 'b'
for _ in range(6):
painter.drawPixmap(rectx, recty, rectwidth + 1, rectheight + 1,
dest)
self.history.blur.append(
[rectx, recty, rectwidth, rectheight, dest])
painter.end()
self.update()
self.begin = QtCore.QPoint()
self.end = QtCore.QPoint()
self.sel_rect = None
self.scene_sel.setRect(0, 0, 0, 0)
self.scene_px.setPixmap(self.pixmap())
self.pixel_data = self.pixmap().toImage()
return
painter = QPainter(self.pixmap())
painter.setRenderHint(QPainter.HighQualityAntialiasing)
brush, pen, pen_outline = self.get_drawing_pen()
painter.setBrush(brush)
painter.setPen(pen)
rect = self.build_rect()
if self.toolkit.switch == 5:
self.build_path()
if not self.path:
return
self.history.sequence += 'f'
self.history.free.append((self.path, pen, brush, pen_outline))
if pen_outline:
painter.setPen(pen_outline)
painter.drawPath(self.path)
painter.setPen(pen)
painter.drawPath(self.path)
self.pen_cords_track_list = []
self.scene_px.setPixmap(self.pixmap())
self.pixel_data = self.pixmap().toImage()
self.update()
return
# draw on pixmap
if self.toolkit.switch == 2:
self.history.sequence += 'c'
self.history.circle.append((rect, pen, brush, pen_outline))
if pen_outline:
painter.setPen(pen_outline)
painter.drawEllipse(rect)
painter.setPen(pen)
painter.drawEllipse(rect)
elif self.toolkit.switch == 3:
self.history.sequence += 'r'
self.history.rect.append((rect, pen, brush, pen_outline))
if pen_outline:
painter.setPen(pen_outline)
painter.drawRect(rect)
painter.setPen(pen)
painter.drawRect(rect)
elif self.toolkit.switch == 4:
self.history.sequence += 'l'
line = QtCore.QLine(self.begin.x(), self.begin.y(), self.end.x(),
self.end.y())
if self.quadratic:
line = QtCore.QLineF(self.begin.x(), self.begin.y(),
self.end.x(), self.end.y())
angle = self.line_align(line.angle())
line.setAngle(angle)
self.history.line.append(((line.x1(), line.y1(), line.x2(),
line.y2()), pen, brush, pen_outline))
if pen_outline:
painter.setPen(pen_outline)
painter.drawLine(line)
painter.setPen(pen)
painter.drawLine(line)
self.begin = QtCore.QPoint()
self.end = QtCore.QPoint()
self.scene_px.setPixmap(self.pixmap())
self.pixel_data = self.pixmap().toImage()
self.update()
def paintEvent(self, event):
super(ScreenWindow, self).paintEvent(event)
painter = QPainter(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
brush, pen, pen_outline = self.get_drawing_pen()
sel_pen = QtGui.QPen(self.toolkit.pen_selection_color, 1, Qt.SolidLine)
sel_brush = QtGui.QBrush(self.toolkit.brush_selection_color)
painter.setPen(pen)
painter.setBrush(brush)
if not self.cords:
rect = self.build_rect()
# if paint tool is selected and LMB clicked, process event
if self.paint_allowed:
if pen_outline:
painter.setPen(pen_outline)
# switch 1: pen drawing, switch 5: free drawing
if self.toolkit.switch == 5:
if not self.pen_point_list:
return
self.build_path()
if not self.path:
return
if pen_outline:
painter.drawPath(self.path)
painter.setPen(pen)
painter.drawPath(self.path)
elif self.toolkit.switch == 2:
if pen_outline:
painter.drawEllipse(rect)
painter.setPen(pen)
painter.drawEllipse(rect)
self.draw_text(painter, rect.x(), rect.y(), rect.width(),
rect.height())
elif self.toolkit.switch == 3:
if pen_outline:
painter.drawRect(rect)
painter.setPen(pen)
painter.drawRect(rect)
self.draw_text(painter, rect.x(), rect.y(), rect.width(),
rect.height())
elif self.toolkit.switch == 4:
line = QtCore.QLineF(self.begin.x(), self.begin.y(),
self.end.x(), self.end.y())
if self.quadratic:
line = QtCore.QLineF(self.begin.x(), self.begin.y(),
self.end.x(), self.end.y())
angle = self.line_align(line.angle())
line.setAngle(angle)
if pen_outline:
painter.drawLine(line)
painter.setPen(pen)
painter.drawLine(line)
self.draw_text(painter,
line.x1(),
line.y1(),
int(line.length()),
float('%.2f' % line.angle()),
offset=False)
else:
# switch 0: selection, switch 6: blur
painter.setPen(sel_pen)
painter.setBrush(sel_brush)
if self.begin != self.end:
painter.drawRect(rect)
self.draw_text(painter, rect.x(), rect.y(),
rect.width(), rect.height())
self.sel_rect = rect
else:
# redraw last selection rectangle on RMB click
if self.sel_rect is not None:
painter.setPen(sel_pen)
painter.setBrush(sel_brush)
painter.drawRect(self.sel_rect)
self.draw_text(painter, self.sel_rect.x(),
self.sel_rect.y(), self.sel_rect.width(),
self.sel_rect.height())
else:
painter.setPen(sel_pen)
painter.setBrush(sel_brush)
painter.drawRect(self.cords)
self.draw_text(painter, self.cords.x(), self.cords.y(),
self.cords.width(), self.cords.height())
self.sel_rect = self.cords
self.cords = None
def mouseMoveEvent(self, event):
self.move_magnifier(event)
# switch 1: pen drawing, switch 5: free drawing
if (self.toolkit.switch == 1 or self.toolkit.switch == 5) \
and event.buttons() == QtCore.Qt.LeftButton:
if self.last_x is None:
self.last_x = event.x()
self.last_y = event.y()
return
painter = QPainter(self.pixmap())
painter.setRenderHint(QPainter.HighQualityAntialiasing)
brush, pen, _ = self.get_drawing_pen()
painter.setBrush(brush)
painter.setPen(pen)
if self.toolkit.switch == 5:
self.last_x = event.x()
self.last_y = event.y()
draw_args = QtCore.QPoint(self.last_x, self.last_y)
self.pen_point_list.append(draw_args)
self.pen_cords_track_list.append((event.x(), event.y()))
else:
draw_args = ((self.last_x, self.last_y, event.x(), event.y()),
pen, brush)
if len(self.history.pen) == 0:
self.history.sequence += 'p'
self.history.pen.append([])
else:
if len(self.history.pen[-1]) < 10:
self.history.pen[-1].append(draw_args)
else:
self.history.sequence += 'p'
self.history.pen.append([])
self.history.pen[-1].append(draw_args)
painter.drawLine(*draw_args[0])
self.update()
self.last_x = event.x()
self.last_y = event.y()
elif event.buttons() == QtCore.Qt.LeftButton:
self.end = event.pos()
# don't display selection for tools not in list
cases = [0, 6, 4, 3, 2]
if any(self.toolkit.switch == x for x in cases) and self.scene_sel:
x, y = self.begin.x(), self.begin.y()
width, height = (self.end.x() - self.begin.x(),
self.end.y() - self.begin.y())
if self.quadratic:
rect = self.rect_quadratic(
QtCore.QRect(x, y, width, height))
x, y, width, height = rect.x(), rect.y(), rect.width(
), rect.height()
self.scene_sel.setRect(x + 0.4, y + 0.4, width, height)
self.update()
def keyPressEvent(self, event):
if event.modifiers() & Qt.ShiftModifier:
self.quadratic = True
return
# is responsible for Ctrl-Z both in English and Cyrillic moonspeak
elif (event.modifiers() & QtCore.Qt.ControlModifier) \
and (event.nativeScanCode() == 52):
if len(self.history.sequence) == 0:
return
self.render_background()
painter = QPainter(self.pixmap())
painter.setRenderHint(QPainter.HighQualityAntialiasing)
pen_cnt = -1
circl_cnt = -1
rect_cnt = -1
line_cnt = -1
free_cnt = -1
blur_cnt = -1
for item in self.history.sequence[:-1]:
if item == 'p':
pen_cnt += 1
args = self.history.pen[pen_cnt]
for pack in args:
painter.setPen(pack[1])
painter.setBrush(pack[2])
painter.drawLine(*pack[0])
elif item == 'c':
circl_cnt += 1
args = self.history.circle[circl_cnt]
if args[-1]:
painter.setPen(args[-1])
painter.setBrush(args[2])
painter.drawEllipse(args[0])
painter.setPen(args[1])
painter.setBrush(args[2])
painter.drawEllipse(args[0])
elif item == 'r':
rect_cnt += 1
args = self.history.rect[rect_cnt]
if args[-1]:
painter.setPen(args[-1])
painter.setBrush(args[2])
painter.drawRect(args[0])
painter.setPen(args[1])
painter.setBrush(args[2])
painter.drawRect(args[0])
elif item == 'l':
line_cnt += 1
args = self.history.line[line_cnt]
if args[-1]:
painter.setPen(args[-1])
painter.setBrush(args[2])
painter.drawLine(*args[0])
painter.setPen(args[1])
painter.setBrush(args[2])
painter.drawLine(*args[0])
elif item == 'f':
free_cnt += 1
args = self.history.free[free_cnt]
if args[-1]:
painter.setPen(args[-1])
painter.setBrush(args[2])
painter.drawPath(args[0])
painter.setPen(args[1])
painter.setBrush(args[2])
painter.drawPath(args[0])
elif item == 'b':
blur_cnt += 1
args = self.history.blur[blur_cnt]
for _ in range(6):
painter.drawPixmap(*args)
last_item = self.history.sequence[-1]
items = [['p', self.history.pen], ['r', self.history.rect],
['l', self.history.line], ['f', self.history.free],
['b', self.history.blur], ['c', self.history.circle]]
for item in items:
if last_item == item[0]:
item[1].pop(-1)
self.history.sequence = self.history.sequence[:-1]
painter.end()
self.scene_px.setPixmap(self.pixmap())
self.pixel_data = self.pixmap().toImage()
return
elif event.key() == QtCore.Qt.Key_Return:
self.save_image(clip_only=True)
self.window_destroy()
elif event.key() == QtCore.Qt.Key_Escape:
self.window_destroy()
elif 10 <= event.nativeScanCode() <= 16:
for key in self.toolkit.switches:
if event.nativeScanCode() == key[1] + 10:
self.toolkit.tool_sel(key[0])
return
elif event.nativeScanCode() == 28: # "T" key
if self.toolkit.isVisible():
self.toolkit.hide()
self.toolkit.tools_config.hide()
else:
self.toolkit.show()
elif event.nativeScanCode() == 39: # "S" key
self.save_image()
elif event.nativeScanCode() == 38: # "A" key
cur_pos = QtGui.QCursor.pos()
cur_window = []
for window in self.active_windows:
x, y = window.x, window.y
w, h = x + window.width - 2, y + window.height - 2
# match window cords to mouse pointer
if x <= cur_pos.x() <= w and y <= cur_pos.y() <= h:
cur_window = [x, y, w, h]
try:
x, y, w, h = cur_window
except ValueError:
return
self.cords = QtCore.QRect(QtCore.QPoint(x, y), QtCore.QPoint(w, h))
self.scene_sel.setRect(x + 0.4, y + 0.4, w - x, h - y)
elif event.nativeScanCode() == 52: # "Z"
if self.view.isVisible():
self.pixel_info.hide()
self.view.hide()
else:
self.pixel_info.show()
self.view.show()
elif event.nativeScanCode() == 54: # "C"
data = self.pixel_info_label.text()
if not data:
return
data = data.split()[0]
self.parent.app.clipboard().setText(data)
self.update()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(painter.Antialiasing)
font = painter.font()
font.setBold(True)
painter.setFont(font)
x = self.rect().x()
y = self.rect().y()
w = self.rect().width() - 1
h = self.rect().height() - 1
r = 8
# draw a rounded style
if self._rolloutStyle == 2:
# draw the text
painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop,
self.title())
# draw the triangle
self.__drawTriangle(painter, x, y)
# draw the borders
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.6)
painter.setPen(pen)
painter.drawRoundedRect(x + 1, y + 1, w - 1, h - 1, r, r)
pen.setColor(self.palette().color(QPalette.Shadow))
painter.setPen(pen)
painter.drawRoundedRect(x, y, w - 1, h - 1, r, r)
# draw a square style
if self._rolloutStyle == 3:
# draw the text
painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop,
self.title())
self.__drawTriangle(painter, x, y)
# draw the borders
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.6)
painter.setPen(pen)
painter.drawRect(x + 1, y + 1, w - 1, h - 1)
pen.setColor(self.palette().color(QPalette.Shadow))
painter.setPen(pen)
painter.drawRect(x, y, w - 1, h - 1)
# draw a Maya style
if self._rolloutStyle == 4:
# draw the text
painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop,
self.title())
painter.setRenderHint(QPainter.Antialiasing, False)
self.__drawTriangle(painter, x, y)
# draw the borders - top
headerHeight = 20
headerRect = QRect(x + 1, y + 1, w - 1, headerHeight)
headerRectShadow = QRect(x - 1, y - 1, w + 1, headerHeight + 2)
# Highlight
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.4)
painter.setPen(pen)
painter.drawRect(headerRect)
painter.fillRect(headerRect, QColor(255, 255, 255, 18))
# Shadow
pen.setColor(self.palette().color(QPalette.Dark))
painter.setPen(pen)
painter.drawRect(headerRectShadow)
if not self.isCollapsed():
# draw the lover border
pen = QPen(self.palette().color(QPalette.Dark))
pen.setWidthF(0.8)
painter.setPen(pen)
offSet = headerHeight + 3
bodyRect = QRect(x, y + offSet, w, h - offSet)
bodyRectShadow = QRect(x + 1, y + offSet, w + 1,
h - offSet + 1)
painter.drawRect(bodyRect)
pen.setColor(self.palette().color(QPalette.Light))
pen.setWidthF(0.4)
painter.setPen(pen)
painter.drawRect(bodyRectShadow)
# draw a boxed style
elif self._rolloutStyle == 1:
if self.isCollapsed():
arect = QRect(x + 1, y + 9, w - 1, 4)
brect = QRect(x, y + 8, w - 1, 4)
text = '+'
else:
arect = QRect(x + 1, y + 9, w - 1, h - 9)
brect = QRect(x, y + 8, w - 1, h - 9)
text = '-'
# draw the borders
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.6)
painter.setPen(pen)
painter.drawRect(arect)
pen.setColor(self.palette().color(QPalette.Shadow))
painter.setPen(pen)
painter.drawRect(brect)
painter.setRenderHint(painter.Antialiasing, False)
painter.setBrush(self.palette().color(QPalette.Window).darker(120))
painter.drawRect(x + 10, y + 1, w - 20, 16)
painter.drawText(x + 16, y + 1, w - 32, 16,
Qt.AlignLeft | Qt.AlignVCenter, text)
painter.drawText(x + 10, y + 1, w - 20, 16, Qt.AlignCenter,
self.title())
if self.dragDropMode():
rect = self.dragDropRect()
# draw the lines
l = rect.left()
r = rect.right()
cy = rect.center().y()
for y in (cy - 3, cy, cy + 3):
painter.drawLine(l, y, r, y)
painter.end()
def createCurveIcons(self):
pix = QPixmap(self.m_iconSize)
painter = QPainter()
gradient = QLinearGradient(0, 0, 0, self.m_iconSize.height())
gradient.setColorAt(0.0, QColor(240, 240, 240))
gradient.setColorAt(1.0, QColor(224, 224, 224))
brush = QBrush(gradient)
# The original C++ code uses undocumented calls to get the names of the
# different curve types. We do the Python equivalant (but without
# cheating).
curve_types = [
(n, c) for n, c in QEasingCurve.__dict__.items()
if isinstance(c, QEasingCurve.Type) and c != QEasingCurve.Custom
]
curve_types.sort(key=lambda ct: ct[1])
painter.begin(pix)
for curve_name, curve_type in curve_types:
painter.fillRect(QRect(QPoint(0, 0), self.m_iconSize), brush)
curve = QEasingCurve(curve_type)
if curve_type == QEasingCurve.BezierSpline:
curve.addCubicBezierSegment(QPointF(0.4,
0.1), QPointF(0.6, 0.9),
QPointF(1.0, 1.0))
elif curve_type == QEasingCurve.TCBSpline:
curve.addTCBSegment(QPointF(0.0, 0.0), 0, 0, 0)
curve.addTCBSegment(QPointF(0.3, 0.4), 0.2, 1, -0.2)
curve.addTCBSegment(QPointF(0.7, 0.6), -0.2, 1, 0.2)
curve.addTCBSegment(QPointF(1.0, 1.0), 0, 0, 0)
painter.setPen(QColor(0, 0, 255, 64))
xAxis = self.m_iconSize.height() / 1.5
yAxis = self.m_iconSize.width() / 3.0
painter.drawLine(0, xAxis, self.m_iconSize.width(), xAxis)
painter.drawLine(yAxis, 0, yAxis, self.m_iconSize.height())
curveScale = self.m_iconSize.height() / 2.0
painter.setPen(Qt.NoPen)
# Start point.
painter.setBrush(Qt.red)
start = QPoint(yAxis,
xAxis - curveScale * curve.valueForProgress(0))
painter.drawRect(start.x() - 1, start.y() - 1, 3, 3)
# End point.
painter.setBrush(Qt.blue)
end = QPoint(yAxis + curveScale,
xAxis - curveScale * curve.valueForProgress(1))
painter.drawRect(end.x() - 1, end.y() - 1, 3, 3)
curvePath = QPainterPath()
curvePath.moveTo(QPointF(start))
t = 0.0
while t <= 1.0:
to = QPointF(yAxis + curveScale * t,
xAxis - curveScale * curve.valueForProgress(t))
curvePath.lineTo(to)
t += 1.0 / curveScale
painter.setRenderHint(QPainter.Antialiasing, True)
painter.strokePath(curvePath, QColor(32, 32, 32))
painter.setRenderHint(QPainter.Antialiasing, False)
item = QListWidgetItem()
item.setIcon(QIcon(pix))
item.setText(curve_name)
self.m_ui.easingCurvePicker.addItem(item)
painter.end()
def paintEvent(self, event):
unused(event)
if self.isVisible():
# Read out most important values to limit hash table lookups
# Low-pass roll, pitch and yaw
self.rollLP = self.roll#rollLP * 0.2f + 0.8f * roll
self.pitchLP = self.pitch#pitchLP * 0.2f + 0.8f * pitch
self.yawLP = self.yaw if isinf(self.yaw) == False and isnan(self.yaw) == False else self.yawLP#yawLP * 0.2f + 0.8f * yaw
# Translate for yaw
maxYawTrans = 60.0
newYawDiff = self.yawDiff
if isinf(newYawDiff):
newYawDiff = self.yawDiff
if newYawDiff > M_PI:
newYawDiff = newYawDiff - M_PI
if newYawDiff < -M_PI:
newYawDiff = newYawDiff + M_PI
newYawDiff = self.yawDiff * 0.8 + newYawDiff * 0.2
self.yawDiff = newYawDiff
self.yawInt += newYawDiff
if self.yawInt > M_PI:
self.yawInt = M_PI
if self.yawInt < -M_PI:
self.yawInt = -M_PI
yawTrans = self.yawInt * maxYawTrans
self.yawInt *= 0.6
if (yawTrans < 5.0) and (yawTrans > -5.0):
yawTrans = 0
# Negate to correct direction
yawTrans = -yawTrans
yawTrans = 0
#qDebug() << "yaw translation" << yawTrans << "integral" << yawInt << "difference" << yawDiff << "yaw" << yaw
# And if either video or the data stream is enabled, draw the next frame.
if self.videoEnabled:
self.xImageFactor = self.width() / float(self.glImage.width())
self.yImageFactor = self.height() / float(self.glImage.height())
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
pmap = QPixmap.fromImage(self.glImage).scaledToWidth(self.width())
painter.drawPixmap(0, (self.height() - pmap.height()) / 2, pmap)
# END OF OPENGL PAINTING
if self.HUDInstrumentsEnabled:
#glEnable(GL_MULTISAMPLE)
# QT PAINTING
#makeCurrent()
painter.translate((self.vwidth/2.0+self.xCenterOffset)*self.scalingFactor, (self.vheight/2.0+self.yCenterOffset)*self.scalingFactor)
# COORDINATE FRAME IS NOW (0,0) at CENTER OF WIDGET
# Draw all fixed indicators
# BATTERY
self.paintText(self.fuelStatus, self.fuelColor, 6.0, (-self.vwidth/2.0) + 10, -self.vheight/2.0 + 6, painter)
# Waypoint
self.paintText(self.waypointName, self.defaultColor, 6.0, (-self.vwidth/3.0) + 10, +self.vheight/3.0 + 15, painter)
linePen = QPen(Qt.SolidLine)
linePen.setWidth(self.refLineWidthToPen(1.0))
linePen.setColor(self.defaultColor)
painter.setBrush(Qt.NoBrush)
painter.setPen(linePen)
# YAW INDICATOR
#
# .
# . .
# .......
#
_yawIndicatorWidth = 12.0
_yawIndicatorY = self.vheight/2.0 - 15.0
yawIndicator = QPolygon(4)
yawIndicator.setPoint(0, QPoint(self.refToScreenX(0.0), self.refToScreenY(_yawIndicatorY)))
yawIndicator.setPoint(1, QPoint(self.refToScreenX(_yawIndicatorWidth/2.0), self.refToScreenY(_yawIndicatorY+_yawIndicatorWidth)))
yawIndicator.setPoint(2, QPoint(self.refToScreenX(-_yawIndicatorWidth/2.0), self.refToScreenY(_yawIndicatorY+_yawIndicatorWidth)))
yawIndicator.setPoint(3, QPoint(self.refToScreenX(0.0), self.refToScreenY(_yawIndicatorY)))
painter.drawPolyline(yawIndicator)
painter.setPen(linePen)
# CENTER
# HEADING INDICATOR
#
# __ __
# \/\/
#
_hIndicatorWidth = 20.0
_hIndicatorY = -25.0
_hIndicatorYLow = _hIndicatorY + _hIndicatorWidth / 6.0
_hIndicatorSegmentWidth = _hIndicatorWidth / 7.0
hIndicator = QPolygon(7)
hIndicator.setPoint(0, QPoint(self.refToScreenX(0.0-_hIndicatorWidth/2.0), self.refToScreenY(_hIndicatorY)))
hIndicator.setPoint(1, QPoint(self.refToScreenX(0.0-_hIndicatorWidth/2.0+_hIndicatorSegmentWidth*1.75), self.refToScreenY(_hIndicatorY)))
hIndicator.setPoint(2, QPoint(self.refToScreenX(0.0-_hIndicatorSegmentWidth*1.0), self.refToScreenY(_hIndicatorYLow)))
hIndicator.setPoint(3, QPoint(self.refToScreenX(0.0), self.refToScreenY(_hIndicatorY)))
hIndicator.setPoint(4, QPoint(self.refToScreenX(0.0+_hIndicatorSegmentWidth*1.0), self.refToScreenY(_hIndicatorYLow)))
hIndicator.setPoint(5, QPoint(self.refToScreenX(0.0+_hIndicatorWidth/2.0-_hIndicatorSegmentWidth*1.75), self.refToScreenY(_hIndicatorY)))
hIndicator.setPoint(6, QPoint(self.refToScreenX(0.0+_hIndicatorWidth/2.0), self.refToScreenY(_hIndicatorY)))
painter.drawPolyline(hIndicator)
# SETPOINT
_centerWidth = 8.0
painter.drawEllipse(
QPointF(self.refToScreenX(min(10.0, self.desiredRoll * 10.0)),
self.refToScreenY(min(10.0, self.desiredPitch * 10.0))),
self.refToScreenX(_centerWidth/2.0), self.refToScreenX(_centerWidth/2.0))
_centerCrossWidth = 20.0
# left
painter.drawLine(QPointF(self.refToScreenX(-_centerWidth / 2.0), self.refToScreenY(0.0)),
QPointF(self.refToScreenX(-_centerCrossWidth / 2.0), self.refToScreenY(0.0)))
# right
painter.drawLine(QPointF(self.refToScreenX(_centerWidth / 2.0), self.refToScreenY(0.0)),
QPointF(self.refToScreenX(_centerCrossWidth / 2.0), self.refToScreenY(0.0)))
# top
painter.drawLine(QPointF(self.refToScreenX(0.0), self.refToScreenY(-_centerWidth / 2.0)),
QPointF(self.refToScreenX(0.0), self.refToScreenY(-_centerCrossWidth / 2.0)))
# COMPASS
_compassY = -self.vheight/2.0 + 6.0
compassRect = QRectF(QPointF(self.refToScreenX(-12.0), self.refToScreenY(_compassY)),
QSizeF(self.refToScreenX(24.0), self.refToScreenY(12.0)))
painter.setBrush(Qt.NoBrush)
painter.setPen(linePen)
painter.drawRoundedRect(compassRect, 3, 3)
# YAW is in compass-human readable format, so 0 .. 360 deg.
_yawDeg = (self.yawLP / M_PI) * 180.0
if _yawDeg < 0:
_yawDeg += 360
if _yawDeg > 360:
_yawDeg -= 360
# final safeguard for really stupid systems
_yawAngle = '{:3d}'.format(int(_yawDeg) % 360)
self.paintText(_yawAngle, self.defaultColor, 8.5, -9.8, _compassY + 1.7, painter)
painter.setBrush(Qt.NoBrush)
painter.setPen(linePen)
# CHANGE RATE STRIPS
self.drawChangeRateStrip(-95.0, -60.0, 40.0, -10.0, 10.0, self.zSpeed, painter)
# CHANGE RATE STRIPS
self.drawChangeRateStrip(95.0, -60.0, 40.0, -10.0, 10.0, self.totalAcc, painter,True)
# GAUGES
# Left altitude gauge
_gaugeAltitude = self.alt if self.alt != 0 else -self.zPos
painter.setBrush(Qt.NoBrush)
painter.setPen(linePen)
self.drawChangeIndicatorGauge(-self.vGaugeSpacing, 35.0, 15.0, 10.0, _gaugeAltitude, self.defaultColor, painter, False)
self.paintText('alt m', self.defaultColor, 5.5, -73.0, 50, painter)
# Right speed gauge
self.drawChangeIndicatorGauge(self.vGaugeSpacing, 35.0, 15.0, 10.0, self.totalSpeed, self.defaultColor, painter, False)
self.paintText('v m/s', self.defaultColor, 5.5, 55.0, 50, painter)
# Waypoint name
if self.waypointName != '':
self.paintText(self.waypointName, self.defaultColor, 2.0, (-self.vwidth/3.0) + 10, +self.vheight/3.0 + 15, painter)
# MOVING PARTS
painter.translate(self.refToScreenX(yawTrans), 0)
attColor = painter.pen().color()
# Draw multi-component attitude
for key in self.attitudes:
att = self.attitudes[key]
attColor = attColor.darker(200)
painter.setPen(attColor)
# Rotate view and draw all roll-dependent indicators
painter.rotate((att.x()/M_PI)* -180.0)
painter.translate(0, (-att.y()/M_PI)* -180.0 * self.refToScreenY(1.8))
#qDebug() << "ROLL" << roll << "PITCH" << pitch << "YAW DIFF" << valuesDot.value("roll", 0.0)
# PITCH
self.paintPitchLines(att.y(), painter)
painter.translate(0, -(-att.y()/M_PI)* -180.0 * self.refToScreenY(1.8))
painter.rotate(-(att.x()/M_PI)* -180.0)
painter.end()
def paintEvent(self, event):
side = min(self.width(), self.height()) # 最小边
time = QTime.currentTime() # 获取系统当前时间
painter = QPainter(self)
# 抗锯齿
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.translate(self.width() / 2, self.height() / 2) # 坐标偏置
# painter.setPen(Qt.NoPen)
painter.setBrush(self.hourColor)
# 表盘主背景
self.target = QPixmap(self.size())
self.target.fill(Qt.transparent)
imgB = self.imgFile
p = QPixmap(imgB).scaled(200, 200, Qt.KeepAspectRatioByExpanding,
Qt.SmoothTransformation)
path = QPainterPath()
path.addRoundedRect(-100, -100, 200, 200, 50, 50)
painter.setClipPath(path)
painter.drawPixmap(-100, -100, p)
# 表盘中心图标
imgM = self.imgFile_M
pm = QPixmap(imgM).scaled(50, 50, Qt.KeepAspectRatioByExpanding,
Qt.SmoothTransformation)
painter.drawPixmap(-25, -60, pm)
# 整点刻度
painter.setPen(self.hourColor)
for i in range(12):
painter.drawLine(QPointF(85, 0), QPointF(96, 0))
# painter.drawLine(88, 0, 96, 0)
painter.rotate(30.0)
painter.setPen(self.minuteColor)
for j in range(60): # 小刻度
if (j % 5) != 0:
painter.drawLine(QPointF(85, 0), QPointF(92, 0))
# painter.drawLine(92, 0, 96, 0)
painter.rotate(6.0)
painter.setPen(Qt.NoPen)
painter.setBrush(self.hourColor)
painter.save()
painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)))
painter.drawConvexPolygon(self.hourHand) # 画三角形
painter.restore()
painter.setPen(Qt.NoPen)
painter.setBrush(self.minuteColor)
painter.save()
painter.rotate(6.0 * (time.minute() + time.second() / 60.0))
painter.drawConvexPolygon(self.minuteHand)
painter.restore()
painter.setPen(QColor(0, 0, 0))
painter.drawEllipse(-5, -5, 10, 10) # 画圆。参数是外接矩形左上点和长宽
class Image(QLabel):
classifiedMLP = pyqtSignal(int)
classifiedCNN = pyqtSignal(int)
clear = pyqtSignal()
def __init__(self, *args):
super().__init__(*args)
self.pressed = False
self.setFixedSize(200, 200)
self.setStyleSheet('border: 3px solid grey;')
self.classifyTimer = QTimer()
self.classifyTimer.timeout.connect(self.classify)
# загрузка весов нейронной сети MLP
data = scipy.io.loadmat('weights.mat')
self.Theta1 = np.matrix(data['Theta1'])
self.Theta2 = np.matrix(data['Theta2'])
# инициализация модели CNN
jsonFile = open('model.json', 'r')
loadedModelJson = jsonFile.read()
jsonFile.close()
self.cnnModel = model_from_json(loadedModelJson)
self.cnnModel.load_weights('model.h5')
self.cnnModel.compile(loss="categorical_crossentropy",
optimizer=Adam(),
metrics=["accuracy"])
def mousePressEvent(self, event):
self.pressed = True
self.xPrev = event.x()
self.yPrev = event.y()
self.painter = QPainter(self.pixmap())
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.begin(self.pixmap())
def mouseMoveEvent(self, event):
if self.pressed:
color = QColor(0, 0, 0)
self.painter.setBrush(color)
pen = QPen(color, 15)
pen.setCapStyle(QtCore.Qt.RoundCap)
self.painter.setPen(pen)
self.painter.drawLine(self.xPrev, self.yPrev, event.x(), event.y())
self.xPrev = event.x()
self.yPrev = event.y()
self.repaint()
def mouseReleaseEvent(self, event):
self.pressed = False
self.painter.end()
# запуск кода классификации картинки
self.classifyTimer.start(1000)
QTimer.singleShot(2000, self.clearImage)
def classify(self):
self.classifyTimer.stop()
# предсказание с помощью MLP
self.classifiedMLP.emit(self.classifyMLP())
# предсказание с помощью свёрточной сети Keras
self.classifiedCNN.emit(self.classifyCNN())
def classifyMLP(self):
# подготовка картинки к классификации
small = self.pixmap().toImage().scaled(20, 20).convertToFormat(
QImage.Format_Grayscale8)
s = small.bits().asstring(20 * 20)
sample = np.fromstring(s, dtype=np.uint8)
sample = sample.reshape((20, 20)).T.reshape((1, 400))
sample = (255 - sample) / 243.0
# предсказание с помощью классификатора
return predict(self.Theta1, self.Theta2, sample)[0] % 10
def classifyCNN(self):
# подготовка картинки к классификации
small = self.pixmap().toImage().scaled(28, 28).convertToFormat(
QImage.Format_Grayscale8)
s = small.bits().asstring(28 * 28)
sample = np.fromstring(s, dtype=np.uint8)
sample = (255 - sample) / 255
sample = sample.reshape((1, 1, 28, 28))
# предсказание с помощью классификатора
return np.argmax(self.cnnModel.predict(sample))
def clearImage(self):
self.painter.begin(self.pixmap())
self.painter.eraseRect(self.rect())
self.painter.end()
self.repaint()
self.clear.emit()
def paintEvent(self, event: QPaintEvent):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(QColor(0, 0, 0, 180))
painter.setPen(Qt.NoPen)
painter.drawRoundedRect(self.rect(), 10, 10)
def paintEvent(self, event):
qp = QPainter(self)
qp.setRenderHint(QPainter.Antialiasing) # <- Set anti-aliasing See https://wiki.python.org/moin/PyQt/Painting%20and%20clipping%20demonstration
qp.setPen(QPen(Qt.black, 5, Qt.SolidLine))
qp.setBrush(QBrush(Qt.red, Qt.SolidPattern))
qp.drawRect(10, 10, 180, 50) # x_start, y_start, x_length, y_length
qp.setBrush(QBrush(QColor("#fcaf3e"), Qt.DiagCrossPattern))
qp.drawRect(210, 10, 180, 50)
qp.setBrush(QBrush(Qt.red, Qt.Dense1Pattern))
qp.drawRect(410, 10, 180, 50)
qp.setBrush(QBrush(Qt.red, Qt.HorPattern))
qp.drawRect(610, 10, 180, 50)
qp.setBrush(QBrush(Qt.red, Qt.VerPattern))
qp.drawRect(810, 10, 180, 50)
qp.setBrush(QBrush(Qt.red, Qt.BDiagPattern))
qp.drawRect(1010, 10, 180, 50)
def paintEvent(self, event):
# Init painter.
painter = QPainter(self)
painter.save()
# Draw background.
painter.setBrush(self.background_color)
painter.drawRect(0, 0, self.rect().width(), self.rect().height())
# Get start/last render index.
start_page_index = int(self.scroll_offset * 1.0 / self.scale /
self.page_height)
last_page_index = int((self.scroll_offset + self.rect().height()) *
1.0 / self.scale / self.page_height)
# Translate painter at y coordinate.
translate_y = (start_page_index * self.scale *
self.page_height) - self.scroll_offset
painter.translate(0, translate_y)
# Render pages in visible area.
for index in list(range(start_page_index, last_page_index + 1)):
if index < self.page_total_number:
# Get page image.
page = self.document[index]
trans = fitz.Matrix(self.scale, self.scale)
pixmap = page.getPixmap(matrix=trans, alpha=False)
img = QImage(pixmap.samples, pixmap.width, pixmap.height,
pixmap.stride, QImage.Format_RGB888)
qpixmap = QPixmap.fromImage(img)
# Init render rect.
render_width = self.page_width * self.scale
render_height = self.page_height * self.scale
render_x = (self.rect().width() - render_width) / 2
render_y = (index -
start_page_index) * self.scale * self.page_height
# Add padding between pages.
if (index - start_page_index) > 0:
painter.translate(0, self.page_padding)
# Draw page image.
painter.drawPixmap(
QRect(render_x, render_y, render_width, render_height),
qpixmap)
painter.restore()
# Render current page.
painter.setFont(self.font)
painter.setPen(self.page_annotate_color)
painter.drawText(
QRect(
self.rect().x(),
self.rect().y() + self.rect().height() -
self.page_annotate_height - self.page_annotate_padding_bottom,
self.rect().width() - self.page_annotate_padding_right,
self.page_annotate_height), Qt.AlignRight,
"{0}% ({1}/{2})".format(
int((start_page_index + 1) * 100 / self.page_total_number),
start_page_index + 1, self.page_total_number))
def paintEvent(self, event):
if not self._image3c.img_data:
self._loading_bar.hide()
self._ico_label.hide()
self._tip_label.show()
self.overlabel_display.hide()
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setPen(QPen(Qt.black, Qt.PenStyle(Qt.DashLine), 3))
painter.setBrush(Qt.white)
self._tip_box = (self.width() * 0.2, self.height() * 0.2,
self.width() * 0.6, self.height() * 0.6)
radius = min(self.width() * 0.1, self.height() * 0.1)
painter.drawRoundedRect(*self._tip_box, radius, radius)
painter.end()
self._tip_label.setGeometry(QRect(*self._tip_box))
self._tip_label.setText(self._action_descs[0])
self._tip_label.setAlignment(Qt.AlignCenter)
elif self._args.sys_category * 10 + self._args.sys_channel not in self._categories:
self._loading_bar.show()
self._ico_label.show()
self._tip_label.show()
self.overlabel_display.hide()
bar_wid = self.width() * 0.8
bar_hig = self.height() * 0.1
self._loading_bar.setGeometry((self.width() - bar_wid) / 2,
self.height() - bar_hig * 1.2,
bar_wid, bar_hig)
resized_img = self._ico.scaled(self.width() * 0.8,
self.height() * 0.8,
Qt.KeepAspectRatio)
img_wid = resized_img.size().width()
img_hig = resized_img.size().height()
self._ico_label.setPixmap(QPixmap.fromImage(resized_img))
self._ico_label.setGeometry((self.width() - img_wid) / 2,
bar_hig * 0.2, img_wid, img_hig)
self._tip_label.setGeometry((self.width() - bar_wid) / 2,
self.height() - bar_hig * 2.2, bar_wid,
bar_hig)
else:
self._loading_bar.hide()
self._ico_label.hide()
self._tip_label.hide()
self.overlabel_display.show()
if not self._image3c.display:
self._image3c.load_image(self._args.sys_category,
self._args.sys_channel)
self._resizing_image = True
if self._image3c.display:
if not self._move_pos:
self.home()
self._move_pos[0] = self.width() - 2 if self._move_pos[
0] > self.width() - 2 else self._move_pos[0]
self._move_pos[0] = 2 - self._move_pos[2] if self._move_pos[
0] < 2 - self._move_pos[2] else self._move_pos[0]
self._move_pos[1] = self.height() - 2 if self._move_pos[
1] > self.height() - 2 else self._move_pos[1]
self._move_pos[1] = 2 - self._move_pos[3] if self._move_pos[
1] < 2 - self._move_pos[3] else self._move_pos[1]
# aspect ratio mode: IgnoreAspectRatio, KeepAspectRatio and KeepAspectRatioByExpanding.
if self._resizing_image:
resized_img = self._image3c.display.scaled(
self._move_pos[2], self._move_pos[3],
Qt.IgnoreAspectRatio)
self.overlabel_display.setPixmap(
QPixmap.fromImage(resized_img))
self._resizing_image = False
self.overlabel_display.setGeometry(*self._move_pos)
if isinstance(self.overlabel_display.croping, tuple):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
painter.drawLine(
QPoint(
self.overlabel_display.croping[0] *
self.overlabel_display.width() +
self.overlabel_display.x(), 0),
QPoint(
self.overlabel_display.croping[0] *
self.overlabel_display.width() +
self.overlabel_display.x(), self.height()))
painter.drawLine(
QPoint(
0, self.overlabel_display.croping[1] *
self.overlabel_display.height() +
self.overlabel_display.y()),
QPoint(
self.width(), self.overlabel_display.croping[1] *
self.overlabel_display.height() +
self.overlabel_display.y()))
painter.drawLine(
QPoint(
self.overlabel_display.croping[2] *
self.overlabel_display.width() +
self.overlabel_display.x(), 0),
QPoint(
self.overlabel_display.croping[2] *
self.overlabel_display.width() +
self.overlabel_display.x(), self.height()))
painter.drawLine(
QPoint(
0, self.overlabel_display.croping[3] *
self.overlabel_display.height() +
self.overlabel_display.y()),
QPoint(
self.width(), self.overlabel_display.croping[3] *
self.overlabel_display.height() +
self.overlabel_display.y()))
painter.end()
self.ps_status_changed.emit(
(self._image3c.rgb_data.shape[1],
self._image3c.rgb_data.shape[0], "{:.1f}".format(
self.overlabel_display.croping[2] * 100),
"{:.1f}".format(self.overlabel_display.croping[3] *
100)))
elif isinstance(self.overlabel_display.locating, tuple):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
painter.drawLine(
QPoint(
self.overlabel_display.locating[0] *
self.overlabel_display.width() +
self.overlabel_display.x(), 0),
QPoint(
self.overlabel_display.locating[0] *
self.overlabel_display.width() +
self.overlabel_display.x(), self.height()))
painter.drawLine(
QPoint(
0, self.overlabel_display.locating[1] *
self.overlabel_display.height() +
self.overlabel_display.y()),
QPoint(
self.width(), self.overlabel_display.locating[1] *
self.overlabel_display.height() +
self.overlabel_display.y()))
painter.end()
self.ps_status_changed.emit(
(self._image3c.rgb_data.shape[1],
self._image3c.rgb_data.shape[0], "{:.1f}".format(
self.overlabel_display.locating[0] * 100),
"{:.1f}".format(self.overlabel_display.locating[1] *
100)))
elif self.overlabel_display.locations[
self._args.sys_activated_idx]:
self.ps_status_changed.emit(
(self._image3c.rgb_data.shape[1],
self._image3c.rgb_data.shape[0],
"{:.1f}".format(self.overlabel_display.locations[
self._args.sys_activated_idx][0] * 100),
"{:.1f}".format(self.overlabel_display.locations[
self._args.sys_activated_idx][1] * 100)))
else:
self.ps_status_changed.emit(
(self._image3c.rgb_data.shape[1],
self._image3c.rgb_data.shape[0]))
def paintEvent(self, event):
super().paintEvent(event)
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
idx_seq = list(range(5))
idx_seq = idx_seq[self._args.sys_activated_idx +
1:] + idx_seq[:self._args.sys_activated_idx + 1]
for idx in idx_seq:
if self.locations[idx]:
pt_xy = np.array((self.locations[idx][0] * self.width(),
self.locations[idx][1] * self.height()))
pt_box = get_outer_box(pt_xy, self._args.circle_dist)
if idx == self._args.sys_activated_idx:
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
else:
painter.setPen(
QPen(QColor(*self._args.negative_color),
self._args.negative_wid))
painter.setBrush(QColor(*self._args.sys_color_set[idx].rgb))
painter.drawEllipse(*pt_box)
if isinstance(self.croping, tuple):
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QColor(255, 255, 255, 160))
croping = self.sort_croping()
croping = (int(self.width() * croping[0]),
int(self.height() * croping[1]),
int(self.width() * croping[2]),
int(self.height() * croping[3]))
self.draw_rect(painter, 0, 0, croping[0], self.height())
self.draw_rect(painter, croping[2], 0, self.width(), self.height())
self.draw_rect(painter, croping[0], 0, croping[2], croping[1])
self.draw_rect(painter, croping[0], croping[3], croping[2],
self.height())
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
painter.setBrush(QBrush(Qt.NoBrush))
if 0 <= self.croping[0] <= self.width():
painter.drawLine(
QPoint(self.croping[0] * self.width(), 0),
QPoint(self.croping[0] * self.width(), self.height()))
if 0 <= self.croping[1] <= self.height():
painter.drawLine(
QPoint(0, self.croping[1] * self.height()),
QPoint(self.width(), self.croping[1] * self.height()))
if 0 <= self.croping[2] <= self.width():
painter.drawLine(
QPoint(self.croping[2] * self.width(), 0),
QPoint(self.croping[2] * self.width(), self.height()))
if 0 <= self.croping[3] <= self.height():
painter.drawLine(
QPoint(0, self.croping[3] * self.height()),
QPoint(self.width(), self.croping[3] * self.height()))
elif isinstance(self.locating, tuple):
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QColor(255, 255, 255, 160))
painter.drawRect(0, 0, self.width(), self.height())
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
painter.setBrush(QBrush(Qt.NoBrush))
if 0 <= self.locating[0] <= self.width():
painter.drawLine(
QPoint(self.locating[0] * self.width(), 0),
QPoint(self.locating[0] * self.width(), self.height()))
if 0 <= self.locating[1] <= self.height():
painter.drawLine(
QPoint(0, self.locating[1] * self.height()),
QPoint(self.width(), self.locating[1] * self.height()))
elif self.croping or self.locating:
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QColor(255, 255, 255, 160))
painter.drawRect(0, 0, self.width(), self.height())
painter.end()
def run(self):
qp = QPainter()
qp.begin(self)
qp.setBrush(QColor(250, 218, 94))
qp.drawEllipse(r(0, 700), r(0, 500), r(10, 400), r(10, 400))
qp.end()
def clear_canvas(self):
painter = QPainter(self.pixmap())
painter.setBrush(QColor(self.backgroundcolor))
painter.drawRect(-100, -100, self.size[0] + 100, self.size[1] + 100)
painter.end()
def __init__(self, parent=None): # pylint: disable=too-many-statements
super(WatchersPanel, self).__init__(parent=parent)
self._app_window = parent
if self._app_window.dwarf is None:
print('Watcherpanel created before Dwarf exists')
return
self._uppercase_hex = True
self.setAutoFillBackground(True)
# connect to dwarf
self._app_window.dwarf.onWatcherAdded.connect(self._on_watcher_added)
self._app_window.dwarf.onWatcherRemoved.connect(
self._on_watcher_removed)
# setup our model
self._watchers_model = QStandardItemModel(0, 5)
self._watchers_model.setHeaderData(0, Qt.Horizontal, 'Address')
self._watchers_model.setHeaderData(1, Qt.Horizontal, 'R')
self._watchers_model.setHeaderData(1, Qt.Horizontal, Qt.AlignCenter,
Qt.TextAlignmentRole)
self._watchers_model.setHeaderData(2, Qt.Horizontal, 'W')
self._watchers_model.setHeaderData(2, Qt.Horizontal, Qt.AlignCenter,
Qt.TextAlignmentRole)
self._watchers_model.setHeaderData(3, Qt.Horizontal, 'X')
self._watchers_model.setHeaderData(3, Qt.Horizontal, Qt.AlignCenter,
Qt.TextAlignmentRole)
self._watchers_model.setHeaderData(4, Qt.Horizontal, 'S')
self._watchers_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._watchers_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)
icon = QIcon()
icon.addPixmap(QPixmap(utils.resource_path('assets/icons/plus.svg')))
btn1 = QPushButton(icon, '')
btn1.setFixedSize(20, 20)
btn1.clicked.connect(self._on_additem_clicked)
btn2 = QPushButton(
QIcon(QPixmap(utils.resource_path('assets/icons/dash.svg'))), '')
btn2.setFixedSize(20, 20)
btn2.clicked.connect(self.delete_items)
btn3 = QPushButton(
QIcon(QPixmap(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 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 paint(self, painter: QPainter, a, b):
"""Show particle on the screen"""
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(255, 0, 255, 255))
painter.drawEllipse(self.boundingRect())
def createArrowBackground(self, transform):
scaledRect = transform.mapRect(
QRect(0, 0, self.logicalSize.width(), self.logicalSize.height()))
image = QImage(scaledRect.width(), scaledRect.height(),
QImage.Format_ARGB32_Premultiplied)
image.fill(QColor(0, 0, 0, 0).rgba())
painter = QPainter(image)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(Qt.NoPen)
if Colors.useEightBitPalette:
painter.setPen(QColor(120, 120, 120))
if self.pressed:
painter.setBrush(QColor(60, 60, 60))
elif self.highlighted:
painter.setBrush(QColor(100, 100, 100))
else:
painter.setBrush(QColor(80, 80, 80))
else:
outlinebrush = QLinearGradient(0, 0, 0, scaledRect.height())
brush = QLinearGradient(0, 0, 0, scaledRect.height())
brush.setSpread(QLinearGradient.PadSpread)
highlight = QColor(255, 255, 255, 70)
shadow = QColor(0, 0, 0, 70)
sunken = QColor(220, 220, 220, 30)
normal1 = QColor(200, 170, 160, 50)
normal2 = QColor(50, 10, 0, 50)
if self.pressed:
outlinebrush.setColorAt(0, shadow)
outlinebrush.setColorAt(1, highlight)
brush.setColorAt(0, sunken)
painter.setPen(Qt.NoPen)
else:
outlinebrush.setColorAt(1, shadow)
outlinebrush.setColorAt(0, highlight)
brush.setColorAt(0, normal1)
if not self.highlighted:
brush.setColorAt(1, normal2)
painter.setPen(QPen(outlinebrush, 1))
painter.setBrush(brush)
painter.drawRect(0, 0, scaledRect.width(), scaledRect.height())
xOff = scaledRect.width() / 2
yOff = scaledRect.height() / 2
sizex = 3.0 * transform.m11()
sizey = 1.5 * transform.m22()
if self.type == TextButton.UP:
sizey *= -1
path = QPainterPath()
path.moveTo(xOff, yOff + (5 * sizey))
path.lineTo(xOff - (4 * sizex), yOff - (3 * sizey))
path.lineTo(xOff + (4 * sizex), yOff - (3 * sizey))
path.lineTo(xOff, yOff + (5 * sizey))
painter.drawPath(path)
return image
