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)
