コード例 #1
0
ファイル: rulerTool.py プロジェクト: anthrotype/trufont
    def paint(self, painter):
        widget = self.parent()
        scale = widget.inverseScale()
        # metrics
        if self._rulerObject is not None:
            line, d, a = self._rulerObject
            origin = line.p1()
            cursor = line.p2()
            sz = 8 * scale
            color = QColor(140, 193, 255, 170)

            # line
            painter.save()
            painter.setPen(color)
            drawing.drawLine(painter, origin.x(), origin.y(), cursor.x(), cursor.y(), scale)
            path = QPainterPath()
            path.addEllipse(origin.x() - sz / 2, origin.y() - sz / 2, sz, sz)
            path.addEllipse(cursor.x() - sz / 2, cursor.y() - sz / 2, sz, sz)
            painter.fillPath(path, color)
            painter.restore()
            # text
            xAlign = yAlign = "center"
            pos = (origin + cursor) / 2
            drawing.drawTextAtPoint(painter, d, pos.x(), pos.y(), scale, xAlign, yAlign)
            xAlign, yAlign = "left", "top"
            dx = cursor.x() - origin.x()
            if dx < 0:
                xAlign = "right"
            drawing.drawTextAtPoint(painter, a, cursor.x(), cursor.y(), scale, xAlign, yAlign)
コード例 #2
0
ファイル: line_graph.py プロジェクト: justbuchanan/qbar
    def paintEvent(self, event):
        # Draw backgrounds according to css
        styleOpt = QStyleOption()
        styleOpt.initFrom(self)
        p = QPainter(self)
        p.setRenderHint(QPainter.Antialiasing)
        self.style().drawPrimitive(QStyle.PE_Widget, styleOpt, p, self)

        if self.values == None or len(self.values) == 0: return

        # print(len(self.values))

        r = self.rect()
        dx = r.width() / float(self.datapoints - 1)

        # Build a path from the readings
        path = QPainterPath()
        path.moveTo(r.bottomRight())
        i = 0
        for reading in reversed(self.values):
            pt = QPointF(r.width() - i*dx, (1.0 - reading) * r.height())
            path.lineTo(pt)
            i = i + 1
        path.lineTo(path.currentPosition().x(), r.height())
        path.closeSubpath()

        # Use foreground color for graph
        gcolor = styleOpt.palette.color(QPalette.Text)
        p.setBrush(gcolor)
        p.setPen(gcolor)
        p.drawPath(path)
コード例 #3
0
ファイル: floor_plan.py プロジェクト: hibtc/madgui
 def orbit(self):
     """Return a QPainterPath that shows the beam orbit."""
     a, b = self.endpoints()
     path = QPainterPath()
     path.moveTo(*a)
     path.lineTo(*b)
     return path
コード例 #4
0
ファイル: selectslicetool.py プロジェクト: cadnano/cadnano2.5
    def painterPath(self):
        rect = self._rect
        radius = self._RADIUS

        path = QPainterPath()
        path.addRoundedRect(rect, radius, radius)
        return path
コード例 #5
0
ファイル: sdlSymbols.py プロジェクト: examon/opengeode
 def set_shape(self, width, height):
     ''' Define the bouding rectangle of the JOIN symbol '''
     circ = min(width, height)
     path = QPainterPath()
     path.addEllipse(0, 0, circ, circ)
     self.setPath(path)
     super(Join, self).set_shape(width, height)
コード例 #6
0
ファイル: qneblock.py プロジェクト: sphaero/pyQNodesEditor
    def addPort(self, name, isOutput = False, flags = 0, ptr = None):
        port = QNEPort(self)
        port.setName(name)
        port.setIsOutput(isOutput)
        port.setNEBlock(self)
        port.setPortFlags(flags)
        port.setPtr(ptr)

        fontmetrics = QFontMetrics(self.scene().font());
        width = fontmetrics.width(name)
        height = fontmetrics.height()
        if width > self.width - self.horzMargin:
            self.width = width + self.horzMargin
        self.height += height

        path = QPainterPath()
        path.addRoundedRect(-self.width/2, -self.height/2, self.width, self.height, 5, 5)
        self.setPath(path)

        y = -self.height / 2 + self.vertMargin + port.radius()
        for port_ in self.childItems():
            if port_.type() != QNEPort.Type:
                continue

            if port_.isOutput():
                port_.setPos(self.width/2 + port.radius(), y)
            else:
                port_.setPos(-self.width/2 - port.radius(), y)
            y += height;

        return port
コード例 #7
0
ファイル: bar.py プロジェクト: sdouglas/lr-notebook
 def updateAngle(self, startAngle, spanAngle):
     self._startAngle = startAngle
     self._spanAngle = spanAngle
     path = QPainterPath()
     path.arcMoveTo(self._parent._rect, startAngle)
     path.arcTo(self._parent._rect, startAngle, spanAngle)
     self.setPath(path)
コード例 #8
0
    def draw_connection_line(self, painter, x1, y1, x2, y2, h1, h2):
        # Account for list view headers.
        y1 += h1
        y2 += h2

        # Invisible output ports don't get a connecting dot.
        if y1 > h1:
            painter.drawLine(x1, y1, x1 + 4, y1)

        # Setup control points
        spline = QPolygon(4)
        cp = int((x2 - x1 - 8) * 0.4)
        spline.setPoints(x1 + 4, y1,
                         x1 + 4 + cp, y1,
                         x2 - 4 - cp, y2,
                         x2 - 4, y2)
        # The connection line
        path = QPainterPath()
        path.moveTo(spline.at(0))
        path.cubicTo(spline.at(1), spline.at(2), spline.at(3))
        painter.strokePath(path, painter.pen())

        # painter.drawLine(x1 + 4, y1, x2 - 4, y2)

        # Invisible input ports don't get a connecting dot.
        if y2 > h2:
            painter.drawLine(x2 - 4, y2, x2, y2)
コード例 #9
0
ファイル: sliceSelectorHud.py プロジェクト: ilastik/volumina
def _get_pos_widget(name, backgroundColor, foregroundColor):
    label = QLabel()
    label.setAttribute(Qt.WA_TransparentForMouseEvents, True)

    pixmap = QPixmap(25 * 10, 25 * 10)
    pixmap.fill(backgroundColor)
    painter = QPainter()
    painter.begin(pixmap)
    pen = QPen(foregroundColor)
    painter.setPen(pen)
    painter.setRenderHint(QPainter.Antialiasing)
    font = QFont()
    font.setBold(True)
    font.setPixelSize(25 * 10 - 30)
    path = QPainterPath()
    path.addText(QPointF(50, 25 * 10 - 50), font, name)
    brush = QBrush(foregroundColor)
    painter.setBrush(brush)
    painter.drawPath(path)
    painter.setFont(font)
    painter.end()
    pixmap = pixmap.scaled(QSize(20, 20), Qt.KeepAspectRatio, Qt.SmoothTransformation)
    label.setPixmap(pixmap)

    spinbox = DelayedSpinBox(750)
    spinbox.setAlignment(Qt.AlignCenter)
    spinbox.setToolTip("{0} Spin Box".format(name))
    spinbox.setButtonSymbols(QAbstractSpinBox.NoButtons)
    spinbox.setMaximumHeight(20)
    font = spinbox.font()
    font.setPixelSize(14)
    spinbox.setFont(font)
    sheet = TEMPLATE.format(foregroundColor.name(), backgroundColor.name())
    spinbox.setStyleSheet(sheet)
    return label, spinbox
コード例 #10
0
ファイル: drawing.py プロジェクト: pathumego/trufont
def drawGlyphAnchors(painter, glyph, scale, rect, drawAnchors=True,
                     drawText=True, color=None):
    if not glyph.anchors:
        return
    if color is None:
        color = defaultColor("glyphAnchor")
    fallbackColor = color
    anchorSize = 6 * scale
    anchorHalfSize = anchorSize / 2
    for anchor in glyph.anchors:
        if anchor.color is not None:
            color = colorToQColor(anchor.color)
        else:
            color = fallbackColor
        x = anchor.x
        y = anchor.y
        name = anchor.name
        painter.save()
        # XXX: put gfx form to selected anchors
        if drawAnchors:
            path = QPainterPath()
            path.addEllipse(x - anchorHalfSize, y - anchorHalfSize,
                            anchorSize, anchorSize)
            painter.fillPath(path, color)
        if drawText and name:
            painter.setPen(color)
            # TODO: we're using + before we shift to top, ideally this should
            # be abstracted w drawTextAtPoint taking a dy parameter that will
            # offset the drawing region from origin regardless of whether we
            # are aligning to top or bottom.
            y += 3 * scale
            drawTextAtPoint(painter, name, x, y, scale,
                            xAlign="center", yAlign="top")
        painter.restore()
コード例 #11
0
ファイル: padulator.py プロジェクト: sparsile/padulator
    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)
コード例 #12
0
ファイル: concept.py プロジェクト: gitter-badger/eddy
 def painterPath(self):
     """
     Returns the current shape as QPainterPath (used for collision detection).
     :rtype: QPainterPath
     """
     path = QPainterPath()
     path.addRect(self.polygon)
     return path
コード例 #13
0
ファイル: operator.py プロジェクト: gitter-badger/eddy
 def shape(self):
     """
     Returns the shape of this item as a QPainterPath in local coordinates.
     :rtype: QPainterPath
     """
     path = QPainterPath()
     path.addPolygon(self.polygon)
     return path
コード例 #14
0
ファイル: label.py プロジェクト: gitter-badger/eddy
 def shape(self):
     """
     Returns the shape of this item as a QPainterPath in local coordinates.
     :rtype: QPainterPath
     """
     path = QPainterPath()
     path.addRect(self.boundingRect())
     return path
コード例 #15
0
ファイル: Connectors.py プロジェクト: examon/opengeode
 def __init__(self, pos, edge, symbol):
     ''' Create the point - as a small, lightblue box '''
     super(Connectionpoint, self).__init__(pos, edge=edge)
     path = QPainterPath()
     path.addRect(0, 0, 10, 10)
     self.setPath(path)
     self.setPos(pos.x() - 5, pos.y() - 5)
     # Symbol actually owning the connection point
     self.symbol = symbol
コード例 #16
0
ファイル: concept.py プロジェクト: gitter-badger/eddy
 def shape(self):
     """
     Returns the shape of this item as a QPainterPath in local coordinates.
     :rtype: QPainterPath
     """
     path = QPainterPath()
     path.addRect(self.polygon)
     for shape in self.handleBound:
         path.addEllipse(shape)
     return path
コード例 #17
0
ファイル: areaitem.py プロジェクト: zdenop/pyTesseractDemo
 def shape(self):
     """
     Returns the shape of this item as a QPainterPath in local coordinates.
     """
     path = QPainterPath()
     path.addRect(self.rect())
     if self.isSelected():
         for shape in self.handles.values():
             path.addEllipse(shape)
     return path
コード例 #18
0
ファイル: inclusion.py プロジェクト: gitter-badger/eddy
 def painterPath(self):
     """
     Returns the current shape as QPainterPath (used for collision detection).
     :rtype: QPainterPath
     """
     path = QPainterPath()
     path.addPath(self.path)
     path.addPolygon(self.head)
     path.addPolygon(self.tail)
     return path
コード例 #19
0
ファイル: griditem.py プロジェクト: hadim/cadnano2.5
    def doHoneycomb(self, part_item, radius, bounds):
        """Summary

        Args:
            part_item (TYPE): Description
            radius (TYPE): Description
            bounds (TYPE): Description

        Returns:
            TYPE: Description
        """
        doLattice = HoneycombDnaPart.latticeCoordToPositionXY
        doPosition = HoneycombDnaPart.positionToLatticeCoordRound
        isEven = HoneycombDnaPart.isEvenParity
        x_l, x_h, y_l, y_h = bounds
        dot_size, half_dot_size = self.dots
        sf = part_item.scale_factor
        points = self.points
        row_l, col_l = doPosition(radius, x_l, -y_l, False, False, scale_factor=sf)
        row_h, col_h = doPosition(radius, x_h, -y_h, True, True, scale_factor=sf)
        # print(row_l, row_h, col_l, col_h)

        path = QPainterPath()
        is_pen_down = False
        draw_lines = self.draw_lines
        for i in range(row_l, row_h):
            for j in range(col_l, col_h+1):
                x, y = doLattice(radius, i, j, scale_factor=sf)
                if draw_lines:
                    if is_pen_down:
                        path.lineTo(x, -y)
                    else:
                        is_pen_down = True
                        path.moveTo(x, -y)
                """ +x is Left and +y is down
                origin of ellipse is Top Left corner so we subtract half in X
                and subtract in y
                """
                pt = GridPoint(x - half_dot_size,
                               -y - half_dot_size,
                               dot_size, self)
                pt.setPen(getPenObj(Qt.blue, 1.0))
                points.append(pt)
            is_pen_down = False
        # end for i
        # DO VERTICAL LINES
        if draw_lines:
            for j in range(col_l, col_h+1):
                # print("newcol")
                for i in range(row_l, row_h):
                    x, y = doLattice(radius, i, j, scale_factor=sf)
                    if is_pen_down and isEven(i, j):
                        path.lineTo(x, -y)
                        is_pen_down = False
                    else:
                        is_pen_down = True
                        path.moveTo(x, -y)
                is_pen_down = False
            # end for j
        self.setPath(path)
コード例 #20
0
ファイル: Connectors.py プロジェクト: examon/opengeode
 def __init__(self, pos, edge):
     ''' Set the original control point - with color, shape '''
     path = QPainterPath()
     path.addEllipse(pos.x() - 5, pos.y() - 5, 10, 10)
     super(Controlpoint, self).__init__(path, parent=edge)
     self.setPen(QColor(50, 100, 120, 200))
     self.setBrush(QColor(200, 200, 210, 120))
     self.setFlags(QGraphicsItem.ItemIsSelectable |
                   QGraphicsItem.ItemIsMovable)
     self.edge = edge
     self.hide()
コード例 #21
0
ファイル: sdlSymbols.py プロジェクト: examon/opengeode
 def set_shape(self, width, height):
     ''' Compute the polygon to fit in width, height '''
     self.setPen(QPen(Qt.blue))
     self.textbox_alignment = Qt.AlignLeft | Qt.AlignTop
     path = QPainterPath()
     path.moveTo(0, 0)
     path.lineTo(0, height)
     #path.moveTo(0, height / 2)
     #path.lineTo(width, height / 2)
     self.setPath(path)
     super(Input, self).set_shape(width, height)
コード例 #22
0
ファイル: tablet.py プロジェクト: Kracav4ik/kana
    def paint_to(self, painter):
        if len(self.points) > 1:
            painter.setPen(Qt.red)
            paint_path = QPainterPath()
            paint_path.moveTo(*self.points[0][0])
            for pos, _ in self.points[1:]:
                paint_path.lineTo(*pos)
            painter.drawPath(paint_path)

        painter.setPen(Qt.green)
        for pos, _ in self.points:
            painter.drawPoint(*pos)
