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 drawForeground(self, painter, rect): QGraphicsView.drawForeground(self, painter, rect) if self._sel_accepted: painter.save() painter.resetTransform() rect = self._sel_rect viewport = self.viewport() option = QStyleOptionRubberBand() option.initFrom(viewport) option.rect = self._sel_rect option.shape = QRubberBand.Rectangle mask = QStyleHintReturnMask() self.style().drawControl(QStyle.CE_RubberBand, option, painter, viewport) painter.restore() elif self._div_accepted: painter.save() painter.resetTransform() line = self._div_line viewport = self.viewport() palette = viewport.palette() pen = QPen(Qt.DashDotLine) pen.setWidth(2) pen.setColor(Qt.red) painter.setPen(pen) painter.drawLine(self._div_line) painter.restore()
def drawForeground(self, painter, rect): if self._tiling is None: return tile_nos = self._tiling.intersected(rect) for tileId in tile_nos: p = self._brushingLayer[tileId] if p.dataVer == p.imgVer: continue p.paint(painter) #access to the underlying image patch is serialized ## draw tile outlines if self._showTileOutlines: # Dashed black line pen = QPen() pen.setDashPattern([5,5]) painter.setPen(pen) painter.drawRect(self._tiling.imageRects[tileId]) # Dashed white line # (offset to occupy the spaces in the dashed black line) pen = QPen() pen.setDashPattern([5,5]) pen.setDashOffset(5) pen.setColor(QColor(Qt.white)) painter.setPen(pen) painter.drawRect(self._tiling.imageRects[tileId])
def drawForeground(self, painter, rect): QGraphicsView.drawForeground(self, painter, rect) if self._sel_accepted: painter.save() painter.resetTransform() rect = self._sel_rect viewport = self.viewport() option = QStyleOptionRubberBand() option.initFrom(viewport) option.rect = self._sel_rect option.shape = QRubberBand.Rectangle mask = QStyleHintReturnMask() self.style().drawControl(QStyle.CE_RubberBand, option, painter, viewport); painter.restore() elif self._div_accepted: painter.save() painter.resetTransform() line = self._div_line viewport = self.viewport() palette = viewport.palette() pen = QPen(Qt.DashDotLine) pen.setWidth(2) pen.setColor(Qt.red) painter.setPen(pen) painter.drawLine(self._div_line) painter.restore()
def __init__(self, parent, pos, angle, pit=False): QGraphicsItemGroup.__init__(self, parent) AbstractSector.__init__(self, pos, angle) self.setZValue(3) self.black = QGraphicsPathItem(self) self.white = QGraphicsPathItem(self) start = 3 * (_trackWidth / 2) end = -start - abs(_pitDistance if pit else 0) rowdelta = _trackWidth / 4 for item, y in [(self.black, -rowdelta), (self.white, rowdelta)]: item.setCacheMode(QGraphicsPathItem.DeviceCoordinateCache) self.addToGroup(item) path = QPainterPath() path.moveTo(start, y) path.lineTo(end, y) path.moveTo(end, -y) path.lineTo(start, -y) item.setPath(path) pen = QPen(Qt.black, _trackWidth / 2) pen.setCapStyle(Qt.FlatCap) pen.setDashPattern([1, 1]) self.black.setPen(QPen(pen)) pen.setColor(Qt.white) self.white.setPen(pen)
def paintEvent(self, event): painter = QPainter(self) minSize = min(self.rect().width(), self.rect().height()) myRect = QRect(self.rect().x(), self.rect().y(), minSize, minSize) painter.drawPixmap(myRect, self.backgroundPic, self.backgroundPic.rect()) pen = QPen() pen.setCapStyle(Qt.RoundCap) pen.setWidthF(4.0) pen.setColor(Qt.red) pen.setJoinStyle(Qt.RoundJoin) painter.setPen(pen) spacing = 40 contentRect = myRect.adjusted(spacing, spacing, -spacing, -spacing) valueInPercent = (self.m_value - self.m_minimum) / (self.m_maximum - self.m_minimum) math_pi = 3.14159265358979323846 degree = (self.m_startAngle + 90) - valueInPercent * 2.0 * self.m_startAngle degree = degree * math_pi / 180.0 radius = (contentRect.width() - spacing * 0.5) * 0.5 vec = QPoint(radius * math.cos(degree), radius * -math.sin(degree)) painter.drawLine(contentRect.center(), contentRect.center() + vec)
def draw_image(name, q): image = QSvgGenerator() image.setSize(QSize(IMAGE_SIZE, IMAGE_SIZE)) image.setFileName(name + ".svg") painter = QPainter() painter.begin(image) painter.setBrush(Qt.white) painter.setPen(Qt.NoPen) painter.drawEllipse(QPointF(IMAGE_SIZE/2, IMAGE_SIZE/2), IMAGE_SIZE/2, IMAGE_SIZE/2) painter.setBrush(QBrush()) painter.setPen(QPen()) draw_defect(painter, q) draw_circle(painter, q) pen = QPen() pen.setWidth(7) pen.setColor(Qt.red) painter.setPen(pen) painter.drawLine(IMAGE_SIZE/2 - ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2) painter.drawLine(IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 + 20) painter.drawLine(IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 - 20) font = painter.font() font.setPixelSize(40) font.setBold(True) painter.setFont(font) painter.drawText(QPointF(IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 - 30), "E") painter.end()
def paintEvent(self, QPaintEvent): super(LabelerWindow, self).paintEvent(QPaintEvent) p = QtGui.QPainter(self) image = ImageQt(Image.fromarray(self.buffer)) image = image.scaled(self.width(), self.height()) p.drawImage(0, 0, image) # Now for the HUD # -> Draw green cross-hairs old_pen = p.pen() new_pen = QPen() new_pen.setColor(Qt.green) new_pen.setStyle(Qt.DotLine) new_pen.setWidth(1) p.setPen(new_pen) p.drawLine(0, self.height()/2, self.width(), self.height()/2) p.drawLine(self.width()/2, 0, self.width()/2, self.height()) p.setPen(old_pen) # -> Show help for keystrokes help = "[X] Pos. [C] Neg. [UP] Zoom in [DN] Zoom Out [LT] Undo Last [RT] Ignore [LMB] Move " p.fillRect(0, 0, self.width(), p.fontMetrics().height()*1.5, Qt.gray) p.drawText(0, p.fontMetrics().height(), help)
def paint(self, painter, option, widget): #Set Pen############################# if self.isSelected(): line_style = Qt.DashLine width = 2 steps = 25 else: line_style = Qt.SolidLine width = 2 steps = 125 pen = QPen() pen.setWidth(width) pen.setColor(self._color) pen.setStyle(line_style) painter.setPen(pen) self.setSteps(steps) ###################################### #painter.drawLine(self.p1(),self.p2()) control_points = self.controlPoints() oldPoint = control_points[0] for point in bezierCurveRange(self.steps(), control_points): painter.drawLine(self.mapToScene(oldPoint), self.mapToScene(point)) oldPoint = point
def create_multicut_edge_layer(self): ActionInfo = ShortcutManager.ActionInfo op = self.__topLevelOperatorView if not op.Output.ready(): return None # Final segmentation -- Edges default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN) default_pen.setColor(Qt.blue) layer = SegmentationEdgesLayer(LazyflowSource(op.Output), default_pen) layer.name = "Multicut Edges" layer.visible = False # Off by default... layer.opacity = 1.0 layer.shortcutRegistration = ( "m", ActionInfo( "Multicut", "MulticutEdgesVisibility", "Show/Hide Multicut Edges", layer.toggleVisible, self.viewerControlWidget(), layer, ), ) return layer
def __drawLine(self, painter, graph, width, height): path = QPainterPath() try: day = graph[0][0].day value = graph[0][0].data(self.__index) (x, y) = self.__getCoordinates(width, height, day, value) path.moveTo(x, y) except IndexError: pass for pos in range(1, len(graph[0])): point = graph[0][pos] day = point.day value = point.data(self.__index) (x, y) = self.__getCoordinates(width, height, day, value) path.lineTo(x, y) pen = QPen() pen.setColor(QColor(graph[2])) pen.setWidth(3) pen.setCapStyle(Qt.RoundCap); pen.setJoinStyle(Qt.RoundJoin); painter.setPen(pen) painter.setBrush(Qt.NoBrush) painter.drawPath(path)
def draw_arrow(self, line, width, color): (x1, y1), (x2, y2) = line # compute points line = QLineF(x1, y1, x2, y2) # If the line is very small, we make our arrowhead smaller arrowsize = min(14, line.length()) lineangle = radians(line.angle()) arrowpt1 = line.p2() + QPointF(sin(lineangle - (pi/3)) * arrowsize, cos(lineangle - (pi/3)) * arrowsize) arrowpt2 = line.p2() + QPointF(sin(lineangle - pi + (pi/3)) * arrowsize, cos(lineangle - pi + (pi/3)) * arrowsize) head = QPolygonF([line.p2(), arrowpt1, arrowpt2]) # We have to draw the actual line a little short for the tip of the arrowhead not to be too wide adjustedLine = QLineF(line) adjustedLine.setLength(line.length() - arrowsize/2) # draw line painter = self.current_painter color = COLORS[color] painter.save() pen = QPen(painter.pen()) pen.setColor(color) pen.setWidthF(width) painter.setPen(pen) painter.drawLine(adjustedLine) # draw arrowhead painter.setPen(Qt.NoPen) brush = painter.brush() brush.setColor(color) brush.setStyle(Qt.SolidPattern) painter.setBrush(brush) painter.drawPolygon(head) painter.restore()
def draw( self, scene, baseX, baseY ): " Draws the diagram on the real canvas " self.baseX = baseX self.baseY = baseY currentY = baseY for row in self.cells: if not row: continue height = row[ 0 ].height currentX = baseX for cell in row: if self.settings.debug: pen = QPen( Qt.DotLine ) pen.setWidth( 1 ) if cell.kind == CellElement.VCANVAS: pen.setColor( QColor( 255, 0, 0, 255 ) ) scene.addLine( currentX + 1, currentY + 1, currentX + cell.width - 2, currentY + 1, pen ) scene.addLine( currentX + 1, currentY + 1, currentX + 1, currentY + cell.height - 2, pen ) scene.addLine( currentX + 1, currentY + cell.height - 2, currentX + cell.width - 2, currentY + cell.height - 2, pen ) scene.addLine( currentX + cell.width - 2, currentY + 1, currentX + cell.width - 2, currentY + cell.height - 2, pen ) else: pen.setColor( QColor( 0, 255, 0, 255 ) ) scene.addLine( currentX, currentY, currentX + cell.width, currentY, pen ) scene.addLine( currentX, currentY, currentX, currentY + cell.height, pen ) scene.addLine( currentX, currentY + cell.height, currentX + cell.width, currentY + cell.height, pen ) scene.addLine( currentX + cell.width, currentY, currentX + cell.width, currentY + cell.height, pen ) cell.draw( scene, currentX, currentY ) currentX += cell.width currentY += height return
def paintEvent(self, QPaintEvent): super(LabelerWindow, self).paintEvent(QPaintEvent) p = QtGui.QPainter(self) image = ImageQt(Image.fromarray(self.buffer)) image = image.scaled(self.width(), self.height()) p.drawImage(0, 0, image) # Now for the HUD # -> Draw green cross-hairs old_pen = p.pen() new_pen = QPen() new_pen.setColor(Qt.green) new_pen.setStyle(Qt.DotLine) new_pen.setWidth(1) p.setPen(new_pen) p.drawLine(0, self.height() / 2, self.width(), self.height() / 2) p.drawLine(self.width() / 2, 0, self.width() / 2, self.height()) p.setPen(old_pen) # -> Show help for keystrokes help = "[X] Pos. [C] Neg. [UP] Zoom in [DN] Zoom Out [LT] Undo Last [RT] Ignore [LMB] Move " p.fillRect(0, 0, self.width(), p.fontMetrics().height() * 1.5, Qt.gray) p.drawText(0, p.fontMetrics().height(), help)
def paintEvent(self, event): """ Reimplements the :meth:`QWidget.paintEvent` method. :param event: Event. :type event: QEvent """ def __setBold(state): """ Sets the current painter font bold state. :return: Definiton success. :rtype: bool """ font = painter.font() font.setBold(state) painter.setFont(font) return True painter = QPainter(self) painter.fillRect(event.rect(), self.__backgroundColor) pen = QPen(QBrush(), self.__separatorWidth) pen.setColor(self.__separatorColor) painter.setPen(pen) topRightCorner = event.rect().topRight() bottomRightCorner = event.rect().bottomRight() painter.drawLine(topRightCorner.x(), topRightCorner.y(), bottomRightCorner.x(), bottomRightCorner.y()) painter.setPen(self.__color) viewportHeight = self.__editor.viewport().height() metrics = QFontMetrics(self.__editor.document().defaultFont()) currentBlock = self.__editor.document().findBlock( self.__editor.textCursor().position()) block = self.__editor.firstVisibleBlock() blockNumber = block.blockNumber() painter.setFont(self.__editor.document().defaultFont()) while block.isValid(): blockNumber += 1 position = self.__editor.blockBoundingGeometry(block).topLeft() + self.__editor.contentOffset() if position.y() > viewportHeight: break if not block.isVisible(): continue block == currentBlock and __setBold(True) or __setBold(False) painter.drawText(self.width() - metrics.width(foundations.strings.toString(blockNumber)) - self.__margin / 3, round(position.y() + metrics.ascent() + metrics.descent() - \ (self.__editor.blockBoundingRect(block).height() * 8.0 / 100)), foundations.strings.toString(blockNumber)) block = block.next() painter.end() QWidget.paintEvent(self, event)
def paint(self, painter, option, widget=None): with painter_context(painter): pen = QPen(painter.pen()) pen.setWidth(10.0) pen.setColor( QColor(255,0,0) ) painter.setPen(pen) shrunken_rectf = self.rectf.adjusted(10,10,-10,-10) painter.drawRoundedRect(shrunken_rectf, 50, 50, Qt.RelativeSize)
def penForID(self, penId): pen = QPen() if penId == PenID.Axis: pen.setColor(Qt.darkGray) pen.setWidthF(self.LINE_WIDTH) elif penId == PenID.AxisOverlay: pen.setColor(Qt.darkGray) pen.setWidthF(self.OVERLAY_AXIS_WIDTH) return pen
def penForID(self, penId): if penId == PenID.Bar: return self.linePen elif penId == PenID.TodayLine: pen = QPen(self.linePen) pen.setColor(Qt.red) return pen else: return GraphView.penForID(self, penId)
def setupLayers(self): layers = [] op = self.__topLevelOperatorView mc_edge_layer = self.create_multicut_edge_layer() if mc_edge_layer: layers.append(mc_edge_layer) # Superpixels -- Edge Probabilities # We use the RAG's superpixels, which may have different IDs self.superpixel_edge_layer = None if op.Superpixels.ready() and op.EdgeProbabilitiesDict.ready(): layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels)) layer.name = "Superpixel Edge Probabilities" layer.visible = True layer.opacity = 1.0 self.superpixel_edge_layer = layer self.__update_probability_edges() # Initialize layers.append(layer) del layer # Superpixels -- Edges if op.Superpixels.ready(): default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN) default_pen.setColor(Qt.yellow) layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels), default_pen) layer.name = "Superpixel Edges" layer.visible = False layer.opacity = 1.0 layers.append(layer) del layer mc_seg_layer = self.create_multicut_segmentation_layer() if mc_seg_layer: layers.append(mc_seg_layer) # Superpixels if op.Superpixels.ready(): layer = self.createStandardLayerFromSlot(op.Superpixels) layer.name = "Superpixels" layer.visible = False layer.opacity = 0.5 layers.append(layer) del layer # Raw Data (grayscale) if op.RawData.ready(): layer = self.createStandardLayerFromSlot(op.RawData) layer.name = "Raw Data" layer.visible = True layer.opacity = 1.0 layers.append(layer) del layer return layers
def assign_random_color( id_pair): print "handling click: {}".format(id_pair) pen = pen_table[id_pair] if pen: pen = QPen(pen) else: pen = QPen() random_color = QColor( *list( np.random.randint(0,255,(3,)) ) ) pen.setColor(random_color) pen_table[id_pair] = pen
def assign_random_color(id_pair, buttons): print "handling click: {}".format(id_pair) pen = pen_table[id_pair] if pen: pen = QPen(pen) else: pen = QPen() random_color = QColor(*list(np.random.randint(0, 255, (3, )))) pen.setColor(random_color) pen_table[id_pair] = pen
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 drawSkel(self, worm_img, worm_qimg, row_data, roi_corner=(0, 0)): if not self.skel_file or not isinstance(self.trajectories_data, pd.DataFrame): return c_ratio_y = worm_qimg.width() / worm_img.shape[1] c_ratio_x = worm_qimg.height() / worm_img.shape[0] skel_id = int(row_data['skeleton_id']) qPlg = {} with tables.File(self.skel_file, 'r') as ske_file_id: for tt in ['skeleton', 'contour_side1', 'contour_side2']: dat = ske_file_id.get_node('/' + tt)[skel_id] dat[:, 0] = (dat[:, 0] - roi_corner[0]) * c_ratio_x dat[:, 1] = (dat[:, 1] - roi_corner[1]) * c_ratio_y qPlg[tt] = QPolygonF() for p in dat: qPlg[tt].append(QPointF(*p)) if 'is_good_skel' in row_data and row_data['is_good_skel'] == 0: self.skel_colors = { 'skeleton': (102, 0, 0), 'contour_side1': (102, 0, 0), 'contour_side2': (102, 0, 0) } else: self.skel_colors = { 'skeleton': (27, 158, 119), 'contour_side1': (217, 95, 2), 'contour_side2': (231, 41, 138) } pen = QPen() pen.setWidth(2) painter = QPainter() painter.begin(worm_qimg) for tt, color in self.skel_colors.items(): pen.setColor(QColor(*color)) painter.setPen(pen) painter.drawPolyline(qPlg[tt]) pen.setColor(Qt.black) painter.setBrush(Qt.white) painter.setPen(pen) radius = 3 painter.drawEllipse(qPlg['skeleton'][0], radius, radius) painter.end()
def setup_mem_axis(self): self.memAxis = QGraphicsLineItem(self.memXOffset, 0, self.memXOffset, self.memAxisLen, None, self.scene) self.memAxis.setPen(QPen(Qt.white)) step = int(self._memTickInterval * self.memAxisLen) pen = QPen(Qt.CustomDashLine) pen.setDashPattern([2, 20]) pen.setColor(Qt.lightGray) for y in range(step, self.memAxisLen + step, step): self.scene.addLine(self.memXOffset, y, 2500.0, y, pen)
def draw_rectangle(self, rect, bgcolor, pencolor): x, y, width, height = rect painter = self.current_painter painter.save() r = QRectF(x, y, width, height) if bgcolor is not None: painter.fillRect(r, COLORS[bgcolor]) if pencolor is not None: pen = QPen(painter.pen()) pen.setColor(COLORS[pencolor]) painter.setPen(pen) painter.drawRect(r) painter.restore()
def _dialog_paintEvent(self, d, event): QDialog.paintEvent(d, event) pen = QPen() pen.setWidth(2) pen.setColor(QColor(200, 200, 200)) rect = d.rect() rect = rect.adjusted(0, 0, -1, -1) painter = QPainter(d) painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(pen) painter.setOpacity(0.8) painter.setBrush(QBrush(QColor(Qt.white))) painter.drawRoundedRect(rect, 15, 15)
def __init__(self, id_pair, painter_path, initial_pen=None): super( SingleEdgeItem, self ).__init__() self.parent = None # Should be initialized with set_parent() self.id_pair = id_pair if not initial_pen: initial_pen = QPen() initial_pen.setCosmetic(True) initial_pen.setCapStyle(Qt.RoundCap) initial_pen.setColor(Qt.white) initial_pen.setWidth(3) self.setPen(initial_pen) self.setPath(painter_path)
def __init_disagreement_label_colortable(self): self.disagreement_colortable = [ QColor(0, 255, 255, 255), # cyan QColor(255, 0, 255, 255) ] # magenta self.disagreement_pen_table = [] for color in self.disagreement_colortable: pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN) pen.setColor(color) pen.setWidth(3) self.disagreement_pen_table.append(pen) op = self.topLevelOperatorView op.EdgeLabelDisagreementDict.notifyDirty( self.__update_disagreement_edges ) self.__cleanup_fns.append( partial( op.EdgeLabelDisagreementDict.unregisterDirty, self.__update_disagreement_edges ) )
def paintEvent(self, event): """ Draw the QImage on screen. """ textPosX,textPosY = 10,200 painter = QPainter(self) painter.drawImage(painter.viewport(), self._image) innerFont = QFont() innerFont.setPointSize(12) painter.setFont(innerFont) painter.setPen(QColor(QtCore.Qt.white)) painter.drawText(10,180,'Current Action:') painter.drawText(10,200,self._currentMovement) self.drawMoreText(painter,10,300,['Control Buttons:', 'w,s - Walking Forwards/Backwards', 'q,e - Walking Left/Right', 'a,d - Turning Left/Right', 'x - stopping', 'Space - standing up', 'Ctrl - crouch', 'Escape,Enter - restMode, wakeUp', '1 - Grabbing small', '2 - Grabbing large', '3 - Grabbing Kuscheltier', '4 - Grabbing bottle']) self.drawMoreText(painter,self.width()-300-25,300,['Dialog Control:({})'.format(self._attitude), 'u - Introduction', 'i - Ask for object', 'h - Object is Somat', 'j - Object is Muesli', 'k - Object is Bottle', 'l - Object is Kuscheltier', 'n - Wertstoff', 'm - Altpapier', 'o - Ask for help', 'z - Ask proband to repeat sentence', 'p - Repeat task', '0(Null) - construct initial state', 't - Goodbye', 'b - thanks', '# - Start free Speech(PopUp)']) self.drawMoreText(painter,100,50,['Movement Speeds','Forward: {}'.format(self._currentSpeeds['Forward']),'Leftward: {}'.format(self._currentSpeeds['Leftward']),'CounterClockwise: {}'.format(self._currentSpeeds['CounterClockwise'])]) pen = QPen() pen.setColor(QColor(QtCore.Qt.red)) pen.setWidth(5) painter.setPen(pen) painter.drawEllipse(20,15,60,30) pen.setColor(QColor(QtCore.Qt.blue)) painter.setPen(pen) painter.drawPolygon(self.rotatePolygon(arrowPolygon,math.degrees(self._motionProxy.getAngles('HeadYaw',True)[0]),[30,20]))
def __init__(self, id_pair, painter_path, initial_pen=None): super(SingleEdgeItem, self).__init__() self.parent = None # Should be initialized with set_parent() self.id_pair = id_pair if not initial_pen: initial_pen = QPen() initial_pen.setCosmetic(True) initial_pen.setCapStyle(Qt.RoundCap) initial_pen.setColor(Qt.white) initial_pen.setWidth(3) self.setPen(initial_pen) self.setPath(painter_path)
def paintEvent(self, event): """ Handles the drawing for this widget and its selection region. :param event | <QPaintEvent> """ pen = QPen(Qt.DashLine) pen.setColor(QColor('red')) painter = QPainter(self) painter.setPen(pen) clr = QColor('black') clr.setAlpha(100) painter.setBrush(clr) painter.drawRect(self._region)
def _init_probability_colortable(self): self.probability_colortable = [] for v in np.linspace(0.0, 1.0, num=101): self.probability_colortable.append( QColor(255*(v), 255*(1.0-v), 0) ) self.probability_pen_table = [] for color in self.probability_colortable: pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN) pen.setColor(color) self.probability_pen_table.append(pen) # When the edge probabilities are dirty, update the probability edge layer pens op = self.topLevelOperatorView cleanup_fn = op.EdgeProbabilitiesDict.notifyDirty( self.update_probability_edges, defer=True ) self.__cleanup_fns.append( cleanup_fn )
def __init_probability_colortable(self): self.probability_colortable = [] for v in np.linspace(0.0, 1.0, num=101): self.probability_colortable.append(QColor(255 * (v), 255 * (1.0 - v), 0)) self.probability_pen_table = [] for color in self.probability_colortable: pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN) pen.setColor(color) self.probability_pen_table.append(pen) # When the edge probabilities are dirty, update the probability edge layer pens op = self.__topLevelOperatorView op.EdgeProbabilitiesDict.notifyDirty(self.__update_probability_edges) self.__cleanup_fns.append(partial(op.EdgeProbabilitiesDict.unregisterDirty, self.__update_probability_edges))
def drawPixmapForPartiallyChecked(self): self.pixmapPartiallyChecked = QPixmap(self.itemWidth, self.itemHeight) self.pixmapPartiallyChecked.fill(Qt.transparent) painter = QPainter() painter.begin(self.pixmapPartiallyChecked) painter.setRenderHint(QPainter.Antialiasing) pen = QPen() pen.setWidth(2) painter.setPen(pen) painter.drawRect(QRect(5,5,self.itemWidth-10, self.itemHeight-10)) pen.setWidth(4) pen.setColor(QColor(139,137,137)) painter.setPen(pen) painter.drawLine(self.itemWidth/2-5, self.itemHeight/2, self.itemWidth/2, self.itemHeight-9) painter.drawLine(self.itemWidth/2, self.itemHeight-9, self.itemWidth/2+10, 2) painter.end()
def handle_edge_clicked(self, id_pair): """ Handles clicks from our associated SegmentationEdgesItem(s). (See connection made in SegmentationEdgesItemRequest.) id_pair: The edge that was clicked. """ DEBUG_BEHAVIOR = False if DEBUG_BEHAVIOR: # Simple debug functionality: change to a random color. # Please verify in the viewer that edges spanning multiple tiles changed color # together, even though only one of the tiles was clicked. random_color = QColor( *list( numpy.random.randint(0,255,(3,)) ) ) pen = QPen(self.pen_table[id_pair]) pen.setColor(random_color) self.pen_table[id_pair] = pen
def _init_edge_label_colortable(self): self.edge_label_colortable = [ QColor( 0, 0, 0, 0), # transparent QColor( 0, 255, 0, 255), # green QColor(255, 0, 0, 255) ] # red self.edge_label_pen_table = [] for color in self.edge_label_colortable: pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN) pen.setColor(color) pen.setWidth(5) self.edge_label_pen_table.append(pen) # When the edge labels are dirty, update the edge label layer pens op = self.topLevelOperatorView cleanup_fn = op.EdgeLabelsDict.notifyDirty( self.update_labeled_edges, defer=True ) self.__cleanup_fns.append( cleanup_fn )
def _init_edge_label_colortable(self): self.edge_label_colortable = [ QColor( 0, 0, 0, 0), # transparent QColor( 0, 255, 0, 255), # green QColor(255, 0, 0, 255) ] # red self.edge_label_pen_table = [] for color in self.edge_label_colortable: pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN) pen.setColor(color) pen.setWidth(5) self.edge_label_pen_table.append(pen) # When the edge labels are dirty, update the edge label layer pens op = self.topLevelOperatorView op.EdgeLabelsDict.notifyDirty( self.update_labeled_edges ) self.__cleanup_fns.append( partial( op.EdgeLabelsDict.unregisterDirty, self.update_labeled_edges ) )
def paint(self, painter, option, widget): if self.isSelected(): pen = QPen(Qt.DashLine) pen.setColor(QColor(0xccff33)) pen.setWidth(2) painter.setPen(pen) else: pen = QPen(Qt.SolidLine) pen.setColor(Qt.black) painter.setPen(pen) painter.setBrush(QBrush(self.color)) painter.drawRoundedRect(self.rect, 5, 5) painter.setPen(Qt.SolidLine | Qt.black) painter.drawText(self.rect, str(self.model.id()), option=QTextOption(Qt.AlignCenter))
def drawSkel(self, worm_img, worm_qimg, row_data, roi_corner = (0,0)): if not self.skel_file or not isinstance(self.trajectories_data, pd.DataFrame): return c_ratio_y = worm_qimg.width()/worm_img.shape[1]; c_ratio_x = worm_qimg.height()/worm_img.shape[0]; skel_id = int(row_data['skeleton_id']) qPlg = {} with tables.File(self.skel_file, 'r') as ske_file_id: for tt in ['skeleton', 'contour_side1', 'contour_side2']: dat = ske_file_id.get_node('/' + tt)[skel_id]; dat[:,0] = (dat[:,0]-roi_corner[0])*c_ratio_x dat[:,1] = (dat[:,1]-roi_corner[1])*c_ratio_y qPlg[tt] = QPolygonF() for p in dat: qPlg[tt].append(QPointF(*p)) if 'is_good_skel' in row_data and row_data['is_good_skel'] == 0: self.skel_colors = {'skeleton':(102, 0, 0 ), 'contour_side1':(102, 0, 0 ), 'contour_side2':(102, 0, 0 )} else: self.skel_colors = {'skeleton':(27, 158, 119 ), 'contour_side1':(217, 95, 2), 'contour_side2':(231, 41, 138)} pen = QPen() pen.setWidth(2) painter = QPainter() painter.begin(worm_qimg) for tt, color in self.skel_colors.items(): pen.setColor(QColor(*color)) painter.setPen(pen) painter.drawPolyline(qPlg[tt]) pen.setColor(Qt.black) painter.setBrush(Qt.white) painter.setPen(pen) radius = 3 painter.drawEllipse(qPlg['skeleton'][0], radius, radius) painter.end()
def initPlots(self): self.plot1.clear() # self.plot1.setTitle("Observed Isotope Distribution") # self.plot1.setAxisTitle(Qwt.QwtPlot.xBottom, 'Raman shift (cm-1)') # self.plot1.setAxisTitle(Qwt.QwtPlot.yLeft, 'Intensity') # grid = Qwt.QwtPlotGrid() pen = QPen(Qt.DotLine) pen.setColor(Qt.black) pen.setWidth(0) # grid.setPen(pen) # grid.attach(self.plot1) self.mass1=self.mass/self.massy*100 self.plot1.setAxisScale(self.plot1.xBottom,self.x_min,self.x_max) self.plot1.setAxisScale(self.plot1.yLeft,0,1.1*100) color = QColor('black') curve = Qwt.QwtPlotCurve("test1") pen = QPen(color) pen.setWidth(1) curve.setPen(pen) curve.setData(self.mass_x,self.mass_y) curve.setStyle(Qwt.QwtPlotCurve.Sticks) curve.attach(self.plot1) self.plot1.replot() self.plot2.clear() # self.plot2.setTitle("Theoretical Isotope Distribution") # self.plot2.setAxisTitle(Qwt.QwtPlot.xBottom, 'Raman shift (cm-1)') # self.plot2.setAxisTitle(Qwt.QwtPlot.yLeft, 'Intensity') # grid = Qwt.QwtPlotGrid() pen = QPen(Qt.DotLine) pen.setColor(Qt.blue) self.plot2.setAxisScale(self.plot1.xBottom,self.x_min,self.x_max) self.plot2.setAxisScale(self.plot1.yLeft,0,1.1*100) color = QColor('blue') curve = Qwt.QwtPlotCurve("test1") pen = QPen(color) pen.setWidth(1) curve.setPen(pen) # self.axis= np.arange(len(self.mass)) curve.setData(self.x,self.y) curve.setStyle(Qwt.QwtPlotCurve.Sticks) curve.attach(self.plot2) pen.setWidth(0) # grid.setPen(pen) # grid.attach(self.plot2) self.plot2.replot()
def paint(self, painter, option, widget = None): QGraphicsPolygonItem.paint(self, painter, option, widget) pen = QPen(QColor("yellow")) pen.setWidth(10) painter.setPen(pen) painter.drawPoint(self.entrance()) pen.setColor(QColor("magenta")) painter.setPen(pen) painter.drawPoint(self.exit()) for c in self.connectors[2:]: painter.drawPoint(c) pen.setColor(QColor(0,255,255)) pen.setWidth(2) painter.setPen(pen) painter.drawEllipse(self.cog(), 5, 5)
def paintEvent(self, event): QWidget.paintEvent(self, event) pen = QPen() pen.setWidth(2) pen.setColor(QColor(200, 200, 200)) rect = self.rect() rect = rect.adjusted(0, 0, -1, -1) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(pen) painter.setOpacity(0.5) painter.setBrush(QBrush(QColor(Qt.white))) painter.drawRoundedRect(rect, 15, 15) painter.setOpacity(1) pen.setColor(Qt.black) painter.setPen(pen) text = self.name + "\n" + self.description painter.drawText(self.rect(), Qt.AlignHCenter | Qt.AlignVCenter, text)
def finalizeImage(self, painter, imageid, image_transform, size=None): caps = self.caps params = self.parameters if params.draw_line: pt1, pt2 = self.pts painter.save() painter.setWorldTransform(image_transform) pen = QPen() pen.setCosmetic(True) pen.setColor(params.line_color) pen.setWidth(params.line_width) painter.setPen(pen) painter.drawLine(pt1, pt2) painter.restore() del self.direction del self.pts del self.current_image return self.parameters.drawScaleBar(painter, caps, self.unit, size)
def paintEvent(self, event): QFrame.paintEvent(self, event) factorForWidth = self.width() / 40 factorForHeight = self.height() / 30 row = 1 column = 1 painter = QPainter(self) painter.setOpacity(0.9) pen = QPen() pen.setColor(Qt.white) painter.setPen(pen) while factorForWidth * column < self.width(): painter.drawLine(factorForWidth * column, 0, factorForWidth * column, self.height()) column += 1 while factorForHeight * row < self.height(): painter.drawLine(0, factorForHeight * row, self.width(), factorForHeight * row) row += 1
def draw(self, scene, baseX, baseY): " Draws the diagram on the real canvas " self.baseX = baseX self.baseY = baseY currentY = baseY for row in self.cells: if not row: continue height = row[0].height currentX = baseX for cell in row: if self.settings.debug: pen = QPen(Qt.DotLine) pen.setWidth(1) if cell.kind == CellElement.VCANVAS: pen.setColor(QColor(255, 0, 0, 255)) scene.addLine(currentX + 1, currentY + 1, currentX + cell.width - 2, currentY + 1, pen) scene.addLine(currentX + 1, currentY + 1, currentX + 1, currentY + cell.height - 2, pen) scene.addLine(currentX + 1, currentY + cell.height - 2, currentX + cell.width - 2, currentY + cell.height - 2, pen) scene.addLine(currentX + cell.width - 2, currentY + 1, currentX + cell.width - 2, currentY + cell.height - 2, pen) else: pen.setColor(QColor(0, 255, 0, 255)) scene.addLine(currentX, currentY, currentX + cell.width, currentY, pen) scene.addLine(currentX, currentY, currentX, currentY + cell.height, pen) scene.addLine(currentX, currentY + cell.height, currentX + cell.width, currentY + cell.height, pen) scene.addLine(currentX + cell.width, currentY, currentX + cell.width, currentY + cell.height, pen) cell.draw(scene, currentX, currentY) currentX += cell.width currentY += height return
def initPlots(self): self.plot3.clear() self.plot3.setAxisScale(self.plot1.xBottom, -4, 4) self.plot3.setAxisScale(self.plot1.yLeft, -4, 4) self.plot1.clear() self.plot1.setTitle("Search MS") self.plot1.setAxisTitle(Qwt.QwtPlot.yLeft, 'Intensity') grid = Qwt.QwtPlotGrid() pen = QPen(Qt.DotLine) pen.setColor(Qt.black) pen.setWidth(0) grid.setPen(pen) grid.attach(self.plot1) self.plot1.setAxisScale(self.plot1.yLeft, 0, 1.1 * np.max(self.mass)) color = QColor('black') curve = Qwt.QwtPlotCurve("test1") pen = QPen(color) pen.setWidth(1) curve.setPen(pen) #self.axis= np.arange(len(self.mass)) curve.setData(self.axis, self.mass) curve.setStyle(Qwt.QwtPlotCurve.Sticks) curve.attach(self.plot1) for i in range(len(self.peak_MS)): text_MS = Qwt.QwtText('%s' % (str(self.peak_MS[i][0]))) marker_MS = Qwt.QwtPlotMarker() marker_MS.setLabelAlignment(Qt.AlignCenter | Qt.AlignTop) marker_MS.setLabel(text_MS) marker_MS.setValue(self.peak_MS[i][0], self.peak_MS[i][1]) marker_MS.attach(self.plot1) self.plot1.replot() self.plot2.clear() self.plot2.setTitle("NIST MS") # self.plot2.setAxisTitle(Qwt.QwtPlot.xBottom, 'Raman shift (cm-1)') self.plot2.setAxisTitle(Qwt.QwtPlot.yLeft, 'Intensity') grid = Qwt.QwtPlotGrid() pen = QPen(Qt.DotLine) pen.setColor(Qt.black) pen.setWidth(0) grid.setPen(pen) grid.attach(self.plot2) self.plot2.replot()
def __init__(self): super(QFramesInTracksScene, self).__init__() self._coords = CoordTransform() self._track_items = {} self._frame_items = {} pen = QPen() pen.setWidthF(1.25) pen.setColor(Qt.black) # pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) brush = QBrush() brush.setColor(Qt.blue) brush.setStyle(Qt.SolidPattern) self._frame_pen_brush = pen, brush pen = QPen(pen) pen.setWidthF(3.5) pen.setJoinStyle(Qt.RoundJoin) pen.setColor(Qt.blue) brush = QBrush(brush) brush.setColor(Qt.gray) self._track_pen_brush = pen, brush
def paintEvent(self, event): QWidget.paintEvent(self, event) width, height = self.width(), self.height() polygon = QPolygon() for i, rate in enumerate(self.loads): x = width - i * self.pointDistance y = height - rate * height if x < self.boxWidth: break polygon.append(QPoint(x, y)) painter = QPainter(self) pen = QPen() pen.setColor(Qt.darkGreen) painter.setPen(pen) painter.setRenderHint(QPainter.Antialiasing, True) #画网格 painter.setOpacity(0.5) gridSize = self.pointDistance * 4 deltaX = (width - self.boxWidth) % gridSize + self.boxWidth deltaY = height % gridSize for i in range(int(width / gridSize)): x = deltaX + gridSize * i painter.drawLine(x, 0, x, height) for j in range(int(height / gridSize)): y = j * gridSize + deltaY painter.drawLine(self.boxWidth, y, width, y) #画折线 pen.setColor(Qt.darkCyan) pen.setWidth(2) painter.setPen(pen) painter.setOpacity(1) painter.drawPolyline(polygon) #画展示框 if len(self.loads) > 0: rate = self.loads[0] else: rate = 1.0 rect1 = QRect(4, height * 0.05, self.boxWidth - 9, height * 0.7) rect2 = QRect(4, height * 0.8, self.boxWidth - 9, height * 0.2) centerX = int(rect1.width() / 2) + 1 pen.setWidth(1) for i in range(rect1.height()): if i % 4 == 0: continue if (rect1.height() - i) / rect1.height() > rate: pen.setColor(Qt.darkGreen) else: pen.setColor(Qt.green) painter.setPen(pen) for j in range(rect1.width()): if centerX - 1 <= j <= centerX + 1: continue painter.drawPoint(rect1.x() + j, rect1.y() + i) pen.setColor(Qt.black) painter.setPen(pen) painter.drawText(rect2, Qt.AlignHCenter | Qt.AlignVCenter, str(int(rate * 100)) + "%")