示例#1
0
    def __showCircle(self):
        ratio = 3

        pen = QPen()
        pen.setBrush(Qt.red)
        pen.setWidth(0.01)

        font = QFont()
        font.setPointSize(200 * ratio)

        self.scene.clear()

        for i in range(len(self.pointsXYItem)):
            (x, y) = self.pointsXYItem[i]
            r = self.radius[i] * ratio

            circleItem = QGraphicsEllipseItem(x - r, y - r, 2 * r, 2 * r)
            circleItem.setPen(pen)

            self.scene.addItem(circleItem)

            strItem = QGraphicsTextItem()
            strItem.setDefaultTextColor(Qt.blue)
            strItem.setFont(font)

            strItem.setPlainText(self.pointsName[i])
            strItem.setPos(x, y)

            self.scene.addItem(strItem)
示例#2
0
    def createValuesText(self):
        painter = QPainter(self)
        # painter.setRenderHint(QPainter.HighQualityAntialiasing)
        painter.setRenderHint(QPainter.Antialiasing)
        painter.translate(self.width() / 2, self.height() / 2)
        font = QFont(self.valueFontName, self.valueFontSize)
        fm = QFontMetrics(font)

        penShadow = QPen()

        penShadow.setBrush(self.displayValueColor)
        painter.setPen(penShadow)

        textRadius = self.widgetDiameter / 2 * self.textRadiusFactor

        # angle_distance = (float(self.scaleAngleSize) / float(self.scala_main_count))
        # for i in range(self.scala_main_count + 1):
        text = str(int(self.value))
        w = fm.width(text) + 1
        h = fm.height()
        painter.setFont(QFont(self.valueFontName, self.valueFontSize))

        angleEnd = float(self.scaleAngleStartValue + self.scaleAngleSize - 360)
        angle = (angleEnd -
                 self.scaleAngleStartValue) / 2 + self.scaleAngleStartValue

        x = textRadius * math.cos(math.radians(angle))
        y = textRadius * math.sin(math.radians(angle))
        text = [
            x - int(w / 2), y - int(h / 2),
            int(w),
            int(h), Qt.AlignCenter, text
        ]
        painter.drawText(text[0], text[1], text[2], text[3], text[4], text[5])
示例#3
0
def _paintRegistrationMarks(printer, painter):
    page = printer.pageLayout().fullRectPoints()
    margin = printer.pageLayout().marginsPoints()

    # Get ourselves some nice abbreviations
    pw = page.width()
    ph = page.height()
    ml = margin.left()
    mr = margin.right()
    mt = margin.top()
    mb = margin.bottom()

    # A caution factor of 90% to keep our registration lines from
    # running into the main page area
    cf = 0.9

    pen = QPen()
    pen.setStyle(Qt.SolidLine)
    pen.setWidth(1)
    pen.setBrush(Qt.black)

    painter.save()
    painter.setPen(pen)
    painter.drawLine(0, mt, ml * cf, mt)
    painter.drawLine(ml, 0, ml, mt * cf)
    painter.drawLine(pw, mt, pw - mr * cf, mt)
    painter.drawLine(pw - mr, 0, pw - mr, mt * cf)
    painter.drawLine(0, ph - mb, ml * cf, ph - mb)
    painter.drawLine(ml, ph, ml, ph - mb * cf)
    painter.drawLine(pw, ph - mb, pw - mr * cf, ph - mb)
    painter.drawLine(pw - mr, ph, pw - mr, ph - mb * cf)
    painter.restore()
示例#4
0
    def paintEvent(self, event):
        # Check whether this orb is enhanced
        if type(self.parent) == Board:
            enh = self.parent.enhanced[self.position]
        else:
            enh = False

        painter = QPainter(self)
        painter.drawPixmap(event.rect().adjusted(2,2,-2,-2), self.pixmap())

        w = event.rect().width()

        if enh:
            path = QPainterPath()

            pen = QPen()
            pen.setWidth(1);
            pen.setBrush(Qt.white)

            brush = QBrush(Qt.yellow)

            font = QFont()
            font.setPointSize(20)
            font.setWeight(QFont.Black)
            
            path.addText(event.rect().x()+w-15,event.rect().y()+w-5,font,'+')

            painter.setPen(pen)
            painter.setBrush(brush)
            painter.setFont(font)

            painter.drawPath(path)