コード例 #23
0
ファイル: sdlSymbols.py プロジェクト: examon/opengeode
    def set_shape(self, width, height):
        ''' Compute the polygon to fit in width, height '''
        path = QPainterPath()
        path.addRoundedRect(0, 0, width, height, height / 4, height)

        if self.nested_scene and self.is_composite():
            # Distinguish composite states with dash line
            self.setPen(QPen(Qt.DashLine))
        else:
            self.setPen(QPen(Qt.SolidLine))
        self.setPath(path)
        super(State, self).set_shape(width, height)
コード例 #24
0
ファイル: drawing.py プロジェクト: adrientetar/defconQt
def lozengePath(x, y, size):
    halfSize = size / 2
    path = QPainterPath()
    path.moveTo(x - halfSize, y)
    path.lineTo(x, y + halfSize)
    path.lineTo(x + halfSize, y)
    path.lineTo(x, y - halfSize)
    path.closeSubpath()
    return path
コード例 #25
0
ファイル: insertionitem.py プロジェクト: hadim/cadnano2.5
    def _updateSequenceText(self):
        seq_item = self._seq_item
        is_on_top = self._is_on_top
        index = self._insertion.idx()
        base_text = self._seq_text
        font = styles.SEQUENCEFONT
        seq_font_h = styles.SEQUENCEFONTH
        insert_w = styles.INSERTWIDTH
        seq_font_char_w = styles.SEQUENCEFONTCHARWIDTH
        # draw sequence on the insert
        if base_text:  # only draw sequences if they exist i.e. not None!
            len_BT = len(base_text)
            if is_on_top:
                angle_offset = 0
            else:
                angle_offset = 180
            if len_BT > 20:
                base_text = base_text[:17] + '...'
                len_BT = len(base_text)
            fraction_arc_len_per_char = (1.0 - 2.0*_FRACTION_INSERT_TO_PAD) / (len_BT + 1)
            seq_item.setPen(QPen(Qt.NoPen))
            seq_item.setBrush(QBrush(Qt.black))

            seq_path = QPainterPath()
            loop_path = self.path()
            for i in range(len_BT):
                frac = _FRACTION_INSERT_TO_PAD + (i+1)*fraction_arc_len_per_char
                pt = loop_path.pointAtPercent(frac)
                tang_ang = loop_path.angleAtPercent(frac)

                temp_path = QPainterPath()
                # 1. draw the text
                temp_path.addText(0, 0, font, base_text[i if is_on_top else -i-1])
                # 2. center it at the zero point different for top and bottom
                # strands
                if not is_on_top:
                    temp_path.translate(0, -seq_font_h - insert_w)

                temp_path.translate(QPointF(-seq_font_char_w / 2.,
                                          -2 if is_on_top else seq_font_h))


                mat = QTransform()
                # 3. rotate it
                mat.rotate(-tang_ang + angle_offset)

                rotated_path = mat.map(temp_path)
                # 4. translate the rotate object to it's position on the part
                rotated_path.translate(pt)
                seq_path.addPath(rotated_path)
            # end for
            seq_item.setPath(seq_path)
コード例 #26
0
ファイル: sdlSymbols.py プロジェクト: examon/opengeode
 def set_shape(self, width, height):
     ''' Compute the polygon to fit in width, height '''
     path = QPainterPath()
     path.lineTo(width, 0)
     path.lineTo(width, height)
     path.lineTo(0, height)
     path.lineTo(0, 0)
     self.setPath(path)
     super(Task, self).set_shape(width, height)
コード例 #27
0
ファイル: sdlSymbols.py プロジェクト: examon/opengeode
 def set_shape(self, width, height):
     ''' Define polygon points to draw the symbol '''
     path = QPainterPath()
     path.moveTo(width / 2, 0)
     path.lineTo(width, height / 2)
     path.lineTo(width / 2, height)
     path.lineTo(0, height / 2)
     path.lineTo(width / 2, 0)
     self.setPath(path)
     super(Decision, self).set_shape(width, height)
コード例 #28
0
ファイル: rulerTool.py プロジェクト: mandel59/trufont
 def mousePressEvent(self, event):
     pos = self.magnetPos(event.localPos())
     x, y = pos.x(), pos.y()
     path = QPainterPath()
     path.moveTo(x, y)
     path.lineTo(x + 1, y)
     path.lineTo(x + 1, y + 1)
     path.closeSubpath()
     text = "0"
     self._rulerObject = (path, text)
コード例 #29
0
ファイル: StudyPlan.py プロジェクト: louisraccoon/PyStudy
    def itemRegion(self, index):
        if not index.isValid():
            return QRegion()

        if index.column() != 1:
            return QRegion(self.itemRect(index))

        if self.model().data(index) <= 0.0:
            return QRegion()

        startAngle = 0.0
        for row in range(self.model().rowCount(self.rootIndex())):

            sliceIndex = self.model().index(row, 1, self.rootIndex())
            value = self.model().data(sliceIndex)

            if value > 0.0:
                angle = 360*value/self.totalValue

                if sliceIndex == index:
                    slicePath = QPainterPath()
                    slicePath.moveTo(self.totalSize/2, self.totalSize/2)
                    slicePath.arcTo(self.margin, self.margin,
                            self.margin+self.pieSize, self.margin+self.pieSize,
                            startAngle, angle)
                    slicePath.closeSubpath()

                    return QRegion(slicePath.toFillPolygon().toPolygon())

                startAngle += angle

        return QRegion()
コード例 #30
0
ファイル: my_buttons.py プロジェクト: minlexx/xnovacmd
 def _drawTextShadow(self, painter: QPainter, x: int, y: int, text: str):
     font = self.font()
     # setup outline path
     text_path = QPainterPath()
     text_path.addText(x, y, font, text)
     # draw outline path 1
     painter.setPen(self.outline_pen)
     painter.setBrush(self.outline_brush)
     painter.drawPath(text_path)
     # draw text
     painter.setPen(self.text_color)
     painter.setFont(font)
     # Note: The y-position is used as the baseline of the font.
     painter.drawText(x, y, text)
コード例 #31
0
from . import slicestyles as styles

PXI_PP_ITEM_WIDTH = IW = 2.0  # 1.5
TRIANGLE = QPolygonF()
TRIANGLE.append(QPointF(0, 0))
TRIANGLE.append(QPointF(0.75*IW, 0.5*IW))
TRIANGLE.append(QPointF(0, IW))
TRIANGLE.append(QPointF(0, 0))
# TRIANGLE.translate(-0.75*IW, -0.5*IW)
TRIANGLE.translate(-0.25*IW, -0.5*IW)

PXI_RECT = QRectF(0, 0, IW, IW)
T90, T270 = QTransform(), QTransform()
T90.rotate(90)
T270.rotate(270)
FWDPXI_PP, REVPXI_PP = QPainterPath(), QPainterPath()
FWDPXI_PP.addPolygon(T90.map(TRIANGLE))
REVPXI_PP.addPolygon(T270.map(TRIANGLE))

# FWDPXI_PP.moveTo(-0.5*IW, 0.7*IW)
# FWDPXI_PP.lineTo(0., -0.2*IW)
# FWDPXI_PP.lineTo(0.5*IW, 0.7*IW)
# extra1 = QPainterPath()
# extra1.addEllipse(-0.5*IW, 0.5*IW, IW, 0.4*IW)
# extra2 = QPainterPath()
# extra2.addEllipse(-0.35*IW, 0.5*IW, 0.7*IW, 0.3*IW)
# FWDPXI_PP += extra1
# FWDPXI_PP -= extra2

# REVPXI_PP.moveTo(-0.5*IW, -0.7*IW)
# REVPXI_PP.lineTo(0., 0.2*IW)
コード例 #32
0
    def createGraphics(self):
        """ Create the graphical representation of the FMU's inputs and outputs """

        def variableColor(variable):
            if variable.type == 'Real':
                return QColor.fromRgb(0, 0, 127)
            elif variable.type in ['Integer', 'Enumeration']:
                return QColor.fromRgb(255, 127, 0)
            elif variable.type == 'Boolean':
                return QColor.fromRgb(255, 0, 255)
            elif variable.type == 'String':
                return QColor.fromRgb(0, 128, 0)
            else:
                return QColor.fromRgb(0, 0, 0)

        inputVariables = []
        outputVariables = []
        maxInputLabelWidth = 0
        maxOutputLabelWidth = 0

        textItem = QGraphicsTextItem()
        fontMetrics = QFontMetricsF(textItem.font())

        for variable in self.modelDescription.modelVariables:
            if variable.causality == 'input':
                inputVariables.append(variable)
            elif variable.causality == 'output':
                outputVariables.append(variable)

        for variable in inputVariables:
            maxInputLabelWidth = max(maxInputLabelWidth, fontMetrics.width(variable.name))

        for variable in outputVariables:
            maxOutputLabelWidth = max(maxOutputLabelWidth, fontMetrics.width(variable.name))

        from math import floor

        scene = QGraphicsScene()
        self.ui.graphicsView.setScene(scene)
        group = QGraphicsItemGroup()
        scene.addItem(group)
        group.setPos(200.5, -50.5)
        lh = 15  # line height

        w = max(150., maxInputLabelWidth + maxOutputLabelWidth + 20)
        h = max(50., 10 + lh * max(len(inputVariables), len(outputVariables)))

        block = QGraphicsRectItem(0, 0, w, h, group)
        block.setPen(QColor.fromRgb(0, 0, 255))

        pen = QPen()
        pen.setWidthF(1)

        font = QFont()
        font.setPixelSize(10)

        # inputs
        y = floor((h - len(inputVariables) * lh) / 2 - 2)
        for variable in inputVariables:
            text = QGraphicsTextItem(variable.name, group)
            text.setDefaultTextColor(QColor.fromRgb(0, 0, 255))
            text.setFont(font)
            text.setX(3)
            text.setY(y)

            polygon = QPolygonF([QPointF(-13.5, y + 4), QPointF(1, y + 11), QPointF(-13.5, y + 18)])

            path = QPainterPath()
            path.addPolygon(polygon)
            path.closeSubpath()
            contour = QGraphicsPathItem(path, group)
            contour.setPen(QPen(Qt.NoPen))
            contour.setBrush(variableColor(variable))

            y += lh

        # outputs
        y = floor((h - len(outputVariables) * lh) / 2 - 2)
        for variable in outputVariables:
            text = QGraphicsTextItem(variable.name, group)
            text.setDefaultTextColor(QColor.fromRgb(0, 0, 255))
            text.setFont(font)
            text.setX(w - 3 - text.boundingRect().width())
            text.setY(y)

            polygon = QPolygonF([QPointF(w, y + 0 + 7.5), QPointF(w + 7, y + 3.5 + 7.5), QPointF(w, y + 7 + 7.5)])

            path = QPainterPath()
            path.addPolygon(polygon)
            path.closeSubpath()
            contour = QGraphicsPathItem(path, group)
            pen = QPen()
            pen.setColor(variableColor(variable))
            pen.setJoinStyle(Qt.MiterJoin)
            contour.setPen(pen)

            y += lh
コード例 #33
0
 def shape(self):
     '''用来进行碰撞检测,这里对于QPP添加一个范围为Head.Rect的圆来定义Path'''
     # 如果两个头部的矩形交叉,但头部椭圆没有碰撞,则不会检测到碰撞
     path = QPainterPath()
     path.addEllipse(Head.Rect)
     return path
コード例 #34
0
ファイル: WaterWidget.py プロジェクト: zizle/PyQtClient
    def paintEvent(self, event):
        super(WaterWidget, self).paintEvent(event)
        if self.minimum >= self.maximum:
            return
        if not self._updateTimer.isActive():
            return

        # 正弦曲线公式 y = A * sin(ωx + φ) + k
        # 当前值所占百分比
        percent = 1 - (self._value - self.minimum) / \
            (self.maximum - self.minimum)
        # w表示周期,6为人为定义
        w = 6 * self.waterDensity * math.pi / self.width()
        # A振幅 高度百分比,1/26为人为定义
        A = self.height() * self.waterHeight * 1 / 26
        # k 高度百分比
        k = self.height() * percent

        # 波浪1
        waterPath1 = QPainterPath()
        waterPath1.moveTo(0, self.height())  # 起点在左下角
        # 波浪2
        waterPath2 = QPainterPath()
        waterPath2.moveTo(0, self.height())  # 起点在左下角

        # 偏移
        self._offset += 0.6
        if self._offset > self.width() / 2:
            self._offset = 0

        for i in range(self.width() + 1):
            # 从x轴开始计算y轴点
            y = A * math.sin(w * i + self._offset) + k
            waterPath1.lineTo(i, y)

            # 相对第一条需要进行错位
            y = A * math.sin(w * i + self._offset + self.width() / 2 * A) + k
            waterPath2.lineTo(i, y)

        # 封闭两条波浪,形成一个 U形 上面加波浪的封闭区间
        waterPath1.lineTo(self.width(), self.height())
        waterPath1.lineTo(0, self.height())
        waterPath2.lineTo(self.width(), self.height())
        waterPath2.lineTo(0, self.height())

        # 开始画路径
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing, True)
        painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
        # 设置没有画笔
        painter.setPen(Qt.NoPen)

        # 波浪1
        painter.save()
        painter.setBrush(self._waterBgColor)
        painter.drawPath(waterPath1)
        painter.restore()

        # 波浪2
        painter.save()
        painter.setBrush(self._waterFgColor)
        painter.drawPath(waterPath2)
        painter.restore()
