def draw_needle(self, qp): """ Draws the Needle. Whether the top or the bottom part of the needle is going to be drawn, the function operates differently. The top part is drawn with a triangle, the bottom part is just a single line. :param qp: QPainter """ __pen = QPen(self.__color, NEEDLE_LINE_WIDTH, Qt.SolidLine) __brush = QBrush(self.__color) qp.setPen(__pen) qp.setBrush(__brush) if self.__top: triangle = QPolygonF() n = 3 r = self.width() - 2 s = 90 w = 360 / n for i in range(n): t = w * i + s x = r * math.cos(math.radians(t)) y = (r - 3) * math.sin(math.radians(t)) triangle.append(QPointF(self.width() / 2 + x, 0 + y)) qp.drawPolygon(triangle) starting_point = QPoint(int(self.width() / 2), 0) finishing_point = QPoint(int(self.width() / 2), self.__drawing_height) qp.drawLine(starting_point, finishing_point)
def paint(self, painter, option, widget): if self.line().length() == 0: return myPen = self.pen() myPen.setColor(Qt.black) arrowSize = 10.0 painter.setPen(myPen) painter.setBrush(Qt.black) angle = math.acos(self.line().dx() / self.line().length()) if self.line().dy() >= 0: angle = (math.pi * 2) - angle arrowP1 = self.line().p2() - QPointF( math.sin(angle + math.pi / 2.5) * arrowSize, math.cos(angle + math.pi / 2.5) * arrowSize) arrowP2 = self.line().p2() - QPointF( math.sin(angle + math.pi - math.pi / 2.5) * arrowSize, math.cos(angle + math.pi - math.pi / 2.5) * arrowSize) arrowHead = QPolygonF() arrowHead.append(self.line().p2()) arrowHead.append(arrowP1) arrowHead.append(arrowP2) painter.drawLine(self.line()) painter.drawPolygon(arrowHead)
def set_contours_list(self, contour): ''' Set the contours, result of the segmentation of the left ventricle. The amount of contours must be the same as the amount of images stored in this widget, and they should not be None nor empty. Even if it is only the contour for a sole image, it should be stored in a list with the format: [Image_idx, [Array of 2D points]] After the contours has been set, the images will be refreshed Args: contour: List of lists, with the contours of the segmented left ventricle ''' contour = np.array(contour) if not contour is None and len(contour.shape): self.contour_set.clear() # We copy the data into the internal buffer for i in np.arange(contour.shape[0]): polygon = QPolygonF() for j in range(len(contour[i])): point = contour[i][j] polygon.append( QPointF(point[0] * self.scaling_factor, point[1] * self.scaling_factor)) self.contour_set.append(polygon) self.refresh_image()
def __readPolygon(self): atts = self.xml.attributes() points = atts.value("points") pointsList = list(filter(lambda x:x.strip()!='', points.split(' '))) polygon = QPolygonF() ok = True for point in pointsList: try: x, y = point.split(',') except: ok = False break x, ok = Float2(x) if (not ok): break y, ok = Float2(y) if (not ok): break polygon.append(QPointF(x, y)) if (not ok): self.xml.raiseError(self.tr("Invalid points data for polygon")) self.xml.skipCurrentElement() return polygon
def get_polygon(self): contours, hierarchy = cv.findContours(self._mask, cv.RETR_CCOMP, cv.CHAIN_APPROX_NONE) if len(contours) < 1: return None # 현재는 최대 크기 polygon 만을 반환. # index = contours.index(max(contours, key=lambda x: cv.contourArea(x))) key = np.array([cv.contourArea(contour) for contour in contours]) index = np.argmax(key) x = contours[index][:, 0][:, 0].tolist() y = contours[index][:, 0][:, 1].tolist() # hierarchy : [Next, Previous, First_Child, Parent] if hierarchy[0][index][2] != -1: # Child 가 존재할 경우 x.extend(contours[hierarchy[0][index][2]][:, 0][:, 0].tolist()) y.extend(contours[hierarchy[0][index][2]][:, 0][:, 1].tolist()) elif hierarchy[0][index][3] != -1: # Parent 가 존재할 경우 x = contours[hierarchy[0][index][2]][:, 0][:, 0].tolist() + x y = contours[hierarchy[0][index][2]][:, 0][:, 1].tolist() + y # Create Polygon polygon = QPolygonF() for idx in range(len(x)): polygon.append(QPointF(x[idx], y[idx])) return polygon
def __readPolygon(self): atts = self.xml.attributes() points = atts.value("points") pointsList = list(filter(lambda x: x.strip() != '', points.split(' '))) polygon = QPolygonF() ok = True for point in pointsList: try: x, y = point.split(',') except: ok = False break x, ok = Float2(x) if (not ok): break y, ok = Float2(y) if (not ok): break polygon.append(QPointF(x, y)) if (not ok): self.xml.raiseError(self.tr("Invalid points data for polygon")) self.xml.skipCurrentElement() return polygon
def set_initial_contours(self, new_contours_dictionary): ''' Setter that will take the information for the initial contours to be shown in the image. This function also converts the list of points for the manual mode into QPolygonF, so the paintEvent function does not need to do it every painting After this function is executed, a new painting is going to be triggered Args: new_contours_dictionary: Dictionary in which the key is the zone that this contours represents. Then inside this key there is another dictionary, which key can be 'type', for the type of contour that it containts, and data if it is manual type, or center_x, center_y and radious if the type is circular ''' self.initial_contours = copy.deepcopy(new_contours_dictionary) for key, value in new_contours_dictionary.items(): if value and value['type'] == snake_init_list[CONTOUR_MANUAL]: contour = np.array(value['data']) polygon = QPolygonF() if not contour is None and len(contour.shape): for i in np.arange(contour.shape[0]): point = contour[i] polygon.append( QPointF(point[0] * self.scaling_factor, point[1] * self.scaling_factor)) self.initial_contours[key]['data'] = polygon self.repaint()
def createPoly(self, n, r, s,pos): polygon = QPolygonF() w = 360 / n # angle per step maxX=0 maxY=0 minX = 0 minY = 0 first = True for i in range(n): # add the points of polygon t = w * i + s rand = random.randint(80,100)/100 rad = r *rand x = rad * math.cos(math.radians(t)) y = rad * math.sin(math.radians(t)) Xpos=pos.x() + x Ypos = pos.y() + y if Xpos>maxX: maxX =Xpos if Ypos>maxY: maxY =Ypos if Xpos<minX: minX =Xpos if Ypos < minY: minY = Ypos if(first): maxX = Xpos maxY = Ypos minX = Xpos minY = Ypos first=False polygon.append(QPointF(Xpos,Ypos)) return {'polygon':polygon,'maxX':maxX,'maxY':maxY,'minX':minX,'minY':minY}
def toQPointList(self): positions = QPolygonF() for control in self.controls: positions.append(control.position) return positions
def draw_arrow(self) -> None: """ This method draws an arrow at the end of the line. """ polygon_arrow_head = QPolygonF() # Compute the arrow angle angle = math.acos(self.line().dx() / self.line().length()) angle = ((math.pi * 2) - angle) # Compute the direction where the arrow points (1 up, -1 down) arrow_direction = 1 if math.asin(self.line().dy() / self.line().length()) < 0: arrow_direction = -1 # First point of the arrow tail arrow_p1 = self.line().p2() - arrow_direction * QPointF( arrow_direction * math.sin(angle + math.pi / 2.5) * self.arrow_size, math.cos(angle + math.pi / 2.5) * self.arrow_size) # Second point of the arrow tail arrow_p2 = self.line().p2() - arrow_direction * QPointF( arrow_direction * math.sin(angle + math.pi - math.pi / 2.5) * self.arrow_size, math.cos(angle + math.pi - math.pi / 2.5) * self.arrow_size) # Third point is the line end polygon_arrow_head.append(self.line().p2()) polygon_arrow_head.append(arrow_p2) polygon_arrow_head.append(arrow_p1) # Add the arrow to the scene self.arrow_head.setZValue(1) self.arrow_head.setParentItem(self) self.arrow_head.setPolygon(polygon_arrow_head)
def paint(self, painter, option, widget): if self.line().length() == 0: return pen = self.pen() pen.setColor(constants.LINECOLOR) painter.setPen(pen) painter.setBrush(constants.LINECOLOR) arrow_size = 10.0 angle = math.acos(self.line().dx() / self.line().length()) if self.line().dy() >= 0: angle = (math.pi * 2) - angle arrow_p1 = self.line().p2() - QPointF(math.sin(angle + math.pi / 2.5) * arrow_size, math.cos(angle + math.pi / 2.5) * arrow_size) arrow_p2 = self.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) arrow_head = QPolygonF() arrow_head.append(self.line().p2()) arrow_head.append(arrow_p1) arrow_head.append(arrow_p2) painter.drawLine(self.line()) painter.drawPolygon(arrow_head)
def generatePicture(self): if self.opts["lut"] is None: lut = np.empty((len(self.xData), 4), dtype=int) pen = self.opts["pen"] if isinstance(pen, QPen): color = pen.color().getRgb() elif len(pen) == 3: color = list(pen) + [255] else: color = pen lut[:, :] = color self.opts["lut"] = lut # generate picture self.picture = QPicture() p = QPainter(self.picture) # if "connect" == "all" if isinstance(self.opts["connect"], str): lut_array = self.adjustLUT(N_segment=len(self.xData)) # add to generated picture line by line for i, col_values in enumerate(lut_array[:-1]): p.setPen(pg.mkPen(col_values)) p.drawLine(QPointF(self.xData[i], self.yData[i]), QPointF(self.xData[i+1], self.yData[i+1])) else: lut_array = self.adjustLUT(N_segment=(self.opts["connect"] == 0).sum()) # add to generated picture with polyline polygonF = QPolygonF() idx = -1 for x, y, c in zip(self.xData, self.yData, self.opts["connect"]): polygonF.append(QPointF(x, y)) if c == 0: idx += 1 p.setPen(pg.mkPen(lut_array[idx])) p.drawPolyline(polygonF) polygonF = QPolygonF()
def polygonFromArc(center, radius, start, end, seg): poly = QPolygonF() for k in range(0, seg): theta = 2 * pi / 360 * (start + k * (end - start) / seg) point = center + radius * QPointF(cos(theta), sin(theta)) poly.append(point) return poly
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
def paint(self, painter, option, widget): if self.line().length() == 0: return pen = self.pen() pen.setColor(constants.LINECOLOR) painter.setPen(pen) painter.setBrush(constants.LINECOLOR) arrow_size = 10.0 angle = math.acos(self.line().dx() / self.line().length()) if self.line().dy() >= 0: angle = (math.pi * 2) - angle arrow_p1 = self.line().p2() - QPointF( math.sin(angle + math.pi / 2.5) * arrow_size, math.cos(angle + math.pi / 2.5) * arrow_size) arrow_p2 = self.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) arrow_head = QPolygonF() arrow_head.append(self.line().p2()) arrow_head.append(arrow_p1) arrow_head.append(arrow_p2) painter.drawLine(self.line()) painter.drawPolygon(arrow_head)
def to_qobject(self, x_offset, y_offset, width, height, inflate_radius=None): width_factor = width / TABLE_WIDTH height_factor = height / TABLE_HEIGHT polygon = QPolygonF() if inflate_radius is None: for pt in self.points: polygon.append( QPointF(pt[0] * width_factor + x_offset, height - (pt[1] * height_factor + y_offset))) else: pco = pyclipper.PyclipperOffset() points = tuple(self.points) pco.AddPath(points, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON) inflated_pt = pco.Execute( inflate_radius ) # inflated_pt is a list of polygons, usually there is only one for pt in inflated_pt[0]: polygon.append( QPointF(pt[0] * width_factor + x_offset, height - (pt[1] * height_factor + y_offset))) return "drawPolygon", polygon
def drawZig(qp, x, y, width, height): qp = qp # type: QPainter pointsCoord = [[x, y + height], [x + width * 0.33, y], [x + width * 0.66, y + height], [x + width, y]] trianglePolygon = QPolygonF() for i in pointsCoord: trianglePolygon.append(QPointF(i[0], i[1])) qp.drawPolygon(trianglePolygon)
class SideRoi: support: List[QRectF] polygon: QPolygonF def __init__(self): self.support = list() self.polygon = QPolygonF() def in_support(self, point: QPointF) -> bool: for s in self.support: if s.contains(point): return True return False def contains(self, point: QPointF) -> bool: return (self.polygon.size() >= 3) and \ self.polygon.containsPoint(point, Qt.OddEvenFill) def to_dict(self): o = dict() o['support'] = list() for s in self.support: r = dict() r['x'] = s.x() r['y'] = s.y() r['width'] = s.width() r['height'] = s.height() o['support'].append(r) o['polygon'] = list() for point in self.polygon: p = dict() p['x'] = point.x() p['y'] = point.y() o['polygon'].append(p) return o def from_dict(self, o: dict): self.support = list() self.polygon = QPolygonF() for r in o['support']: x = r['x'] y = r['y'] w = r['width'] h = r['height'] s = QRectF(x, y, w, h) self.support.append(s) for p in o['polygon']: x = p['x'] y = p['y'] point = QPointF(x, y) self.polygon.append(point) return self
def __scaled(self): vertices = self.listVertices() scaled_poly = QPolygonF() for vx in vertices: vx.setX(vx.x()*self.scale) vx.setY(vx.y()*self.scale) scaled_poly.append(vx) return scaled_poly
def boundingPolygonOfCircle(radius, sides): n = sides t = 2 * pi / n r = radius / cos(t / 2) poly = QPolygonF() for k in range(0, n): poly.append(QPointF(r * cos(t * k), r * sin(t * k))) return poly
def add_polygon(points, pen): p = QPolygonF() for i in points: new_p = QPoint(i.x(), i.y()) p.append(new_p) p_brush = QBrush(wind.color_back) wind.scene.addPolygon(p, QPen(pen.color()), p_brush)
def __bufferPolygon(self, context, data, model): buffer = QPolygonF() for point in data: point = self.__transform(model, point) buffer.append(QPointF(point[0], point[1])) return buffer
def setPoly(self, points): self.vertices = points polyF = QPolygonF() for p in points: polyF.append(QPointF(p[0], p[1])) self.polygon.setPolygon(polyF)
def plotOutline(self, vertexs): scene = self.view.getScene() polygon = QPolygonF() polygon.clear() for point in vertexs: polygon.append(QPointF(point[0] * consts.DPM_X, point[1] * consts.DPM_Y)) scene.addPolygon(polygon, QColor(0,0,128))
def __init__(self, points, filled=False): super().__init__() polygon = QPolygonF() for point in points: polygon.append(QPoint(point[0], point[1])) p = QGraphicsPolygonItem(polygon) self.addToGroup(p)
def toPolygon(self, variant): polygon = QPolygonF() for pointVariant in variant: pointVariantMap = pointVariant pointX = pointVariantMap.get("x",0.0) pointY = pointVariantMap.get("y",0.0) polygon.append(QPointF(pointX, pointY)) return polygon
def drawPoly(self, n, r, s, pos): polygon = QPolygonF() w = 360 / n for i in range(n): t = w * i + s x = r * math.cos(math.radians(t)) y = r * math.sin(math.radians(t)) polygon.append(QPointF(pos[0] + x, pos[1] + y)) return polygon
class Curve: def __init__(self, ctype, name=''): self.name = name self.points = [] self.points_no = 0 self.ctype = ctype self.is_changed = True self.is_guide = False self.plot = None self.guide = None def add_point(self, x, y, z=0): self.points.append((x, y)) self.points_no += 1 self.is_changed = True def move_point_to(self, i, x=None, y=None): (old_x, old_y) = self.points[i] self.points[i] = (x if x is not None else old_x, y if y is not None else old_y) self.is_changed = True def move_point_by(self, i, dx, dy): (x, y) = self.points[i] self.points[i] = (x + dx, y + dy) self.is_changed = True def make_plot(self, scx, scy): if self.is_changed: if self.is_guide: self.make_guide(scx, scy) plot_size = 100. + 10. * self.points_no if self.ctype == 'bezier' and self.points_no > 0: points = [ deCasteljau(self.points, t / plot_size) for t in range(int(plot_size + 1)) ] elif self.ctype == 'rbezier' and self.points_no > 0: points = [ deCasteljauRat(self.points, self.weights, t / plot_size) for t in range(int(plot_size + 1)) ] else: points = [] self.plot = QPolygonF() for (x, y) in points: self.plot.append(QPointF(scx * x + 5, scy * y + 5)) self.is_changed = False def make_guide(self, scx, scy): self.guide = QPolygonF() for (x, y) in self.points: self.guide.append(QPointF(scx * x + 5, scy * y + 5)) def toggle_guide(self, is_guide): self.is_guide = is_guide self.is_changed = True
def polygonPlusMidpoints(poly): poly1 = QPolygonF() for k in range(1, poly.count() + 1): j = k % poly.count() poly1.append(poly[k - 1]) poly1.append((poly[k - 1] + poly[j]) / 2) return poly1
def add_polygon(): p = QPolygonF() for i in wind.cutter: new_p = QPointF(i.x(), i.y()) p.append(new_p) pen = QPen(wind.pen_cutter.color()) p_brush = QBrush(wind.color_back) wind.scene.addPolygon(p, pen, p_brush)
def draw_polygon(self, qp, img_w): # 绘制多边形 for res in self.results: text_region = res["text_region"] polygon = QPolygonF() for region in text_region: polygon.append(QPointF(img_w + region[0], region[1])) qp.drawPolygon(polygon)
def toPolygon(self, variant): polygon = QPolygonF() for pointVariant in variant: pointVariantMap = pointVariant pointX = pointVariantMap.get("x", 0.0) pointY = pointVariantMap.get("y", 0.0) polygon.append(QPointF(pointX, pointY)) return polygon
def createPoly(self, n, r, s, pos): polygon = QPolygonF() w = 360 / n # angle per step for i in range(n): # add the points of polygon t = w * i + s x = r * math.cos(math.radians(t)) y = r * math.sin(math.radians(t)) polygon.append(QPoint(pos.x() + x, pos.y() + y)) return polygon
def update_shape(self): poly, bbox = self.rb.update_shape() polygon = QPolygonF() for p in poly: # Qt canvas coordinates have 0,0 at top left of window, i.e. +y is # pointing down polygon.append(QPointF(p[0], -p[1])) self.setPolygon(polygon)
def startNewMapObject(self, pos, objectGroup): super().startNewMapObject(pos, objectGroup) newMapObject = self.mNewMapObjectItem.mapObject() polygon = QPolygonF() polygon.append(QPointF()) newMapObject.setPolygon(polygon) polygon.append(QPointF()) # The last point is connected to the mouse self.mOverlayPolygonObject.setPolygon(polygon) self.mOverlayPolygonObject.setShape(newMapObject.shape()) self.mOverlayPolygonObject.setPosition(pos) self.mOverlayPolygonItem = MapObjectItem(self.mOverlayPolygonObject, self.mapDocument(), self.mObjectGroupItem)
def pixelRectToScreenPolygon(self, rect): polygon = QPolygonF() polygon.append(QPointF(self.pixelToScreenCoords_(rect.topLeft()))) polygon.append(QPointF(self.pixelToScreenCoords_(rect.topRight()))) polygon.append(QPointF(self.pixelToScreenCoords_(rect.bottomRight()))) polygon.append(QPointF(self.pixelToScreenCoords_(rect.bottomLeft()))) return polygon
def updatePath(self): try: attrs = self.stackedWidget.currentWidget().get_attributes() attrs.keys() except Exception as e: msg = 'Tracking Lib. Attributes Error:\n{}'.format(e) self.generateCriticalMessage(msg) return if 'position' in attrs: self.trackingPathGroup.setPoints(self.currentFrameNo) if 'arrow' in attrs: for i, arrow_item in enumerate(self.item_dict['arrow']): begin = self.df['position'].loc[self.currentFrameNo, i].as_matrix() end = self.df['arrow'].loc[self.currentFrameNo, i].as_matrix() arrow_item.setPosition(begin, end) if 'path' in attrs: for path_item, path_data in zip(self.item_dict['path'], self.data_dict['path'][self.currentFrameNo]): poly = QPolygonF() for p in path_data: poly.append(QPointF(*p)) painter_path = QPainterPath() painter_path.addPolygon(poly) path_item.setPath(painter_path) pen = QPen(Qt.blue) pen.setWidth(2) path_item.setPen(pen) if 'polygon' in attrs: for path_item, path_data in zip(self.item_dict['polygon'], self.data_dict['polygon'][self.currentFrameNo]): poly = QPolygonF() for p in path_data: poly.append(QPointF(*p)) painter_path = QPainterPath() painter_path.addPolygon(poly) path_item.setPath(painter_path) pen = QPen(Qt.black) pen.setWidth(1) path_item.setPen(pen) if 'rect' in attrs: for rect_item, rect in zip(self.item_dict['rect'], self.data_dict['rect'][self.currentFrameNo]): rect_item.setRect(QRectF(QPointF(*rect[0]), QPointF(*rect[1])))
def tileRectToScreenPolygon(self, rect): tileWidth = self.map().tileWidth() tileHeight = self.map().tileHeight() topRight = self.tileToScreenCoords_(rect.topRight()) bottomRight = self.tileToScreenCoords_(rect.bottomRight()) bottomLeft = self.tileToScreenCoords_(rect.bottomLeft()) polygon = QPolygonF() polygon.append(QPointF(self.tileToScreenCoords_(rect.topLeft()))) polygon.append(QPointF(topRight.x() + tileWidth / 2, topRight.y() + tileHeight / 2)) polygon.append(QPointF(bottomRight.x(), bottomRight.y() + tileHeight)) polygon.append(QPointF(bottomLeft.x() - tileWidth / 2, bottomLeft.y() + tileHeight / 2)) return polygon
def paint(self, painter, option, widget=None): """ Public method to paint the item in local coordinates. @param painter reference to the painter object (QPainter) @param option style options (QStyleOptionGraphicsItem) @param widget optional reference to the widget painted on (QWidget) """ if (option.state & QStyle.State_Selected) == \ QStyle.State(QStyle.State_Selected): width = 2 else: width = 1 # draw the line first line = QLineF(self._origin, self._end) painter.setPen( QPen(Qt.black, width, Qt.SolidLine, Qt.FlatCap, Qt.MiterJoin)) painter.drawLine(line) # draw the arrow head arrowAngle = self._type * ArrowheadAngleFactor slope = math.atan2(line.dy(), line.dx()) # Calculate left arrow point arrowSlope = slope + arrowAngle a1 = QPointF(self._end.x() - self._halfLength * math.cos(arrowSlope), self._end.y() - self._halfLength * math.sin(arrowSlope)) # Calculate right arrow point arrowSlope = slope - arrowAngle a2 = QPointF(self._end.x() - self._halfLength * math.cos(arrowSlope), self._end.y() - self._halfLength * math.sin(arrowSlope)) if self._filled: painter.setBrush(Qt.black) else: painter.setBrush(Qt.white) polygon = QPolygonF() polygon.append(line.p2()) polygon.append(a1) polygon.append(a2) painter.drawPolygon(polygon)
def _setSpeeds(self, speeds): polygon = QPolygonF() polygon.append(QPointF(0, self.SIZE[1])) # start the polygon nSamples = len(speeds) xPerSample = self.SIZE[0] / nSamples for i, speed in enumerate(speeds): y = self._translateSpeedToPosY(speed) polygon.append(QPointF(xPerSample * i, y)) polygon.append(QPointF(xPerSample * (i+1), y)) polygon.append(QPointF(*self.SIZE)) # close the polygon self._speedsPolygon.setPolygon(polygon)
class Arrow(QGraphicsLineItem): def __init__(self, start_item, end_item, parent=None): super(Arrow, self).__init__(parent) self.arrowHead = QPolygonF() self.my_start_item = start_item self.my_end_item = end_item self.setFlag(QGraphicsItem.ItemIsSelectable, True) self.my_color = Qt.black self.setPen(QPen(self.my_color, 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) def set_color(self, color): self.my_color = color def start_item(self): return self.my_start_item def end_item(self): return self.my_end_item def boundingRect(self): extra = (self.pen().width() + 20) / 2.0 p1 = self.line().p1() p2 = self.line().p2() return QRectF(p1, QSizeF(p2.x() - p1.x(), p2.y() - p1.y())).normalized().adjusted(-extra, -extra, extra, extra) def shape(self): path = super(Arrow, self).shape() path.addPolygon(self.arrowHead) return path def update_position(self): line = QLineF(self.mapFromItem(self.my_start_item, 0, 0), self.mapFromItem(self.my_end_item, 0, 0)) self.setLine(line) def paint(self, painter, option, widget=None): if self.my_start_item.collidesWithItem(self.my_end_item): return my_start_item = self.my_start_item my_end_item = self.my_end_item my_color = self.my_color my_pen = self.pen() my_pen.setColor(self.my_color) arrow_size = 20.0 painter.setPen(my_pen) painter.setBrush(my_color) center_line = QLineF(my_start_item.pos(), my_end_item.pos()) end_polygon = my_end_item.polygon p1 = end_polygon.first() + my_end_item.pos() intersect_point = QPointF() for i in end_polygon: p2 = i + my_end_item.pos() poly_line = QLineF(p1, p2) intersect_type = poly_line.intersect(center_line, intersect_point) if intersect_type == QLineF.BoundedIntersection: break p1 = p2 self.setLine(QLineF(intersect_point, my_start_item.pos())) line = self.line() angle = math.acos(line.dx() / line.length()) if line.dy() >= 0: angle = (math.pi * 2) - angle arrow_p1 = line.p1() + QPointF(math.sin(angle + math.pi / 3.0) * arrow_size, math.cos(angle + math.pi / 3) * arrow_size) arrow_p2 = line.p1() + QPointF(math.sin(angle + math.pi - math.pi / 3.0) * arrow_size, math.cos(angle + math.pi - math.pi / 3.0) * arrow_size) self.arrowHead.clear() for point in [line.p1(), arrow_p1, arrow_p2]: self.arrowHead.append(point) painter.drawLine(line) painter.drawPolygon(self.arrowHead) if self.isSelected(): painter.setPen(QPen(my_color, 1, Qt.DashLine)) my_line = QLineF(line) my_line.translate(0, 4.0) painter.drawLine(my_line) my_line.translate(0, -8.0) painter.drawLine(my_line)
_yScale = styles.PATH_XOVER_LINE_SCALE_Y # control point y constant _rect = QRectF(0, 0, _BASE_WIDTH, _BASE_WIDTH) _blankRect = QRectF(0, 0, 2*_BASE_WIDTH, _BASE_WIDTH) PPL5 = QPainterPath() # Left 5' PainterPath PPR5 = QPainterPath() # Right 5' PainterPath PPL3 = QPainterPath() # Left 3' PainterPath PPR3 = QPainterPath() # Right 3' PainterPath # set up PPL5 (left 5' blue square) PPL5.addRect(0.25*_BASE_WIDTH, 0.125*_BASE_WIDTH, 0.75*_BASE_WIDTH, 0.75*_BASE_WIDTH) # set up PPR5 (right 5' blue square) PPR5.addRect(0, 0.125*_BASE_WIDTH, 0.75*_BASE_WIDTH, 0.75*_BASE_WIDTH) # set up PPL3 (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)) PPL3.addPolygon(L3_POLY) # set up PPR3 (right 3' blue triangle) R3_POLY = QPolygonF() R3_POLY.append(QPointF(0, 0)) R3_POLY.append(QPointF(0.75*_BASE_WIDTH, 0.5*_BASE_WIDTH)) R3_POLY.append(QPointF(0, _BASE_WIDTH)) PPR3.addPolygon(R3_POLY) class ForcedXoverNode3(QGraphicsRectItem): """ This is a QGraphicsRectItem to allow actions and also a QGraphicsSimpleTextItem to allow a label to be drawn
class MovableArrow(QGraphicsLineItem): def __init__(self, parent=None): super(MovableArrow, self).__init__(parent) self.setZValue(1000) self.arrowHead = QPolygonF() self.begin = np.array([0.0, 0.0]) self.end =np.array([10.0, 10.0]) self.myColor = Qt.black self.setPen(QPen(self.myColor, 5)) self.arrowSize = 5 self.setOpacity(0.4) self.isMousePressed = False self.setFlags(QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsFocusable | QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemSendsGeometryChanges) self.angleFixedFlag = False self.objectName = None def boundingRect(self): extra = (self.pen().width() + 20) / 2.0 size = QSizeF( 1.3*(self.line().p1().x() - self.line().p2().x()), 1.3*(self.line().p1().y() - self.line().p2().y()) ) return QRectF(self.line().p2(), size).normalized().adjusted(-extra, -extra, extra, extra) def shape(self): path = super(MovableArrow, self).shape() path.addPolygon(self.arrowHead) return path def setColor(self, colorArray): self.myColor = QColor(*colorArray) def updatePosition(self): line = QLineF(QPointF(*self.end), QPointF(*self.begin)) self.setLine(line) self.shape() def paint(self, painter, option, widget=None): self.updatePosition() myPen = self.pen() myPen.setColor(self.myColor) painter.setPen(myPen) # painter.setBrush(self.myColor) try: angle = np.arccos(self.line().dx() / self.line().length()) except ZeroDivisionError: angle = 0.0 if self.line().dy() >= 0: angle = (np.pi * 2) - angle; l = self.line().length()*0.1 arrowP0 = self.line().p1() - QPointF(self.line().dx()/l, self.line().dy()/l) arrowP1 = self.line().p1() + QPointF(np.sin(angle + np.pi / 6) * self.arrowSize, np.cos(angle + np.pi / 6) * self.arrowSize) arrowP2 = self.line().p1() + QPointF(np.sin(angle + np.pi - np.pi / 6) * self.arrowSize, np.cos(angle + np.pi - np.pi / 6) * self.arrowSize) self.arrowHead.clear(); self.arrowHead.append(arrowP0) self.arrowHead.append(arrowP1) self.arrowHead.append(arrowP2) # painter.drawConvexPolygon(self.arrowHead) arrow = QPainterPath() arrow.addPolygon(self.arrowHead) painter.fillPath(arrow, QBrush(self.myColor)) painter.drawLine(self.line()) self.shape() def mousePressEvent(self, event): self.isMousePressed = True self.mousePressedPos = event.scenePos() self.end_old = self.end.copy() super(MovableArrow, self).mousePressEvent(event) def mouseMoveEvent(self, event): mouseCursorPos = event.scenePos() #mouseCursorPos = event.Pos() if self.isMousePressed: x = mouseCursorPos.x() - self.mousePressedPos.x() y = mouseCursorPos.y() - self.mousePressedPos.y() delta = np.array([x,y]) # angle = ang(self.begin, self.end+delta) if self.angleFixedFlag == False: self.end[:] = self.end_old + delta else: T = self.end_old-self.begin delta = delta self.end[:] = self.begin+((T)/np.linalg.norm(T))*np.linalg.norm(delta) self.updatePosition() #super(MovableArrow, self).mouseMoveEvent(event) def mouseReleaseEvent(self, event): self.isMousePressed = False super(MovableArrow, self).mouseReleaseEvent(event) def getVector(self): return self.end-self.begin def setObjectName(self,name): self.objectName = name def objectName(self): return self.objectName
QGraphicsPathItem, QGraphicsRectItem ) from cadnano.gui.palette import ( getBrushObj, getColorObj, getNoPen, getPenObj ) from . import gridstyles 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)
def paintEvent(self, _event): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) width = self.width() height = self.height() if self.dynamic_resize: knob_radius = self.dynamic_knob_radius else: knob_radius = self.knob_radius # ensure that the center point is in the middle of a pixel to ensure # that exact vertial and horizantal ticks are drawn exactly 1px wide x = math.floor(width / 2.0) + 0.5 y = math.floor(height / 2.0) + 0.5 if DEBUG: painter.fillRect(0, 0, width, height, Qt.yellow) painter.translate(x, y) if self.knob_style == KnobWidget.STYLE_NEEDLE: r = min(x, y) - 1 painter.setPen(Qt.white) painter.setBrush(Qt.white) painter.drawEllipse(QPoint(0, 0), r, r) angle = self.value_factor * self.total_angle - (self.total_angle / 2.0) # draw base knob or needle spike if self.knob_style == KnobWidget.STYLE_ROUND: painter.setPen(self.border_color) if self.pressed: gradient = QRadialGradient(0, 0, knob_radius) gradient.setColorAt(0, self.base_color_pressed) gradient.setColorAt(0.85, self.base_color) gradient.setColorAt(1, self.base_color) painter.setBrush(gradient) else: painter.setBrush(self.base_color) painter.drawEllipse(QPoint(0, 0), knob_radius, knob_radius) elif self.knob_style == KnobWidget.STYLE_NEEDLE: painter.save() painter.rotate(angle) painter.setPen(self.needle_color) painter.setBrush(self.needle_color) needle = QPolygonF() needle.append(QPointF(self.needle_base_radius * 0.6, 0)) needle.append(QPointF(0, -knob_radius)) needle.append(QPointF(-self.needle_base_radius * 0.6, 0)) painter.drawPolygon(needle) painter.restore() # draw knob mark or needle base if self.knob_style == KnobWidget.STYLE_ROUND: painter.save() painter.rotate(angle) painter.setPen(QPen(self.mark_color, 2)) painter.drawLine(0, -knob_radius * 0.4, 0, -knob_radius * 0.8) painter.restore() elif self.knob_style == KnobWidget.STYLE_NEEDLE: painter.setPen(self.border_color) painter.setBrush(self.base_color) painter.drawEllipse(QPoint(0, 0), self.needle_base_radius, self.needle_base_radius) if self.scale_visible: painter.setPen(Qt.black) # draw scale arc if self.scale_arc_visible: painter.drawArc(-knob_radius - self.knob_to_scale, -knob_radius - self.knob_to_scale, knob_radius * 2 + self.knob_to_scale * 2, knob_radius * 2 + self.knob_to_scale * 2, (90 + self.total_angle / 2) * 16, -self.total_angle * 16) # draw scale ticks def value_to_angle(value): return (float(value - self.minimum_value) / self.value_range) * self.total_angle - (self.total_angle / 2.0) value = self.minimum_value while value <= self.maximum_value: angle = value_to_angle(value) painter.save() painter.rotate(value_to_angle(value)) painter.drawLine(0, -knob_radius - self.knob_to_scale, 0, -knob_radius - self.knob_to_scale - self.tick_size_large) if self.scale_text_visible: p = painter.worldTransform().map(QPoint(0, -knob_radius - \ self.knob_to_scale - \ self.tick_size_large - \ self.tick_to_text - \ self.text_radius)) painter.restore() if self.scale_text_visible: if DEBUG: painter.save() painter.setPen(QColor(255, 0, 0, 50)) painter.setBrush(QColor(255, 0, 0, 50)) painter.drawEllipse(QPoint(p.x() - x, p.y() - y), self.text_radius, self.text_radius) painter.restore() painter.drawText(p.x() - x - 30, p.y() - y - 30, 60, 60, Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter, str(value)) for i in range(1, self.scale_step_divisions): sub_value = value + (float(self.scale_step_size) * i) / self.scale_step_divisions if sub_value > self.maximum_value: break painter.save() painter.rotate(value_to_angle(sub_value)) painter.drawLine(0, -knob_radius - self.knob_to_scale, 0, -knob_radius - self.knob_to_scale - self.tick_size_small) painter.restore() value += self.scale_step_size if self.title_text != None: painter.drawText(-knob_radius, knob_radius - 30, knob_radius * 2, 60, Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter, self.title_text)
class Arrow(QGraphicsLineItem): def __init__(self, startp=Point(), endp=None, length=60.0, angle=50.0, color=QtCore.Qt.red, pencolor=QtCore.Qt.green, startarrow=True): """ Initialisation of the class. """ self.sc = None super(Arrow, self).__init__() self.startp = QtCore.QPointF(startp.x, -startp.y) self.endp = endp self.length = length self.angle = angle self.startarrow = startarrow self.allwaysshow = False self.arrowHead = QPolygonF() self.setFlag(QGraphicsItem.ItemIsSelectable, False) self.myColor = color self.pen = QPen(pencolor, 1, QtCore.Qt.SolidLine) self.pen.setCosmetic(True) self.arrowSize = 8.0 def contains_point(self, point): """ Arrows cannot be selected. Return maximal distance """ return float(0x7fffffff) def setSelected(self, flag=True, blockSignals=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 for painting the arrow. """ demat = painter.deviceTransform() self.sc = demat.m11() if self.endp is None: dx = cos(self.angle) * self.length / self.sc dy = sin(self.angle) * self.length / self.sc endp = QtCore.QPointF(self.startp.x() - dx, self.startp.y() + dy) else: endp = QtCore.QPointF(self.endp.x, -self.endp.y) arrowSize = self.arrowSize / self.sc painter.setPen(self.pen) painter.setBrush(self.myColor) self.setLine(QtCore.QLineF(endp, self.startp)) line = self.line() if line.length() != 0: angle = acos(line.dx() / line.length()) if line.dy() >= 0: angle = (pi * 2.0) - angle if self.startarrow: arrowP1 = line.p2() - QtCore.QPointF(sin(angle + pi / 3.0) * arrowSize, cos(angle + pi / 3.0) * arrowSize) arrowP2 = line.p2() - QtCore.QPointF(sin(angle + pi - pi / 3.0) * arrowSize, cos(angle + pi - pi / 3.0) * arrowSize) self.arrowHead.clear() for Point in [line.p2(), arrowP1, arrowP2]: self.arrowHead.append(Point) else: arrowP1 = line.p1() + QtCore.QPointF(sin(angle + pi / 3.0) * arrowSize, cos(angle + pi / 3.0) * arrowSize) arrowP2 = line.p1() + QtCore.QPointF(sin(angle + pi - pi / 3.0) * arrowSize, cos(angle + pi - pi / 3.0) * arrowSize) self.arrowHead.clear() for Point in [line.p1(), arrowP1, arrowP2]: self.arrowHead.append(Point) painter.drawLine(line) painter.drawPolygon(self.arrowHead) def boundingRect(self): """ Override inherited function to enlarge selection of Arrow to include all @param flag: The flag to enable or disable Selection """ if not self.sc: # since this function is called before paint; and scale is unknown return QtCore.QRectF(self.startp.x(), self.startp.y(), 1e-9, 1e-9) arrowSize = self.arrowSize / self.sc extra = arrowSize # self.pen.width() + if self.endp is None: dx = cos(self.angle) * self.length / self.sc dy = sin(self.angle) * self.length / self.sc endp = QtCore.QPointF(self.startp.x() - dx, self.startp.y() + dy) else: endp = QtCore.QPointF(self.endp.x, -self.endp.y) brect = QtCore.QRectF(self.startp, QtCore.QSizeF(endp.x()-self.startp.x(), endp.y()-self.startp.y())).normalized().adjusted(-extra, -extra, extra, extra) return brect
"""Summary """ from PyQt5.QtCore import QRectF, QPointF from PyQt5.QtGui import QPainterPath, QPolygonF from cadnano.gui.views.pathview import pathstyles as styles from cadnano.gui.palette import getPenObj from .abstractpathtool import AbstractPathTool _BW = styles.PATH_BASE_WIDTH _PEN = getPenObj(styles.RED_STROKE, 1) _RECT = QRectF(0, 0, _BW, _BW) _PATH_ARROW_LEFT = QPainterPath() _L3_POLY = QPolygonF() _L3_POLY.append(QPointF(_BW, 0)) _L3_POLY.append(QPointF(0.25 * _BW, 0.5 * _BW)) _L3_POLY.append(QPointF(_BW, _BW)) _PATH_ARROW_LEFT.addPolygon(_L3_POLY) _PATH_ARROW_RIGHT = QPainterPath() _R3_POLY = QPolygonF() # right-hand 3' arr _R3_POLY.append(QPointF(0, 0)) _R3_POLY.append(QPointF(0.75 * _BW, 0.5 * _BW)) _R3_POLY.append(QPointF(0, _BW)) _PATH_ARROW_RIGHT.addPolygon(_R3_POLY) class BreakTool(AbstractPathTool): """ docstring for BreakTool """ def __init__(self, manager): """Summary
) from cadnano.cntypes import ( ABInfoT, NucleicAcidPartT, RectT, Vec2T, SegmentT ) BASE_WIDTH = styles.PATH_BASE_WIDTH BASE_RECT = QRectF(0, 0, BASE_WIDTH, BASE_WIDTH) PHOS_ITEM_WIDTH = 0.25*BASE_WIDTH TRIANGLE = QPolygonF() TRIANGLE.append(QPointF(0, 0)) TRIANGLE.append(QPointF(0.75 * PHOS_ITEM_WIDTH, 0.5 * PHOS_ITEM_WIDTH)) TRIANGLE.append(QPointF(0, PHOS_ITEM_WIDTH)) TRIANGLE.append(QPointF(0, 0)) TRIANGLE.translate(0, -0.5*PHOS_ITEM_WIDTH) T180 = QTransform() T180.rotate(-180) FWDPHOS_PP, REVPHOS_PP = QPainterPath(), QPainterPath() FWDPHOS_PP.addPolygon(TRIANGLE) REVPHOS_PP.addPolygon(T180.map(TRIANGLE)) KEYINPUT_ACTIVE_FLAG = QGraphicsItem.ItemIsFocusable PROX_ALPHA = 64 class PropertyWrapperObject(QObject):
def paintEvent(self, event): page_bottom = self.edit.viewport().height() font_metrics = QFontMetrics(self.edit.document().defaultFont()) current_block = self.edit.document().findBlock( self.edit.textCursor().position()) pattern = self.pat if self.edit.lang == "python" else self.patNotPython painter = QPainter(self) background = resources.CUSTOM_SCHEME.get('sidebar-background', resources.COLOR_SCHEME['sidebar-background']) foreground = resources.CUSTOM_SCHEME.get('sidebar-foreground', resources.COLOR_SCHEME['sidebar-foreground']) pep8color = resources.CUSTOM_SCHEME.get('pep8-underline', resources.COLOR_SCHEME['pep8-underline']) errorcolor = resources.CUSTOM_SCHEME.get('error-underline', resources.COLOR_SCHEME['error-underline']) migrationcolor = resources.CUSTOM_SCHEME.get('migration-underline', resources.COLOR_SCHEME['migration-underline']) painter.fillRect(self.rect(), QColor(background)) block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() line_count = block.blockNumber() painter.setFont(self.edit.document().defaultFont()) while block.isValid(): line_count += 1 # The top left position of the block in the document position = self.edit.blockBoundingGeometry(block).topLeft() + \ viewport_offset # Check if the position of the block is outside of the visible area if position.y() > page_bottom: break # Set the Painter Pen depending on special lines error = False if settings.CHECK_STYLE and \ ((line_count - 1) in self._pep8Lines): painter.setPen(QColor(pep8color)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True elif settings.FIND_ERRORS and \ ((line_count - 1) in self._errorsLines): painter.setPen(QColor(errorcolor)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True elif settings.SHOW_MIGRATION_TIPS and \ ((line_count - 1) in self._migrationLines): painter.setPen(QColor(migrationcolor)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True else: painter.setPen(QColor(foreground)) # We want the line number for the selected line to be bold. bold = False if block == current_block: bold = True font = painter.font() font.setBold(True) painter.setFont(font) # Draw the line number right justified at the y position of the # line. 3 is a magic padding number. drawText(x, y, text). if block.isVisible(): painter.drawText(self.width() - self.foldArea - font_metrics.width(str(line_count)) - 3, round(position.y()) + font_metrics.ascent() + font_metrics.descent() - 1, str(line_count)) # Remove the bold style if it was set previously. if bold: font = painter.font() font.setBold(False) painter.setFont(font) if error: font = painter.font() font.setItalic(False) font.setUnderline(False) painter.setFont(font) block = block.next() self.highest_line = line_count #Code Folding xofs = self.width() - self.foldArea painter.fillRect(xofs, 0, self.foldArea, self.height(), QColor(resources.CUSTOM_SCHEME.get('fold-area', resources.COLOR_SCHEME['fold-area']))) if self.foldArea != self.rightArrowIcon.width(): polygon = QPolygonF() self.rightArrowIcon = QPixmap(self.foldArea, self.foldArea) self.rightArrowIcon.fill(Qt.transparent) self.downArrowIcon = QPixmap(self.foldArea, self.foldArea) self.downArrowIcon.fill(Qt.transparent) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.25)) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.75)) polygon.append(QPointF(self.foldArea * 0.8, self.foldArea * 0.5)) iconPainter = QPainter(self.rightArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush(QColor( resources.CUSTOM_SCHEME.get('fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) polygon.clear() polygon.append(QPointF(self.foldArea * 0.25, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.75, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.5, self.foldArea * 0.8)) iconPainter = QPainter(self.downArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush(QColor( resources.CUSTOM_SCHEME.get('fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) block = self.edit.firstVisibleBlock() while block.isValid(): position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset #Check if the position of the block is outside of the visible area if position.y() > page_bottom: break if pattern.match(block.text()) and block.isVisible(): if block.blockNumber() in self._foldedBlocks: painter.drawPixmap(xofs, round(position.y()), self.rightArrowIcon) else: painter.drawPixmap(xofs, round(position.y()), self.downArrowIcon) #Add Bookmarks and Breakpoint elif block.blockNumber() in self._breakpoints: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(255, 11, 11)) linear_gradient.setColorAt(1, QColor(147, 9, 9)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawEllipse( xofs + 1, round(position.y()) + 6, self.foldArea - 1, self.foldArea - 1) elif block.blockNumber() in self._bookmarks: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(13, 62, 243)) linear_gradient.setColorAt(1, QColor(5, 27, 106)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawRoundedRect( xofs + 1, round(position.y()) + 6, self.foldArea - 2, self.foldArea - 1, 3, 3) block = block.next()# block = next(block) painter.end() super(SidebarWidget, self).paintEvent(event)