def paintEvent( self, event ): """ Das automatisch ausgelöste paintEvent, das das Widget bei jeder Fensterveränderung neu zeichnet. """ if self.__maximum > 0: frameWidth = 1 separatorWidth = 1 # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß das Quadrat entsprechend kleiner sein. squareSideLength = 10 framePen = QPen( frameWidth ) framePen.setColor( self.__colorFrame ) squareSideLengthPlus = squareSideLength + 2 * frameWidth painter = QPainter( self ) windowWidth = self.width() / min( self.__maximum, self.__columnMax ) windowHeight = self.__maximum / self.__columnMax windowHeight = math.ceil( windowHeight ) windowHeight = self.height() / windowHeight side = min( windowWidth, windowHeight ) painter.setRenderHint( QPainter.Antialiasing ) # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. if ( not self.isEnabled() ): painter.setOpacity( .5 ) #painter.translate( float( windowWidth ), float( windowHeight ) ) painter.scale( side / squareSideLengthPlus, side / squareSideLengthPlus ) painter.setPen( framePen ) painter.setBrush( self.__colorEmpty ) painter.save() squareColumnIter = 0 squareLineIter = 0 squareCount = 0 for squareCount in range(self.__maximum): square = QRect( ( squareSideLength + separatorWidth ) * squareColumnIter + frameWidth * ( squareColumnIter + 1 ), ( squareSideLength + separatorWidth ) * squareLineIter + frameWidth * ( squareLineIter + 1 ), squareSideLength, squareSideLength ) painter.drawRect( square ) # Wir zeichnen die ausgekreuzten Quadrate if (self.__value > (self.__columnMax * squareLineIter + squareColumnIter)): painter.drawLine(square.bottomLeft(), square.topRight()) painter.drawLine(square.topLeft(), square.bottomRight()) squareColumnIter += 1 if ( squareColumnIter >= self.__columnMax ): squareColumnIter = 0 squareLineIter += 1 painter.restore()
def pixmapFromSvg(self, pmapSize=None, withBorders=None): """returns a pixmap with default size as given in SVG and optional borders/shadows""" if withBorders is None: withBorders = Preferences.showShadows if withBorders: wantSize = self.tileset.tileSize.toSize() else: wantSize = self.tileset.faceSize.toSize() if not pmapSize: pmapSize = wantSize result = QPixmap(pmapSize) result.fill(Qt.transparent) painter = QPainter(result) if not painter.isActive(): logException('painter is not active. Wanted size: %s' % str(pmapSize)) try: xScale = float(pmapSize.width()) / wantSize.width() yScale = float(pmapSize.height()) / wantSize.height() except ZeroDivisionError: xScale = 1 yScale = 1 if not withBorders: painter.scale(*self.tileset.tileFaceRelation()) painter.translate(-self.facePos()) renderer = self.tileset.renderer() renderer.render(painter, self.elementId()) painter.resetTransform() self._drawDarkness(painter) if self.showFace(): faceSize = self.tileset.faceSize.toSize() faceSize = QSize(faceSize.width() * xScale, faceSize.height() * yScale) painter.translate(self.facePos()) renderer.render(painter, self.tileset.svgName[self.tile.element.lower()], QRectF(QPointF(), QSizeF(faceSize))) return result
def paintEvent(event): painter = QPainter(self.label_image) painter.setRenderHint(QPainter.SmoothPixmapTransform, True) w = self.label_image.size().width() h = self.label_image.size().height() painter.scale(w / 80.0, h / 60.0) painter.drawImage(0, 0, self.image) if 35 != None and 45 != None: pen = QPen() pen.setColor(Qt.white) pen.setWidth(0.2) painter.setPen(pen) from_x, from_y, to_x, to_y = [35, 25, 45, 35] from_x = from_x * self.image_pixel_width + 1 from_y = from_y * self.image_pixel_width + 1 to_x = to_x * self.image_pixel_width + 1 to_y = to_y * self.image_pixel_width + 1 cross_x = from_x + (to_x - from_x) / 2.0 cross_y = from_y + (to_y - from_y) / 2.0 if to_x - from_x > 5 or to_y - from_y > 5: lines = [ QLine(from_x, from_y, from_x + self.crosshair_width, from_y), QLine(from_x, from_y, from_x, from_y + self.crosshair_width), QLine(to_x, to_y, to_x, to_y - self.crosshair_width), QLine(to_x, to_y, to_x - self.crosshair_width, to_y), QLine(from_x, to_y, from_x, to_y - self.crosshair_width), QLine(from_x, to_y, from_x + self.crosshair_width, to_y), QLine(to_x, from_y, to_x, from_y + self.crosshair_width), QLine(to_x, from_y, to_x - self.crosshair_width, from_y) ] painter.drawLines(lines) lines = [ QLine(cross_x - self.crosshair_width, cross_y, cross_x + self.crosshair_width, cross_y), QLine(cross_x, cross_y - self.crosshair_width, cross_x, cross_y + self.crosshair_width) ] painter.drawLines(lines) self.update_spotmeter_roi_label()
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) painter.setBrush(QBrush(QColor(192, 192, 255))) painter.drawRect(event.rect()) painter.translate(self.width()/2.0, self.height()/2.0) painter.scale(self.width()*0.75/100.0, self.height()*0.75/100.0) painter.setBrush(QBrush(self.gradient)) painter.drawPath(self.path) painter.end()
def paintEvent(self, e): time = QTime.currentTime() qp = QPainter() qp.begin(self) #qp.setRenderHint(QPainter.Antialiasing) # 开启这个抗锯齿,会很占cpu的! qp.translate(self.width() / 2, self.height() / 2) qp.scale(self.side / 200.0, self.side / 200.0) qp.setPen(QtCore.Qt.NoPen) qp.setBrush(self.hourColor) qp.save() qp.rotate(30.0 * ((time.hour() + time.minute() / 60.0))) qp.drawConvexPolygon(self.hourHand) qp.restore() qp.setPen(self.hourColor) for i in range(12): qp.drawLine(88, 0, 96, 0) qp.rotate(30.0) qp.setPen(QtCore.Qt.NoPen) qp.setBrush(self.minuteColor) qp.save() qp.rotate(6.0 * ((time.minute() + (time.second() + time.msec() / 1000.0) / 60.0))) qp.drawConvexPolygon(self.minuteHand) qp.restore() qp.setPen(self.minuteColor) for i in range(60): if (i % 5) is not 0: qp.drawLine(92, 0, 96, 0) qp.rotate(6.0) qp.setPen(QtCore.Qt.NoPen) qp.setBrush(self.secondColor) qp.save() qp.rotate(6.0 * (time.second() + time.msec() / 1000.0)) qp.drawConvexPolygon(self.secondHand) qp.restore() qp.end()
def paintEvent(self, event): realSize = min(self.width(), self.height()) painter = QPainter() painter.begin(self) pen = QPen(Qt.black) pen.setWidth(1) painter.setPen(Qt.black) painter.setRenderHint(QPainter.Antialiasing) painter.translate(self.width() / 2, self.height() / 2) painter.scale( float(realSize) / self.scaledSize, float(realSize) / self.scaledSize) gradient = QRadialGradient(QPointF(-500, -500), 1500, QPointF(-500, -500)) gradient.setColorAt(0, QColor(224, 224, 224)) gradient.setColorAt(1, QColor(28, 28, 28)) painter.setPen(pen) painter.setBrush(QBrush(gradient)) painter.drawEllipse(QPointF(0, 0), 500, 500) gradient = QRadialGradient(QPointF(500, 500), 1500, QPointF(500, 500)) gradient.setColorAt(0, QColor(224, 224, 224)) gradient.setColorAt(1, QColor(28, 28, 28)) painter.setPen(pen) painter.setBrush(QBrush(gradient)) painter.drawEllipse(QPointF(0, 0), 450, 450) painter.setPen(pen) if (self.isChecked()): gradient = QRadialGradient(QPointF(-500, -500), 1500, QPointF(-500, -500)) gradient.setColorAt(0, self._onColor1) gradient.setColorAt(1, self._onColor2) else: gradient = QRadialGradient(QPointF(500, 500), 1500, QPointF(500, 500)) gradient.setColorAt(0, self._offColor1) gradient.setColorAt(1, self._offColor2) painter.setBrush(gradient) painter.drawEllipse(QPointF(0, 0), 400, 400) painter.end()
def paintEvent(self, e): time = QTime.currentTime() qp = QPainter() qp.begin(self) #qp.setRenderHint(QPainter.Antialiasing) # 开启这个抗锯齿,会很占cpu的! qp.translate(self.width() / 2, self.height() / 2) qp.scale(self.side / 200.0, self.side / 200.0) qp.setPen(QtCore.Qt.NoPen) qp.setBrush(self.hourColor) qp.save() qp.rotate(30.0 * ((time.hour() + time.minute()/ 60.0))) qp.drawConvexPolygon(self.hourHand) qp.restore() qp.setPen(self.hourColor) for i in range(12): qp.drawLine(88, 0, 96, 0) qp.rotate(30.0) qp.setPen(QtCore.Qt.NoPen) qp.setBrush(self.minuteColor) qp.save() qp.rotate(6.0 * ((time.minute() + (time.second()+time.msec()/1000.0) / 60.0))) qp.drawConvexPolygon(self.minuteHand) qp.restore() qp.setPen(self.minuteColor) for i in range(60): if (i % 5) is not 0: qp.drawLine(92, 0, 96, 0) qp.rotate(6.0) qp.setPen(QtCore.Qt.NoPen) qp.setBrush(self.secondColor) qp.save() qp.rotate(6.0*(time.second()+time.msec()/1000.0)) qp.drawConvexPolygon(self.secondHand) qp.restore() qp.end()
def paintEvent(self, event): if not self.image: return p = QPainter(self) ers, sorig = event.rect().size(), self.image.size() img_scaled = self.image.scaled(ers, Qt.KeepAspectRatio) p.drawImage(QPoint(0, 0), img_scaled) p.setRenderHint(QPainter.Antialiasing) p.setPen(Qt.green) p.drawText(10, 20, self.fullpath) p.drawText(10, 40, '#annotations: {}'.format(len(self.polylines))) sx = float(img_scaled.size().width()) / sorig.width() sy = float(img_scaled.size().height()) / sorig.height() p.scale(sx, sy) p.setPen(Qt.yellow) for polyline in self.polylines: self._draw_polyline(p, polyline)
def genWINDPIXMAPS(): """prepare wind tiles""" tileset = Tileset(Preferences.windTilesetName) for wind in WINDS: for prevailing in False, True: pwind = PlayerWind(wind, tileset, prevailing) pMap = QPixmap(40, 40) pMap.fill(Qt.transparent) painter = QPainter(pMap) painter.setRenderHint(QPainter.Antialiasing) painter.scale(0.40, 0.40) pwind.paint(painter, QStyleOptionGraphicsItem()) for child in pwind.childItems(): if isinstance(child, QGraphicsSvgItem): painter.save() painter.translate(child.mapToParent(0.0, 0.0)) child.paint(painter, QStyleOptionGraphicsItem()) painter.restore() WINDPIXMAPS[(wind, prevailing)] = pMap
def genWINDPIXMAPS(): """prepare wind tiles""" tileset = Tileset(common.PREF.windTilesetName) for wind in WINDS: for prevailing in False, True: pwind = PlayerWind(wind, tileset, prevailing) pMap = QPixmap(40, 40) pMap.fill(Qt.transparent) painter = QPainter(pMap) painter.setRenderHint(QPainter.Antialiasing) painter.scale(0.40, 0.40) pwind.paint(painter, QStyleOptionGraphicsItem()) for child in pwind.childItems(): if isinstance(child, QGraphicsSvgItem): painter.save() painter.translate(child.mapToParent(0.0, 0.0)) child.paint(painter, QStyleOptionGraphicsItem()) painter.restore() WINDPIXMAPS[(wind, prevailing)] = pMap
def printout(self): # Page width, page height, widget width pw = self._printer.pageRect().width() ph = self._printer.pageRect().height() ww = self._ComparingProfile.width() painter = QPainter(self._printer) scale = (ww / pw) * 1.5 painter.scale(scale, scale) self._ReactionsWindow.currentWidget().render(painter) painter.translate(0, ph/2) self._ComparingProfile.render(painter) painter.translate(pw * 0.6, -ph/2) painter.scale(0.8, 0.8) self._ReactionsWindow.currentWidget().PrintGraph(painter, "Concentration") painter.translate(0, ph*0.25) self._ReactionsWindow.currentWidget().PrintGraph(painter, "Rate") painter.translate(0, ph * 0.4) self._ComparingProfile.PrintGraph(painter, "Concentration") painter.translate(0, ph * 0.25) self._ComparingProfile.PrintGraph(painter, "Rate") painter.end()
def paintEvent(self,event): realSize=min(self.width(),self.height()) painter=QPainter() painter.begin(self) pen=QPen(Qt.black) pen.setWidth(1) painter.setPen(Qt.black) painter.setRenderHint(QPainter.Antialiasing) painter.translate(self.width()/2,self.height()/2) painter.scale(float(realSize)/self.scaledSize, float(realSize)/self.scaledSize) gradient = QRadialGradient (QPointF(-500,-500), 1500, QPointF(-500,-500)); gradient.setColorAt(0, QColor(224,224,224)); gradient.setColorAt(1, QColor(28,28,28)); painter.setPen(pen); painter.setBrush(QBrush(gradient)); painter.drawEllipse(QPointF(0,0), 500, 500); gradient = QRadialGradient (QPointF(500,500), 1500, QPointF(500,500)); gradient.setColorAt(0, QColor(224,224,224)); gradient.setColorAt(1, QColor(28,28,28)); painter.setPen(pen); painter.setBrush(QBrush(gradient)); painter.drawEllipse(QPointF(0,0), 450, 450); painter.setPen(pen); if(self.isChecked()): gradient = QRadialGradient (QPointF(-500,-500), 1500, QPointF(-500,-500)); gradient.setColorAt(0, self._onColor1); gradient.setColorAt(1, self._onColor2); else: gradient = QRadialGradient (QPointF(500,500), 1500, QPointF(500,500)); gradient.setColorAt(0, self._offColor1); gradient.setColorAt(1, self._offColor2); painter.setBrush(gradient); painter.drawEllipse(QPointF(0,0), 400, 400); painter.end()
def printout(self): # Page width, page height, widget width pw = self._printer.pageRect().width() ph = self._printer.pageRect().height() ww = self._ComparingProfile.width() painter = QPainter(self._printer) scale = (ww / pw) * 1.5 painter.scale(scale, scale) self._ReactionsWindow.currentWidget().render(painter) painter.translate(0, ph / 2) self._ComparingProfile.render(painter) painter.translate(pw * 0.6, -ph / 2) painter.scale(0.8, 0.8) self._ReactionsWindow.currentWidget().PrintGraph( painter, "Concentration") painter.translate(0, ph * 0.25) self._ReactionsWindow.currentWidget().PrintGraph(painter, "Rate") painter.translate(0, ph * 0.4) self._ComparingProfile.PrintGraph(painter, "Concentration") painter.translate(0, ph * 0.25) self._ComparingProfile.PrintGraph(painter, "Rate") painter.end()
def paintEvent( self, event ): # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. frameWidth = 16 dotCenter = QPoint( 0, 0 ) color = self.__colorEmpty if self.__value: color = self.__colorFull # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß der Kreis entsprechend kleiner sein. dotRadius = 100 framePen = QPen( frameWidth ) framePen.setColor( self.__colorFrame ) dotDiameter = 2 * dotRadius + frameWidth painter = QPainter( self ) windowWidth = self.width() windowHeight = float( self.height() ) side = min( windowWidth, windowHeight ) painter.setRenderHint( QPainter.Antialiasing ) if ( not self.isEnabled() ): painter.setOpacity( .5 ) painter.translate( side / 2, self.height() / 2 ) painter.scale( side / dotDiameter, side / dotDiameter ) painter.setPen( framePen ) painter.setBrush( color ) painter.save() painter.drawEllipse( dotCenter, dotRadius, dotRadius ) painter.restore()
def paintEvent(self, event): if self._isRunning: anglestep = 360. / self._steps fillsteps = self._fillsteps factor = min(self.width(), self.height()) / 16. bw = self._bw p = QPainter(self) p.setRenderHint(QPainter.Antialiasing, True) p.scale(factor, factor) p.setPen(Qt.NoPen) for i in range(self._steps): x1, y1 = self._coords[i] c = fillsteps[self._steps - 1 - i] a = anglestep * i p.setBrush(QBrush(QColor.fromRgbF(bw, bw, bw, c))) p.save() p.translate(x1 - 2, y1 - 1) p.translate(2, 1) p.rotate(a) p.translate(-2, -1) p.drawPath(self._path) p.restore()
class Meter(QtGui.QWidget): """ a PyQt instance of QtMeter from Qt example code """ def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.value = 0 self.minValue = 0 self.maxValue = 100 self.logo = "" self.scaleMajor = 10 self.scaleMijor = 10 self.startAngle = 60 self.endAngle = 60 self.crownColor = Qt.blue self.foreground = Qt.green self.background = Qt.black self.timer = QTimer() self.timer.timeout.connect(self.update) self.timer.start(200) self.resize(200, 200) def updateValue(self): pass def paintEvent(self, QPaintEvent): self.updateValue() self.side = min(self.width(), self.height()) self.painter = QPainter() self.painter.begin(self) #self.painter.setRenderHint(QPainter.Antialiasing) self.painter.translate(self.width() / 2, self.height() / 2) self.painter.scale(self.side / 200.0, self.side / 200.0) self.painter.setPen(Qt.NoPen) self.drawCrown() self.drawBackgroud() self.drawLogo() self.drawScale() self.drawScaleNum() self.drawNumbericValue() self.drawPointer() self.painter.end() def setValue(self, updatefun): self.value = updatefun() def setLogo(self, logo): self.logo = logo def drawCrown(self): self.painter.save() self.painter.setPen(QtGui.QPen(self.crownColor, 3)) self.painter.drawEllipse(-92, -92, 184, 184) self.painter.restore() def drawBackgroud(self): self.painter.save() self.painter.setBrush(self.background) self.painter.drawEllipse(-92, -92, 184, 184) self.painter.restore() def drawScale(self): self.painter.save() self.painter.rotate(self.startAngle) self.painter.setPen(self.foreground) steps = self.scaleMajor * self.scaleMijor angleStep = (360.0 - self.startAngle - self.endAngle) / steps pen = QtGui.QPen(self.painter.pen()) for i in xrange(steps + 1): if i % self.scaleMajor == 0: pen.setWidth(1) self.painter.setPen(pen) self.painter.drawLine(0, 62, 0, 72) else: pen.setWidth(0) self.painter.setPen(pen) self.painter.drawLine(0, 62, 0, 65) self.painter.rotate(angleStep) self.painter.restore() def drawScaleNum(self): self.painter.save() self.painter.setPen(self.foreground) startRad = (360 - self.startAngle - 90) * (3.14 / 180) deltaRad = (360 - self.startAngle - self.endAngle) * (3.14 / 180) / self.scaleMajor fm = QtGui.QFontMetricsF(self.font()) for i in xrange(self.scaleMajor + 1): sina = sin(startRad - i * deltaRad) cosa = cos(startRad - i * deltaRad) tmpVal = 1.0 * i * ((self.maxValue - self.minValue) / self.scaleMajor) + self.minValue numstr = QString("%1").arg(tmpVal) w = fm.size(Qt.TextSingleLine, numstr).width() h = fm.size(Qt.TextSingleLine, numstr).height() x = 82 * cosa - w / 2 y = -82 * sina + h / 4 self.painter.drawText(x, y, numstr) self.painter.restore() def drawLogo(self): self.painter.save() self.painter.setPen(self.foreground) self.painter.setBrush(self.foreground) logostr = QString(self.logo) fm = QtGui.QFontMetricsF(self.font()) w = fm.size(Qt.TextSingleLine, logostr).width() self.painter.drawText(-w / 2, -30, logostr) self.painter.restore() def drawNumbericValue(self): self.painter.save() color = QtGui.QColor(150, 150, 200) pen = self.painter.pen() pen.setWidth(3) self.painter.setPen(pen) self.painter.setPen(color) self.painter.drawRect(-30, 30, 60, 14) cpustr = QString("%1").arg(self.value) fm = QtGui.QFontMetricsF(self.font()) w = fm.size(Qt.TextSingleLine, cpustr).width() self.painter.setPen(self.foreground) self.painter.drawText(-w / 2, 42, cpustr) self.painter.restore() def drawPointer(self): self.painter.save() self.pointerHand = QPolygon([-2, 0, 2, 0, 0, 60]) self.pointerColor = QColor(127, 0, 127) self.painter.setBrush(self.pointerColor) self.painter.rotate(self.startAngle) degRotate = (360.0 - self.startAngle - self.endAngle) / ( self.maxValue - self.minValue) * (self.value - self.minValue) self.painter.rotate(degRotate) self.painter.drawConvexPolygon(self.pointerHand) self.painter.restore()
def getLegendGraphic(self, params): qgsLayer = self.layerRegistry.mapLayer(params.get('layer')) boxSpace = 1 layerSpace = 2 # layerTitleSpace = 3 symbolSpace = 2 iconLabelSpace = 2 symbolWidth = 5 symbolHeight = 3 drawLegendLabel = True rootGroup = QgsLayerTreeGroup() rootGroup.addLayer(qgsLayer) # layer = QgsLayerTreeLayer(qgsLayer) # if qgsLayer.title(): # layer.setLayerName(qgsLayer.title()) legendModel = QgsLayerTreeModel(rootGroup) rootChildren = rootGroup.children() img_tmp = QImage(QSize(1, 1), QImage.Format_ARGB32_Premultiplied) dpm = 1 / 0.00028 img_tmp.setDotsPerMeterX(dpm) img_tmp.setDotsPerMeterY(dpm) dpmm = img_tmp.dotsPerMeterX() / 1000.0 del img_tmp legendSettings = QgsLegendSettings() legendSettings.setTitle('') legendSettings.setBoxSpace(boxSpace) legendSettings.rstyle(QgsComposerLegendStyle.Subgroup).setMargin(QgsComposerLegendStyle.Top, layerSpace) legendSettings.rstyle(QgsComposerLegendStyle.Symbol).setMargin(QgsComposerLegendStyle.Top, symbolSpace) legendSettings.rstyle(QgsComposerLegendStyle.SymbolLabel).setMargin(QgsComposerLegendStyle.Left, iconLabelSpace) legendSettings.setSymbolSize(QSizeF(symbolWidth, symbolHeight)) # legendSettings.rstyle(QgsComposerLegendStyle.Subgroup).setFont(layerFont) # legendSettings.rstyle(QgsComposerLegendStyle.SymbolLabel).setFont(itemFont) # // TODO: not available: layer font color # legendSettings.setFontColor( itemFontColor ); # for node in rootChildren: # if (QgsLayerTree.isLayer(node)): # QgsLegendRenderer.setNodeLegendStyle(node, QgsComposerLegendStyle.Subgroup) # # rule item titles # # if ( !mDrawLegendItemLabel ) # # for legendNode in legendModel.layerLegendNodes(nodeLayer): # # legendNode.setUserLabel(' ') # # } legendRenderer = QgsLegendRenderer(legendModel, legendSettings) minSize = legendRenderer.minimumSize() s = QSize(minSize.width() * dpmm, minSize.height() * dpmm) img = QImage(s, QImage.Format_ARGB32_Premultiplied) # fill in the background color = QColor(0, 0, 0, 0) img.fill(color) p = QPainter() p.begin(img) p.setRenderHint(QPainter.Antialiasing, True) p.scale(dpmm, dpmm) legendRenderer.drawLegend(p) map_buffer = QBuffer() map_buffer.open(QIODevice.ReadWrite) img.save(map_buffer, 'PNG') # clean up map_buffer.close() p.end() # self.layerRegistry.removeAllMapLayers() return map_buffer.data()
class Meter(QtGui.QWidget): """ a PyQt instance of QtMeter from Qt example code """ def __init__(self,parent=None): QtGui.QWidget.__init__(self,parent) self.value = 0 self.minValue = 0 self.maxValue = 100 self.logo = "" self.scaleMajor = 10 self.scaleMijor = 10 self.startAngle = 60 self.endAngle = 60 self.crownColor = Qt.blue self.foreground = Qt.green self.background = Qt.black self.timer = QTimer() self.timer.timeout.connect(self.update) self.timer.start(200) self.resize(200,200) def updateValue(self): pass def paintEvent(self,QPaintEvent): self.updateValue() self.side = min(self.width(),self.height()) self.painter = QPainter() self.painter.begin(self) #self.painter.setRenderHint(QPainter.Antialiasing) self.painter.translate(self.width()/2,self.height()/2) self.painter.scale(self.side / 200.0, self.side / 200.0) self.painter.setPen(Qt.NoPen) self.drawCrown() self.drawBackgroud() self.drawLogo() self.drawScale() self.drawScaleNum() self.drawNumbericValue() self.drawPointer() self.painter.end() def setValue(self,updatefun): self.value = updatefun() def setLogo(self,logo): self.logo = logo def drawCrown(self): self.painter.save() self.painter.setPen(QtGui.QPen(self.crownColor, 3)) self.painter.drawEllipse(-92, -92, 184, 184) self.painter.restore() def drawBackgroud(self): self.painter.save() self.painter.setBrush(self.background) self.painter.drawEllipse(-92, -92, 184, 184) self.painter.restore() def drawScale(self): self.painter.save() self.painter.rotate(self.startAngle) self.painter.setPen(self.foreground) steps = self.scaleMajor * self.scaleMijor angleStep = (360.0 - self.startAngle - self.endAngle) /steps pen = QtGui.QPen(self.painter.pen()) for i in xrange(steps+1): if i % self.scaleMajor == 0: pen.setWidth(1) self.painter.setPen(pen) self.painter.drawLine(0, 62, 0, 72) else: pen.setWidth(0) self.painter.setPen(pen) self.painter.drawLine(0, 62, 0, 65) self.painter.rotate(angleStep) self.painter.restore() def drawScaleNum(self): self.painter.save() self.painter.setPen(self.foreground) startRad = (360 - self.startAngle - 90) * (3.14 / 180) deltaRad = (360 - self.startAngle - self.endAngle) * (3.14 / 180) / self.scaleMajor fm = QtGui.QFontMetricsF(self.font()) for i in xrange(self.scaleMajor+1): sina = sin(startRad - i * deltaRad) cosa = cos(startRad - i * deltaRad) tmpVal = 1.0 * i *((self.maxValue - self.minValue) / self.scaleMajor) + self.minValue numstr = QString( "%1" ).arg(tmpVal) w = fm.size(Qt.TextSingleLine,numstr).width() h = fm.size(Qt.TextSingleLine,numstr).height() x = 82 * cosa - w / 2 y = -82 * sina + h / 4 self.painter.drawText(x, y, numstr) self.painter.restore() def drawLogo(self): self.painter.save() self.painter.setPen(self.foreground) self.painter.setBrush(self.foreground) logostr = QString(self.logo) fm = QtGui.QFontMetricsF(self.font()) w = fm.size(Qt.TextSingleLine,logostr).width() self.painter.drawText(-w / 2, -30, logostr) self.painter.restore() def drawNumbericValue(self): self.painter.save() color = QtGui.QColor(150, 150, 200) pen = self.painter.pen() pen.setWidth(3) self.painter.setPen(pen) self.painter.setPen(color) self.painter.drawRect(-30, 30, 60, 14) cpustr = QString("%1").arg(self.value) fm = QtGui.QFontMetricsF(self.font()) w = fm.size(Qt.TextSingleLine,cpustr).width() self.painter.setPen(self.foreground) self.painter.drawText(-w / 2, 42, cpustr) self.painter.restore() def drawPointer(self): self.painter.save() self.pointerHand=QPolygon([-2,0, 2,0, 0,60]) self.pointerColor = QColor(127 , 0, 127) self.painter.setBrush(self.pointerColor) self.painter.rotate(self.startAngle) degRotate = (360.0 - self.startAngle - self.endAngle)/(self.maxValue - self.minValue)*(self.value - self.minValue) self.painter.rotate(degRotate) self.painter.drawConvexPolygon(self.pointerHand) self.painter.restore()
class QtRenderer(Renderer): def __init__(self, pd): """Creates a new renderer based on a QPaintDevice pd """ self._defpose = Pose() # The pose in the bottom-left corner self._zoom = 1 # The zooming factor self._zoom_c = False # Whether the scaling is done from center Renderer.__init__(self, (pd.width(), pd.height()), pd) def set_canvas(self, canvas): """Tell the renderer to draw on canvas The type of canvas is implementation-dependent """ 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()) self.set_pen(None) # push the default state self._painter.save() self._painter.save() def set_zoom(self, zoom_level): self._zoom = float(zoom_level) self.__update_default_state() def __update_default_state(self): self._painter.restore() # Reset state self._painter.restore() # Set zoom to 1 self._painter.save() # Re-save the zoom-1 if self._zoom_c: self._painter.translate(self.size[0]/2,self.size[1]/2) self._painter.scale(self._zoom,self._zoom) self._painter.rotate(degrees(-self._defpose.theta)) self._painter.translate(-self._defpose.x, -self._defpose.y) self._painter.save() # Save the zoomed state self.clear_screen() def __set_scr_pose(self,pose): self._defpose = pose self.__update_default_state() self.clear_screen() def set_screen_pose(self, pose): self._zoom_c = False self.__set_scr_pose(pose) def set_screen_center_pose(self, pose): self._zoom_c = True self.__set_scr_pose(pose) def clear_screen(self): 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() def __delete__(self): self._painter.restore() self._painter.restore() def reset_pose(self): """Resets the renderer to world coordinates """ self._painter.restore() self._painter.save() def add_pose(self,pose): """Add a pose transformation to the current transformation """ self._painter.translate(pose.x,pose.y) self._painter.rotate(degrees(pose.theta)) @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): """Sets the line color. Color is interpreted as 0xAARRGGBB. """ if color is None: self._painter.setPen(Qt.NoPen) else: self._painter.setPen(self.__qcolor(color)) 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, x, y, w, h): """Draws an ellipse. """ self._painter.drawEllipse(x,y,w,h) def draw_rectangle(self, x, y, w, h): """Draws a rectangle. """ self._painter.drawRect(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) """ pass
def drawImage(self, imageid): cache = image_cache.cache cellColoring = self.cellColoring wallColoring = self.wallColoring pointColoring = self.pointColoring ellipsisDraw = self.ellipsisDraw overSampling = self.overSampling extraDrawing = self.extraDrawing bgColor = self.bgColor.rgb() result = self.result if self.result_type == "Data": data = result img_name = result.images_name[imageid] else: data = result.data img_name = result.images[imageid] #scale = data.images_scale[img_name] min_scale = data.minScale() img = cache.image(data.image_path(img_name)) img_data = data[img_name] size = self._crop.size() pix = QImage(size * overSampling, QImage.Format_ARGB32) pix.fill(bgColor) painter = QPainter() if not painter.begin(pix): self.abort("Cannot create painter on QImage") return None, None, None painter.setRenderHints(QPainter.SmoothPixmapTransform, True) painter.setRenderHints(QPainter.Antialiasing, True) if overSampling > 1: painter.scale(overSampling, overSampling) painter.translate(-self._crop.topLeft()) painter.save() painter.translate(self.translate) log_debug("Translating: %gx%g" % (self.translate.x(), self.translate.y())) painter.scale(1 / min_scale, 1 / min_scale) painter.save() matrix = img_data.matrix() painter.setWorldTransform(matrix, True) painter.drawImage(QPoint(0, 0), img) painter.restore() #pt_matrix = QTransform() #pt_matrix.scale(1/min_scale, 1/min_scale) #painter.setTransform(pt_matrix, True) cellColoring.startImage(painter, imageid) wallColoring.startImage(painter, imageid) for ed in extraDrawing: ed.startImage(painter, imageid) if self.result_type == "Growth": cells = result.cells[imageid] walls = result.walls[imageid] else: cells = img_data.cells walls = set() for cid in img_data.cells: pts = [pt for pt in data.cells[cid] if pt in img_data] if len(pts) > 1: for i in range(len(pts)): walls.add(data.wallId(pts[i - 1], pts[i])) # Now, draw the cells and the ellipsis for cid in cells: painter.setPen(Qt.NoPen) color = cellColoring(imageid, cid) painter.setBrush(color) pts = data.cellAtTime(cid, img_data.index) if pts: pts.append(pts[0]) ppts = [] for p1, p2 in zip(pts[:-1], pts[1:]): ppts.append(img_data[p1]) ppts.extend(img_data.walls[p1, p2]) ppts.append(ppts[0]) poly = QPolygonF(ppts) painter.drawPolygon(poly) # And draw the walls wallThickness = self.wallThickness * min_scale for wid in walls: color = wallColoring(imageid, wid) if color.alpha() > 0: pen = QPen(color) pen.setWidthF(wallThickness) painter.setPen(pen) pts = [img_data[wid[0]] ] + img_data.walls[wid[0], wid[1]] + [img_data[wid[1]]] #painter.drawLine(img_data[wid[0]], img_data[wid[1]]) painter.drawPolyline(*pts) # Then, draw the points pointSize = self.pointSize * min_scale pointLineColor = self.pointLineColor pointLineThickness = self.pointLineThickness * min_scale log_debug("pointSize = %g" % pointSize) for pid in img_data: color = pointColoring(imageid, pid) if color.alpha() > 0: pen = QPen(pointLineColor) pen.setWidthF(pointLineThickness) brush = QBrush(color) painter.setPen(pen) painter.setBrush(brush) pos = img_data[pid] rect = QRectF(pos.x() - pointSize, pos.y() - pointSize, 2 * pointSize, 2 * pointSize) painter.drawEllipse(rect) if ellipsisDraw.plot: for cid in cells: pts = data.cellAtTime(cid, img_data.index) if pts: pts.append(pts[0]) ppts = [] for p1, p2 in zip(pts[:-1], pts[1:]): ppts.append(img_data[p1]) ppts.extend(img_data.walls[p1, p2]) ppts.append(ppts[0]) #poly = QPolygonF(ppts) #painter.drawPolygon(poly) ellipsisDraw(painter, imageid, cid, ppts, min_scale) # At last, draw the extra data for ed in extraDrawing: ed(painter, imageid) tr = painter.worldTransform() painter.restore() pic_w = wallColoring.finalizeImage(painter, imageid, tr, self.crop) pic_c = cellColoring.finalizeImage(painter, imageid, tr, self.crop) for ed in extraDrawing: ed.finalizeImage(painter, imageid, tr, self.crop) painter.end() return pix, pic_w, pic_c
def writePrintFiles(self, appdef, folder, app, progress): progress.setText("Writing print layout files") progress.setProgress(0) printFolder = os.path.join(folder, "resources", "print") if not QDir(printFolder).exists(): QDir().mkpath(printFolder) dpis = [72, 150, 300] layoutDefs = [] def getBasicInfo(item): coords = {} pos = item.pos() coords["x"] = pos.x() coords["y"] = pos.y() rect = item.rect() coords["width"] = rect.width() coords["height"] = rect.height() coords["id"] = str(uuid.uuid4()) return coords composers = iface.activeComposers() for i, composer in enumerate(composers): name = composer.composerWindow().windowTitle() layoutSafeName = safeName(name) layoutDef = {} composition = composer.composition() img = composition.printPageAsRaster(0) img = img.scaledToHeight(100, Qt.SmoothTransformation) img.save(os.path.join(printFolder, "%s_thumbnail.png" % layoutSafeName)) layoutDef["width"] = composition.paperWidth() layoutDef["height"] = composition.paperHeight() elements = [] layoutDef["thumbnail"] = "%s_thumbnail.png" % layoutSafeName layoutDef["name"] = name layoutDef["elements"] = elements for item in composition.items(): element = None if isinstance(item, (QgsComposerLegend, QgsComposerShape, QgsComposerScaleBar, QgsComposerArrow)): element = getBasicInfo(item) for dpi in dpis: dpmm = dpi / 25.4 s = QSize(item.rect().width() * dpmm, item.rect().height() * dpmm) img = QImage(s, QImage.Format_ARGB32_Premultiplied) img.fill(Qt.transparent) painter = QPainter(img) painter.scale(dpmm, dpmm) item.paint(painter, None, None) painter.end() img.save(os.path.join(printFolder, "%s_%s_%s.png" % (layoutSafeName, element["id"], str(dpi)))) elif isinstance(item, QgsComposerLabel): element = getBasicInfo(item) element["name"] = item.text() element["size"] = item.font().pointSize() element["font"] = item.font().rawName() elif isinstance(item, QgsComposerMap): element = getBasicInfo(item) grid = item.grid() if grid is not None: element["grid"] = {} element["grid"]["intervalX"] = grid.intervalX() element["grid"]["intervalY"] = grid.intervalY() element["grid"]["crs"] = grid.crs().authid() element["grid"]["annotationEnabled"] = grid.annotationEnabled() elif isinstance(item, QgsComposerPicture): filename = os.path.basename(item.picturePath()) if os.path.exists(filename): element = getBasicInfo(item) shutil.copy(item.pictureFile(), os.path.join(printFolder, filename)) element["file"] = filename if element is not None: element["type"] = item.__class__.__name__[11:].lower() elements.append(element) layoutDefs.append(layoutDef) progress.setProgress(int((i+1)*100.0/len(composers))) app.variables.append("var printLayouts = %s;" % json.dumps(layoutDefs))
def paintEvent(self, event): painter = QPainter(self) width = self.width() height = self.height() if self.scales_visible: curve_width = width - self.y_scale.total_width - self.curve_to_scale - self.curve_outer_border curve_height = height - self.y_scale_height_offset - self.x_scale.total_height - self.curve_to_scale else: curve_width = width - self.curve_outer_border - self.curve_outer_border curve_height = height - self.curve_outer_border - self.curve_outer_border if DEBUG: painter.fillRect(0, 0, width, height, Qt.green) # fill canvas if self.scales_visible: canvas_x = self.y_scale.total_width + self.curve_to_scale - self.curve_outer_border canvas_y = self.y_scale_height_offset - self.curve_outer_border else: canvas_x = 0 canvas_y = 0 canvas_width = self.curve_outer_border + curve_width + self.curve_outer_border canvas_height = self.curve_outer_border + curve_height + self.curve_outer_border painter.fillRect(canvas_x, canvas_y, canvas_width, canvas_height, self.canvas_color) # draw cross hair at cursor position if self.cross_hair_visible: p = self.mapFromGlobal(QCursor.pos()) p_x = p.x() p_y = p.y() if p_x >= canvas_x and p_x < canvas_x + canvas_width and \ p_y >= canvas_y and p_y < canvas_y + canvas_height: painter.setPen(QPen(QColor(190, 190, 190), 1, Qt.DashLine)) painter.drawLine(canvas_x, p_y, canvas_x + canvas_width - 1, p_y) painter.drawLine(p_x, canvas_y, p_x, canvas_y + canvas_height - 1) # draw canvas border if self.curve_outer_border > 0: painter.setPen(QColor(190, 190, 190)) painter.drawRect(canvas_x, canvas_y, canvas_width - 1, canvas_height - 1) # -1 to accommodate the 1px width of the border painter.setPen(Qt.black) if DEBUG: painter.fillRect(canvas_x + self.curve_outer_border, canvas_y + self.curve_outer_border, curve_width, curve_height, Qt.cyan) # draw scales y_min_scale = self.y_scale.value_min y_max_scale = self.y_scale.value_max factor_x = float(curve_width) / self.history_length_x factor_y = float(curve_height - 1) / max(y_max_scale - y_min_scale, EPSILON) # -1 to accommodate the 1px width of the curve if self.scales_visible: self.draw_x_scale(painter, factor_x) self.draw_y_scale(painter, curve_height, factor_y) # draw curves if self.x_min != None and self.x_max != None: x_min = self.x_min x_max = self.x_max if self.scales_visible: curve_x_offset = 0 else: curve_x_offset = round((self.history_length_x - (x_max - x_min)) * factor_x) painter.save() painter.translate(canvas_x + self.curve_outer_border + curve_x_offset, canvas_y + self.curve_outer_border + curve_height - 1 + self.curve_y_offset) # -1 to accommodate the 1px width of the curve painter.scale(factor_x, -factor_y) painter.translate(-x_min, -y_min_scale) for c in range(len(self.curves_x)): if not self.curves_visible[c]: continue curve_x = self.curves_x[c] curve_y = self.curves_y[c] path = QPainterPath() lineTo = path.lineTo path.moveTo(curve_x[0], curve_y[0]) for i in xrange(1, len(curve_x)): lineTo(curve_x[i], curve_y[i]) painter.setPen(self.plots[c][1]) painter.drawPath(path) painter.restore()
def paintEvent(self, event): # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. frameWidth = 16 dotCenter = QPoint(0, 0) shiftCenter = dotCenter # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß der Kreis entsprechend kleiner sein. dotRadius = 100 framePen = QPen() framePen.setWidth(frameWidth) framePen.setColor(self._colorFrame) dotDiameter = 2 * dotRadius + frameWidth painter = QPainter(self) windowWidth = self.width() // self.__maximum windowHeight = float(self.height()) side = min(windowWidth, windowHeight) painter.setRenderHint(QPainter.Antialiasing) if (not self.isEnabled()): painter.setOpacity(.5) painter.translate(side / 2, self.height() / 2) painter.scale(side / dotDiameter, side / dotDiameter) painter.setPen(framePen) painter.setBrush(self._colorFull) painter.save() for i in range(self.__value): shiftCenter = dotCenter + QPoint(0 + dotDiameter * i, 0) painter.drawEllipse(shiftCenter, dotRadius, dotRadius) ## if (v_forbiddenValues.contains(i+1)){ ## painter.drawEllipse(shiftCenter, dotRadius/2, dotRadius/2); painter.restore() painter.setBrush(self._colorEmpty) painter.save() for i in range(self.__value, self.__maximum): shiftCenter = dotCenter + QPoint(0 + dotDiameter * i, 0) painter.drawEllipse(shiftCenter, dotRadius, dotRadius) j = i + 1 if (j in self.__forbiddenValues): dotRadiusHalf = dotRadius / 2 painter.drawLine(shiftCenter.x() - dotRadiusHalf, shiftCenter.y() - dotRadiusHalf, shiftCenter.x() + dotRadiusHalf, shiftCenter.y() + dotRadiusHalf) painter.drawLine(shiftCenter.x() - dotRadiusHalf, shiftCenter.y() + dotRadiusHalf, shiftCenter.x() + dotRadiusHalf, shiftCenter.y() - dotRadiusHalf) ## for (int i = 0; i < v_forbiddenValues.count(); ++i) { ## shiftCenter = dotCenter + QPoint( 0 + dotDiameter * (v_forbiddenValues.at(i) - 1), 0 ); ## ## painter.drawLine(shiftCenter.x()-dotDiameter/2, shiftCenter.y()-dotDiameter/2, shiftCenter.x()+dotDiameter/2, shiftCenter.y()+dotDiameter/2); ## ## painter.drawLine(shiftCenter.x()+dotDiameter/2, shiftCenter.y()-dotDiameter/2, shiftCenter.x()-dotDiameter/2, shiftCenter.y()+dotDiameter/2); ## painter.drawEllipse(shiftCenter, dotRadius/2, dotRadius/2); ## } painter.restore()
def drawImage(self, imageid): cache = image_cache.cache cellColoring = self.cellColoring wallColoring = self.wallColoring pointColoring = self.pointColoring ellipsisDraw = self.ellipsisDraw overSampling = self.overSampling extraDrawing = self.extraDrawing bgColor = self.bgColor.rgb() result = self.result if self.result_type == "Data": data = result img_name = result.images_name[imageid] else: data = result.data img_name = result.images[imageid] #scale = data.images_scale[img_name] min_scale = data.minScale() img = cache.image(data.image_path(img_name)) img_data = data[img_name] size = self._crop.size() pix = QImage(size*overSampling, QImage.Format_ARGB32) pix.fill(bgColor) painter = QPainter() if not painter.begin(pix): self.abort("Cannot create painter on QImage") return None, None, None painter.setRenderHints(QPainter.SmoothPixmapTransform, True) painter.setRenderHints(QPainter.Antialiasing, True) if overSampling > 1: painter.scale(overSampling, overSampling) painter.translate(-self._crop.topLeft()) painter.save() painter.translate(self.translate) log_debug("Translating: %gx%g" % (self.translate.x(), self.translate.y()) ) painter.scale(1/min_scale, 1/min_scale) painter.save() matrix = img_data.matrix() painter.setWorldTransform(matrix, True) painter.drawImage(QPoint(0,0), img) painter.restore() #pt_matrix = QTransform() #pt_matrix.scale(1/min_scale, 1/min_scale) #painter.setTransform(pt_matrix, True) cellColoring.startImage(painter, imageid) wallColoring.startImage(painter, imageid) for ed in extraDrawing: ed.startImage(painter, imageid) if self.result_type == "Growth": cells = result.cells[imageid] walls = result.walls[imageid] else: cells = img_data.cells walls = set() for cid in img_data.cells: pts = [ pt for pt in data.cells[cid] if pt in img_data ] if len(pts) > 1: for i in range(len(pts)): walls.add(data.wallId(pts[i-1], pts[i])) # Now, draw the cells and the ellipsis for cid in cells: painter.setPen(Qt.NoPen) color = cellColoring(imageid, cid) painter.setBrush(color) pts = data.cellAtTime(cid, img_data.index) if pts: pts.append(pts[0]) ppts = [] for p1,p2 in zip(pts[:-1], pts[1:]): ppts.append(img_data[p1]) ppts.extend(img_data.walls[p1,p2]) ppts.append(ppts[0]) poly = QPolygonF(ppts) painter.drawPolygon(poly) # And draw the walls wallThickness = self.wallThickness*min_scale for wid in walls: color = wallColoring(imageid, wid) if color.alpha() > 0: pen = QPen(color) pen.setWidthF(wallThickness) painter.setPen(pen) pts = [img_data[wid[0]]] + img_data.walls[wid[0], wid[1]] + [img_data[wid[1]]] #painter.drawLine(img_data[wid[0]], img_data[wid[1]]) painter.drawPolyline(*pts) # Then, draw the points pointSize = self.pointSize*min_scale pointLineColor = self.pointLineColor pointLineThickness = self.pointLineThickness*min_scale log_debug("pointSize = %g" % pointSize) for pid in img_data: color = pointColoring(imageid, pid) if color.alpha() > 0: pen = QPen(pointLineColor) pen.setWidthF(pointLineThickness) brush = QBrush(color) painter.setPen(pen) painter.setBrush(brush) pos = img_data[pid] rect = QRectF(pos.x()-pointSize, pos.y()-pointSize, 2*pointSize, 2*pointSize) painter.drawEllipse(rect) if ellipsisDraw.plot: for cid in cells: pts = data.cellAtTime(cid, img_data.index) if pts: pts.append(pts[0]) ppts = [] for p1,p2 in zip(pts[:-1], pts[1:]): ppts.append(img_data[p1]) ppts.extend(img_data.walls[p1,p2]) ppts.append(ppts[0]) #poly = QPolygonF(ppts) #painter.drawPolygon(poly) ellipsisDraw(painter, imageid, cid, ppts, min_scale) # At last, draw the extra data for ed in extraDrawing: ed(painter, imageid) tr = painter.worldTransform() painter.restore() pic_w = wallColoring.finalizeImage(painter, imageid, tr, self.crop) pic_c = cellColoring.finalizeImage(painter, imageid, tr, self.crop) for ed in extraDrawing: ed.finalizeImage(painter, imageid, tr, self.crop) painter.end() return pix, pic_w, pic_c
def paintEvent(self, event): painter = QPainter(self) width = self.width() height = self.height() if self.scales_visible: curve_width = width - self.y_scale.total_width - self.curve_to_scale - self.curve_outer_border curve_height = height - self.y_scale_height_offset - self.x_scale.total_height - self.curve_to_scale else: curve_width = width - self.curve_outer_border - self.curve_outer_border curve_height = height - self.curve_outer_border - self.curve_outer_border if DEBUG: painter.fillRect(0, 0, width, height, Qt.green) # fill canvas if self.scales_visible: canvas_x = self.y_scale.total_width + self.curve_to_scale - self.curve_outer_border canvas_y = self.y_scale_height_offset - self.curve_outer_border else: canvas_x = 0 canvas_y = 0 canvas_width = self.curve_outer_border + curve_width + self.curve_outer_border canvas_height = self.curve_outer_border + curve_height + self.curve_outer_border painter.fillRect(canvas_x, canvas_y, canvas_width, canvas_height, self.canvas_color) # draw cross hair at cursor position if self.cross_hair_visible: p = self.mapFromGlobal(QCursor.pos()) p_x = p.x() p_y = p.y() if p_x >= canvas_x and p_x < canvas_x + canvas_width and \ p_y >= canvas_y and p_y < canvas_y + canvas_height: painter.setPen(QPen(QColor(190, 190, 190), 1, Qt.DashLine)) painter.drawLine(canvas_x, p_y, canvas_x + canvas_width - 1, p_y) painter.drawLine(p_x, canvas_y, p_x, canvas_y + canvas_height - 1) # draw canvas border if self.curve_outer_border > 0: painter.setPen(QColor(190, 190, 190)) painter.drawRect( canvas_x, canvas_y, canvas_width - 1, canvas_height - 1) # -1 to accommodate the 1px width of the border painter.setPen(Qt.black) if DEBUG: painter.fillRect(canvas_x + self.curve_outer_border, canvas_y + self.curve_outer_border, curve_width, curve_height, Qt.cyan) # draw scales y_min_scale = self.y_scale.value_min y_max_scale = self.y_scale.value_max factor_x = float(curve_width) / self.history_length_x factor_y = float(curve_height - 1) / max( y_max_scale - y_min_scale, EPSILON) # -1 to accommodate the 1px width of the curve if self.scales_visible: self.draw_x_scale(painter, factor_x) self.draw_y_scale(painter, curve_height, factor_y) # draw curves if self.x_min != None and self.x_max != None: x_min = self.x_min x_max = self.x_max if self.scales_visible: curve_x_offset = 0 else: curve_x_offset = round( (self.history_length_x - (x_max - x_min)) * factor_x) painter.save() painter.translate( canvas_x + self.curve_outer_border + curve_x_offset, canvas_y + self.curve_outer_border + curve_height - 1 + self.curve_y_offset ) # -1 to accommodate the 1px width of the curve painter.scale(factor_x, -factor_y) painter.translate(-x_min, -y_min_scale) for c in range(len(self.curves_x)): if not self.curves_visible[c]: continue curve_x = self.curves_x[c] curve_y = self.curves_y[c] path = QPainterPath() lineTo = path.lineTo path.moveTo(curve_x[0], curve_y[0]) for i in xrange(1, len(curve_x)): lineTo(curve_x[i], curve_y[i]) painter.setPen(self.plots[c][1]) painter.drawPath(path) painter.restore()
class QtRenderer(Renderer): """An implementation of :class:`~renderer.Renderer` for PyQt4. 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): """Sets the line color. Color is interpreted as 0xAARRGGBB.""" if color is None: self._painter.setPen(Qt.NoPen) else: self._painter.setPen(self.__qcolor(color)) 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 paintEvent(self, event): """Adapted from http://doc.qt.io/qt-5/qtwidgets-widgets-analogclock-example.html""" HOURHAND = QPolygon([QPoint(7, 8), QPoint(-7, 8), QPoint(0, -55)]) MINUTEHAND = QPolygon([QPoint(7, 8), QPoint(-7, 8), QPoint(0, -87)]) HOURCOLOR = QColor(Qt.black) MINUTECOLOR = QColor(0x11, 0x11, 0x11, 0xAA) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) painter.translate(self.width() / 2, self.height() / 2) SIDE = 200 side = min(self.width(), self.height()) painter.scale(side / SIDE, side / SIDE) # Background (night/day) if self._time_to is not None: time = self._time_to.time() hour_offset = time.hour() + time.minute() / 60 DAY, NIGHT = QColor(Qt.white), QColor('#5555ff') if 7 <= hour_offset <= 19: background = DAY elif 6 <= hour_offset <= 7: palette = GradientPaletteGenerator(NIGHT, DAY) background = palette[(hour_offset - 6) / (7 - 6)] elif 19 <= hour_offset <= 20: palette = GradientPaletteGenerator(DAY, NIGHT) background = palette[(hour_offset - 19) / (20 - 19)] else: assert hour_offset < 7 or hour_offset > 20 background = NIGHT painter.setBrush(QBrush(background)) painter.setPen(HOURCOLOR) painter.drawEllipse(-SIDE / 2, -SIDE / 2, SIDE, SIDE) # Minute tickmarks painter.save() painter.setPen(MINUTECOLOR) for j in range(60): painter.drawLine(94, 0, 97, 0) painter.rotate(6) painter.restore() # Hour tickmarks painter.save() painter.setPen(HOURCOLOR) for _ in range(12): painter.drawLine(88, 0, 98, 0) painter.rotate(30) painter.restore() # Hour span if self._time_from is not None: time_from = self._time_from.time() time_to = self._time_to.time() if time_from.secsTo( time_to) / 3600 > .2: # Don't draw really small intervals hour_from = (time_from.hour() + time_from.minute() / 60) % 12 - 3 hour_to = (time_to.hour() + time_to.minute() / 60) % 12 - 3 startAngle = -hour_to * 30 * 16 spanAngle = -hour_from * 30 * 16 - startAngle color = QColor(0xFF, 0xFF, 0, 0xAA) painter.save() painter.setBrush(QBrush(color, Qt.DiagCrossPattern)) painter.setPen(color.darker(180)) painter.drawPie(-SIDE / 2, -SIDE / 2, SIDE, SIDE, startAngle, spanAngle) painter.restore() # Hour and minute hand if self._time_to is not None: time = self._time_to.time() painter.setPen(Qt.NoPen) painter.save() painter.setBrush(HOURCOLOR) painter.rotate(30 * (time.hour() + time.minute() / 60)) painter.drawConvexPolygon(HOURHAND) painter.restore() painter.save() painter.setBrush(MINUTECOLOR) painter.rotate(6 * (time.minute() + time.second() / 60)) painter.drawConvexPolygon(MINUTEHAND) painter.restore()
class QtRenderer(Renderer): """An implementation of :class:`~renderer.Renderer` for PyQt4. 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 export(self): if not os.path.isdir(self.imagePath): os.mkdir(self.imagePath) total = 100.0 / len(self.composers) dpis = [72, 150, 300] layouts = [] for i, c in enumerate(self.composers): name = c.composerWindow().windowTitle() safeName = self._safeName(name) composition = c.composition() img = composition.printPageAsRaster(0) img = img.scaledToHeight(100, Qt.SmoothTransformation) img.save( os.path.join(self.imagePath, "{}_thumbnail.png".format(safeName))) layoutDef = {} layoutDef["name"] = name layoutDef["width"] = composition.paperWidth() layoutDef["height"] = composition.paperHeight() layoutDef["thumbnail"] = "{}_thumbnail.png".format(safeName) elements = [] layoutDef["elements"] = elements for item in composition.items(): element = None if isinstance(item, (QgsComposerLegend, QgsComposerShape, QgsComposerScaleBar, QgsComposerArrow)): element = self._basicInfo(item) for dpi in dpis: dpmm = dpi / 25.4 s = QSize(item.rect().width() * dpmm, item.rect().height() * dpmm) img = QImage(s, QImage.Format_ARGB32_Premultiplied) img.fill(Qt.transparent) painter = QPainter(img) painter.scale(dpmm, dpmm) item.paint(painter, None, None) painter.end() img.save( os.path.join( self.imagePath, "{}_{}_{}.png".format(safeName, element["id"], dpi))) elif isinstance(item, QgsComposerLabel): element = self._basicInfo(item) element["name"] = item.text() element["size"] = item.font().pointSize() element["font"] = item.font().rawName() elif isinstance(item, QgsComposerMap): element = self._basicInfo(item) grid = item.grid() if grid is not None: element["grid"] = {} element["grid"]["intervalX"] = grid.intervalX() element["grid"]["intervalY"] = grid.intervalY() element["grid"]["crs"] = grid.crs().authid() element["grid"][ "annotationEnabled"] = grid.annotationEnabled() elif isinstance(item, QgsComposerPicture): filename = os.path.basename(item.picturePath()) if os.path.exists(filename): element = self._basicInfo(item) shutil.copy(item.pictureFile(), os.path.join(self.imagePath, filename)) element["file"] = filename if element is not None: element["type"] = item.__class__.__name__[11:].lower() elements.append(element) layouts.append(layoutDef) self.composerExported.emit(int(i * total)) with codecs.open(self.filePath, "w", "utf-8") as f: f.write(json.dumps(layouts)) self.finished.emit()
def paintEvent( self, event ): # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. frameWidth = 16 dotCenter = QPoint( 0, 0 ) shiftCenter = dotCenter # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß der Kreis entsprechend kleiner sein. dotRadius = 100 framePen = QPen() framePen.setWidth(frameWidth ) framePen.setColor( self._colorFrame ) dotDiameter = 2 * dotRadius + frameWidth painter = QPainter( self ) windowWidth = self.width() // self.maximum windowHeight = float( self.height() ) side = min( windowWidth, windowHeight ) painter.setRenderHint( QPainter.Antialiasing ) if ( not self.isEnabled() ): painter.setOpacity( .5 ) painter.translate( side / 2, self.height() / 2 ) painter.scale( side / dotDiameter, side / dotDiameter ) painter.setPen( framePen ) painter.setBrush( self._colorFull ) painter.save() for i in range(self.value): shiftCenter = dotCenter + QPoint( 0 + dotDiameter * i, 0 ) painter.drawEllipse( shiftCenter, dotRadius, dotRadius ) ## if (v_forbiddenValues.contains(i+1)){ ## painter.drawEllipse(shiftCenter, dotRadius/2, dotRadius/2); painter.restore() painter.setBrush( QColor(Config.COLOR_BONUS) ) painter.save() for i in range(self.value, self.value + self.__bonusValue): shiftCenter = dotCenter + QPoint( 0 + dotDiameter * i, 0 ) painter.drawEllipse( shiftCenter, dotRadius, dotRadius ) painter.restore() painter.setBrush( self._colorEmpty ) painter.save() for i in range(self.value + self.__bonusValue, self.maximum): shiftCenter = dotCenter + QPoint( 0 + dotDiameter * i, 0 ) painter.drawEllipse( shiftCenter, dotRadius, dotRadius ) j = i+1 if ( j in self.forbiddenValues ): dotRadiusHalf = dotRadius / 2 painter.drawLine( shiftCenter.x() - dotRadiusHalf, shiftCenter.y() - dotRadiusHalf, shiftCenter.x() + dotRadiusHalf, shiftCenter.y() + dotRadiusHalf ) painter.drawLine( shiftCenter.x() - dotRadiusHalf, shiftCenter.y() + dotRadiusHalf, shiftCenter.x() + dotRadiusHalf, shiftCenter.y() - dotRadiusHalf ) painter.restore()
def renderer(self): if 'QGIS_AUTH_DB_DIR_PATH' not in os.environ: os.environ['QGIS_AUTH_DB_DIR_PATH'] = '/tmp' qgis = None while True: options, result = self.queue.get() # Don't start QGIS until first request if qgis is None: qgis = QgsApplication([], False) qgis.setPrefixPath(self.settings.get('path'), True) qgis.setDefaultSvgPaths(qgis.svgPaths() + self.settings.get('svgpaths')) qgis.setMaxThreads(1) qgis.initQgis() try: if isinstance(options, LegendOptions): style, = options layer = self._qgs_memory_layer(style) layer.setName(style.parent.display_name) QgsMapLayerRegistry.instance().addMapLayer(layer) root = QgsLayerTreeGroup() root.addLayer(layer) # 'Cannot create a QPixmap when no GUI is being used' # warning occurs here model = QgsLayerTreeModel(root) settings = QgsLegendSettings() settings.setTitle('') settings.setBoxSpace(1) settings.setSymbolSize(QSizeF(5, 3)) settings.setDpi(96) renderer = QgsLegendRenderer(model, settings) # Dots per mm dpmm = settings.dpi() / 25.4 min_size = renderer.minimumSize() size = QSize(dpmm * min_size.width(), dpmm * min_size.height()) img = QImage(size, QImage.Format_ARGB32) img.fill(QColor(0, 0, 0, 0)) painter = QPainter() painter.begin(img) painter.scale(dpmm, dpmm) renderer.drawLegend(painter) painter.end() QgsMapLayerRegistry.instance().removeAllMapLayers() ba = QByteArray() bf = QBuffer(ba) bf.open(QIODevice.WriteOnly) img.save(bf, 'PNG') bf.close() buf = StringIO() buf.write(bf.data()) buf.seek(0) result.put(buf) else: path = features = None if isinstance(options, VectorRenderOptions): style, features, render_size, \ extended, target_box = options layer = self._qgs_memory_layer(style, features=features) elif isinstance(options, RasterRenderOptions): style, path, render_size, \ extended, target_box = options layer = QgsRasterLayer(path) layer.loadNamedStyle( self.env.file_storage.filename(style.qml_fileobj)) settings = QgsMapSettings() settings.setLayers([layer.id()]) settings.setFlag(QgsMapSettings.DrawLabeling) settings.setFlag(QgsMapSettings.Antialiasing) settings.setCrsTransformEnabled(True) settings.setDestinationCrs(layer.crs()) settings.setMapUnits(layer.crs().mapUnits()) settings.setOutputSize(QSize(*render_size)) settings.setExtent(QgsRectangle(*extended)) settings.setOutputImageFormat(QImage.Format_ARGB32) bgcolor = QColor.fromRgba(qRgba(255, 255, 255, 0)) settings.setBackgroundColor(bgcolor) settings.setOutputDpi(96) QgsMapLayerRegistry.instance().addMapLayer(layer) settings.setLayers([layer.id()]) # Create QImage by hand to be able to use # QgsMapRendererCustomPainterJob. Others will not # allow to workaround a bug with overlay rendering. img = QImage(settings.outputSize(), QImage.Format_ARGB32) # These cludges are needed for rendering # on transparent background, otherwise it's a mess. img.fill(QColor.fromRgba(qRgba(255, 255, 255, 255))) img.fill(QColor.fromRgba(qRgba(255, 255, 255, 0))) # DPI should be equal to settings, otherwise an error. # In QImage the resolution is set in dots per meter # for each axis. dpm = settings.outputDpi() / 25.4 * 1000 img.setDotsPerMeterX(dpm) img.setDotsPerMeterY(dpm) painter = QPainter(img) job = QgsMapRendererCustomPainterJob(settings, painter) job.renderSynchronously() painter.end() QgsMapLayerRegistry.instance().removeAllMapLayers() img = self._qimage_to_pil(img) # Clip needed part result.put(img.crop(target_box)) # Cleanup if path is not None: gdal.Unlink(path) except Exception as exc: self.logger.error(exc.message) result.put(exc) qgis.exitQgis()
def paintEvent(self, event): """Adapted from http://doc.qt.io/qt-5/qtwidgets-widgets-analogclock-example.html""" HOURHAND = QPolygon([QPoint(7, 8), QPoint(-7, 8), QPoint(0, -55)]) MINUTEHAND = QPolygon([QPoint(7, 8), QPoint(-7, 8), QPoint(0, -87)]) HOURCOLOR = QColor(Qt.black) MINUTECOLOR = QColor(0x11, 0x11, 0x11, 0xAA) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) painter.translate(self.width() / 2, self.height() / 2) SIDE = 200 side = min(self.width(), self.height()) painter.scale(side / SIDE, side / SIDE) # Background (night/day) if self._time_to is not None: time = self._time_to.time() hour_offset = time.hour() + time.minute() / 60 DAY, NIGHT = QColor(Qt.white), QColor('#5555ff') if 7 <= hour_offset <= 19: background = DAY elif 6 <= hour_offset <= 7: palette = GradientPaletteGenerator(NIGHT, DAY) background = palette[(hour_offset - 6) / (7 - 6)] elif 19 <= hour_offset <= 20: palette = GradientPaletteGenerator(DAY, NIGHT) background = palette[(hour_offset - 19) / (20 - 19)] else: assert hour_offset < 7 or hour_offset > 20 background = NIGHT painter.setBrush(QBrush(background)) painter.setPen(HOURCOLOR) painter.drawEllipse(-SIDE / 2, -SIDE / 2, SIDE, SIDE) # Minute tickmarks painter.save() painter.setPen(MINUTECOLOR) for j in range(60): painter.drawLine(94, 0, 97, 0) painter.rotate(6) painter.restore() # Hour tickmarks painter.save() painter.setPen(HOURCOLOR) for _ in range(12): painter.drawLine(88, 0, 98, 0) painter.rotate(30) painter.restore() # Hour span if self._time_from is not None: time_from = self._time_from.time() time_to = self._time_to.time() if time_from.secsTo(time_to) / 3600 > .2: # Don't draw really small intervals hour_from = (time_from.hour() + time_from.minute() / 60) % 12 - 3 hour_to = (time_to.hour() + time_to.minute() / 60) % 12 - 3 startAngle = -hour_to * 30 * 16 spanAngle = -hour_from * 30 * 16 - startAngle color = QColor(0xFF, 0xFF, 0, 0xAA) painter.save() painter.setBrush(QBrush(color, Qt.DiagCrossPattern)) painter.setPen(color.darker(180)) painter.drawPie(-SIDE / 2, -SIDE / 2, SIDE, SIDE, startAngle, spanAngle) painter.restore() # Hour and minute hand if self._time_to is not None: time = self._time_to.time() painter.setPen(Qt.NoPen) painter.save() painter.setBrush(HOURCOLOR) painter.rotate(30 * (time.hour() + time.minute() / 60)) painter.drawConvexPolygon(HOURHAND) painter.restore() painter.save() painter.setBrush(MINUTECOLOR) painter.rotate(6 * (time.minute() + time.second() / 60)) painter.drawConvexPolygon(MINUTEHAND) painter.restore()
def paintEvent(self, event): # Initialize QPainter properties painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) if self.height() <= self.width() / self.ref_aspect_ratio: v_scale = self.height() h_scale = v_scale * self.ref_aspect_ratio else: h_scale = self.width() v_scale = h_scale / self.ref_aspect_ratio # Scale all objects proportionate to window size painter.scale(h_scale / self.width_ref, v_scale / self.height_ref) painter.setClipPath(self.dial) # Don't allow objects or text to extend outside of main dial shape painter.save() # First draw main gauge background pen = QPen(painter.pen()) pen.setWidth(1) pen.setColor(Qt.black) painter.setPen(pen) painter.setBrush(QColor(100, 100, 100, 255)) # self.dial_bg) painter.drawPath(self.dial) # Add Minor and Major Alarm limit bars pen.setWidth(16) pen.setCapStyle(Qt.FlatCap) pen.setJoinStyle(Qt.BevelJoin) pen.setColor(Qt.yellow) painter.setPen(pen) painter.setBrush(Qt.NoBrush) painter.drawPath(self.low_arc) painter.drawPath(self.high_arc) pen.setColor(Qt.red) painter.setPen(pen) painter.drawPath(self.lolo_arc) painter.drawPath(self.hihi_arc) painter.restore() # Display PV current value painter.save() font = QFont() font.setPixelSize(45) painter.setFont(font) sevr = self.channel.sevr.lower() if sevr == 'major': color = Qt.red elif sevr == 'minor': color = Qt.yellow elif sevr == 'invalid': color = Qt.magenta else: color = Qt.green pen.setColor(color) painter.setPen(pen) font_metric = QFontMetrics(font) painter.translate(self.dial_width / 2, self.dial_height / 2) label = self.format_label(self.channel_value) painter.drawText(QPointF(0.0 - font_metric.width(label) / 2.0, font_metric.height() / 2.0), label) # Display PV name painter.setFont(self.pv_label_font) pen.setColor(Qt.black) # Qt.darkCyan) pen.setWidth(1) painter.setPen(pen) # brush = QBrush(Qt.darkCyan) # painter.setBrush(brush) font_metric = QFontMetrics(self.pv_label_font) pv_label = self.channel.egu # self.channel.name + ' (' + self.channel.egu + ')' painter.drawText(QPointF(0.0 - font_metric.width(pv_label) / 2.0, (self.dial_height / 2.0) + (font_metric.height() * 1.5)), pv_label) # painter.drawPath(self.pv_label_path) painter.restore() # Next add division markers painter.save() painter.translate(self.dial_width / 2, self.dial_height * 0.98) pen.setColor(Qt.black) # Qt.cyan) pen.setWidth(2) painter.setPen(pen) for i in range(0, 31): if (i % 5) != 0: painter.drawLine(-self.dial_width / 2.1, 0.0, -self.dial_width / 2.2, 0.0) else: painter.drawLine(-self.dial_width / 2.1, 0.0, -self.dial_width / 2.3, 0.0) painter.rotate(6.0) painter.restore() # Layout division text labels painter.save() painter.translate(self.dial_width / 2, self.dial_height * 0.98) pen.setColor(Qt.black) # Qt.cyan) painter.setPen(pen) font = QFont() font.setPixelSize(18) painter.setFont(font) font_metric = QFontMetrics(font) labels = linspace(self.lim_low, self.lim_hi, 7) painter.rotate(-90) for i in range(0, 7): label = self.format_label(labels[i]) painter.drawText(QPointF(0.0 - font_metric.width(label) / 2.0, -self.dial_height * 0.75), label) painter.rotate(30) painter.restore() # Draw needle at appropriate angle for data painter.save() painter.translate(self.dial_width / 2, self.dial_height * 0.98) painter.rotate(-180 * (1.0 - self.percentage)) pen.setColor(QColor(self.needle_color).darker(200)) pen.setWidth(1) painter.setPen(pen) painter.setBrush(self.needle_color) painter.drawPolygon(self.needle) painter.restore() # if self.percentage <= 0.5: # shadow = max(490 * self.percentage, 127) # needle_left_color = QColor(0, shadow, shadow) # Qt.darkCyan # QColor(80,80,80,255) # needle_right_color = Qt.cyan # QColor(230,230,230,255) # else: # shadow = max(125 / self.percentage, 127) # needle_left_color = Qt.cyan # QColor(230,230,230,255) # needle_right_color = QColor(0, shadow, shadow) # Qt.darkCyan # QColor(80,80,80,255) # # # Draw Highlight side of needle # pen.setWidth(1) # pen.setColor(Qt.gray) # needle_left_color) # painter.setPen(pen) # painter.setBrush(Qt.gray) # needle_left_color) # painter.drawPolygon(self.needle_left) # # # Draw shadow side of needle # pen.setColor(Qt.gray) # needle_right_color) # painter.setPen(pen) # painter.setBrush(Qt.gray) # needle_right_color) # painter.drawPolygon(self.needle_right) # painter.restore() # Draw needle axel pin painter.save() pen.setWidth(1) pen.setColor(Qt.black) painter.setPen(pen) painter.setBrush(QColor(50, 50, 50, 255)) # self.pin_bg) painter.translate(self.dial_width / 2, self.dial_height * 0.98) painter.drawEllipse(self.pin_rect) painter.restore() # Draw glass reflection and shadow effects # painter.save() # painter.translate(self.dial_width / 2.0, self.dial_height / 2.0) # painter.setPen(Qt.NoPen) # painter.setBrush(QColor(0, 0, 0, 20)) # painter.drawEllipse(self.shadow_rect) # painter.setBrush(self.gloss_gradient) # painter.drawEllipse(self.gloss_rect) # painter.restore() painter.end()