コード例 #35
0
ファイル: pixmapdial.py プロジェクト: denisfitz57/Carla
    def paintEvent(self, event):
        painter = QPainter(self)
        event.accept()

        painter.save()
        painter.setRenderHint(QPainter.Antialiasing, True)

        if self.fLabel:
            if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
                painter.setPen(self.fLabelGradientColor2)
                painter.setBrush(self.fLabelGradient)
                painter.drawRect(self.fLabelGradientRect)

            painter.setFont(self.fLabelFont)
            painter.setPen(
                self.fLabelGradientColorT[0 if self.isEnabled() else 1])
            painter.drawText(self.fLabelPos, self.fLabel)

        if self.isEnabled():
            normValue = float(self.fRealValue -
                              self.fMinimum) / float(self.fMaximum -
                                                     self.fMinimum)
            target = QRectF(0.0, 0.0, self.fPixmapBaseSize,
                            self.fPixmapBaseSize)

            curLayer = int((self.fPixmapLayersCount - 1) * normValue)

            if self.fPixmapOrientation == self.HORIZONTAL:
                xpos = self.fPixmapBaseSize * curLayer
                ypos = 0.0
            else:
                xpos = 0.0
                ypos = self.fPixmapBaseSize * curLayer

            source = QRectF(xpos, ypos, self.fPixmapBaseSize,
                            self.fPixmapBaseSize)
            painter.drawPixmap(target, self.fPixmap, source)

            # Custom knobs (Dry/Wet and Volume)
            if self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_WET,
                                         self.CUSTOM_PAINT_MODE_CARLA_VOL):
                # knob color
                colorGreen = QColor(0x5D, 0xE7,
                                    0x3D).lighter(100 + self.fHoverStep * 6)
                colorBlue = QColor(0x3E, 0xB8,
                                   0xBE).lighter(100 + self.fHoverStep * 6)

                # draw small circle
                ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
                ballPath = QPainterPath()
                ballPath.addEllipse(ballRect)
                #painter.drawRect(ballRect)
                tmpValue = (0.375 + 0.75 * normValue)
                ballValue = tmpValue - floor(tmpValue)
                ballPoint = ballPath.pointAtPercent(ballValue)

                # draw arc
                startAngle = 216 * 16
                spanAngle = -252 * 16 * normValue

                if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_WET:
                    painter.setBrush(colorBlue)
                    painter.setPen(QPen(colorBlue, 0))
                    painter.drawEllipse(
                        QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))

                    gradient = QConicalGradient(15.5, 15.5, -45)
                    gradient.setColorAt(0.0, colorBlue)
                    gradient.setColorAt(0.125, colorBlue)
                    gradient.setColorAt(0.625, colorGreen)
                    gradient.setColorAt(0.75, colorGreen)
                    gradient.setColorAt(0.76, colorGreen)
                    gradient.setColorAt(1.0, colorGreen)
                    painter.setBrush(gradient)
                    painter.setPen(QPen(gradient, 3))

                else:
                    painter.setBrush(colorBlue)
                    painter.setPen(QPen(colorBlue, 0))
                    painter.drawEllipse(
                        QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))

                    painter.setBrush(colorBlue)
                    painter.setPen(QPen(colorBlue, 3))

                painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)

            # Custom knobs (L and R)
            elif self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_L,
                                           self.CUSTOM_PAINT_MODE_CARLA_R):
                # knob color
                color = QColor(0xAD, 0xD5,
                               0x48).lighter(100 + self.fHoverStep * 6)

                # draw small circle
                ballRect = QRectF(7.0, 8.0, 11.0, 12.0)
                ballPath = QPainterPath()
                ballPath.addEllipse(ballRect)
                #painter.drawRect(ballRect)
                tmpValue = (0.375 + 0.75 * normValue)
                ballValue = tmpValue - floor(tmpValue)
                ballPoint = ballPath.pointAtPercent(ballValue)

                painter.setBrush(color)
                painter.setPen(QPen(color, 0))
                painter.drawEllipse(
                    QRectF(ballPoint.x(), ballPoint.y(), 2.0, 2.0))

                # draw arc
                if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_L:
                    startAngle = 216 * 16
                    spanAngle = -252.0 * 16 * normValue
                else:
                    startAngle = 324.0 * 16
                    spanAngle = 252.0 * 16 * (1.0 - normValue)

                painter.setPen(QPen(color, 2))
                painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)

            # Custom knobs (Color)
            elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_COLOR:
                # knob color
                color = self.fCustomPaintColor.lighter(100 +
                                                       self.fHoverStep * 6)

                # draw small circle
                ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
                ballPath = QPainterPath()
                ballPath.addEllipse(ballRect)
                tmpValue = (0.375 + 0.75 * normValue)
                ballValue = tmpValue - floor(tmpValue)
                ballPoint = ballPath.pointAtPercent(ballValue)

                # draw arc
                startAngle = 216 * 16
                spanAngle = -252 * 16 * normValue

                painter.setBrush(color)
                painter.setPen(QPen(color, 0))
                painter.drawEllipse(
                    QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))

                painter.setBrush(color)
                painter.setPen(QPen(color, 3))
                painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)

            # Custom knobs (Zita)
            elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_ZITA:
                a = normValue * pi * 1.5 - 2.35
                r = 10.0
                x = 10.5
                y = 10.5
                x += r * sin(a)
                y -= r * cos(a)
                painter.setBrush(Qt.black)
                painter.setPen(QPen(Qt.black, 2))
                painter.drawLine(QPointF(11.0, 11.0), QPointF(x, y))

            # Custom knobs
            else:
                painter.restore()
                return

            if self.HOVER_MIN < self.fHoverStep < self.HOVER_MAX:
                self.fHoverStep += 1 if self.fIsHovered else -1
                QTimer.singleShot(20, self.update)

        else:  # isEnabled()
            target = QRectF(0.0, 0.0, self.fPixmapBaseSize,
                            self.fPixmapBaseSize)
            painter.drawPixmap(target, self.fPixmap, target)

        painter.restore()
コード例 #36
0
ファイル: drawFlowsheet.py プロジェクト: MAZamarripa/FOQUS-1
 def drawGrid(self):
     '''
         Draw the grid for the drawing area
     '''
     # Add vertical minor grids
     path = QPainterPath()
     minLoc = self.xMinGrid + self.minorGrid
     maxLoc = self.xMaxGrid
     gStep = self.minorGrid
     for i in range(minLoc, maxLoc, gStep):
         path.moveTo(i, self.yMinGrid)
         path.lineTo(i, self.yMaxGrid)
     self.addPath(path, self.minorGridPen)
     # Add horizontal minor grids
     path = QPainterPath()
     for i in range(minLoc, maxLoc, gStep):
         path.moveTo(self.xMinGrid, i)
         path.lineTo(self.xMaxGrid, i)
     self.addPath(path, self.minorGridPen)
     # Add vertical minor grids
     path = QPainterPath()
     minLoc = self.xMinGrid
     maxLoc = self.xMaxGrid
     gStep = self.majorGrid
     for i in range(minLoc, maxLoc, gStep):
         path.moveTo(i, self.yMinGrid)
         path.lineTo(i, self.yMaxGrid)
     self.addPath(path, self.majorGridPen)
     # Add vertical minor grids
     path = QPainterPath()
     for i in range(minLoc, maxLoc, gStep):
         path.moveTo(self.xMinGrid, i)
         path.lineTo(self.xMaxGrid, i)
     self.addPath(path, self.majorGridPen)
コード例 #37
0
ファイル: line.py プロジェクト: rnk-industries/Chemical-PFD
class Grabber(QGraphicsPathItem):
    """
    Extends QGraphicsPathItem to create grabber for line for moving a particular segment
    """
    circle = QPainterPath()
    circle.addEllipse(QRectF(-5, -5, 10, 10))

    def __init__(self, annotation_line, index, direction):
        super(Grabber, self).__init__()
        # store line to which it connects
        self.m_annotation_item = annotation_line
        # index of first point of segment of above line
        self.m_index = index
        self.direction = direction
        self.setPath(Grabber.circle)
        # set graphical settings for this item
        self.setFlag(QGraphicsItem.ItemIsSelectable, True)
        self.setFlag(QGraphicsItem.ItemIsMovable, True)
        self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True)
        self.setAcceptHoverEvents(True)
        # initially make invisible
        self.pen = QPen(Qt.white, -1, Qt.SolidLine)
        self.brush = QBrush(Qt.transparent)

    def itemChange(self, change, value):
        """ move position of grabber after resize"""
        if change == QGraphicsItem.ItemPositionChange and self.isEnabled():
            p = QPointF(self.pos())
            if self.direction == Qt.Horizontal:
                p.setX(value.x())
                if self.parentItem().refLine and self.m_index == len(self.parentItem().points) - 2:
                    points = self.parentItem().refLine.points
                    point1 = points[self.parentItem().refIndex]
                    point2 = points[self.parentItem().refIndex + 1]
                    point1 = self.parentItem().mapFromItem(self.parentItem().refLine, point1)
                    point2 = self.parentItem().mapFromItem(self.parentItem().refLine, point2)
                    if p.x() < min(point1.x(), point2.x()):
                        p.setX(min(point1.x(), point2.x()))
                    elif p.x() > max(point1.x(), point2.x()):
                        p.setX(max(point1.x(), point2.x()))
            elif self.direction == Qt.Vertical:
                p.setY(value.y())
                if self.parentItem().refLine and self.m_index == len(self.parentItem().points) - 2:
                    points = self.parentItem().refLine.points
                    point1 = points[self.parentItem().refIndex]
                    point2 = points[self.parentItem().refIndex + 1]
                    point1 = self.parentItem().mapFromItem(self.parentItem().refLine, point1)
                    point2 = self.parentItem().mapFromItem(self.parentItem().refLine, point2)
                    if p.y() < min(point1.y(), point2.y()):
                        p.setY(min(point1.y(), point2.y()))
                    elif p.y() > max(point1.y(), point2.y()):
                        p.setY(max(point1.y(), point2.y()))

            movement = p - self.pos()
            self.m_annotation_item.movePoints(self.m_index, movement)
            return p
        return super(Grabber, self).itemChange(change, value)

    def paint(self, painter, option, widget):
        """paints the path of grabber only if it is selected
        """
        if self.isSelected() and not self.m_annotation_item.isSelected():
            # show parent line of grabber
            self.m_annotation_item.setSelected(True)
        painter.setBrush(self.brush)
        painter.setPen(self.pen)
        painter.drawPath(self.path())

    def shape(self):
        """Overrides shape method and set shape to segment on which grabber is located"""
        index = self.m_index
        # take start and end point of segment
        startPoint = QPointF(self.parentItem().points[index])
        endPoint = QPointF(self.parentItem().points[index + 1])
        # map in grabber's co-ordinate
        startPoint = self.mapFromParent(startPoint)
        endPoint = self.mapFromParent(endPoint)
        # create path as line
        path = QPainterPath(startPoint)
        path.lineTo(endPoint)
        # generate outlines for path
        stroke = QPainterPathStroker()
        stroke.setWidth(8)
        return stroke.createStroke(path)

    def boundingRect(self):
        return self.shape().boundingRect()

    def hoverEnterEvent(self, event):
        """
        Changes cursor to horizontal movement or vertical movement
         depending on the direction of the grabber on mouse enter
        """
        if self.direction == Qt.Horizontal:
            self.setCursor(QCursor(Qt.SplitHCursor))
        else:
            self.setCursor(QCursor(Qt.SplitVCursor))
        super(Grabber, self).hoverEnterEvent(event)

    def hoverLeaveEvent(self, event):
        """
        reverts cursor to default on mouse leave
        """
        self.setCursor(QCursor(Qt.ArrowCursor))
        super(Grabber, self).hoverLeaveEvent(event)

    def show(self):
        # set pen to show
        self.pen = QPen(Qt.black, 2, Qt.SolidLine)
        self.brush = QBrush(Qt.cyan)

    def hide(self):
        # set pen to transparent
        self.pen = QPen(Qt.white, -1, Qt.SolidLine)
        self.brush = QBrush(Qt.transparent)
コード例 #38
0
 def drawValue(self, p: QPainter, baseRect: QRectF, value: float,
               delta: float):
     if value == self.m_min:
         return
     if self.m_barStyle == self.BarStyle.EXPAND:
         p.setBrush(self.palette().highlight())
         p.setPen(QPen(self.palette().shadow().color(),
                       self.m_dataPenWidth))
         radius = (baseRect.height() / 2) / delta
         p.drawEllipse(baseRect.center(), radius, radius)
         return
     if self.m_barStyle == self.BarStyle.LINE:
         p.setPen(
             QPen(self.palette().highlight().color(), self.m_dataPenWidth))
         p.setBrush(Qt.NoBrush)
         if value == self.m_max:
             p.drawEllipse(
                 baseRect.adjusted(self.m_outlinePenWidth / 2,
                                   self.m_outlinePenWidth / 2,
                                   -self.m_outlinePenWidth / 2,
                                   -self.m_outlinePenWidth / 2))
         else:
             arcLength = 360 / delta
             p.drawArc(
                 baseRect.adjusted(self.m_outlinePenWidth / 2,
                                   self.m_outlinePenWidth / 2,
                                   -self.m_outlinePenWidth / 2,
                                   -self.m_outlinePenWidth / 2),
                 int(self.m_nullPosition * 16), int(-arcLength * 16))
         return
     dataPath = QPainterPath()
     dataPath.setFillRule(Qt.WindingFill)
     if value == self.m_max:
         dataPath.addEllipse(baseRect)
     else:
         arcLength = 360 / delta
         dataPath.moveTo(baseRect.center())
         dataPath.arcTo(baseRect, self.m_nullPosition, -arcLength)
         dataPath.lineTo(baseRect.center())
     p.setBrush(self.palette().highlight())
     p.setPen(QPen(self.palette().shadow().color(), self.m_dataPenWidth))
     p.drawPath(dataPath)
コード例 #39
0
    def paintEvent(self, e):
        if self.ready:
            qp = QPainter()
            qp.begin(self)
            path = QPainterPath()
            for x, y in zip(self.x, self.y):
                path.addRoundedRect(QRectF(x - 1, y - 1, 3, 3), 1, 1)
            qp.fillPath(path, Qt.darkGreen)
            qp.end()
            # print(self.x,self.y)
        if self.polylineOn:
            qp = QPainter()
            qp.begin(self)
            pen = QPen(Qt.darkRed, 2)
            qp.setPen(pen)
            # qp.drawLine(self.x[0],self.y[0],self.x[-1],self.y[-1])
            for i in range(len(self.x)):
                qp.drawLine(self.x[i], self.y[i], self.x[i - 1], self.y[i - 1])

            path = QPainterPath()
            for x, y in zip(self.x, self.y):
                path.addRoundedRect(QRectF(x - 2, y - 2, 5, 5), 2, 2)
            qp.fillPath(path, Qt.darkGreen)
            qp.end()
        if self.interpolationSplineOne:
            qp = QPainter()
            qp.begin(self)
            pen = QPen(Qt.black, 2)
            qp.setPen(pen)
            for i in range(self.x2.size - 1):
                qp.drawLine(self.x2[i], self.y2[i], self.x2[i + 1],
                            self.y2[i + 1])

            path = QPainterPath()
            for x, y in zip(self.x, self.y):
                path.addRoundedRect(QRectF(x - 2, y - 2, 5, 5), 2, 2)
            qp.fillPath(path, Qt.darkGreen)
            qp.end()

        if self.eulerianPlot:
            qp = QPainter()
            qp.begin(self)
            pen = QPen(Qt.darkCyan, 2)
            qp.setPen(pen)
            for i in range(self.x2.size):
                qp.drawLine(self.x2[i], self.y2[i], self.x2[i - 1],
                            self.y2[i - 1])

            path = QPainterPath()
            for x, y in zip(self.x, self.y):
                path.addRoundedRect(QRectF(x - 2, y - 2, 5, 5), 2, 2)
            qp.fillPath(path, Qt.darkGreen)
            qp.end()

        self.ready = False
        self.polylineOn = False
        self.interpolationSplineOne = False
        self.eulerianPlot = False
コード例 #40
0
ファイル: polygon.py プロジェクト: chengscott/thegame
 def shape(self):
     path = QPainterPath()
     path.addPolygon(self.polygonShape)
     return path