示例#5
0
	def drawLines(self, qp):

		pen = QPen(Qt.black, 2, Qt.SolidLine)

		qp.setPen(Qt.gray)

		with open('edge_list.pkl', 'rb') as f:
			edg = pickle.load(f)
		
		   #main()
		for e in edg :
		   qp.drawLine(e[0][0],e[0][1],e[1][0],e[1][1])	

		if(self.init_phase == 3):
			pen = QPen(Qt.black, 5, Qt.DashDotLine)
			# qp.setPen(Qt.red)
			# qp.setWidth(10)
			pen.setBrush(Qt.red)
			pen.setWidth(5)
			qp.setPen(pen)
			for i in range(len(self.path_t)-1):
				a=self.path_t[i]
				# print("---- point a --- ")
				# print(a)
				a_pos=dict_index_coord[a]
				b=self.path_t[i+1]
				# print("---- point b --- ")
				# print(b)
				b_pos=dict_index_coord[b]	
				qp.drawLine(a_pos[0],a_pos[1],b_pos[0],b_pos[1])
示例#6
0
    def drawDigitalValueUnits(self):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        painter.translate(self.width() / 2, self.height() / 2)

        font = QFont(self.digitalValueFontName, self.digitalValueUnitsFontSize)
        fm = QFontMetrics(font)

        penShadow = QPen()
        penShadow.setBrush(self.digitalValueColor)
        painter.setPen(penShadow)

        digitalValueRadius = self.widgetDiameter / 2 * self.digitalValueRadius

        text = self.gaugeValueUnits
        w = fm.width(text) + 1
        h = fm.height()
        painter.setFont(
            QFont(self.digitalValueFontName, self.digitalValueUnitsFontSize))

        angleEnd = float(self.gaugeRotation + self.gaugeArcAngle - 360)
        angle = (angleEnd - self.gaugeRotation) / 2 + self.gaugeRotation

        x = digitalValueRadius * math.cos(math.radians(angle))
        y = digitalValueRadius * math.sin(math.radians(angle))

        text = [
            x - int(w / 2) + 20, y - int(h / 2),
            int(w),
            int(h), Qt.AlignCenter, text
        ]
        painter.drawText(text[0], text[1], text[2], text[3], text[4], text[5])
