def __init__(self, parent=None):
super().__init__(parent)
self.monitorWin = parent
if self.monitorWin:
self.monitorWin.sigTaskUpdating.connect(self.slotTaskUpdate)
self.scene = QGraphicsScene(self)
self.scene.setSceneRect(0, 0, self.SIZE[0], self.SIZE[1])
self.setScene(self.scene)
self._speedsPen = QPen(Qt.white)
gradient = QLinearGradient(0, 0, self.SIZE[0], self.SIZE[1])
gradient.setColorAt(0.0, Qt.darkGreen)
gradient.setColorAt(1.0, Qt.yellow)
self._speedsBrush = QBrush(gradient)
# add elements to the scene
self._speedsPolygon = self.scene.addPolygon(QPolygonF(),
self._speedsPen,
self._speedsBrush)
self._progressText = self.scene.addText("")
self._progressText.setPos(10, 0)
self.setupDropSupport()
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 mouseMoveEvent(self, event):
e = event.pos()
e = self.mapToScene(e)
area_select = QRectF(e.x() - 3, e.y() - 3, 6, 6)
items = self.scene_v.items(area_select)
if not self.buttonPressed:
dx = e.x() - self._startPos.x()
dy = e.y() - self._startPos.y()
new_x = self.horizontalScrollBar().value() - dx
new_y = self.verticalScrollBar().value() - dy
self.horizontalScrollBar().setValue(new_x)
self.verticalScrollBar().setValue(new_y)
if self.is_pipe and self.cond_pipe:
if items:
l_n = self.l_i_nodes + self.l_i_reservoir
l_n_2 = self.l_nodes + self.l_reservoir
if items[0] in l_n:
e.setX(l_n_2[l_n.index(items[0])].x)
e.setY(l_n_2[l_n.index(items[0])].y)
self.current_item.setLine(self.start_e.x(), self.start_e.y(),
e.x(), e.y())
pen = QPen(QColor('black'))
pen.setWidth(1)
pen.setStyle(Qt.DotLine)
self.current_item.setPen(pen)
if self.is_area_select and len(self.area_select) > 1:
self.area_select.append(e)
self.current_item.setPolygon(QPolygonF(self.area_select))
self.area_select = self.area_select[:-1]
def draw(self,qwidget_obj,qp,GISView_view):
qPolygonFsToScreen = GISView_view.toScreenPolygon(self.List_allvertex)
qwidget_obj.scene.addItem(QGraphicsPolygonItem(QPolygonF(qPolygonFsToScreen)))
#pen = QPen(Qt.blue, 1, Qt.SolidLine)
#qwidget_obj.scene.addLine(qLineF , pen)
return
def calc_path(self):
path = QPainterPath(QPointF(self.pos_src[0], self.pos_src[1])) # 起点
path.lineTo(QPointF(self.pos_dst[0], self.pos_dst[1])) # 终点
if self.directed:
# 画箭头
self.line = QLineF(QPointF(self.pos_src[0], self.pos_src[1]), QPointF(self.pos_dst[0], self.pos_dst[1]))
if self.flag == 0:
self.line.setLength(self.line.length() - 20)
else:
self.line.setLength(self.line.length() - self.edge_wrap.end_item.r)
v = self.line.unitVector()
v.setLength(20)
v.translate(QPointF(self.line.dx(), self.line.dy()))
n = v.normalVector()
n.setLength(n.length() * 0.5)
n2 = n.normalVector().normalVector()
p1 = v.p2()
p2 = n.p2()
p3 = n2.p2()
# 方法2
arrow = QPolygonF([p1, p2, p3, p1])
path.addPolygon(arrow)
# path = QPainterPath(QPointF(self.pos_src[0], self.pos_src[1]))
# path.lineTo(self.pos_dst[0], self.pos_dst[1])
return path
def sharedToHalfPolygons(self):
result = []
for m in self.shared:
qpointsf = []
qpointsf2 = []
d = {}
c = m.corners(self.hexagons['layout'])
for i in range(2, 6):
qpointsf.append(QPointF(c[i].x, c[i].y))
qpointsf2.append(QPointF(c[5].x, c[5].y))
for i in range(0, 3):
qpointsf2.append(QPointF(c[i].x, c[i].y))
d['left'] = QPolygonF(qpointsf)
d['right'] = QPolygonF(qpointsf2)
result.append(d)
return result
def __init__(self, x, y, color, max_speed, name):
super().__init__(None)
self._x = x
self._y = y
self._theta = 0
self.setPos(self._x, self._y)
self.setRotation(self._theta)
self._color = color
self._speed = max_speed
# randint(1, 100)/100 * max_speed
points = [QPointF(10, 0), QPointF(8, -3), QPointF(5, -5), QPointF(-10, 0), QPointF(5, 5), QPointF(8, 3)]
polygon = QPolygonF(points)
self._path = QPainterPath()
self._path.addPolygon(polygon)
self._path.closeSubpath()
self._swim_counter = 0
self._theta_swim = 0
self._name = name
# SETTINGS ======================================================================================#
self._max_speed = max_speed
self._cohesive_rad = 50
self._repulsive_rad = 3
self._cohesion_factor = 0.3
self._repulsion_factor = 0.3
self._random_factor = 0.2
self._obstacle_distance = 50
def sutherland_hodgman(clip, pol, norm):
# дублируем начальную вершину отсекателя в конец
clip.append(clip[0])
s = None
f = None
# цикл по вершинам отсекателя
for i in range(len(clip) - 1):
new = [] # новый массив вершин
for j in range(len(pol)): # цикл по вершинам многоугольника
if j == 0:
f = pol[j]
else:
t = is_intersection([s, pol[j]], [clip[i], clip[i + 1]], norm)
if t:
new.append(t)
s = pol[j]
if is_visiable(s, clip[i], clip[i + 1], norm):
new.append(s)
if len(new) != 0:
t = is_intersection([s, f], [clip[i], clip[i + 1]], norm)
if t:
new.append(t)
pol = copy.deepcopy(new)
if len(pol) == 0:
return False
else:
return QPolygonF(pol)
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 add_triangle(self, x, y, l):
polygon = QPolygonF()
polygon.append(QPoint(x, y))
polygon.append(QPoint(x + l // 2, y - l))
polygon.append(QPoint(x - l // 2, y - l))
polygon.append(QPoint(x, y))
self.scene.addPolygon(polygon, QPen(), QBrush(Qt.black))
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 __init__(self, start, dst, offset, color=Qt.black):
"""
Constructor for a conjunction.
It generates all necessary variables and calls the draw function
It adds also the parent arrow from the source to the conjunction rectangle
:param start: Starting object of the arrow
:param dst: End object of the arrow
:param offset: left/right offset for the starting arrow
:param color: Color of the arrow
"""
super().__init__()
self.arrowHead = QPolygonF()
self.start = start
self.dst = dst
self.offset = offset
self.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.setPen(QPen(color, 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
self.updatePosition()
def drawD2(self):
if self.vtkViewer.reader == None:
return
num = self.inputD2.text()
try:
num = list(map(int, num.split(' ')))
except Exception:
return
if len(num) != 2 or num[0] <= 1 or num[1] <= 1:
return
self.clear()
histogram, scale = self.vtkViewer.d2Sample(num[0], num[1])
d2Chart = QChart()
d2Chart.legend().hide()
polyline = QPolygonF(num[0])
pointer = polyline.data()
dtype, tinfo = np.float, np.finfo
pointer.setsize(2*polyline.size()*tinfo(dtype).dtype.itemsize)
memory = np.frombuffer(pointer, dtype)
memory[:(num[0]-1)*2+1:2] = scale
memory[1:(num[0]-1)*2+2:2] = histogram
curve = QLineSeries()
curve.append(polyline)
d2Chart.addSeries(curve)
d2Chart.createDefaultAxes()
ChartView = QChartView(d2Chart)
self.d2ChartLayout.addWidget(ChartView)
def Segments2QPolygonF(segList):
'''Given an unordered list of line segments ((x1,y1),(x2,y2)), return an (ordered) QPolygonF.
Delete converted line segments from list.
Does not work for disconnected polygons.
'''
# Seed list of ordered points with an arbitrary pair of (necessarily adjacent) points
poly = list(segList.pop())
# Keep extending list of ordered points by finding the matching line segment
p = poly[1]
while segList != []:
found = False
for i in range(len(segList)):
if segList[i][0] == p:
p = segList[i][1]
found = True
break
elif segList[i][1] == p:
p = segList[i][0]
found = True
break
if found:
poly.append(p)
del segList[i]
else:
# This algorithm doesn't work if segments can't be ordered into a single chain
raise RuntimeError(
'error converting segments to polygon: segList = {}, poly = {}, p = {}'
.format(segList, poly, p))
return QPolygonF(map(lambda xy: QPointF(*xy), poly))
def paintEvent(self, event):
if self.display_status:
super().paintEvent(event)
painter = QPainter(self)
painter_path = QPainterPath()
qt_pen_1 = QPen(Qt.red, 2, Qt.SolidLine)
qt_pen_2 = QPen(Qt.green, 10, Qt.SolidLine)
qt_pen_3 = QPen(Qt.red, 2, Qt.DotLine)
painter.setPen(qt_pen_1)
painter.drawPolygon(QPolygon(self.roi_rect), Qt.WindingFill)
painter_path.addPolygon(QPolygonF(self.roi_rect))
painter_path.closeSubpath()
# qt_brush = QBrush(Qt.green)
qt_brush = QBrush(QColor(0, 255, 0, 64))
painter.setBrush(qt_brush)
painter.drawPath(painter_path)
# painter.drawPoint(self.tmp_center_pt)
painter.setPen(qt_pen_3)
painter.drawLine(self.roi_rect[0], self.roi_rect[2])
painter.drawLine(self.roi_rect[1], self.roi_rect[3])
painter.setPen(qt_pen_2)
for elem in self.roi_rect:
painter.drawPoint(elem)
# for elem in self.img_rect:
# painter.drawPoint(elem)
if self.default_rect:
self.update()
def __init__(self):
super().__init__()
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setScene(QGraphicsScene())
self.setBackgroundBrush(Qt.transparent)
self.setRenderHint(QPainter.Antialiasing)
self.graph = self.scene().addPolygon(QPolygonF(), QPen(Qt.transparent),
QBrush())
color = QColor.fromRgb(0x35, 0x37, 0x72)
pen = QPen(color, 3)
pen.setCapStyle(Qt.RoundCap)
self.path = self.scene().addPath(QPainterPath(), pen)
self.score_text = self.scene().addText("")
self.score_text.setDefaultTextColor(color)
self.msg_text = self.scene().addText("")
self.msg_text.setDefaultTextColor(color)
self.msg_text.setX(0)
self.msg_text.setY(0)
self.sitting_time_text = self.scene().addText("")
self.sitting_time_text.setDefaultTextColor(color)
self.score_list = [0]
self.minimize = False
self.size_changed(False)
self.connected_changed(False)
def test_scene_set_nodes_polygons(mod, scene, polygon_ids):
"""Check that setNodesPolygons change overlay brushes for all nodes."""
polygon_ids = [NodePolygon(id) for id in polygon_ids]
circle = NodePolygon.Circle
polygons = [NODE_POLYGON_MAP[id] if id != NodePolygon.Circle else QPolygonF()
for id in polygon_ids]
if mod.__name__ == 'PyQtNetworkView._pure': # Python
assert type(mod.NodePolygon).__name__ == 'EnumMeta'
else: # C++/SIP
assert type(mod.NodePolygon).__name__ == 'enumtype'
polygon_ids = [id.value for id in polygon_ids]
circle = circle.value
for node in scene.nodes():
assert node.polygon() == mod.NodePolygon.Circle
assert node.customPolygon().isEmpty()
scene.setNodesPolygons(polygon_ids)
if len(polygons) >= len(scene.nodes()):
for i, node in enumerate(scene.nodes()):
assert node.polygon() == polygon_ids[i]
assert node.customPolygon().size() == polygons[i].size()
assert scene.nodesPolygons() == polygon_ids
else:
for node in scene.nodes():
assert node.polygon() == circle
def __init__(self, starCount=1, maxStarCount=5):
self._starCount = starCount
self._maxStarCount = maxStarCount
self.starPolygon = QPolygonF([QPointF(1.0, 0.5)])
for i in range(5):
self.starPolygon << QPointF(
0.5 + 0.5 * math.cos(0.8 * i * math.pi),
0.5 + 0.5 * math.sin(0.8 * i * math.pi))
self.diamondPolygon = QPolygonF()
self.diamondPolygon << QPointF(0.4, 0.5) \
<< QPointF(0.5, 0.4) \
<< QPointF(0.6, 0.5) \
<< QPointF(0.5, 0.6) \
<< QPointF(0.4, 0.5)
def __init__(self, parentItem, segments, colour): QGraphicsItem.__init__(self, parent=parentItem) self.colour_name = colour self.shape = QPainterPath() self.labels = QGraphicsItemGroup(self) self.bbox = QRectF(0, 0, 0, 0) for (p1, p2), label in segments: lvect = QVector2D(p2 - p1) lpath = QPainterPath() m = TWY_line_margin l = lvect.length() plst = [QPointF(-m, 0), QPointF(-m/3, -m), QPointF(l + m/3, -m), QPointF(l + m, 0), QPointF(l + m/3, m), QPointF(-m/3, m)] lpath.addPolygon(QPolygonF(plst)) lrot = QTransform() lrot.rotateRadians(atan2(lvect.y(), lvect.x())) lpath = lrot.map(lpath) lpath.translate(p1) self.shape.addPath(lpath) rect = QRectF(p1, p2).normalized() if label != None: self.labels.addToGroup(TaxiwayLabelItem(label, rect.center(), self)) self.bbox |= rect self.shape.setFillRule(Qt.WindingFill) self.mouse_highlight = False self.labels.setVisible(False)
def draw_polygons(self, event):
if self.polygons:
painter = QPainter(self)
# painter.drawEllipse(0, 0, self.width()/2, self.width()/2)
for (pa, pb, pc), color in self.polygons:
a = QPoint(pa.x, pa.y)
b = QPoint(pb.x, pb.y)
c = QPoint(pc.x, pc.y)
pen = QPen()
if color:
pen.setColor(color)
else:
pen.setColor(QColor(0, 0, 0))
painter.setPen(pen)
polygon = QPolygonF([a, b, c])
painter.drawPolygon(polygon)
if color:
path = QPainterPath()
path.addPolygon(polygon)
# painter.setBrush(QBrush(color))
painter.fillPath(path, QBrush(color))
def FOV(self, Robo):
view = QPainterPath()
xPos = math.cos(math.radians(Robo.alpha +
(Robo.FOV / 2))) * Robo.radius
yPos = math.sin(math.radians(Robo.alpha +
(Robo.FOV / 2))) * Robo.radius
xPos2 = math.cos(math.radians(Robo.alpha -
(Robo.FOV / 2))) * Robo.radius
yPos2 = math.sin(math.radians(Robo.alpha -
(Robo.FOV / 2))) * Robo.radius
x1 = QPoint(
int(round(Robo.position.x())) + Robo.radius,
int(round(Robo.position.y())) + Robo.radius)
x2 = x1 + QPoint(
(int(round(Robo.position.x())) + Robo.radius) + 1000 * xPos,
(int(round(Robo.position.y())) + Robo.radius) - 1000 * yPos)
x3 = x1 + QPoint(
(int(round(Robo.position.x())) + Robo.radius) + 1000 * xPos2,
(int(round(Robo.position.y())) + Robo.radius) - 1000 * yPos2)
view.addPolygon(QPolygonF([x1, x2, x3]))
view.closeSubpath()
return view
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 setPolyline(self, frameNo=None):
if frameNo is not None:
self.currentFrameNo = frameNo
key = str(self.currentFrameNo)
if key in self.data.keys():
self.show()
for i, rectItems in enumerate(self.rectItemsList):
poly = QPolygonF()
line_data = self.data[key][i]
current_range = len(rectItems)
for j in range(current_range, len(line_data)):
rectItems.append(QGraphicsRectItem(self))
for p, rect_item in zip(line_data, rectItems):
q_pt = QPointF(*p)
rect_item.setPos(q_pt)
rect_item.mouseMoveEvent = self.generateItemMouseMoveEvent(
rect_item, p)
rect = QRectF(-self.markSize / 2, -self.markSize / 2,
self.markSize, self.markSize)
rect_item.setRect(rect)
rect_item.show()
for j in range(len(line_data), len(rectItems)):
rectItems[j].hide()
self.setItemsAreMovable(self.isItemMovable)
else:
self.hide()
def mousePressEvent(self, e):
#logger.debug('DragPoly.mousePressEvent, at point: %s on scene: %s '%\
# (str(e.pos()), str(e.scenePos()))) # self.__class__.__name__
QGraphicsPolygonItem.mousePressEvent(self, e) # points would not show up w/o this line
if e.button()==Qt.RightButton: self._end_of_add = True
ps = e.scenePos()
#print('%s.mousePressEvent itemAt:' % self.__class__.__name__, self.scene().itemAt(ps))
t = self.scene().views()[0].transform()
item_sel = self.scene().itemAt(ps.x(), ps.y(), t)
#item_sel = self.scene().itemAt(ps)
if self.lst_ctl_points is None:
logger.warning('DragPoly.lst_ctl_points is None')
return
if item_sel in self.lst_ctl_points:
self.indx_sel = self.lst_ctl_points.index(item_sel)
print('XXX DragPoly.mousePressEvent index_selected = ', self.indx_sel)
self.set_drag_mode(EDIT)
self.set_child_item_sel(item_sel)
if item_sel == self.ped: self.control_point_menu()
if self.poly0 is not None: del self.poly0
self.poly0 = QPolygonF(self.polygon())
self.pos0 = [gi.pos() for gi in self.lst_ctl_points]
def rectToPoly(rect):
poly = QPolygonF()
poly.append(rect.topLeft())
poly.append(rect.topRight())
poly.append(rect.bottomRight())
poly.append(rect.bottomLeft())
return poly
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 _drawSkel(self, worm_qimg, skel_dat, skel_colors = GOOD_SKEL_COLOURS):
qPlg = {}
for tt, dat in skel_dat.items():
qPlg[tt] = QPolygonF()
for p in dat:
#do not add point if it is nan
if p[0] == p[0]:
qPlg[tt].append(QPointF(*p))
if not qPlg or len(qPlg['skeleton']) == 0:
return
pen = QPen()
pen.setWidth(1)
painter = QPainter()
painter.begin(worm_qimg)
for k, pol_v in qPlg.items():
color = skel_colors[k]
pen.setColor(QColor(*color))
painter.setPen(pen)
painter.drawPolyline(pol_v)
pen.setColor(Qt.black)
painter.setBrush(Qt.white)
painter.setPen(pen)
radius = 3
painter.drawEllipse(qPlg['skeleton'][0], radius, radius)
painter.drawEllipse(QPointF(0,0), radius, radius)
painter.end()
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 image(cls, **kwargs):
"""
Returns an image suitable for the palette.
:rtype: QPixmap
"""
# INITIALIZATION
pixmap = QPixmap(kwargs['w'], kwargs['h'])
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
# INITIALIZE EDGE LINE
pp1 = QPointF(((kwargs['w'] - 52) / 2), kwargs['h'] / 2)
pp2 = QPointF(((kwargs['w'] - 52) / 2) + 52 - 2, kwargs['h'] / 2)
line = QLineF(pp1, pp2)
# CALCULATE HEAD COORDINATES
angle = radians(line.angle())
p1 = QPointF(line.p2().x() + 2, line.p2().y())
p2 = p1 - QPointF(sin(angle + M_PI / 3.0) * 8, cos(angle + M_PI / 3.0) * 8)
p3 = p1 - QPointF(sin(angle + M_PI - M_PI / 3.0) * 8, cos(angle + M_PI - M_PI / 3.0) * 8)
# INITIALIZE EDGE HEAD
head = QPolygonF([p1, p2, p3])
# DRAW THE POLYGON
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QPen(QColor(0, 0, 0), 1.1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(line)
# DRAW HEAD
painter.setPen(QPen(QColor(0, 0, 0), 1.1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.setBrush(QColor(0, 0, 0))
painter.drawPolygon(head)
# DRAW THE TEXT ON TOP OF THE EDGE
space = 2 if Platform.identify() is Platform.Darwin else 0
painter.setFont(Font('Arial', 9, Font.Light))
painter.drawText(pp1.x() + space, (kwargs['h'] / 2) - 4, 'instanceOf')
return pixmap
def draw_pattern(self):
path = './patterns/' + self.pattern
lines, ellipses, rectangles, polygons = get_picture.read_file(path)
x, y = self.get_start_pattern(lines, ellipses, rectangles, polygons)
if len(lines) != 0:
for line in lines:
points, pencil = get_picture.get_inf_line(line)
new_points = self.get_new_points(points, [], x, y)
self.draw_line(new_points, pencil)
if len(ellipses) != 0:
for ellipse in ellipses:
points, width, height,\
pencil, fill = get_picture.get_inf_ellipse(ellipse)
new_points = self.get_new_points(points, [], x, y)
width = width * self.figure_size / 180
height = height * self.figure_size / 180
self.draw_ellipse(new_points, width, height, pencil, fill)
if len(rectangles) != 0:
for rectangle in rectangles:
points, width, height,\
pencil, fill = get_picture.get_inf_rectangle(rectangle)
new_points = self.get_new_points(points, [], x, y)
width = width * self.figure_size / 180
height = height * self.figure_size / 180
self.draw_rectangle(new_points, width, height, pencil, fill)
if len(polygons) != 0:
for polygon in polygons:
polygon, pencil, fill = get_picture.get_inf_polygon(polygon)
newpolygon = self.get_new_points(polygon, QPolygonF(), x, y)
self.draw_polygon(newpolygon, pencil, fill)