コード例 #41
0
ファイル: shape.py プロジェクト: xgDebug/GameAISDK
    def paint(self, painter):
        if self.points:
            color = self.select_line_color if self.selected else self.line_color
            pen = QPen(color)
            # Try using integer sizes for smoother drawing(?)
            # pen.setWidth(max(1, int(round(2.0 / self.scale))))
            pen.setWidth(max(1, int(round(5.0 / self.scale))))
            painter.setPen(pen)

            line_path = QPainterPath()
            vrtx_path = QPainterPath()

            line_path.moveTo(self.points[0])
            # Uncommenting the following line will draw 2 paths
            # for the 1st vertex, and make it non-filled, which
            # may be desirable.
            #self.draw_vertex(vrtx_path, 0)

            for i, p in enumerate(self.points):
                line_path.lineTo(p)
                self.draw_vertex(vrtx_path, i)
            if self.is_closed():
                line_path.lineTo(self.points[0])

            painter.drawPath(line_path)
            painter.drawPath(vrtx_path)
            painter.fillPath(vrtx_path, self.vertex_fill_color)

            # Draw text at the top-left
            if self.paint_label:
                min_x = sys.maxsize
                min_y = sys.maxsize
                for point in self.points:
                    min_x = min(min_x, point.x())
                    min_y = min(min_y, point.y())

                if min_x != sys.maxsize and min_y != sys.maxsize:
                    pen = QPen()
                    pen.setWidth(3)
                    pen.setColor(QColor(0, 0, 0))
                    painter.setRenderHint(QPainter.Antialiasing, True)
                    painter.setPen(pen)
                    linear_grad = QLinearGradient()
                    linear_grad.setColorAt(0, QColor(255, 255, 255))

                    font = QFont()
                    font.setPointSize(25)
                    font.setBold(True)
                    font.setFamily("Microsoft YaHei")

                    min_y += MIN_Y_LABEL
                    if len(self.label) > 0:
                        text_path = QPainterPath()
                        if self._current_label_text:
                            text_path.addText(min_x, min_y, font, self._current_label_text)
                        else:
                            text_path.addText(min_x, min_y, font, self.label[0])  # 应该取最后一个比较合理
                        painter.setBrush(linear_grad)
                        painter.drawPath(text_path)
                    min_y += 25

                    painter.setBrush(Qt.NoBrush)

            if self.fill:
                color = self.select_fill_color if self.selected else self.fill_color
                painter.fillPath(line_path, color)
コード例 #42
0
ファイル: shape.py プロジェクト: xgDebug/GameAISDK
 def make_path(self):
     path = QPainterPath(self.points[0])
     for p in self.points[1:]:
         path.lineTo(p)
     return path
コード例 #43
0
    def drawObject(self, painter: 'QPainter', rect: QtCore.QRectF, doc: 'QTextDocument', pos_in_document: int,
                   format_: 'QTextFormat') -> None:
        painter.setRenderHint(QPainter.Antialiasing, True)
        c = QColor(255, 80, 0, 160)
        painter.setBrush(QBrush(c, Qt.SolidPattern))
        painter.setPen(QPen(QtCore.Qt.white, 2, QtCore.Qt.SolidLine))
        tag_kind: TagKind = format_.property(TagTextObject.kind_propid)

        top = rect.top()
        left = rect.left()
        width = rect.width()
        height = rect.height()
        square_size = rect.height() / 2

        if tag_kind == TagKind.START:
            path = QPainterPath()
            path.setFillRule(Qt.WindingFill)
            path.addRoundedRect(rect, 10, 10)

            # QRectF(aleft: float, atop: float, awidth: float, aheight: float)
            bottom_left_rect = QRectF(left, top + height - square_size, square_size, square_size)
            path.addRoundedRect(bottom_left_rect, 2, 2)  # Bottom left

            top_left_rect = QRectF(left, top, square_size, square_size)
            path.addRoundedRect(top_left_rect, 2, 2)  # Top left
            painter.drawPath(path.simplified())
        elif tag_kind == TagKind.END:
            path = QPainterPath()
            path.setFillRule(Qt.WindingFill)
            path.addRoundedRect(rect, 10, 10)

            top_right_rect = QRectF((left + width) - square_size, top, square_size, square_size)
            path.addRoundedRect(top_right_rect, 2, 2)  # Top right

            bottom_right_rect = QRectF((left + width) - square_size, top + height - square_size, square_size,
                                       square_size)
            path.addRoundedRect(bottom_right_rect, 2, 2)  # Bottom right
            painter.drawPath(path.simplified())
        else:
            painter.drawRoundedRect(rect, 4, 4)
        tag_name = format_.property(TagTextObject.name_propid)
        painter.drawText(rect, QtCore.Qt.AlignHCenter | QtCore.Qt.AlignCenter, tag_name)
コード例 #44
0
 def bulletShape(self):
     shape = QPainterPath()
     shape.addEllipse(self.position.x() - (0.5 * Bullet_Size),
                      self.position.y() - (0.5 * Bullet_Size), Bullet_Size,
                      Bullet_Size)
     return shape
コード例 #45
0
ファイル: QgsVideo.py プロジェクト: ogsdave/QGISFMV
    def paintEvent(self, event):
        self.gt = GetGCPGeoTransform()  # TODO : Here?
        painter = QPainter(self)

        if (self.surface.isActive()):
            videoRect = self.surface.videoRect()
            if not videoRect.contains(event.rect()):
                region = event.region()
                region.subtracted(QRegion(videoRect))
                brush = self.palette().window()
                for rect in region.rects():
                    painter.fillRect(rect, brush)

            try:
                self.surface.paint(painter)
            except:
                None
        else:
            painter.fillRect(event.rect(), self.palette().window())
        try:
            SetImageSize(self.surface.currentFrame.width(),
                         self.surface.currentFrame.height())
        except:
            None

        # Magnifier Glass
        if self.zoomed and magnifier:
            dim = min(self.width(), self.height())
            magnifierSize = min(MAX_MAGNIFIER, dim * 2 / 3)
            radius = magnifierSize / 2
            ring = radius - 15
            box = QSize(magnifierSize, magnifierSize)

            # reupdate our mask
            if self.maskPixmap.size() != box:
                self.maskPixmap = QPixmap(box)
                self.maskPixmap.fill(Qt.transparent)
                g = QRadialGradient()
                g.setCenter(radius, radius)
                g.setFocalPoint(radius, radius)
                g.setRadius(radius)
                g.setColorAt(1.0, QColor(64, 64, 64, 0))
                g.setColorAt(0.5, QColor(0, 0, 0, 255))
                mask = QPainter(self.maskPixmap)
                mask.setRenderHint(QPainter.Antialiasing)
                mask.setCompositionMode(QPainter.CompositionMode_Source)
                mask.setBrush(g)
                mask.setPen(Qt.NoPen)
                mask.drawRect(self.maskPixmap.rect())
                mask.setBrush(QColor(Qt.transparent))
                mask.drawEllipse(g.center(), ring, ring)
                mask.end()

            center = self.dragPos - QPoint(0, radius)
            center += QPoint(0, radius / 2)
            corner = center - QPoint(radius, radius)
            xy = center * 2 - QPoint(radius, radius)
            # only set the dimension to the magnified portion
            if self.zoomPixmap.size() != box:
                self.zoomPixmap = QPixmap(box)
                self.zoomPixmap.fill(Qt.lightGray)

            if True:
                painter = QPainter(self.zoomPixmap)
                painter.translate(-xy)
                self.largePixmap = QPixmap.fromImage(self.surface.image)
                painter.drawPixmap(self.offset * 2, self.largePixmap)
                painter.end()

            clipPath = QPainterPath()
            clipPath.addEllipse(QPointF(center), ring, ring)
            painter = QPainter(self)
            painter.setRenderHint(QPainter.Antialiasing)
            painter.setClipPath(clipPath)
            painter.drawPixmap(corner, self.zoomPixmap)
            # painter.setClipping(False)
            painter.drawPixmap(corner, self.maskPixmap)
            painter.setPen(Qt.gray)
            painter.drawPath(clipPath)
コード例 #46
0
    def __init__(self, diagramType, contextMenu, parent=None):
        super(DiagramItem, self).__init__(parent)

        self.arrows = []

        self.diagramType = diagramType
        self.contextMenu = contextMenu

        path = QPainterPath()
        if self.diagramType == self.StartEnd:
            path.moveTo(200, 50)
            path.arcTo(150, 0, 50, 50, 0, 90)
            path.arcTo(50, 0, 50, 50, 90, 90)
            path.arcTo(50, 50, 50, 50, 180, 90)
            path.arcTo(150, 50, 50, 50, 270, 90)
            path.lineTo(200, 25)
            self.myPolygon = path.toFillPolygon()
        elif self.diagramType == self.Conditional:
            self.myPolygon = QPolygonF([
                QPointF(-100, 0),
                QPointF(0, 100),
                QPointF(100, 0),
                QPointF(0, -100),
                QPointF(-100, 0)
            ])
        elif self.diagramType == self.Step:
            self.myPolygon = QPolygonF([
                QPointF(-100, -100),
                QPointF(100, -100),
                QPointF(100, 100),
                QPointF(-100, 100),
                QPointF(-100, -100)
            ])
        else:
            self.myPolygon = QPolygonF([
                QPointF(-120, -80),
                QPointF(-70, 80),
                QPointF(120, 80),
                QPointF(70, -80),
                QPointF(-120, -80)
            ])

        self.setPolygon(self.myPolygon)
        self.setFlag(QGraphicsItem.ItemIsMovable, True)
        self.setFlag(QGraphicsItem.ItemIsSelectable, True)
コード例 #47
0
ファイル: drawFlowsheet.py プロジェクト: MAZamarripa/FOQUS-1
 def drawEdge(self, x1, y1, x2, y2, index, curve, tear=False):
     '''
         Draw an edge from x1, y1 to x2, y2.  Edges connect two nodes
         --Args--
         index: the edge index
         curve: distance from center of straight edge to a point on
                curved edge (can be positive or negitive.  Used to
                keep edges from overlapping.
         tear: if true draw in tear edge style
     '''
     # determine if edge conntects a node to itself.
     if abs(x1 - x2) < 0.01 and abs(y1 - y2) < 0.01:
         path = QPainterPath()
         curve = curve * 2
         path.addEllipse(x1, y1 - curve / 2.0, curve, curve)
         if tear:
             gi = self.addPath(path, self.edgePen)
         else:
             gi = self.addPath(path, self.tearEdgePen)
     else:
         # mid point of the edge if it is a straight line
         xmid = (x1 + x2) / 2.0
         ymid = (y1 + y2) / 2.0
         # get the angle of the edge and the angle perpendicular
         ang = math.atan2((y2 - y1), (x2 - x1))
         ang_perp = math.atan2((x1 - x2), (y2 - y1))
         # calculate the mid point of the curved edge
         xcurve = xmid + curve * math.cos(ang_perp)
         ycurve = ymid + curve * math.sin(ang_perp)
         # calculate control point for drawing quaratic curve
         xcontrol = 2 * xcurve - xmid
         ycontrol = 2 * ycurve - ymid
         #draw Edge
         path = QPainterPath()
         path.moveTo(x1, y1)
         path.quadTo(xcontrol, ycontrol, x2, y2)
         p2 = QPainterPathStroker()
         path = p2.createStroke(path)
         # if edge is selected draw it highlighted
         if index in self.selectedEdges:
             self.addPath(path, self.eSelectionPen)
         # if edge is a tear draw it tear style else draw it normal
         if tear:
             gi = self.addPath(path, self.tearEdgePen)
         else:
             gi = self.addPath(path, self.edgePen)
         # Add data to edge so if seleted we can determine that it
         # is an edge and which edge it is.
         gi.setData(1, index)
         gi.setData(2, "edge")
         # Draw the arrow
         path = QPainterPath()
         xs = xcurve + self.edgeArrowSize * math.cos(ang)
         ys = ycurve + self.edgeArrowSize * math.sin(ang)
         path.moveTo(xs, ys)
         path.lineTo(
             xs - self.edgeArrowSize*math.cos(ang) +\
                 self.edgeArrowSize/2.0*math.cos(ang_perp),
             ys - self.edgeArrowSize*math.sin(ang) +\
                 self.edgeArrowSize/2.0*math.sin(ang_perp))
         path.lineTo(
             xs - self.edgeArrowSize*math.cos(ang) -\
                 self.edgeArrowSize/2.0*math.cos(ang_perp),
             ys - self.edgeArrowSize*math.sin(ang) -\
                 self.edgeArrowSize/2.0*math.sin(ang_perp))
         path.lineTo(xs, ys)
         gi = self.addPath(path, self.edgePen, self.edgeArrowBrush)
         # Add data so selecting the arrow in like selecting the edge
         gi.setData(1, index)
         gi.setData(2, "edge")