示例#7
0
def draw_head_arrow(
        painter: QPainter,
        up: bool,
        center_x: int,
        center_y: int,
        width: int,
        height: int,
        brush: QBrush
):
    painter.save()

    pen = QPen()
    pen.setBrush(brush)
    painter.setBrush(brush)
    painter.setPen(pen)

    path = QPainterPath()
    path.moveTo(center_x + width // 2, center_y)
    path.lineTo(center_x - width // 2, center_y)
    path.lineTo(center_x, center_y - height if up else center_y + height)
    path.lineTo(center_x + width // 2, center_y)

    painter.fillPath(path, brush)
    painter.drawPath(path)

    painter.restore()
示例#8
0
    def drawSnakeAndFood(self, event, painter):
        """ Draws the snake and food"""

        pen = QPen()
        pen.setWidth(1)
        pen.setBrush(Qt.white)
        pen.setCapStyle(Qt.SquareCap)
        pen.setJoinStyle(Qt.MiterJoin)

        brush = QBrush(Qt.white)

        painter.setPen(pen)
        painter.setBrush(brush)

        # Draw each individual square of snake
        for bodySquare in self.snake.bodyPositions:

            x = bodySquare[0] * self.squareSize
            y = bodySquare[1] * self.squareSize

            painter.drawRect(x, y, self.squareSize, self.squareSize)

        # Draw food
        x = self.foodPosition[0] * self.squareSize
        y = self.foodPosition[1] * self.squareSize

        painter.drawRect(x, y, self.squareSize, self.squareSize)
示例#9
0
def draw_beacon_indicators(painter: QPainter, map: map, robot: Robot):
    pen = QPen()
    pen.setStyle(Qt.DotLine)
    pen.setCapStyle(Qt.RoundCap)
    pen.setBrush(SETTINGS["COLOR_BEACON"])
    pen.setWidth(2)
    painter.setPen(pen)

    distances = [b.distance_to(robot.x, robot.y) for b in map.beacons]
    closest_beacon_id = distances.index(min(distances))

    for i, beacon in enumerate(map.beacons):
        if beacon.distance_to(
                robot.x, robot.y) <= SETTINGS["BEACON_INDICATOR_DISTANCE"]:
            painter.drawLine(beacon.x, beacon.y, robot.x, robot.y)
            if i == closest_beacon_id:
                pen.setWidth(1)
                pen.setStyle(Qt.SolidLine)
                painter.setPen(pen)
                painter.drawEllipse(QPoint(beacon.x, beacon.y),
                                    SETTINGS["BEACON_SIZE"] * 1.2,
                                    SETTINGS["BEACON_SIZE"] * 1.2)
                pen.setWidth(2)
                pen.setStyle(Qt.DotLine)
                painter.setPen(pen)
示例#10
0
文件: Canvas.py 项目: Fesmat/CamPaint
 def draw(self, pt):
     # Устанавливаем кисть, цвет, и прочее
     pen = QPen()
     pen.setBrush(QBrush(self.color))
     pen.setCapStyle(Qt.RoundCap)
     pen.setWidth(self.width)
     pt.setPen(pen)
     pt.drawRect(self.sx, self.sy, self.w, self.h)
示例#11
0
文件: Canvas.py 项目: Fesmat/CamPaint
 def draw(self, pt):
     # Устанавливаем кисть, цвет, и прочее
     pen = QPen()
     pen.setBrush(QBrush(self.color))
     pen.setWidth(self.width)
     pt.setPen(pen)
     pt.drawEllipse(self.x - self.width // 2, self.y - self.width // 2,
                    self.width, self.width)
示例#12
0
 def pen(self):
     """create and return default pen"""
     pen = QPen()
     pen.setStyle(DefaultDrawParams.pen_style)
     pen.setWidth(DefaultDrawParams.pen_thickness)
     pen.setBrush(self.border_color)
     pen.setCapStyle(DefaultDrawParams.pen_cap_style)
     pen.setJoinStyle(DefaultDrawParams.pen_join_style)
     return pen
示例#13
0
文件: Canvas.py 项目: Fesmat/CamPaint
 def draw(self, pt):
     # Устанавливаем кисть, цвет, и прочее
     # Находим радиус окружностипо формуле из геометрии
     pen = QPen()
     pen.setBrush(QBrush(self.color))
     pen.setCapStyle(Qt.RoundCap)
     pen.setWidth(self.width)
     pt.setPen(pen)
     rad = int(((self.ex - self.sx)**2 + (self.ey - self.sy)**2)**0.5)
     pt.drawEllipse(self.ex - rad, self.ey - rad, 2 * rad, 2 * rad)
示例#14
0
def draw_filter_trace(painter: QPainter, trace: QPainterPath):
    pen = QPen()
    pen.setStyle(Qt.DashLine)
    pen.setCapStyle(Qt.RoundCap)
    pen.setBrush(SETTINGS["COLOR_FILTER_TRACE"])
    pen.setWidth(3)
    painter.setPen(pen)
    painter.setBrush(Qt.NoBrush)

    painter.drawPath(trace)
示例#15
0
    def create_inner_and_outer_mask(self):
        '''
        Based on the traces, this function creates two masks: One ('inner_mask') to mark all pixels inside the shape
        as defined by the traces,  and one mask, 'outer_mask' to mark the pixels outside the shape defined by the traces
        :return: inner_mask and outer_mask: Two boolean masks
        '''

        # use the same method to draw the traces
        pixmap = QPixmap(self.slice_photo.size())
        pixmap.fill(QColor(255, 255, 255))
        painter = QPainter()
        painter.begin(pixmap)
        pen = QPen()
        pen.setWidth(self.pen_width)
        pen.setBrush(Qt.black)
        pen.setCapStyle(Qt.RoundCap)
        painter.setPen(pen)
        for trace in self.traces:
            painter.drawPolyline(QPolygon(trace))
        painter.end()
        # that is us done painting
        #convert the Qpixmap into a numpy array
        arr = self.get_np_array(pixmap)
        # find the center
        arr = np.mean(arr, axis=-1, dtype=np.uint8)
        l = []
        for trace in self.traces:
            l = l + [[p.x(), p.y()] for p in trace]
        center = np.mean(np.array(l), axis=0, dtype=np.int)

        # fill the shape ( using floodfill)  starting from the center
        inner_mask = arr.copy()
        h, w = inner_mask.shape[:2]
        mask = np.zeros((h + 2, w + 2), np.uint8)
        cv2.floodFill(inner_mask, mask, (center[0], center[1]), 128)

        #and calculate the masks
        inner_mask = (inner_mask > 100).astype(np.bool)
        middle_mask = (arr < 32).astype(np.bool)
        outer_mask = np.logical_and(~inner_mask, ~middle_mask)

        # for debugging purposes, create a matplotlib image (only visible in IDE)
        fig, axs = plt.subplots(2, 2)
        axs[0, 0].imshow(arr)
        axs[0, 1].imshow(middle_mask)
        axs[1, 0].imshow(inner_mask)
        axs[1, 1].imshow(outer_mask)

        for axh in axs:
            for ax in axh:
                ax.set_aspect('equal')
        fig.tight_layout()
        plt.show()

        return inner_mask, outer_mask
示例#16
0
class MyQLabel(QLabel):
    def __init__(self, parent):
        super().__init__(parent)
        self.label_maxw = 1200.0
        self.label_maxh = 700.0
        self.setGeometry(50, 50, self.label_maxw, self.label_maxh)

        self.pen = QPen()
        self.pen.setWidth(5)
        self.pen.setBrush(Qt.red)

        self.pos = None
        self.png = None

    def paintEvent(self, e):
        qp = QPainter()
        qp.begin(self)
        if self.png:
            qp.drawPixmap(0, 0, self.png)
        if self.pos:
            qp.setPen(self.pen)
            qp.drawPoint(self.pos.x(), self.pos.y())
        qp.end()

    def mousePressEvent(self, e):
        self.pos = e.pos()
        print('PRESS: %d,%d' % (self.pos.x(), self.pos.y()))
        self.update()

        global CurrentAnnos
        if CurrentAnnos.imagepath:
            CurrentAnnos.cur_keypoint[CurrentAnnos.cur_partID,
                                      0] = self.pos.x()
            CurrentAnnos.cur_keypoint[CurrentAnnos.cur_partID,
                                      1] = self.pos.y()
            if CurrentAnnos.cur_vis == True:
                CurrentAnnos.cur_keypoint[CurrentAnnos.cur_partID, 2] = 1
            elif CurrentAnnos.cur_vis == False:
                CurrentAnnos.cur_keypoint[CurrentAnnos.cur_partID, 2] = 2
            CurrentAnnos.print('mousePressEvent')

    def loadimg(self, filename):

        self.pos = None
        png = QPixmap(filename)
        ratio = min(self.label_maxw / png.width(),
                    self.label_maxh / png.height())
        self.png = png.scaled(png.width() * ratio, png.height() * ratio)
        self.update()

        global CurrentAnnos
        CurrentAnnos.init()
        CurrentAnnos.imagepath = filename
        CurrentAnnos.scaleratio = ratio
        CurrentAnnos.print('loadimg')
示例#17
0
 def drawPipes(self, qp):
     pen = QPen()
     pen.setWidth(2)
     brush = QBrush()
     brush.setColor(QColor(0x88, 0x88, 0x88))
     brush.setStyle(Qt.SolidPattern)
     pen.setBrush(brush)
     qp.setPen(pen)
     for b, (i, j) in zip(self.blocks, self.block_generator()):
         coord = self.get_coord(i, j)
         b.draw(qp, coord)
示例#18
0
 def draw_line(self, points, pencil):
     pen = QPen()
     pen.setBrush(QColor(pencil))
     point1 = points[0]
     point2 = points[1]
     self.addLine(point1.x(), point1.y(), point2.x(), point2.y(), pen)
     self.svg_document.add(
         self.svg_document.line(start=(point1.x(), point1.y()),
                                end=(point2.x(), point2.y()),
                                stroke=pencil))
     self.resert_clicks()
示例#19
0
    def __makePen(self):
        """
        Dit is een hulpmethode om de gepaste pen te maken die dan wordt teruggegeven

        :return: QPen
        """
        pen = QPen()
        pen.setColor(self.__color)
        pen.setBrush(QBrush(self.__color))
        pen.setWidth(self.__penWidth)
        return pen
示例#20
0
 def __init__(self, x1, y1, x2, y2, thickness, visible, color, parent):
     super().__init__(x1, y1, x2, y2, parent)
     pen = QPen()
     pen.setWidth(1)
     if color is None:
         pen.setBrush(Qt.green)
     else:
         pen.setBrush(color)
     #self.setBrush(Qt.white)
     self.setPen(pen)
     self.setFlag(QGraphicsItem.ItemIsMovable)
     self.setVisible(visible)
示例#21
0
    def paintEvent(self, event):
        qp = QPainter()
        qp.begin(self)
        qp.setRenderHint(QPainter.Antialiasing)
        pen = QPen()
        pen.setStyle(Qt.SolidLine)
        pen.setBrush(SETTINGS["COLOR_BACKGROUND"].darker(200))
        pen.setWidth(6)

        qp.setOpacity(0.6)
        qp.setPen(pen)
        qp.setBrush(SETTINGS["COLOR_BACKGROUND"].darker(120))
        qp.drawRect(0, 0, self.tracker_width, self.tracker_height)
        qp.end()
示例#22
0
 def draw_polygon(self, polygon, pencil, fill):
     pen = QPen()
     pen.setBrush(QColor(pencil))
     self.addPolygon(polygon, pen) \
         .setBrush(QColor(fill))
     newpolygon = []
     for e in polygon:
         newpolygon.append((int(e.x()), int(e.y())))
     self.svg_document.add(
         self.svg_document.polygon(newpolygon,
                                   stroke_width="1",
                                   stroke=pencil,
                                   fill=fill))
     self.resert_clicks()
示例#23
0
 def draw_rectangle(self, points, width, height, pencil, fill):
     pen = QPen()
     pen.setBrush(QColor(pencil))
     point = points[0]
     (self.addRect(point.x(), point.y(),
                   width, height, pen)) \
         .setBrush(QColor(fill))
     self.svg_document.add(
         self.svg_document.rect(insert=(point.x(), point.y()),
                                size=("{}px".format(width),
                                      "{}px".format(height)),
                                stroke_width="1",
                                stroke=pencil,
                                fill=fill))
     self.resert_clicks()
示例#24
0
 def draw_ellipse(self, points, width, height, pencil, fill):
     pen = QPen()
     pen.setBrush(QColor(pencil))
     point = points[0]
     self.addEllipse(point.x(), point.y(),
                     width, height, pen) \
         .setBrush(QColor(fill))
     self.svg_document.add(
         self.svg_document.ellipse(center=(point.x() + width / 2,
                                           point.y() + height / 2),
                                   r=(width / 2, height / 2),
                                   stroke_width="1",
                                   stroke=pencil,
                                   fill=fill))
     self.resert_clicks()
示例#25
0
    def paintEvent(self, QPaintEvent):
        painter = QPainter(self)
        pen = QPen()

        if self.direction == 'forward':
            trianglePointsF = [
                QPointF(self.size * 0.05, self.size * 0.05),
                QPointF(self.size - (self.size * 0.05), self.size / 2),
                QPointF(self.size * 0.05, self.size - (self.size * 0.05))
            ]

            gradient = QLinearGradient(0, 0, 100, 100)

        else:
            trianglePointsF = [
                QPointF(self.size - (self.size * 0.05), self.size * 0.05),
                QPointF(self.size * 0.05, self.size / 2),
                QPointF(self.size - (self.size * 0.05),
                        self.size - (self.size * 0.05))
            ]

            gradient = QLinearGradient(100, 0, 0, 100)

        pen.setWidth(self.size * 0.04)

        painter.setRenderHint(QPainter.Antialiasing)

        if self.isChecked():
            color = QColor(110, 110, 110)

            gradient.setColorAt(0, self.on_color_1)
            gradient.setColorAt(1, self.on_color_2)

        else:
            color = QColor(189, 189, 189)

            gradient.setColorAt(0, self.off_color_1)
            gradient.setColorAt(1, self.off_color_2)

        pen.setBrush(QBrush(color))
        painter.setPen(pen)

        painter.setBrush(gradient)

        triangleF = QPolygonF(trianglePointsF)

        basePoly = QPolygonF(triangleF)
        painter.drawPolygon(basePoly)
示例#26
0
 def createArrow(self):
     rad = self._RADIUS
     pen = QPen()
     pen.setWidth(3)
     color = QColor(Qt.blue)
     color.setAlphaF(0.25)
     pen.setBrush(color)
     if self._virtual_helix.isEvenParity():
         arrow = QGraphicsLineItem(rad, rad, 2*rad, rad, self)
     else:
         arrow = QGraphicsLineItem(0, rad, rad, rad, self)
     arrow.setTransformOriginPoint(rad, rad)
     arrow.setZValue(400)
     arrow.setPen(pen)
     self.arrow = arrow
     self.arrow.hide()
    def paint(self, painter):
        if self._num_signals is None:
            return None
        self._calc_visual_parametres()
        pen = QPen()
        pen.setStyle(Qt.DashLine)
        pen.setWidth(1)
        pen.setBrush(QColor('#565656'))

        painter.setPen(pen)
        for curr_yaxe_position in self._yaxes_positions:
            painter.drawLine(0, curr_yaxe_position, self.width(),
                             curr_yaxe_position)
        for curr_xaxe_position in self._xaxes_positions:
            painter.drawLine(curr_xaxe_position, 0, curr_xaxe_position,
                             self.height())
示例#28
0
    def paintEvent(self, event):

        if self.eventByButton == True:
            self.eventByButton = False

            self.width = self.frameGeometry().width()
            self.height = self.frameGeometry().height()

            painter = QPainter()
            painter.begin(self)

            myPen = QPen()

            for i in range(self.nbPointsNoirs):
                myPen.setColor(Qt.black)
                myPen.setBrush(Qt.black)
                painter.setPen(myPen)
                calcul_taille_bordure_gauche = int(30 / 1366 * self.width)
                calcul_taille_bordure_droite = int(
                    self.width -
                    166)  #166 : 1366-1200 : taille de la bordure sur mon écran
                calcul_taille_bordure_haut = calcul_taille_bordure_gauche
                calcul_taille_bordure_bas = int(665 / 728 * self.height)

                x = randint(calcul_taille_bordure_gauche,
                            int(calcul_taille_bordure_droite))
                y = randint(calcul_taille_bordure_haut,
                            calcul_taille_bordure_bas)

                painter.drawRect(x, y, 1, 1)

            myPen.setColor(Qt.red)
            myPen.setBrush(Qt.red)

            x = randint(calcul_taille_bordure_gauche,
                        int(calcul_taille_bordure_droite))
            y = randint(calcul_taille_bordure_haut, calcul_taille_bordure_bas)
            print(x, y)
            painter.setPen(myPen)
            painter.drawRect(x, y, 1, 1)

            myPen.setWidth(5)
            painter.setPen(myPen)
            painter.drawEllipse(x - 15, y - 15, 30, 30)

            painter.end()
示例#29
0
    def createImage(self, transform):
        sx = min(transform.m11(), transform.m22())
        sy = max(transform.m22(), sx)
        fm = QFontMetrics(Colors.headingFont())

        w = fm.width(self.text) + 1
        h = fm.height()
        xShadow = 3.0
        yShadow = 3.0

        image = QImage(
            int((w + xShadow) * sx),
            int((h + yShadow) * sy),
            QImage.Format_ARGB32_Premultiplied,
        )
        image.fill(QColor(0, 0, 0, 0).rgba())
        painter = QPainter(image)
        painter.setFont(Colors.headingFont())
        painter.scale(sx, sy)

        # Draw shadow.
        brush_shadow = QLinearGradient(xShadow, yShadow, w, yShadow)
        brush_shadow.setSpread(QLinearGradient.PadSpread)
        if Colors.useEightBitPalette:
            brush_shadow.setColorAt(0.0, QColor(0, 0, 0))
        else:
            brush_shadow.setColorAt(0.0, QColor(0, 0, 0, 100))
        pen_shadow = QPen()
        pen_shadow.setBrush(brush_shadow)
        painter.setPen(pen_shadow)
        painter.drawText(int(xShadow), int(yShadow), int(w), int(h),
                         Qt.AlignLeft, self.text)

        # Draw text.
        brush_text = QLinearGradient(0, 0, w, w)
        brush_text.setSpread(QLinearGradient.PadSpread)
        brush_text.setColorAt(0.0, QColor(255, 255, 255))
        brush_text.setColorAt(0.2, QColor(255, 255, 255))
        brush_text.setColorAt(0.5, QColor(190, 190, 190))
        pen_text = QPen()
        pen_text.setBrush(brush_text)
        painter.setPen(pen_text)
        painter.drawText(0, 0, int(w), int(h), Qt.AlignLeft, self.text)

        return image
示例#30
0
    def paint(self, painter, size, show_traces):
        '''
        painting the slice
        :param painter: the painter it is to use
        :param size:
        :param show_traces:
        :return:
        '''
        try:
            photo = self.slice_photo
            size_draw = QSize(min(size.width(), photo.width()),
                              min(size.height(), photo.height()))

            if not show_traces and not self.mask is None:
                #if we are not showing traces but we do have a mask
                # create a full new QPixmap which combines the slice_photo with the mask
                # more or less standard work with images
                arr_photo = self.get_np_array(photo)
                arr_photo = cv2.cvtColor(arr_photo, cv2.COLOR_BGR2RGB)
                exp_mask = np.expand_dims(self.mask, -1)
                #adding the alpha channel:
                arr_photo = np.concatenate((arr_photo, 255 * exp_mask),
                                           axis=2).astype(np.uint8)
                #creating the QImage
                qimage = QImage(arr_photo, arr_photo.shape[1],
                                arr_photo.shape[0], QImage.Format_ARGB32)
                #and the QPixmap
                pixmap = QPixmap(qimage)
                painter.drawPixmap(QRect(QPoint(0, 0), size_draw), pixmap,
                                   QRect(QPoint(0, 0), size_draw))

            else:
                painter.drawPixmap(QRect(QPoint(0, 0), size_draw), photo,
                                   QRect(QPoint(0, 0), size_draw))
                pen = QPen()
                pen.setWidth(self.pen_width)
                pen.setBrush(Qt.green)
                pen.setCapStyle(Qt.RoundCap)
                painter.setPen(pen)
                for trace in self.traces:
                    painter.drawPolyline(QPolygon(trace))
        except:
            self.logger.error(sys.exc_info()[0])
            self.logger.error(traceback.format_exc())
            return None
示例#31
0
    def create_values_text(self):
        painter = QPainter(self)
        # painter.setRenderHint(QPainter.HighQualityAntialiasing)
        painter.setRenderHint(QPainter.Antialiasing)

        # Koordinatenursprung in die Mitte der Flaeche legen
        painter.translate(self.width() / 2, self.height() / 2)
        # painter.save()
        # xShadow = 3.0
        # yShadow = 3.0
        font = QFont(self.value_fontname, self.value_fontsize)
        fm = QFontMetrics(font)

        pen_shadow = QPen()

        pen_shadow.setBrush(self.DisplayValueColor)
        painter.setPen(pen_shadow)

        text_radius = self.widget_diameter / 2 * self.text_radius_factor

        # angle_distance = (float(self.scale_angle_size) / float(self.scala_main_count))
        # for i in range(self.scala_main_count + 1):
        text = str(int(self.value))
        w = fm.width(text) + 1
        h = fm.height()
        painter.setFont(QFont(self.value_fontname, self.value_fontsize))

        # Mitte zwischen Skalenstart und Skalenende:
        # Skalenende = Skalenanfang - 360 + Skalenlaenge
        # Skalenmitte = (Skalenende - Skalenanfang) / 2 + Skalenanfang
        angle_end = float(self.scale_angle_start_value +
                          self.scale_angle_size - 360)
        angle = (angle_end - self.scale_angle_start_value
                 ) / 2 + self.scale_angle_start_value

        x = text_radius * math.cos(math.radians(angle))
        y = text_radius * math.sin(math.radians(angle))
        # print(w, h, x, y, text)
        text = [
            x - int(w / 2), y - int(h / 2),
            int(w),
            int(h), Qt.AlignCenter, text
        ]
        painter.drawText(text[0], text[1], text[2], text[3], text[4], text[5])
示例#32
0
    def __init__(self, img):
        super(DrawScene, self).__init__()

        self.imagePanel = ImageDrawPanel(parent=self, image=img)
        self.addItem(self.imagePanel)
        self.rect = QGraphicsRectItem()
        self.addItem(self.rect)

        self.setImage(img)

        pen = QPen(Qt.DashDotLine)
        pen.setBrush(Qt.red)
        # pen.setWidth(3)
        self.rect.setPen(pen)

        self.setBackgroundBrush(QBrush(Qt.darkGray))

        comm.rectResult.connect(self.drawRect)
        comm.reset.connect(self.resetRect)
示例#33
0
    def createImage(self, transform):
        sx = min(transform.m11(), transform.m22())
        sy = max(transform.m22(), sx)
        fm = QFontMetrics(Colors.headingFont())

        w = fm.width(self.text) + 1
        h = fm.height()
        xShadow = 3.0
        yShadow = 3.0

        image = QImage(int((w + xShadow) * sx), int((h + yShadow) * sy),
                QImage.Format_ARGB32_Premultiplied)
        image.fill(QColor(0, 0, 0, 0).rgba())
        painter = QPainter(image)
        painter.setFont(Colors.headingFont())
        painter.scale(sx, sy)

        # Draw shadow.
        brush_shadow = QLinearGradient(xShadow, yShadow, w, yShadow)
        brush_shadow.setSpread(QLinearGradient.PadSpread)
        if Colors.useEightBitPalette:
            brush_shadow.setColorAt(0.0, QColor(0, 0, 0))
        else:
            brush_shadow.setColorAt(0.0, QColor(0, 0, 0, 100))
        pen_shadow = QPen()
        pen_shadow.setBrush(brush_shadow)
        painter.setPen(pen_shadow)
        painter.drawText(int(xShadow), int(yShadow), int(w), int(h),
                Qt.AlignLeft, self.text)

        # Draw text.
        brush_text = QLinearGradient(0, 0, w, w)
        brush_text.setSpread(QLinearGradient.PadSpread)
        brush_text.setColorAt(0.0, QColor(255, 255, 255))
        brush_text.setColorAt(0.2, QColor(255, 255, 255))
        brush_text.setColorAt(0.5, QColor(190, 190, 190))
        pen_text = QPen()
        pen_text.setBrush(brush_text)
        painter.setPen(pen_text)
        painter.drawText(0, 0, int(w), int(h), Qt.AlignLeft, self.text)

        return image
示例#34
0
    def paintEvent(self,event):
        global monster_data
        global dmg
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        painter.drawPixmap(event.rect(),self.pixmap)

        if self.card is not None and self.card.ID is not 0:
            card = self.card
            # Draw card level at the bottom centered
            pen = QPen()
            if np.floor(card.lv) == monster_data[card.ID]['max_level']:
                lvstr = 'Lv.Max'
                brush = QBrush(QColor(252,232,131))
            else:
                lvstr = 'Lv.%d' % np.floor(card.lv)
                brush = QBrush(Qt.white)

            path = QPainterPath()
            pen.setWidth(0);
            pen.setBrush(Qt.black)

            font = QFont()
            font.setPointSize(11)
            font.setWeight(QFont.Black)
            
            path.addText(event.rect().x(),event.rect().y()+48,font,lvstr)

            rect = path.boundingRect()
            target = (event.rect().x()+event.rect().width())/2

            # center the rect in event.rect()
            path.translate(target-rect.center().x(), 0)

            painter.setPen(pen)
            painter.setBrush(QBrush(Qt.black))
            painter.drawPath(path.translated(.5,.5))

            painter.setPen(pen)
            painter.setBrush(brush)

            painter.drawPath(path)

            # Draw +eggs at the top right
            eggs = card.plus_atk+card.plus_hp+card.plus_rcv
            if eggs > 0:
                eggstr = '+%d' % eggs
                pen.setBrush(Qt.yellow)
                brush = QBrush(Qt.yellow)

                path = QPainterPath()
                pen.setWidth(0)
                pen.setBrush(Qt.black)
                font = QFont()
                font.setPointSize(11)
                font.setWeight(QFont.Black)
                path.addText(event.rect().x(),event.rect().y()+12,font,eggstr)

                path.translate(50-path.boundingRect().right()-3,0)
                #painter.setFont(font)
                painter.setPen(pen)
                painter.setBrush(QBrush(Qt.black))
                painter.drawPath(path.translated(.5,.5))

                painter.setPen(pen)
                painter.setBrush(brush)
                painter.drawPath(path)
                #painter.drawText(event.rect().adjusted(0,0,0,0),Qt.AlignRight, eggstr)

            # Draw awakenings at the top left in a green circle
            if card.current_awakening > 0:
                path = QPainterPath()
                rect = QRectF(event.rect()).adjusted(4,4,-36,-36)
                path.addEllipse(rect)
                painter.setBrush(QBrush(QColor(34,139,34)))
                pen.setBrush(Qt.white)
                pen.setWidth(1)
                painter.setPen(pen)
                painter.drawPath(path)

                path = QPainterPath()
                font.setPointSize(9)
                awkstr = ('%d' % card.current_awakening if
                        card.current_awakening < card.max_awakening else
                        '★')
                path.addText(rect.x(),rect.bottom(),font,awkstr)
                
                br = path.boundingRect()
                path.translate(rect.center().x()-br.center().x(),
                        rect.center().y()-br.center().y())

                pen.setBrush(QColor(0,0,0,0))
                pen.setWidth(0)
                painter.setPen(pen)
                painter.setBrush(QBrush(Qt.yellow))
                painter.drawPath(path)

            # Draw main attack damage
            #print(self.main_attack)
            if self.main_attack > 0:
                matkstr = '%d' % self.main_attack
                painter.setBrush(QBrush(COLORS[self.card.element[0]]))
                path = QPainterPath()
                font = QFont()
                font.setFamily('Helvetica')
                font.setWeight(QFont.Black)
                #font.setStretch(25)
                font.setPointSize(13)
                path.addText(rect.x(),rect.bottom(),font,matkstr)

                rect = QRectF(event.rect())
                br = path.boundingRect()
                path.translate(rect.center().x()-br.center().x(),
                        rect.center().y()-br.bottom()-1)

                # 
                pen.setBrush(Qt.black)
                pen.setWidthF(.75)
                painter.setPen(pen)
                painter.drawPath(path)

            # Draw sub attack damage
            #print(self.main_attack)
            if self.sub_attack > 0:
                satkstr = '%d' % self.sub_attack
                painter.setBrush(QBrush(COLORS[self.card.element[1]]))
                path = QPainterPath()
                font = QFont()
                font.setFamily('Helvetica')
                font.setWeight(QFont.Black)
                #font.setStretch(25)
                font.setPointSize(12)
                path.addText(rect.x(),rect.bottom(),font,satkstr)

                rect = QRectF(event.rect())
                br = path.boundingRect()
                path.translate(rect.center().x()-br.center().x(),
                        rect.center().y()-br.top()+1)

                # 
                pen.setBrush(Qt.black)
                pen.setWidthF(.75)
                painter.setPen(pen)
                painter.drawPath(path)