コード例 #48
0
class Canvas(QWidget):
    def __init__(self, parent=None):
        super(Canvas, self).__init__(parent)

        self.is_enable_knee_control = False

        # 画像専用のレイヤであるかを制御する
        # 1度Trueになったら2度とFalseにならないことを意図する
        self.is_picture_canvas = False
        self.picture_file_name = ""
        self.image = QImage()

        # マウストラック有効化
        self.setMouseTracking(True)

        # マウス移動で出る予測線とクリックして出る本線を描画するときに区別する
        self.is_line_prediction = False

        # イベント同士の競合を防ぐ
        self.event_Locker = False

        self.rounded_polygon = RoundedPolygon(10000)

        self.existing_paths = []  # 確定したパスを保存
        self.recorded_points = []  # 確定した点を保存(実験の記録用)
        self.clicked_points = []  # 今描いている線の制御点を記録
        self.cursor_position = QPointF()
        self.cursor_position_mousePressed = QPointF()
        self.knee_position = QPointF()
        self.knee_position_mousePressed = QPointF()
        self.current_drawing_mode = OperationMode.DRAWING_POINTS
        self.current_knee_operation_mode = OperationMode.NONE

        self.__line_color = []
        self.current_line_color = QColor()

        self.nearest_path = QPainterPath()
        self.nearest_distance = 50.0
        self.nearest_index = 0
        self.is_dragging = False

        self.pen_width = 2

        self.show()

    def set_experiment_controller(self, excontroller):
        self.experiment_controller = excontroller

    def mousePressEvent(self, event: QMouseEvent):
        if self.current_drawing_mode == OperationMode.DRAWING_POINTS:
            # 制御点の追加
            if event.button() == Qt.LeftButton:
                self.clicked_points.append(event.pos())
                # print(self.clickedPoints)

            # 直前の制御点の消去
            if event.button() == Qt.RightButton:
                if len(self.clicked_points) > 0:
                    self.clicked_points.pop()
                self.update()

        elif self.current_drawing_mode == OperationMode.MOVING_POINTS:
            if event.button() == Qt.LeftButton:
                self.is_dragging = True
                if self.is_enable_knee_control:
                    self.recode_knee_and_cursor_position()

                self.cursor_position = event.pos()
                self.update()

    def mouseMoveEvent(self, event: QMouseEvent):
        self.experiment_controller.current_mouse_position = event.pos()
        self.experiment_controller.record_frame(
            self.current_drawing_mode, self.current_knee_operation_mode)
        if self.current_drawing_mode == OperationMode.DRAWING_POINTS:
            self.clicked_points.append(event.pos())
            self.is_line_prediction = True
            self.update()

        elif self.current_drawing_mode == OperationMode.MOVING_POINTS:
            print(self.nearest_distance)
            self.cursor_position = event.pos()
            if self.is_dragging:
                self.move_point()
            self.update()

    def mouseReleaseEvent(self, event: QMouseEvent):
        self.is_dragging = False

    def paintEvent(self, event: QPaintEvent):
        # if not self.event_Locker:
        painter = QPainter(self)

        if self.is_picture_canvas:
            painter.drawImage(QRect(0, 0, 600, 600), self.image)

        else:
            # すでに確定されているパスの描画
            if len(self.existing_paths) > 0:
                for i in range(len(self.existing_paths)):
                    print("linecolor {}: {}".format(
                        i, self.__line_color[i].hue()))
                    painter.setPen(QPen(self.__line_color[i], self.pen_width))
                    painter.drawPath(self.existing_paths[i])

            if self.current_drawing_mode == OperationMode.DRAWING_POINTS:
                #  現在描いているパスの描画
                if len(self.clicked_points) > 3:
                    painter.setPen(
                        QPen(self.current_line_color, self.pen_width))
                    # print(self.clickedPoints)
                    # クリックした点まで線を伸ばすため、終点を一時的にリストに入れている
                    self.clicked_points.append(
                        self.clicked_points[len(self.clicked_points) - 1])
                    painter_path = self.rounded_polygon.get_path(
                        self.clicked_points)

                    # 設置した点の描画
                    painter.setPen(Qt.black)
                    for i in range(len(self.clicked_points)):
                        painter.drawEllipse(self.clicked_points[i], 2, 2)
                    painter.setPen(
                        QPen(self.current_line_color, self.pen_width))
                    # 現在のマウス位置での予告線
                    if self.is_line_prediction:
                        self.clicked_points.pop()
                        self.is_line_prediction = False
                    painter.drawPath(painter_path)
                    self.clicked_points.pop()

                # 線が描けない時
                else:
                    # 現在のマウス位置での予告線
                    if self.is_line_prediction:
                        painter.setPen(Qt.red)
                        for i in range(len(self.clicked_points)):
                            painter.drawEllipse(self.clicked_points[i], 2, 2)
                        if not len(self.clicked_points) == 0:
                            self.clicked_points.pop()
                        self.is_line_prediction = False

                    # 予告線でもない場合は単に点を書く
                    else:
                        for i in range(len(self.clicked_points)):
                            painter.drawEllipse(self.clicked_points[i], 2, 2)

            # 制御点を移動するとき
            elif self.current_drawing_mode == OperationMode.MOVING_POINTS:
                # すでに確定されているパスの制御点の描画
                self.nearest_distance = 50.0
                painter.setPen(Qt.black)
                for path in self.existing_paths:
                    for i in range(path.elementCount()):
                        control_point = QPointF(
                            path.elementAt(i).x,
                            path.elementAt(i).y)
                        painter.drawEllipse(control_point, 3, 3)

                        # 現在のカーソル位置から最も近い点と、その点が属するpathを記録、更新
                        # if not self.is_dragging & self.is_enable_knee_control:
                        distance = math.sqrt(
                            (control_point.x() - self.cursor_position.x())**2 +
                            (control_point.y() - self.cursor_position.y())**2)
                        if distance < self.nearest_distance:
                            self.nearest_distance = distance
                            self.nearest_path = path
                            self.nearest_index = i

                # 一定の距離未満かつ最も近い点を赤く描画
                if self.nearest_distance < 20:
                    painter.setPen(QPen(Qt.red, self.pen_width))
                    nearest_control_point = QPointF(
                        self.nearest_path.elementAt(self.nearest_index).x,
                        self.nearest_path.elementAt(self.nearest_index).y)
                    painter.drawEllipse(nearest_control_point, 3, 3)

    def move_point(self):
        if self.is_enable_knee_control:
            if self.nearest_distance < 20 or self.is_dragging:
                self.nearest_path.setElementPositionAt(
                    self.nearest_index, self.cursor_position.x(),
                    self.cursor_position.y())

                amount_of_change = QPointF(
                    self.cursor_position.x() +
                    (self.knee_position.x() -
                     self.knee_position_mousePressed.x()),
                    self.cursor_position.y() -
                    (self.knee_position.y() -
                     self.knee_position_mousePressed.y()))
                self.nearest_path.setElementPositionAt(self.nearest_index,
                                                       amount_of_change.x(),
                                                       amount_of_change.y())

        else:
            if self.nearest_distance < 20:
                self.nearest_path.setElementPositionAt(
                    self.nearest_index, self.cursor_position.x(),
                    self.cursor_position.y())

    def set_knee_position(self, x, y):
        self.knee_position.setX(x)
        self.knee_position.setY(y)

        if self.is_dragging:
            if self.current_drawing_mode == OperationMode.MOVING_POINTS:
                self.move_point()
                self.update()

    def set_line_color(self, color):
        self.current_line_color = color

    def recode_knee_and_cursor_position(self):
        self.knee_position_mousePressed.setX(self.knee_position.x())
        self.knee_position_mousePressed.setY(self.knee_position.y())
        self.cursor_position_mousePressed = self.cursor_position

    def fix_path(self):
        # パスを確定
        if self.is_line_prediction and not len(self.clicked_points) == 0:
            self.clicked_points.pop()
        # クリックした点まで線を伸ばすため、終点をリストに入れている
        if len(self.clicked_points) > 0:
            self.clicked_points.append(
                self.clicked_points[len(self.clicked_points) - 1])
            painter_path = self.rounded_polygon.get_path(self.clicked_points)

            # 線と色を記録
            self.existing_paths.append(painter_path)
            self.__line_color.append(self.current_line_color)
            for i in range(len(self.__line_color)):
                print("{}, {}".format(i, self.__line_color[i].value()))
            self.clicked_points.pop()
            self.recorded_points.append(self.clicked_points)

            # 点をリセット
            self.clicked_points = []
            self.update()

    def delete_last_path(self):
        if len(self.existing_paths) > 0:
            self.existing_paths.pop()
            self.__line_color.pop()
            self.update()

    def switch_visible(self, is_visible: bool):
        palette = self.palette()
        if is_visible:
            palette.setColor(QPalette.Background, QColor(255, 255, 255, 120))
        else:
            palette.setColor(QPalette.Background, QColor(255, 255, 255, 255))
        self.setPalette(palette)

    def operation_mode_changed(self, to_drawing: OperationMode,
                               to_knee: OperationMode):
        self.current_drawing_mode = to_drawing
        self.current_knee_operation_mode = to_knee
        self.fix_path()

    def set_picture_file_name(self, picture_file_name: str):
        self.is_picture_canvas = True
        self.picture_file_name = picture_file_name
        self.update()

    def set_enable_knee_control(self, is_enable_knee_control):
        self.is_enable_knee_control = is_enable_knee_control

    def load_picture(self, image: QImage):
        self.image = image
        self.is_picture_canvas = True
        self.update()
コード例 #49
0
ファイル: line.py プロジェクト: rnk-industries/Chemical-PFD
    def createPath(self):
        """
        creates initial path and stores it's points
        :return:
        """
        offset = 30
        x0, y0 = self.startPoint.x(), self.startPoint.y()
        x1, y1 = self.endPoint.x(), self.endPoint.y()
        # create path for line in process
        self.points = [self.startPoint, QPointF((x0 + x1) / 2, y0), QPointF((x0 + x1) / 2, y1), self.endPoint]
        # final path of line
        if self.refLine:
            # line has end point on other line
            from .shapes import LineGripItem
            direction = "left"
            points = self.refLine.points
            point1 = points[self.refIndex]
            point2 = points[self.refIndex + 1]
            if point1.x() == point2.x():
                if point1.x() < self.startPoint.x():
                    direction = "right"
                else:
                    direction = "left"
            elif point1.y() == point2.y():
                if point1.y() > self.startPoint.y():
                    direction = "top"
                else:
                    direction = "bottom"
            self.endGripItem = LineGripItem(-1, [0, 0, direction], self)
            self.endGripItem.setPos(self.endPoint)

        if self.startGripItem and self.endGripItem:
            # determine ns (point next to start)
            item = self.startGripItem
            if item.m_location == "top":
                ns = QPointF(self.startPoint.x(), self.startPoint.y() - offset)
            elif item.m_location == "left":
                ns = QPointF(self.startPoint.x() - offset, self.startPoint.y())
            elif item.m_location == "bottom":
                ns = QPointF(self.startPoint.x(), self.startPoint.y() + offset)
            else:
                ns = QPointF(self.startPoint.x() + offset, self.startPoint.y())
            # determine pe (point previous to end)
            item = self.endGripItem
            if item.m_location == "top":
                pe = QPointF(self.endPoint.x(), self.endPoint.y() - offset)
            elif item.m_location == "left":
                pe = QPointF(self.endPoint.x() - offset, self.endPoint.y())
            elif item.m_location == "bottom":
                pe = QPointF(self.endPoint.x(), self.endPoint.y() + offset)
            else:
                pe = QPointF(self.endPoint.x() + offset, self.endPoint.y())
            start = self.startPoint
            end = self.endPoint
            sitem = self.startGripItem.mapRectToScene(self.startGripItem.parentItem().boundingRect())
            eitem = self.endGripItem.mapRectToScene(self.endGripItem.parentItem().boundingRect())
            if self.refLine:
                eitem = self.endGripItem.mapRectToScene(QRectF(0, 0, 0, 0))

            if self.startGripItem.m_location in ["right"]:
                if self.endGripItem.m_location in ["top"]:
                    if start.x() + offset < end.x():
                        if start.y() + offset < end.y():
                            self.points = [start, QPointF(end.x(), start.y()), end]
                        else:
                            if start.x() + offset < eitem.left() - offset:
                                self.points = [start, ns, QPointF(ns.x(), pe.y()), pe, end]
                            else:
                                x = max(eitem.right() + offset, ns.x())
                                self.points = [start, QPointF(x, start.y()), QPointF(x, pe.y()), pe, end]

                    elif sitem.left() > end.x():
                        if sitem.bottom() + offset < end.y():
                            self.points = [start, ns, QPointF(ns.x(), pe.y()), pe, end]
                        elif sitem.top() - offset < end.y():
                            self.points = [start, ns, QPointF(ns.x(), sitem.top() - offset),
                                           QPointF(pe.x(), sitem.top() - offset), end]
                        else:
                            self.points = [start, ns, QPointF(ns.x(), pe.y()), pe, end]
                    else:
                        self.points = [start, ns, QPointF(ns.x(), pe.y()), pe, end]
                        if start.y() > end.y():
                            x = max(eitem.right() + offset, ns.x())
                            self.points = [start, QPointF(x, start.y()), QPointF(x, pe.y()), pe, end]

                elif self.endGripItem.m_location in ["bottom"]:
                    if start.x() + offset < eitem.left():
                        if start.y() - offset < end.y():
                            self.points = [start, ns, QPointF(ns.x(), pe.y()), pe, end]
                        else:
                            self.points = [start, QPointF(end.x(), start.y()), end]

                    elif sitem.left() > end.x():
                        if sitem.bottom() + offset < end.y():
                            self.points = [start, ns, QPointF(ns.x(), pe.y()), pe, end]
                        elif sitem.top() - offset < end.y():
                            y = max(pe.y(), sitem.bottom() + offset)
                            self.points = [start, ns, QPointF(ns.x(), y),
                                           QPointF(pe.x(), y), end]
                        else:
                            self.points = [start, ns, QPointF(ns.x(), pe.y()), pe, end]
                    else:
                        self.points = [start, ns, QPointF(ns.x(), pe.y()), pe, end]
                        if start.y() < end.y():
                            x = max(eitem.right() + offset, ns.x())
                            self.points = [start, QPointF(x, start.y()), QPointF(x, pe.y()), pe, end]

                elif self.endGripItem.m_location in ["right"]:
                    x = max(start.x() + offset, pe.x())
                    self.points = [start, QPointF(x, start.y()), QPointF(x, end.y()), end]
                    if start.x() + offset < eitem.top():
                        if start.y() + offset > eitem.top() and end.y() >= start.y():
                            self.points = [start, ns, QPointF(ns.x(), eitem.top()),
                                           QPointF(pe.x(), eitem.top()), pe, end]
                        elif start.y() - offset < eitem.bottom() and end.y() <= start.y():
                            self.points = [start, ns, QPointF(ns.x(), eitem.bottom()),
                                           QPointF(pe.x(), eitem.bottom()), pe, end]
                    elif sitem.top() - offset < end.y() < sitem.bottom() + offset:
                        if end.y() < start.y():
                            self.points = [start, ns, QPointF(ns.x(), sitem.top()),
                                           QPointF(pe.x(), sitem.top()), pe, end]
                        else:
                            self.points = [start, ns, QPointF(ns.x(), sitem.bottom()),
                                           QPointF(pe.x(), sitem.bottom()), pe, end]

                elif self.endGripItem.m_location in ["left"]:
                    self.points = [start, QPointF((start.x() + end.x()) / 2, start.y()),
                                   QPointF((start.x() + end.x()) / 2, end.y()), end]
                    if end.x() < start.x() + offset:
                        if eitem.bottom() <= sitem.top() - offset:
                            self.points = [start, ns, QPointF(ns.x(), sitem.top()),
                                           QPointF(pe.x(), sitem.top()), pe, end]
                        elif eitem.top() >= sitem.bottom() + offset:
                            self.points = [start, ns, QPointF(ns.x(), sitem.bottom()),
                                           QPointF(pe.x(), sitem.bottom()), pe, end]
                        elif end.y() <= start.y():
                            y = min(eitem.top(), sitem.top())
                            self.points = [start, ns, QPointF(ns.x(), y),
                                           QPointF(pe.x(), y), pe, end]
                        else:
                            y = max(eitem.bottom(), sitem.bottom())
                            self.points = [start, ns, QPointF(ns.x(), y),
                                           QPointF(pe.x(), y), pe, end]


            elif self.startGripItem.m_location in ["left"]:
                if self.endGripItem.m_location in ["top"]:
                    if start.x() + offset < eitem.left():
                        if end.y() > sitem.bottom() + offset:
                            self.points = [start, ns, QPointF(ns.x(), sitem.bottom()),
                                           QPointF(pe.x(), sitem.bottom()), end]
                        else:
                            y = min(sitem.top(), pe.y())
                            self.points = [start, ns, QPointF(ns.x(), y),
                                           QPointF(pe.x(), y), end]
                    elif eitem.right() >= start.x() - offset:
                        x = min(ns.x(), eitem.left())
                        self.points = [start, QPointF(x, ns.y()),
                                       QPointF(x, pe.y()), pe, end]
                    else:
                        if end.y() >= start.y() + offset:
                            self.points = [start, QPointF(end.x(), start.y()), end]
                        else:
                            x = (start.x() + end.x()) / 2
                            self.points = [start, QPointF(x, start.y()),
                                           QPointF(x, pe.y()), pe, end]

                elif self.endGripItem.m_location in ["bottom"]:
                    if start.x() + offset < eitem.left():
                        if end.y() < sitem.top() - offset:
                            self.points = [start, ns, QPointF(ns.x(), sitem.top()),
                                           QPointF(pe.x(), sitem.top()), end]
                        else:
                            y = max(sitem.bottom(), pe.y())
                            self.points = [start, ns, QPointF(ns.x(), y),
                                           QPointF(pe.x(), y), end]
                    elif eitem.right() >= start.x() - offset:
                        x = min(ns.x(), eitem.left())
                        self.points = [start, QPointF(x, ns.y()),
                                       QPointF(x, pe.y()), pe, end]
                    else:
                        if end.y() <= start.y() - offset:
                            self.points = [start, QPointF(end.x(), start.y()), end]
                        else:
                            x = (start.x() + end.x()) / 2
                            self.points = [start, QPointF(x, start.y()),
                                           QPointF(x, pe.y()), pe, end]

                elif self.endGripItem.m_location in ["right"]:
                    self.points = [start, QPointF((start.x() + end.x()) / 2, start.y()),
                                   QPointF((start.x() + end.x()) / 2, end.y()), end]
                    if end.x() > start.x() + offset:
                        if eitem.bottom() <= sitem.top() - offset:
                            self.points = [start, ns, QPointF(ns.x(), sitem.top()),
                                           QPointF(pe.x(), sitem.top()), pe, end]
                        elif eitem.top() >= sitem.bottom() + offset:
                            self.points = [start, ns, QPointF(ns.x(), sitem.bottom()),
                                           QPointF(pe.x(), sitem.bottom()), pe, end]
                        elif end.y() <= start.y():
                            y = min(eitem.top(), sitem.top())
                            self.points = [start, ns, QPointF(ns.x(), y),
                                           QPointF(pe.x(), y), pe, end]
                        else:
                            y = max(eitem.bottom(), sitem.bottom())
                            self.points = [start, ns, QPointF(ns.x(), y),
                                           QPointF(pe.x(), y), pe, end]

                elif self.endGripItem.m_location in ["left"]:
                    self.points = [start, QPointF(pe.x(), start.y()), pe, end]
                    if start.x() + offset < end.x():
                        self.points = [start, ns, QPointF(ns.x(), end.y()), end]
                        if sitem.bottom() + offset > end.y() > sitem.top() - offset:
                            self.points = [start, ns, QPointF(ns.x(), sitem.top()),
                                           QPointF(pe.x(), sitem.top()), pe, end]
                    elif eitem.top() - offset < start.y() < eitem.bottom() + offset:
                        if end.y() > start.y():
                            self.points = [start, ns, QPointF(ns.x(), eitem.top()),
                                           QPointF(pe.x(), eitem.top()), pe, end]
                        else:
                            self.points = [start, ns, QPointF(ns.x(), eitem.bottom()),
                                           QPointF(pe.x(), eitem.bottom()), pe, end]


            elif self.startGripItem.m_location in ["top"]:
                if self.endGripItem.m_location in ["top"]:
                    self.points = [self.startPoint, QPointF(start.x(), pe.y()),
                                   pe, self.endPoint]
                    if start.y() < end.y():
                        self.points = [self.startPoint, ns, QPointF(pe.x(), ns.y()), self.endPoint]
                    if sitem.right() > end.x() > sitem.left() or eitem.right() > start.x() > eitem.left():
                        x = max(sitem.right(), eitem.right())
                        x += offset
                        if start.x() > end.x():
                            x = min(sitem.left(), eitem.left())
                            x -= offset
                        self.points = [start, ns, QPointF(x, ns.y()),
                                       QPointF(x, pe.y()), pe, end]

                elif self.endGripItem.m_location in ["bottom"]:
                    self.points = [self.startPoint, ns, QPointF((x0 + x1) / 2, ns.y()), QPointF((x0 + x1) / 2, pe.y()),
                                   pe, self.endPoint]
                    if start.y() - offset > end.y():
                        self.points = [start, QPointF(start.x(), (y0 + y1) / 2), QPointF(end.x(), (y0 + y1) / 2),
                                       self.endPoint]
                    elif sitem.right() > end.x() > sitem.left() or eitem.right() > start.x() > eitem.left():
                        x = max(sitem.right(), eitem.right())
                        x += offset
                        if start.x() > end.x():
                            x = min(sitem.left(), eitem.left())
                            x -= offset
                        self.points = [start, ns, QPointF(x, ns.y()),
                                       QPointF(x, pe.y()), pe, end]

                elif self.endGripItem.m_location in ["right"]:
                    y = min(ns.y(), eitem.bottom() + offset)
                    self.points = [start, QPointF(ns.x(), y), QPointF(pe.x(), y), pe, end]
                    if sitem.left() - offset < end.x() < sitem.right() + offset and end.y() > start.y() + offset:
                        self.points = [start, ns, QPointF(sitem.right() + offset, ns.y()),
                                       QPointF(sitem.right() + offset, pe.y()), end]
                    elif eitem.top() < start.y() - offset < eitem.bottom():
                        self.points = [start, ns, QPointF(start.x(), eitem.top()),
                                       QPointF(pe.x(), eitem.top()), pe, end]

                elif self.endGripItem.m_location in ["left"]:
                    y = min(ns.y(), eitem.bottom() + offset)
                    self.points = [start, QPointF(ns.x(), y), QPointF(pe.x(), y), pe, end]
                    if sitem.left() - offset < end.x() < sitem.right() + offset and end.y() > start.y() + offset:
                        self.points = [start, ns, QPointF(sitem.left() - offset, ns.y()),
                                       QPointF(sitem.left() - offset, pe.y()), end]
                    elif eitem.top() < start.y() - offset < eitem.bottom():
                        self.points = [start, QPointF(start.x(), eitem.top()),
                                       QPointF(pe.x(), eitem.top()), pe, end]

            elif self.startGripItem.m_location in ["bottom"]:
                if self.endGripItem.m_location in ["top"]:
                    self.points = [self.startPoint, ns, QPointF((x0 + x1) / 2, ns.y()), QPointF((x0 + x1) / 2, pe.y()),
                                   pe, self.endPoint]
                    if start.y() < end.y():
                        self.points = [self.startPoint, ns, QPointF(pe.x(), ns.y()), self.endPoint]
                    if sitem.right() > end.x() > sitem.left() or eitem.right() > start.x() > eitem.left():
                        x = max(sitem.right(), eitem.right())
                        x += offset
                        self.points = [start, ns, QPointF(x, ns.y()),
                                       QPointF(x, pe.y()), pe, end]

                elif self.endGripItem.m_location in ["bottom"]:
                    self.points = [self.startPoint, ns, QPointF((x0 + x1) / 2, ns.y()), QPointF((x0 + x1) / 2, pe.y()),
                                   pe, self.endPoint]
                    if sitem.right() > end.x() > sitem.left() or eitem.right() > start.x() > eitem.left():
                        x = max(sitem.right(), eitem.right())
                        x += offset
                        self.points = [start, ns, QPointF(x, ns.y()),
                                       QPointF(x, pe.y()), pe, end]

                elif self.endGripItem.m_location in ["right"]:
                    y = max(ns.y(), eitem.bottom() + offset)
                    self.points = [start, QPointF(ns.x(), y), QPointF(pe.x(), y), pe, end]
                    if sitem.left() - offset < end.x() < sitem.right() + offset:
                        self.points = [start, ns, QPointF(sitem.right() + offset, ns.y()),
                                       QPointF(sitem.right() + offset, pe.y()), end]

                elif self.endGripItem.m_location in ["left"]:
                    y = max(ns.y(), eitem.bottom() + offset)
                    self.points = [start, QPointF(ns.x(), y), QPointF(pe.x(), y), pe, end]
                    if sitem.left() - offset < end.x() < sitem.right() + offset:
                        self.points = [start, ns, QPointF(sitem.left() - offset, ns.y()),
                                       QPointF(sitem.left() - offset, pe.y()), end]

        # path of line
        path = QPainterPath(self.startPoint)
        for i in range(1, len(self.points)):
            path.lineTo(self.points[i])
        self.setPath(path)

        if self.refLine:
            # remove added grip
            self.scene().removeItem(self.endGripItem)
            self.endGripItem = None
            self.addGrabber()
        if self.endGripItem:
            self.addGrabber()
コード例 #50
0
ファイル: canvas2d.py プロジェクト: vorptronica/dxf2gcode
class StMoveGUI(QGraphicsLineItem, StMove):
    def __init__(self, shape):
        QGraphicsLineItem.__init__(self)
        StMove.__init__(self, shape)

        self.allwaysshow = False
        self.path = QPainterPath()

        self.setFlag(QGraphicsItem.ItemIsSelectable, False)

        self.pen = QPen(QColor(50, 100, 255), 1, QtCore.Qt.SolidLine,
                        QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
        self.pen.setCosmetic(True)
        self.make_papath()

    def contains_point(self, point):
        """
        StMove cannot be selected. Return maximal distance
        """
        return float(0x7fffffff)

    def make_papath(self):
        """
        To be called if a Shape shall be printed to the canvas
        @param canvas: The canvas to be printed in
        @param pospro: The color of the shape
        """
        self.path = QPainterPath()
        if len(self.geos):
            start = self.geos.abs_el(0).get_start_end_points(True)
            self.path.moveTo(start.x, -start.y)
        drawHorLine = lambda caller, start, end: self.path.lineTo(
            end.x, -end.y)
        drawVerLine = lambda caller, start: None  # Not used in 2D mode
        self.make_path(drawHorLine, drawVerLine)

    def setSelected(self, flag=True):
        """
        Override inherited function to turn off selection of Arrows.
        @param flag: The flag to enable or disable Selection
        """
        if self.allwaysshow:
            pass
        elif flag is True:
            self.show()
        else:
            self.hide()

    def setallwaysshow(self, flag=False):
        """
        If the directions shall be allwaysshown the parameter will be set and
        all paths will be shown.
        @param flag: The flag to enable or disable Selection
        """
        self.allwaysshow = flag
        if flag is True:
            self.show()
        elif flag is True and self.isSelected():
            self.show()
        else:
            self.hide()

    def paint(self, painter, option, widget=None):
        """
        Method will be triggered with each paint event. Possible to give options
        @param painter: Reference to std. painter
        @param option: Possible options here
        @param widget: The widget which is painted on.
        """
        painter.setPen(self.pen)
        painter.drawPath(self.path)

    def boundingRect(self):
        """
        Required method for painting. Inherited by Painterpath
        @return: Gives the Bounding Box
        """
        return self.path.boundingRect()
コード例 #51
0
    def paint(self, painter):
        painter.setRenderHint(QPainter.Antialiasing)

        pixelRatio = self.devicePixelRatioF()
        rect = QRectF(0, 0,
                      self.width() * pixelRatio,
                      self.height() * pixelRatio)
        sz = QSizeF(self.width() * pixelRatio,
                    self.height() * pixelRatio).toSize()

        self.resizePixmap(sz)

        yOffset = rect.toRect().topLeft().y() + (100 - self.value() -
                                                 10) * sz.height() / 100

        # draw water
        waterImage = QImage(sz, QImage.Format_ARGB32_Premultiplied)
        waterPainter = QPainter()
        waterPainter.begin(waterImage)
        waterPainter.setRenderHint(QPainter.Antialiasing)
        waterPainter.setCompositionMode(QPainter.CompositionMode_Source)

        pointStart = QPointF(sz.width() / 2, 0)
        pointEnd = QPointF(sz.width() / 2, sz.height())
        linear = QLinearGradient(pointStart, pointEnd)
        startColor = QColor('#1F08FF')
        startColor.setAlphaF(1)
        endColor = QColor('#50FFF7')
        endColor.setAlphaF(0.28)
        linear.setColorAt(0, startColor)
        linear.setColorAt(1, endColor)
        linear.setSpread(QGradient.PadSpread)
        waterPainter.setPen(Qt.NoPen)
        waterPainter.setBrush(linear)
        waterPainter.drawEllipse(waterImage.rect().center(),
                                 sz.width() / 2 + 1,
                                 sz.height() / 2 + 1)

        waterPainter.setCompositionMode(QPainter.CompositionMode_SourceOver)
        waterPainter.drawImage(int(self.backXOffset), yOffset,
                               self.waterBackImage)
        waterPainter.drawImage(
            int(self.backXOffset) - self.waterBackImage.width(), yOffset,
            self.waterBackImage)
        waterPainter.drawImage(int(self.frontXOffset), yOffset,
                               self.waterFrontImage)
        waterPainter.drawImage(
            int(self.frontXOffset) - self.waterFrontImage.width(), yOffset,
            self.waterFrontImage)

        # draw pop
        if self.value() > 30:
            for pop in self.pops:
                popPath = QPainterPath()
                popPath.addEllipse(pop.xOffset * sz.width() / 100,
                                   (100 - pop.yOffset) * sz.height() / 100,
                                   pop.size * sz.width() / 100,
                                   pop.size * sz.height() / 100)
                waterPainter.fillPath(popPath, QColor(255, 255, 255,
                                                      255 * 0.3))

        if self.isTextVisible():
            font = waterPainter.font()
            rectValue = QRect()
            progressText = self.text().strip('%')

            if progressText == '100':
                font.setPixelSize(sz.height() * 35 / 100)
                waterPainter.setFont(font)

                rectValue.setWidth(sz.width() * 60 / 100)
                rectValue.setHeight(sz.height() * 35 / 100)
                rectValue.moveCenter(rect.center().toPoint())
                waterPainter.setPen(Qt.white)
                waterPainter.drawText(rectValue, Qt.AlignCenter, progressText)
            else:
                font.setPixelSize(sz.height() * 40 / 100)
                waterPainter.setFont(font)

                rectValue.setWidth(sz.width() * 45 / 100)
                rectValue.setHeight(sz.height() * 40 / 100)
                rectValue.moveCenter(rect.center().toPoint())
                rectValue.moveLeft(rect.left() + rect.width() * 0.45 * 0.5)

                waterPainter.setPen(Qt.white)
                waterPainter.drawText(rectValue, Qt.AlignCenter, progressText)
                font.setPixelSize(font.pixelSize() / 2)
                waterPainter.setFont(font)
                rectPerent = QRect(
                    QPoint(rectValue.right(),
                           rectValue.bottom() - rect.height() * 20 / 100),
                    QPoint(rectValue.right() + rect.width() * 20 / 100,
                           rectValue.bottom()))

                waterPainter.drawText(rectPerent, Qt.AlignCenter, '%')

        waterPainter.end()

        maskPixmap = QPixmap(sz)
        maskPixmap.fill(Qt.transparent)
        path = QPainterPath()
        path.addEllipse(QRectF(0, 0, sz.width(), sz.height()))
        maskPainter = QPainter()
        maskPainter.begin(maskPixmap)
        maskPainter.setRenderHint(QPainter.Antialiasing)
        maskPainter.setPen(QPen(Qt.white, 1))
        maskPainter.fillPath(path, QBrush(Qt.white))
        maskPainter.end()

        mode = QPainter.CompositionMode_SourceIn
        contentImage = QImage(sz, QImage.Format_ARGB32_Premultiplied)
        contentPainter = QPainter()
        contentPainter.begin(contentImage)
        contentPainter.setCompositionMode(QPainter.CompositionMode_Source)
        contentPainter.fillRect(contentImage.rect(), Qt.transparent)
        contentPainter.setCompositionMode(QPainter.CompositionMode_SourceOver)
        contentPainter.drawImage(0, 0, maskPixmap.toImage())
        contentPainter.setCompositionMode(mode)
        contentPainter.drawImage(0, 0, waterImage)
        contentPainter.setCompositionMode(
            QPainter.CompositionMode_DestinationOver)
        contentPainter.end()

        contentImage.setDevicePixelRatio(pixelRatio)
        painter.drawImage(self.rect(), contentImage)
コード例 #52
0
class Segment(QGraphicsItem):
    '''
    # 新建Path
    QPath 可以通过从empty path或者另一个path新建,
    Once created, lines and curves can be added to the path using the lineTo(), arcTo(), cubicTo() and quadTo() functions.
    currentPosition() of the QPainterPath object is always the end position of the last subpath that was added (or the initial start point)
    # 开始新的subpath的两种方法:
    moveTo(): function implicitly starts a new subpath, and closes the previous one.
    closeSubpath():Another way of starting a new subpath is to call the closeSubpath() function which closes the current path by adding a line from the currentPosition()
    back to the path's start position. Note that the new path will have (0, 0) as its initial currentPosition().
    # 一些便捷的方法:
    addEllipse(), addPath(), addRect(), addRegion() and addText(). The addPolygon() function adds an unclosed subpath. 
    In fact, these functions are all collections of moveTo(), lineTo() and cubicTo() operations.
    # 连接到上一条Path:
    In addition, a path can be added to the current path using the connectPath() function. 
    But note that this function will connect the last element of the current path to the first element of given one by adding a line.
    
    '''
    def __init__(self, color, offset, parent):
        # offset接收一个偏移量,这是身子相对于头的偏移量
        super(Segment, self).__init__(parent)
        self.color = color
        self.rect = QRectF(offset, -20, 30, 40)
        self.path = QPainterPath()
        self.path.addEllipse(self.rect)
        x = offset + 15
        y = -20
        self.path.addPolygon(
            QPolygonF(
                [QPointF(x, y),
                 QPointF(x - 5, y - 12),
                 QPointF(x - 5, y)]))
        self.path.closeSubpath()
        # Closes the current subpath by drawing a line to the beginning of the subpath,
        # automatically starting a new path.
        # The current point of the new path is (0, 0).
        y = 20
        self.path.addPolygon(
            QPolygonF(
                [QPointF(x, y),
                 QPointF(x - 5, y + 12),
                 QPointF(x - 5, y)]))
        self.path.closeSubpath()
        self.change = 1
        self.angle = 0
        self.timer = QTimer()
        self.timer.timeout.connect(self.timeout)
        self.timer.start(INTERVAL)

    def boundingRect(self):
        return self.path.boundingRect()

    def shape(self):
        return self.path

    def paint(self, painter, option, widget=None):
        painter.setPen(Qt.NoPen)
        painter.setBrush(QBrush(self.color))
        global SCALE
        martix = SCALE
        if option.levelOfDetailFromTransform(martix) < 0.9:
            painter.drawEllipse(self.rect)
        else:
            painter.drawPath(self.path)

    def timeout(self):
        if not Running:
            # print("暂停身体生成")
            return
        matrix = self.transform()
        matrix.reset()
        self.setTransform(matrix)
        self.angle += self.change
        if self.angle > 3:
            self.change = -1
            self.angle -= 1
            # print("浪过去")
        elif self.angle < -3:
            self.change = 1
            self.angle += 1
            # print("浪回来")
        self.setRotation(self.angle)
コード例 #53
0
ファイル: endpointitem.py プロジェクト: jleon008/cadnano2.5
from math import floor

# import logging
# logger = logging.getLogger(__name__)

from PyQt5.QtCore import QPointF, QRectF, Qt
from PyQt5.QtGui import QBrush, QPen, QPainterPath, QPolygonF
from PyQt5.QtWidgets import QGraphicsItem, QGraphicsPathItem
from PyQt5.QtWidgets import QGraphicsRectItem, QGraphicsEllipseItem

from cadnano.gui.palette import getColorObj
from cadnano.gui.views.pathview import pathstyles as styles

_BASE_WIDTH = styles.PATH_BASE_WIDTH

PP_L5 = QPainterPath()  # Left 5' PainterPath
PP_R5 = QPainterPath()  # Right 5' PainterPath
PP_L3 = QPainterPath()  # Left 3' PainterPath
PP_R3 = QPainterPath()  # Right 3' PainterPath
PP_53 = QPainterPath()  # Left 5', Right 3' PainterPath
PP_35 = QPainterPath()  # Left 5', Right 3' PainterPath
# set up PP_L5 (left 5' blue square)
PP_L5.addRect(0.25 * _BASE_WIDTH, 0.125 * _BASE_WIDTH, 0.75 * _BASE_WIDTH,
              0.75 * _BASE_WIDTH)
# set up PP_R5 (right 5' blue square)
PP_R5.addRect(0, 0.125 * _BASE_WIDTH, 0.75 * _BASE_WIDTH, 0.75 * _BASE_WIDTH)
# set up PP_L3 (left 3' blue triangle)
L3_POLY = QPolygonF()
L3_POLY.append(QPointF(_BASE_WIDTH, 0))
L3_POLY.append(QPointF(0.25 * _BASE_WIDTH, 0.5 * _BASE_WIDTH))
L3_POLY.append(QPointF(_BASE_WIDTH, _BASE_WIDTH))
コード例 #54
0
ファイル: drawing.py プロジェクト: yalvex/trufont
def _drawGuidelines(
    painter,
    glyph,
    scale,
    rect,
    guidelines,
    drawLines=True,
    drawText=True,
    drawSelection=True,
    color=None,
):
    if not (drawLines or drawText):
        return
    xMin, yMin, width, height = rect
    xMax = xMin + width
    yMax = yMin + height
    for line in guidelines:
        color_ = color
        if color_ is None:
            if line.color:
                color_ = colorToQColor(line.color)
            else:
                color_ = defaultColor("glyphGuideline")
        painter.save()
        painter.setPen(color)
        line1 = None
        if None not in (line.x, line.y):
            if line.angle is not None:
                # make an infinite line that intersects *(line.x, line.y)*
                # 1. make horizontal line from *(line.x, line.y)* of length
                # *diagonal*
                diagonal = math.sqrt(width ** 2 + height ** 2)
                line1 = QLineF(line.x, line.y, line.x + diagonal, line.y)
                # 2. set the angle
                # defcon guidelines are clockwise
                line1.setAngle(line.angle)
                # 3. reverse the line and set length to 2 * *diagonal*
                line1.setPoints(line1.p2(), line1.p1())
                line1.setLength(2 * diagonal)
            else:
                line1 = QLineF(xMin, line.y, xMax, line.y)
        textX = 0
        textY = 0
        if drawLines:
            if line1 is not None:
                # line
                drawLine(painter, line1.x1(), line1.y1(), line1.x2(), line1.y2())
                # point
                x, y = line.x, line.y
                smoothWidth = 8 * scale
                smoothHalf = smoothWidth / 2.0
                painter.save()
                pointPath = QPainterPath()
                x -= smoothHalf
                y -= smoothHalf
                pointPath.addEllipse(x, y, smoothWidth, smoothWidth)
                pen = QPen(color_)
                pen.setWidthF(1 * scale)
                painter.setPen(pen)
                if drawSelection and line.selected:
                    painter.fillPath(pointPath, color_)
                painter.drawPath(pointPath)
                painter.restore()
            else:
                if line.y is not None:
                    drawLine(painter, xMin, line.y, xMax, line.y)
                elif line.x is not None:
                    drawLine(painter, line.x, yMin, line.x, yMax)
        if drawText and line.name:
            if line1 is not None:
                textX = line.x
                textY = line.y - 6 * scale
                xAlign = "center"
            else:
                if line.y is not None:
                    fontSize = painter.font().pointSize()
                    textX = glyph.width + 6 * scale
                    textY = line.y - (fontSize / 3.5) * scale
                elif line.x is not None:
                    textX = line.x + 6 * scale
                    textY = 0
                xAlign = "left"
            drawTextAtPoint(painter, line.name, textX, textY, scale, xAlign=xAlign)
        painter.restore()
コード例 #55
0
ファイル: line.py プロジェクト: rnk-industries/Chemical-PFD
    def paint(self, painter, option, widget):
        color = Qt.red if self.isSelected() else Qt.black
        painter.setPen(QPen(color, 2, Qt.SolidLine))
        path = QPainterPath(self.startPoint) # start path
        # iterating over all points of line
        for i in range(len(self.points) - 1):
            x1, y1 = self.points[i].x(), self.points[i].y()
            x2, y2 = self.points[i + 1].x(), self.points[i + 1].y()
            for point in sorted(self.commonPathsCenters, key=lambda x: x.x() + x.y(), reverse=x2 < x1 or y2 < y1):
                x, y = point.x(), point.y()
                if x == x1 == x2:
                    # vertical
                    if min(y1, y2) + 8 <= y < max(y1, y2) - 8:
                        if y2 > y1:
                            path.lineTo(point - QPointF(0, 8))
                            path.arcTo(QRectF(x - 8, y - 8, 16, 16), 90, -180)
                            path.moveTo(point + QPointF(0, 8))
                        else:
                            path.lineTo(point + QPointF(0, 8))
                            path.arcTo(QRectF(x - 8, y - 8, 16, 16), -90, 180)
                            path.moveTo(point - QPointF(0, 8))
                elif y == y1 == y2:
                    # horizontal
                    if min(x1, x2) + 8 <= x < max(x1, x2) - 8:
                        if x2 > x1:
                            path.lineTo(point - QPointF(8, 0))
                            path.arcTo(QRectF(x - 8, y - 8, 16, 16), 180, 180)
                            path.moveTo(point + QPointF(8, 0))
                        else:
                            path.lineTo(point + QPointF(8, 0))
                            path.arcTo(QRectF(x - 8, y - 8, 16, 16), 0, -180)
                            path.lineTo(point - QPointF(8, 0))
            path.lineTo(self.points[i + 1])
            # draw arrow in last segment
            if i == len(self.points) - 2:
                arrow_size = 20.0
                line = QLineF(self.points[i], self.points[i + 1])
                if line.length() < 20:
                    continue
                angle = math.acos(line.dx() / line.length())

                if line.dy() >= 0:
                    angle = (math.pi * 2) - angle

                arrow_p1 = line.p2() - QPointF(math.sin(angle + math.pi / 2.5) * arrow_size,
                                               math.cos(angle + math.pi / 2.5) * arrow_size)

                arrow_p2 = line.p2() - QPointF(math.sin(angle + math.pi - math.pi / 2.5) * arrow_size,
                                               math.cos(angle + math.pi - math.pi / 2.5) * arrow_size)

                arrowHead = QPolygonF()
                arrowHead.append(line.p2())
                arrowHead.append(arrow_p1)
                arrowHead.append(arrow_p2)
                painter.save()
                painter.setBrush(Qt.black)
                painter.drawPolygon(arrowHead)
                painter.restore()

        painter.drawPath(path) # draw final path
コード例 #56
0
    def _paint_utility_blocks(self):
        scene = self
        w = scene.width() - (self._left_p + self._right_p)
        h = scene.height() - (self._top_p + self._bot_p)

        block_width = self._block_width
        font = QFont()
        font.setPointSize(12)
        font.setBold(True)

        fm = QFontMetrics(font)
        # hot utility
        pen = QPen(Qt.red, 5, Qt.SolidLine, Qt.SquareCap, Qt.RoundJoin)
        path = QPainterPath()
        path.addRoundedRect(0, 0, block_width, h, 10, 10)
        path = scene.addPath(path, pen=pen)
        path.setPos(self._map_x(0), self._map_y(h))

        text = scene.addText("Hot Utility", font=font)
        text.setDefaultTextColor(Qt.red)
        t_wid = fm.horizontalAdvance(text.toPlainText())
        text.setPos(
            self._map_x((block_width - fm.height()) / 2),
            self._map_y((h - t_wid) / 2)
        )
        text.setRotation(-90.0)

        # cold utility
        pen = QPen(Qt.blue, 5, Qt.SolidLine, Qt.SquareCap, Qt.RoundJoin)
        path = QPainterPath()
        path.addRoundedRect(0, 0, block_width, h, 10, 10)
        path = scene.addPath(path, pen=pen)
        path.setPos(self._map_x(w - block_width), self._map_y(h))

        text = scene.addText("Cold Utility", font=font)
        text.setDefaultTextColor(Qt.blue)
        t_wid = fm.horizontalAdvance(text.toPlainText())
        text.setPos(
            self._map_x(w - (block_width + fm.height()) / 2),
            self._map_y((h - t_wid) / 2)
        )
        text.setRotation(-90.0)
コード例 #57
0
ファイル: drawing.py プロジェクト: yalvex/trufont
def drawGlyphPoints(
    painter,
    glyph,
    scale,
    drawStartPoints=True,
    drawOnCurves=True,
    drawOffCurves=True,
    drawCoordinates=False,
    drawHandleCoordinates=False,
    drawCoordinatesOnSelection=False,
    drawSelection=True,
    drawBluesMarkers=True,
    onCurveColor=None,
    onCurveSmoothColor=None,
    offCurveColor=None,
    otherColor=None,
    backgroundColor=None,
):
    if onCurveColor is None:
        onCurveColor = defaultColor("glyphOnCurvePoints")
    if onCurveSmoothColor is None:
        onCurveSmoothColor = defaultColor("glyphOnCurveSmoothPoints")
    if offCurveColor is None:
        offCurveColor = defaultColor("glyphOffCurvePoints")
    if otherColor is None:
        otherColor = defaultColor("glyphOtherPoints")
    if backgroundColor is None:
        backgroundColor = defaultColor("background")
    bluesMarkerColor = defaultColor("glyphBluesMarker")
    notchColor = defaultColor("glyphContourStroke").lighter(200)
    # get the outline data
    outlineData = glyph.getRepresentation("defconQt.OutlineInformation")
    points = []
    handles = []
    # blue zones markers
    if drawBluesMarkers and drawOnCurves:
        font = glyph.font
        blues = []
        if font.info.postscriptBlueValues:
            blues += font.info.postscriptBlueValues
        if font.info.postscriptOtherBlues:
            blues += font.info.postscriptOtherBlues
        if blues:
            blues_ = set(blues)
            size = 13 * scale
            selectedSize = 15 * scale
            snapSize = 17 * scale
            selectedSnapSize = 20 * scale
            painter.save()
            pen = painter.pen()
            pen.setColor(QColor(255, 255, 255, 125))
            pen.setWidth(0)
            painter.setPen(pen)
            for point in outlineData["onCurvePoints"]:
                x, y = point["point"]
                # TODO: we could add a non-overlapping interval tree special
                # cased for borders
                selected = drawSelection and point.get("selected", False)
                if selected:
                    size_ = selectedSize
                    snapSize_ = selectedSnapSize
                else:
                    size_ = size
                    snapSize_ = snapSize
                for yMin, yMax in zip(blues[::2], blues[1::2]):
                    if not (y >= yMin and y <= yMax):
                        continue
                    # if yMin > 0 and y == yMin or yMin <= 0 and y == yMax:
                    if y in blues_:
                        path = lozengePath(x, y, snapSize_)
                    else:
                        path = ellipsePath(x, y, size_)
                    painter.fillPath(path, bluesMarkerColor)
                    painter.drawPath(path)
            painter.restore()
    # handles
    if drawOffCurves and outlineData["offCurvePoints"]:
        painter.save()
        painter.setPen(otherColor)
        for x1, y1, x2, y2 in outlineData["bezierHandles"]:
            handles.append((x2, y2))
            drawLine(painter, x1, y1, x2, y2)
        painter.restore()
    # on curve
    if drawOnCurves and outlineData["onCurvePoints"]:
        size = 6.5 * scale
        selectedSize = 8.5 * scale
        smoothSize = 8 * scale
        selectedSmoothSize = 10 * scale
        startSize = 7 * scale
        selectedStartSize = 9 * scale
        loneStartSize = 12 * scale
        selectedLoneStartSize = 14 * scale
        painter.save()
        notchPath = QPainterPath()
        paths = (QPainterPath(), QPainterPath())
        smoothPaths = (QPainterPath(), QPainterPath())
        for point in outlineData["onCurvePoints"]:
            x, y = point["point"]
            points.append((x, y))
            # notch
            if "smoothAngle" in point:
                angle = point["smoothAngle"]
                t = Identity.rotate(angle)
                x1, y1 = t.transformPoint((-1.35 * scale, 0))
                x2, y2 = -x1, -y1
                x1 += x
                y1 += y
                x2 += x
                y2 += y
                notchPath.moveTo(x1, y1)
                notchPath.lineTo(x2, y2)
            # points
            selected = drawSelection and point.get("selected", False)
            if selected:
                size_ = selectedSize
                smoothSize_ = selectedSmoothSize
                startSize_ = selectedStartSize
                loneStartSize_ = selectedLoneStartSize
            else:
                size_ = size
                smoothSize_ = smoothSize
                startSize_ = startSize
                loneStartSize_ = loneStartSize
            if drawStartPoints and "startPointAngle" in point:
                angle = point["startPointAngle"]
                if angle is not None:
                    pointPath = trianglePath(x, y, startSize_, angle)
                else:
                    pointPath = ellipsePath(x, y, loneStartSize_)
            elif point["smooth"]:
                pointPath = ellipsePath(x, y, smoothSize_)
            else:
                pointPath = rectanglePath(x, y, size_)
            # store the path
            if point["smooth"]:
                smoothPaths[selected].addPath(pointPath)
            else:
                paths[selected].addPath(pointPath)
            if drawCoordinatesOnSelection and selected and not drawCoordinates:
                drawPointText(painter, x, y, scale, ishandle=False)
        path, selectedPath = paths
        smoothPath, selectedSmoothPath = smoothPaths
        # fill
        selectedPath.setFillRule(Qt.WindingFill)
        selectedSmoothPath.setFillRule(Qt.WindingFill)
        painter.fillPath(selectedPath, onCurveColor)
        painter.fillPath(selectedSmoothPath, onCurveSmoothColor)
        # stroke
        pen = QPen(onCurveColor)
        pen.setWidthF(1.2 * scale)
        painter.setPen(pen)
        painter.drawPath(path)
        pen.setColor(onCurveSmoothColor)
        painter.setPen(pen)
        painter.drawPath(smoothPath)
        # notch
        pen.setColor(notchColor)
        pen.setWidth(0)
        painter.setPen(pen)
        painter.drawPath(notchPath)
        painter.restore()
    # off curve
    if drawOffCurves and outlineData["offCurvePoints"]:
        # points
        offSize = 4.25 * scale
        selectedOffSize = 6.75 * scale
        path = QPainterPath()
        selectedPath = QPainterPath()
        selectedPath.setFillRule(Qt.WindingFill)
        for point in outlineData["offCurvePoints"]:
            x, y = point["point"]
            selected = drawSelection and point.get("selected", False)
            if selected:
                offSize_ = selectedOffSize
            else:
                offSize_ = offSize
            pointPath = ellipsePath(x, y, offSize_)
            if selected:
                selectedPath.addPath(pointPath)
            else:
                path.addPath(pointPath)
            if drawCoordinatesOnSelection and selected and not drawHandleCoordinates:
                drawPointText(painter, x, y, scale, ishandle=True)
        pen = QPen(offCurveColor)
        pen.setWidthF(2.5 * scale)
        painter.save()
        painter.setPen(pen)
        painter.drawPath(path)
        painter.fillPath(path, QBrush(backgroundColor))
        painter.fillPath(selectedPath, QBrush(offCurveColor.lighter(135)))
        painter.restore()
    # coordinates
    if drawCoordinates:
        painter.save()
        for x, y in points:
            drawPointText(painter, x, y, scale, ishandle=False)
        painter.restore()
    # handle coordinates
    if drawHandleCoordinates:
        painter.save()
        for x, y in handles:
            drawPointText(painter, x, y, scale, ishandle=True)
        painter.restore()
コード例 #58
0
    def showWedge(self, angle, color,
                  extended=False, rev_gradient=False, outline_only=False):
        """Summary

        Args:
            angle (TYPE): Description
            color (TYPE): Description
            extended (bool, optional): Description
            rev_gradient (bool, optional): Description
            outline_only (bool, optional): Description
        """
        # Hack to keep wedge in front
        # self.setRotation(self.pre_xover_item_group.rotation())

        self._last_params = (angle, color, extended, rev_gradient, outline_only)
        radius = self._radius
        span = self.pre_xover_item_group.partCrossoverSpanAngle() / 2
        radius_adjusted = radius + (_WEDGE_RECT_GAIN / 2)

        tip = QPointF(radius_adjusted, radius_adjusted)
        EXT = 1.35 if extended else 1.0

        # print("wtf", tip, pos)
        base_p2 = QPointF(1, 1)

        line0 = QLineF(tip, QPointF(base_p2))
        line1 = QLineF(tip, QPointF(base_p2))
        line2 = QLineF(tip, QPointF(base_p2))

        quad_scale = 1 + (.22*(span - 5) / 55)  # lo+(hi-lo)*(val-min)/(max-min)
        line0.setLength(radius_adjusted * EXT*quad_scale)  # for quadTo control point
        line1.setLength(radius_adjusted * EXT)
        line2.setLength(radius_adjusted * EXT)
        line0.setAngle(angle)
        line1.setAngle(angle - span)
        line2.setAngle(angle + span)

        path = QPainterPath()

        if outline_only:
            self.setPen(getPenObj(color, 0.5, alpha=128, capstyle=Qt.RoundCap))
            path.moveTo(line1.p2())
            path.quadTo(line0.p2(), line2.p2())
        else:
            gradient = QRadialGradient(tip, radius_adjusted * EXT)
            color1 = getColorObj(color, alpha=80)
            color2 = getColorObj(color, alpha=0)
            if rev_gradient:
                color1, color2 = color2, color1

            if extended:
                gradient.setColorAt(0, color1)
                gradient.setColorAt(radius_adjusted / (radius_adjusted * EXT), color1)
                gradient.setColorAt(radius_adjusted / (radius_adjusted * EXT) + 0.01, color2)
                gradient.setColorAt(1, color2)
            else:
                gradient.setColorAt(0, getColorObj(color, alpha=50))
            brush = QBrush(gradient)
            self.setBrush(brush)

            path.moveTo(line1.p1())
            path.lineTo(line1.p2())
            path.quadTo(line0.p2(), line2.p2())
            path.lineTo(line2.p1())

        self.setPath(path)
        self.show()
コード例 #59
0
ファイル: painterpaths.py プロジェクト: farisachugthai/qtcalc
    def __init__(self):
        super(Window, self).__init__()

        rectPath = QPainterPath()
        rectPath.moveTo(20.0, 30.0)
        rectPath.lineTo(80.0, 30.0)
        rectPath.lineTo(80.0, 70.0)
        rectPath.lineTo(20.0, 70.0)
        rectPath.closeSubpath()

        roundRectPath = QPainterPath()
        roundRectPath.moveTo(80.0, 35.0)
        roundRectPath.arcTo(70.0, 30.0, 10.0, 10.0, 0.0, 90.0)
        roundRectPath.lineTo(25.0, 30.0)
        roundRectPath.arcTo(20.0, 30.0, 10.0, 10.0, 90.0, 90.0)
        roundRectPath.lineTo(20.0, 65.0)
        roundRectPath.arcTo(20.0, 60.0, 10.0, 10.0, 180.0, 90.0)
        roundRectPath.lineTo(75.0, 70.0)
        roundRectPath.arcTo(70.0, 60.0, 10.0, 10.0, 270.0, 90.0)
        roundRectPath.closeSubpath()

        ellipsePath = QPainterPath()
        ellipsePath.moveTo(80.0, 50.0)
        ellipsePath.arcTo(20.0, 30.0, 60.0, 40.0, 0.0, 360.0)

        piePath = QPainterPath()
        piePath.moveTo(50.0, 50.0)
        piePath.lineTo(65.0, 32.6795)
        piePath.arcTo(20.0, 30.0, 60.0, 40.0, 60.0, 240.0)
        piePath.closeSubpath()

        polygonPath = QPainterPath()
        polygonPath.moveTo(10.0, 80.0)
        polygonPath.lineTo(20.0, 10.0)
        polygonPath.lineTo(80.0, 30.0)
        polygonPath.lineTo(90.0, 70.0)
        polygonPath.closeSubpath()

        groupPath = QPainterPath()
        groupPath.moveTo(60.0, 40.0)
        groupPath.arcTo(20.0, 20.0, 40.0, 40.0, 0.0, 360.0)
        groupPath.moveTo(40.0, 40.0)
        groupPath.lineTo(40.0, 80.0)
        groupPath.lineTo(80.0, 80.0)
        groupPath.lineTo(80.0, 40.0)
        groupPath.closeSubpath()

        textPath = QPainterPath()
        timesFont = QFont("Times", 50)
        timesFont.setStyleStrategy(QFont.ForceOutline)
        textPath.addText(10, 70, timesFont, "Qt")

        bezierPath = QPainterPath()
        bezierPath.moveTo(20, 30)
        bezierPath.cubicTo(80, 0, 50, 50, 80, 80)

        starPath = QPainterPath()
        starPath.moveTo(90, 50)
        for i in range(1, 5):
            starPath.lineTo(50 + 40 * cos(0.8 * i * pi),
                            50 + 40 * sin(0.8 * i * pi))
        starPath.closeSubpath()

        self.renderAreas = [
            RenderArea(rectPath),
            RenderArea(roundRectPath),
            RenderArea(ellipsePath),
            RenderArea(piePath),
            RenderArea(polygonPath),
            RenderArea(groupPath),
            RenderArea(textPath),
            RenderArea(bezierPath),
            RenderArea(starPath),
        ]
        assert len(self.renderAreas) == 9

        self.fillRuleComboBox = QComboBox()
        self.fillRuleComboBox.addItem("Odd Even", Qt.OddEvenFill)
        self.fillRuleComboBox.addItem("Winding", Qt.WindingFill)

        fillRuleLabel = QLabel("Fill &Rule:")
        fillRuleLabel.setBuddy(self.fillRuleComboBox)

        self.fillColor1ComboBox = QComboBox()
        self.populateWithColors(self.fillColor1ComboBox)
        self.fillColor1ComboBox.setCurrentIndex(
            self.fillColor1ComboBox.findText("mediumslateblue"))

        self.fillColor2ComboBox = QComboBox()
        self.populateWithColors(self.fillColor2ComboBox)
        self.fillColor2ComboBox.setCurrentIndex(
            self.fillColor2ComboBox.findText("cornsilk"))

        fillGradientLabel = QLabel("&Fill Gradient:")
        fillGradientLabel.setBuddy(self.fillColor1ComboBox)

        fillToLabel = QLabel("to")
        fillToLabel.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        self.penWidthSpinBox = QSpinBox()
        self.penWidthSpinBox.setRange(0, 20)

        penWidthLabel = QLabel("&Pen Width:")
        penWidthLabel.setBuddy(self.penWidthSpinBox)

        self.penColorComboBox = QComboBox()
        self.populateWithColors(self.penColorComboBox)
        self.penColorComboBox.setCurrentIndex(
            self.penColorComboBox.findText("darkslateblue"))

        penColorLabel = QLabel("Pen &Color:")
        penColorLabel.setBuddy(self.penColorComboBox)

        self.rotationAngleSpinBox = QSpinBox()
        self.rotationAngleSpinBox.setRange(0, 359)
        self.rotationAngleSpinBox.setWrapping(True)
        self.rotationAngleSpinBox.setSuffix(u"\N{DEGREE SIGN}")

        rotationAngleLabel = QLabel("&Rotation Angle:")
        rotationAngleLabel.setBuddy(self.rotationAngleSpinBox)

        self.fillRuleComboBox.activated.connect(self.fillRuleChanged)
        self.fillColor1ComboBox.activated.connect(self.fillGradientChanged)
        self.fillColor2ComboBox.activated.connect(self.fillGradientChanged)
        self.penColorComboBox.activated.connect(self.penColorChanged)

        for i in range(Window.NumRenderAreas):
            self.penWidthSpinBox.valueChanged.connect(
                self.renderAreas[i].setPenWidth)
            self.rotationAngleSpinBox.valueChanged.connect(
                self.renderAreas[i].setRotationAngle)

        topLayout = QGridLayout()
        for i in range(Window.NumRenderAreas):
            topLayout.addWidget(self.renderAreas[i], i / 3, i % 3)

        mainLayout = QGridLayout()
        mainLayout.addLayout(topLayout, 0, 0, 1, 4)
        mainLayout.addWidget(fillRuleLabel, 1, 0)
        mainLayout.addWidget(self.fillRuleComboBox, 1, 1, 1, 3)
        mainLayout.addWidget(fillGradientLabel, 2, 0)
        mainLayout.addWidget(self.fillColor1ComboBox, 2, 1)
        mainLayout.addWidget(fillToLabel, 2, 2)
        mainLayout.addWidget(self.fillColor2ComboBox, 2, 3)
        mainLayout.addWidget(penWidthLabel, 3, 0)
        mainLayout.addWidget(self.penWidthSpinBox, 3, 1, 1, 3)
        mainLayout.addWidget(penColorLabel, 4, 0)
        mainLayout.addWidget(self.penColorComboBox, 4, 1, 1, 3)
        mainLayout.addWidget(rotationAngleLabel, 5, 0)
        mainLayout.addWidget(self.rotationAngleSpinBox, 5, 1, 1, 3)
        self.setLayout(mainLayout)

        self.fillRuleChanged()
        self.fillGradientChanged()
        self.penColorChanged()
        self.penWidthSpinBox.setValue(2)

        self.setWindowTitle("Painter Paths")
コード例 #60
0
ファイル: node.py プロジェクト: paradoxfxx/pysimCoder-1
 def setup(self):
     p = QPainterPath()
     p.addEllipse(-NW / 2, -NW / 2, NW, NW)
     self.setPath(p)