def _addItem(self, item: np.ndarray) -> None:
index = 0 if len(self.polygons) == 0 else max(self.polygons.keys()) + 1
self.polygons[index] = item
if self.geom == DrawingGeom.rectangle:
item = qw.QGraphicsRectItem(*item)
elif self.geom == DrawingGeom.polygon:
poly = qg.QPolygonF([qc.QPointF(*p) for p in item])
item = qw.QGraphicsPolygonItem(poly)
if self.colorMode == ColorMode.auto:
pen = qg.QPen(qg.QColor(*make_color(index)))
elif self.colorMode == ColorMode.cmap:
pen = qg.QPen(
qg.QColor(*get_cmap_color(index % self.maxColors,
self.maxColors,
self.colormap)))
else:
pen = qg.QPen(self.color)
pen.setWidth(self.linewidth)
item.setPen(pen)
self.addItem(item)
self.itemDict[index] = item
bbox = item.sceneBoundingRect()
text = self.addText(str(index), self.font)
self.labelDict[index] = text
text.setDefaultTextColor(self.color)
# logging.debug(f'Scene bounding rect of {index}={bbox}')
if self.labelInside:
text.setPos(bbox.x(), bbox.y())
else:
text.setPos(bbox.x(), bbox.y() - text.boundingRect().height())
text.setFlag(qw.QGraphicsItem.ItemIgnoresTransformations,
self.textIgnoresTransformation)
self.sigPolygons.emit(self.polygons)
self.sigPolygonsSet.emit()
def mouseDoubleClickEvent(self, event):
qpoly = QtGui.QPolygonF(self.polygon)
qgpoly = QtWidgets.QGraphicsPolygonItem(qpoly)
qgpoly.setPen(self.pen)
qgpoly.setBrush(self.brush)
self.addItem(qgpoly)
del self.polygon[:]
def drawATriangle(self,
centerX,
centerY,
Radius,
angleDeg=0,
brush=None,
pen=None):
pts = []
x, y = self.polarToRect(centerX, centerY, Radius, 0 + angleDeg)
pts.append(qtc.QPointF(x, y))
x, y = self.polarToRect(centerX, centerY, Radius, 120 + angleDeg)
pts.append(qtc.QPointF(x, y))
x, y = self.polarToRect(centerX, centerY, Radius, 240 + angleDeg)
pts.append(qtc.QPointF(x, y))
x, y = self.polarToRect(centerX, centerY, Radius, 0 + angleDeg)
pts.append(qtc.QPointF(x, y))
pg = qtg.QPolygonF(pts)
PG = qtw.QGraphicsPolygonItem(pg)
if pen is not None:
PG.setPen(pen)
if brush is not None:
PG.setBrush(brush)
self.scene.addItem(PG)
def __create_parts(self):
"""Create circles and rectangle."""
dir_vec = QtGui.QVector2D(self.__end.x() - self.__begin.x(),
self.__end.y() - self.__begin.y())
dir_vec.normalize()
norm_vec = QtGui.QVector2D(-dir_vec.y(), dir_vec.x())
vecs = [
QtGui.QVector2D(self.__begin) + self.__radius * norm_vec,
QtGui.QVector2D(self.__end) + self.__radius * norm_vec,
QtGui.QVector2D(self.__end) - self.__radius * norm_vec,
QtGui.QVector2D(self.__begin) - self.__radius * norm_vec,
]
self.__polygon = QtWidgets.QGraphicsPolygonItem(
QtGui.QPolygonF([QtCore.QPointF(vec.x(), vec.y())
for vec in vecs]))
self.__ellipse_1 = QtWidgets.QGraphicsEllipseItem(
self.__begin.x() - self.__radius,
self.__begin.y() - self.__radius, 2 * self.__radius,
2 * self.__radius)
self.__ellipse_2 = QtWidgets.QGraphicsEllipseItem(
self.__end.x() - self.__radius,
self.__end.y() - self.__radius, 2 * self.__radius,
2 * self.__radius)
for item in (self.__ellipse_1, self.__ellipse_2, self.__polygon):
item.setPen(self.__pen)
item.setBrush(self.__brush)
def make_arrow_obj(self):
r_2 = QtCore.QPointF(self.scale_factor * self.p2[0], self.scale_factor * self.p2[1])
r_1 = QtCore.QPointF(self.scale_factor * self.p1[0], self.scale_factor * self.p1[1])
r_vec = r_2 - r_1
r_mag = np.sqrt((r_2.x() - r_1.x()) ** 2 + (r_2.y() - r_1.y()) ** 2)
factor = self.r / (r_mag * 2)
k_2 = r_1 + (1 - factor) * r_vec
theta = np.pi / 4
l_3 = - factor * QtCore.QPointF(r_vec.x() * np.cos(theta) + r_vec.y() * np.sin(theta), - r_vec.x() * np.sin(theta) + r_vec.y() * np.cos(theta))
l_3 = k_2 + l_3
l_4 = - factor * QtCore.QPointF(r_vec.x() * np.cos(-theta) + r_vec.y() * np.sin(-theta), - r_vec.x() * np.sin(-theta) + r_vec.y() * np.cos(-theta))
l_4 = k_2 + l_4
tri_2 = (k_2, l_3, l_4)
poly_2 = QtGui.QPolygonF(tri_2)
line = QtWidgets.QGraphicsLineItem(self.scale_factor * self.p1[0],
self.scale_factor * self.p1[1],
self.scale_factor * self.p2[0],
self.scale_factor * self.p2[1])
head_2 = QtWidgets.QGraphicsPolygonItem(poly_2)
self.addToGroup(line)
self.addToGroup(head_2)
self.setZValue(-1)
def __init__(self, parent):
super().__init__(parent=parent)
self.translate(
.5, .5
) # avoid stupid antialiased-orthogonal-black-lines-become-two-gray-pixels-thick problem.
self._zoom = 1.0
self._roll = 0
self._angular_resolution = 120 # foldl1 lcm [3,4,5,6,8]
#self.dragMode = QtWidgets.QGraphicsView.ScrollHandDrag # what to do wtih mouse clicks not caught by a GraphicsItem
self._drag_type = self.DRAG_NONE
self._drag_start_pos = None
self._drag_start_roll = None
self._rubberBandItem = QtWidgets.QGraphicsPolygonItem()
self._rubberBandItem.setZValue(2)
self._rubberBandItem.setBrush(
QtGui.QBrush(QtGui.QColor(255, 255, 0, 31)))
self._rubberBandItem.setPen(
QtGui.QPen(QtCore.Qt.black, 0, QtCore.Qt.DashLine))
self._rubberBandItem.hide()
#self.scene().addItem(self._rubberBandItem)
self.setRenderHints(self.renderHints() | QtGui.QPainter.Antialiasing)
#self.setRubberBandSelectionMode(QtCore.Qt.ContainsItemShape)
self.setMouseTracking(True)
self.setAcceptDrops(True)
self._log = None
def __init__(self,i,j,polygon,parent=None):
super(my_wedge,self).__init__()
self.item = QtWidgets.QGraphicsPolygonItem(polygon,parent)
self.i, self.j = i,j
self.setAcceptHoverEvents(True)
self._status_chosen = False
self._status_edited = False
self._available = True
def add_outline(self, stain):
poly = QtGui.QPolygonF()
for pt in stain.contour.tolist():
poly.append(QtCore.QPointF(*pt[0]))
outline = QtWidgets.QGraphicsPolygonItem(poly)
pen = QtGui.QPen(QtCore.Qt.magenta)
pen.setWidth(3)
outline.setPen(pen)
return outline
def add_direction_line(self, stain):
if stain.major_axis:
poly = QtGui.QPolygonF()
poly.append(QtCore.QPointF(*stain.major_axis[0]))
poly.append(QtCore.QPointF(*stain.major_axis[1]))
line = QtWidgets.QGraphicsPolygonItem(poly)
pen = QtGui.QPen(QtCore.Qt.darkBlue)
pen.setWidth(2)
line.setPen(pen)
return line
def drawPolygon(self):
"""Draw Polygon based on VerexItems centers."""
points = QtGui.QPolygonF(vertex.scenePos() + vertex.rect().center()
for vertex in self.verticies)
polygon = QtWidgets.QGraphicsPolygonItem(
points, self.canvas.scene.background_item)
polygon.setBrush(self.color)
polygon.setPen(self.color)
# undo-redo only polygon, not verticies
self.canvas.undo_redo.insert_in_undo_redo_add(polygon)
def mouseDoubleClickEvent(self, event):
if (self.tool == 'polygon'):
qpoly = QtGui.QPolygonF(self.polygon)
qgpoly = QtWidgets.QGraphicsPolygonItem(qpoly)
qgpoly.setPen(self.pen)
qgpoly.setBrush(self.brush)
self.addItem(qgpoly)
self.addPoly()
del self.polygon[:]
for i in range(len(self.polyRects)):
self.removeItem(self.polyRects[i])
del self.polyRects[:]
def draw_polygon(self, poly_points):
Points = QtGui.QPolygonF()
for point in poly_points:
Points.append(QtCore.QPointF(point[0], point[1]))
Polygon = QtWidgets.QGraphicsPolygonItem()
pen = QtGui.QPen(QtCore.Qt.red)
pen.setWidth(2)
Polygon.setPen(pen)
Polygon.setPolygon(Points)
Polygon.setTransform(QtGui.QTransform())
self._scene.addItem(Polygon)
def __getPolygonsByTag(self, docDOM, tag, tagAttribute):
polygonGraphicsList = []
SVGNode = docDOM.elementsByTagName('svg')
if len(SVGNode) > 0:
SVGNodeElement = SVGNode.at(0).toElement()
polyNodeList = SVGNodeElement.elementsByTagName(tag)
for i in range(polyNodeList.size()):
polyElementItem = polyNodeList.item(i).toElement()
points = self.__findParams(
r"([-?+?0-9.,]+)", polyElementItem.attribute(tagAttribute))
graphicsPoints = []
if len(points) > 2 and points[0] == points[len(points) - 1]:
for point in points:
p = point.split(',')
graphicsPoints.append(
QtCore.QPoint(float(p[0]), float(p[1])))
polygon = QtGui.QPolygonF(graphicsPoints)
graphicsPolyItem = QtWidgets.QGraphicsPolygonItem(polygon)
fillColor = QtGui.QColor(
self.__getAttributes(polyElementItem, 'fill',
'#ffffff'))
fillColor.setAlphaF(
float(
self.__getAttributes(polyElementItem,
'fill-opacity', '0')))
brush = QtGui.QBrush(fillColor)
strokeColor = QtGui.QColor(
self.__getAttributes(polyElementItem, 'stroke',
'#000000'))
strokeColor.setAlphaF(
float(
self.__getAttributes(polyElementItem,
'stroke-opacity', '1')))
pen = QtGui.QPen(strokeColor)
pen.setWidth(
int(
self.__getAttributes(polyElementItem,
'stroke-width', '1')))
self.__applyAllTransforms(
graphicsPolyItem,
self.__getTransforms(polyElementItem))
graphicsPolyItem.setPen(pen)
graphicsPolyItem.setBrush(brush)
polygonGraphicsList.append(graphicsPolyItem)
return polygonGraphicsList
def drawATriangle(self, centerX, centerY, Radius, brush=None, pen=None):
pts = []
pts.append(qtc.QPointF(centerX - Radius, centerY + Radius))
pts.append(qtc.QPointF(centerX + Radius, centerY))
pts.append(qtc.QPointF(centerX - Radius, centerY - Radius))
pts.append(qtc.QPointF(centerX - Radius, centerY + Radius))
pg = qtg.QPolygonF(pts)
PG = qtw.QGraphicsPolygonItem(pg)
if pen is not None:
PG.setPen(pen)
if brush is not None:
PG.setBrush(brush)
self.scene.addItem(PG)
def update_vision(self):
# 0. assign to vision_shape ideal vision
self.vision.setVisible(False)
self.vision_shape = QtGui.QPolygonF(self.vision_ideal)
for shadow in self.shadow_shape_list:
shadow.setParentItem(None)
del self.shadow_shape_list[:]
# 1. find all colliding with vision items
items_in_vision_before_filtering = self.m_scene.collidingItems(
self.vision)
items_in_vision = []
for item in items_in_vision_before_filtering:
if (isinstance(item, obstacle.Obstacle)):
items_in_vision.append(item)
# sort list by distance
if len(items_in_vision) == 0:
# reset vision to ideal
self.vision.setPolygon(self.vision_ideal)
self.vision.setVisible(self.vision_shape_visibility)
return
shadows = []
for item in items_in_vision:
all_lines_of_item = (functions.find_all_lines_in_my_sc(item, self))
# create item polygonf - need it later
all_dots_of_item = []
for line in all_lines_of_item:
all_dots_of_item.append(line.p1())
# item_shape_my_sc = QtGui.QPolygonF(all_dots_of_item)
# 3. find lines only inside vision poligonf
lines_in_vision = self.find_lines_in_ideal_vision(
all_lines_of_item)
# 4. find shadows for every item in vision
# shadow_item = QtGui.QPolygonF()
for line in lines_in_vision:
# 4.1. find shadow for every line of item
shadow_line = self.find_shadow(line)
shadows.append(shadow_line)
for shadow in shadows:
self.shadow_shape_list.append(
QtWidgets.QGraphicsPolygonItem(shadow, self))
self.shadow_shape_list[-1].setPen(
QtGui.QPen(QtGui.QColor(0, 0, 0, 0)))
self.shadow_shape_list[-1].setBrush(self.shadow_brush)
self.shadow_shape_list[-1].setVisible(
self.vision_shadows_visibility)
# 5. assign current shape to PolygonItem
self.vision.setPolygon(self.vision_shape)
self.vision.setVisible(self.vision_shape_visibility)
def data_to_items(self, data):
assert (type(data) is list)
for item_data in data:
item = None
t = item_data["obj"]
if t == "line":
x1, y1, x2, y2 = item_data["x1"], item_data["y1"], item_data[
"x2"], item_data["y2"]
item = QtWidgets.QGraphicsLineItem(x1, y1, x2, y2)
elif t == "rectangle":
x, y, w, h = item_data["x"], item_data["y"], item_data[
"width"], item_data["height"]
item = QtWidgets.QGraphicsRectItem(x, y, w, h)
elif t == "ellipse":
x, y, w, h = item_data["x"], item_data["y"], item_data[
"width"], item_data["height"]
item = QtWidgets.QGraphicsEllipseItem(x, y, w, h)
elif t == "polygon":
for p in item_data["points"]:
pos = QtCore.QPoint(p["x"], p["y"])
# print(pos)
self.polygon.append(pos)
qpoly = QtGui.QPolygonF(self.polygon)
item = QtWidgets.QGraphicsPolygonItem(qpoly)
del self.polygon[:]
elif t == "text":
transform = QtGui.QTransform()
transform.translate(item_data["x"], item_data["y"])
item = QtWidgets.QGraphicsTextItem(item_data["string"])
item.setFont(
QtGui.QFont(item_data["font"]["family"],
item_data["font"]["pointSize"]))
item.setTransform(transform)
else:
continue
if "pen" in item_data:
pen = QtGui.QPen(
QtGui.QBrush(QtGui.QColor(item_data["pen"]["color"])),
item_data["pen"]["width"], item_data["pen"]["style"])
item.setPen(pen)
if "brush" in item_data:
brush = QtGui.QBrush(QtGui.QColor(item_data["brush"]["color"]),
item_data["brush"]["style"])
item.setBrush(brush)
self.addItem(item)
def __init__(self, scene, pos, angle, bot_flag=True):
QtWidgets.QGraphicsPixmapItem.__init__(self)
self.rect = QtWidgets.QGraphicsRectItem(QtCore.QRectF(0, 0, 10, 10),
self)
# delete counter after debug!!!
self.built_li_shapes_list = []
self.BumpChecker = bump_checker_new.BumpCheckerNew()
# path brush
self.setPos(pos)
self.setRotation(angle)
self.speed = 0
self.Tank_rotation_speed = 20
self.setPixmap(QtGui.QPixmap(self.tank_picture_path))
self.setOffset(-self.boundingRect().width() / 2,
-self.boundingRect().height() / 2)
self.setScale(0.15)
self.last_angle_time = scene.time.elapsed()
self.Tank_angle_period = 6000 + QtCore.qrand() % 5000
self.destination_angle = self.rotation()
self.tower = tower.Tower(scene, self, bot_flag)
self.bot_flag = bot_flag
self.path_positions_list = []
# self.health = health
# create special colour poligonf around our tank
return
if self.bot_flag is False:
print()
self.colour_bound = QtGui.QPolygonF([
QtCore.QPointF(-self.boundingRect().width() / 2,
-self.boundingRect().height() / 2),
QtCore.QPointF(self.boundingRect().width() / 2,
-self.boundingRect().height() / 2),
QtCore.QPointF(self.boundingRect().width() / 2,
self.boundingRect().height() / 2),
QtCore.QPointF(-self.boundingRect().width() / 2,
self.boundingRect().height() / 2)
])
self.colour_bound_item = QtWidgets.QGraphicsPolygonItem(
self.colour_bound, self)
self.colour_bound_item_pen = QtGui.QPen(
QtGui.QColor(0, 0, 255, 255))
self.colour_bound_item_pen.setWidth(10)
self.colour_bound_item.setPen(self.colour_bound_item_pen)
self.colour_bound_item.setVisible(True)
def get_handle(self, obj):
if isinstance(obj, draw.Poly):
poly = QtGui.QPolygonF([QPointF(*pt) for pt in obj])
handle = QtWidgets.QGraphicsPolygonItem(poly)
elif isinstance(obj, draw.AABB):
x, y, dx, dy = obj.rect
y -= dy
handle = QtWidgets.QGraphicsRectItem(x, y, dx, dy)
elif isinstance(obj, draw.Circle):
x, y = obj.pos
r = obj.radius
handle = QtWidgets.QGraphicsEllipseItem(x, y, r, r)
else:
print(obj, type(obj))
return None
handle.setBrush(self.get_brush(obj.color))
self.scene.addItem(handle)
return handle
def __init__(self):
QtWidgets.QDialog.__init__(self)
uic.loadUi('mp.ui', self)
# scenes initialization
self.scene_before = QtWidgets.QGraphicsScene(self)
self.scene_after = QtWidgets.QGraphicsScene(self)
self.graphicsViewBefore.setScene(self.scene_before)
self.graphicsViewAfter.setScene(self.scene_after)
# buttons binding
self.pushButtonLoad.clicked.connect(self.generate_random_polygon)
self.pushButtonStart.clicked.connect(self.start)
#
self.points = []
self.polygon = QtWidgets.QGraphicsPolygonItem()
self.scene_after.addItem(self.polygon)
self.load_polygon()
def draw_polygons(self):
sf = shapefile.Reader(self.shapefile)
polygons = sf.shapes()
for polygon in polygons:
# convert shapefile geometries into shapely geometries
# to extract the polygons of a multipolygon
polygon = shapely.geometry.shape(polygon)
# if it is a polygon, we use a list to make it iterable
if polygon.geom_type == 'Polygon':
polygon = [polygon]
for land in polygon:
qt_polygon = QtGui.QPolygonF()
longitudes, latitudes = land.exterior.coords.xy
for lon, lat in zip(longitudes, latitudes):
px, py = self.to_canvas_coordinates(lon, lat)
if px > 1e+10:
continue
qt_polygon.append(QtCore.QPointF(px, py))
polygon_item = QtWidgets.QGraphicsPolygonItem(qt_polygon)
polygon_item.setBrush(self.land_brush)
polygon_item.setPen(self.land_pen)
polygon_item.setZValue(1)
yield polygon_item
def __init__(self, nodeStart, nodeEnd, directed: bool):
super().__init__()
self.setPen(pen)
if directed:
pointiness = 0.2
self.arrowShape = QtGui.QPolygonF()
self.arrowShape << QtCore.QPointF(0, 0) \
<< QtCore.QPointF(-pointiness, -0.5) \
<< QtCore.QPointF(1, 0) \
<< QtCore.QPointF(-pointiness, 0.5) \
<< QtCore.QPointF(0, 0)
self.arrow = QtWidgets.QGraphicsPolygonItem(self.arrowShape, self)
self.arrow.setPen(
QtGui.QPen(pen.color(), 1, QtCore.Qt.SolidLine,
QtCore.Qt.SquareCap, QtCore.Qt.MiterJoin))
self.arrow.setBrush(pen.color())
else:
self.arrowShape = None
self.arrow = None
self.adjustPosition()
def draw_polygons(self):
sf = shapefile.Reader(self.shapefile)
polygons = sf.shapes()
for polygon in polygons:
# convert shapefile geometries into shapely geometries
# to extract the polygons of a multipolygon
polygon = shapely.geometry.shape(polygon)
# if it is a polygon, we use a list to make it iterable
if polygon.geom_type == 'Polygon':
polygon = [polygon]
for land in polygon:
qt_polygon = QtGui.QPolygonF()
land = str(land)[10:-2].replace(', ', ',').replace(' ', ',')
coords = land.replace('(', '').replace(')', '').split(',')
for lon, lat in zip(coords[0::2], coords[1::2]):
px, py = self.to_canvas_coordinates(lon, lat)
if px > 1e+10:
continue
qt_polygon.append(QtCore.QPointF(px, py))
polygon_item = QtWidgets.QGraphicsPolygonItem(qt_polygon)
polygon_item.setBrush(self.land_brush)
polygon_item.setPen(self.land_pen)
polygon_item.setZValue(1)
yield polygon_item
def loadFile(self, items):
#lines
nLines = items[0]["number"]
for i in range(nLines):
bx = items[0][str(i) + "bx"]
by = items[0][str(i) + "by"]
ex = items[0][str(i) + "ex"]
ey = items[0][str(i) + "ey"]
self.line = QtWidgets.QGraphicsLineItem(bx, by, ex, ey)
self.set_pen_width(items[0][str(i) + "width"])
self.set_pen_color(items[0][str(i) + "color"])
self.set_pen_line(items[0][str(i) + "penline"])
self.line.setPen(self.pen)
self.addItem(self.line)
self.line = None
#Rects
nRects = items[1]["number"]
for i in range(nRects):
x = items[1][str(i) + "x"]
y = items[1][str(i) + "y"]
w = items[1][str(i) + "w"]
h = items[1][str(i) + "h"]
self.rect = QtWidgets.QGraphicsRectItem(x, y, w, h)
self.set_pen_width(items[1][str(i) + "width"])
self.set_pen_color(items[1][str(i) + "color"])
self.set_pen_line(items[1][str(i) + "penline"])
self.set_brush_style(items[1][str(i) + "brushstyle"])
self.set_brush_color(items[1][str(i) + "brushcolor"])
self.rect.setPen(self.pen)
self.rect.setBrush(self.brush)
self.addItem(self.rect)
self.rect = None
#Ellipses
nEllipses = items[2]["number"]
for i in range(nEllipses):
x = items[2][str(i) + "x"]
y = items[2][str(i) + "y"]
w = items[2][str(i) + "w"]
h = items[2][str(i) + "h"]
self.ellipse = QtWidgets.QGraphicsEllipseItem(x, y, w, h)
self.set_pen_width(items[2][str(i) + "width"])
self.set_pen_color(items[2][str(i) + "color"])
self.set_pen_line(items[2][str(i) + "penline"])
self.set_brush_style(items[2][str(i) + "brushstyle"])
self.set_brush_color(items[2][str(i) + "brushcolor"])
self.ellipse.setPen(self.pen)
self.ellipse.setBrush(self.brush)
self.addItem(self.ellipse)
self.ellipse = None
#Texts
nTexts = items[3]["number"]
for i in range(nTexts):
t = items[3][str(i) + "t"]
x = items[3][str(i) + "x"]
y = items[3][str(i) + "y"]
#font = items[3][str(i)+"font"]
text = QtWidgets.QGraphicsTextItem(t)
# if(font) :
# text.setFont(font)
text.setPos(x, y)
self.addItem(text)
#Polygons
nPolys = items[4]["number"]
for i in range(nPolys):
polygon = []
for p in range(items[4][str(i) + "points"]):
polygon.append(
QtCore.QPointF(items[4][str(i) + str(p) + "x"],
items[4][str(i) + str(p) + "y"]))
qpoly = QtGui.QPolygonF(polygon)
qgpoly = QtWidgets.QGraphicsPolygonItem(qpoly)
self.set_pen_width(items[4][str(i) + "width"])
self.set_pen_color(items[4][str(i) + "color"])
self.set_pen_line(items[4][str(i) + "penline"])
self.set_brush_style(items[4][str(i) + "brushstyle"])
self.set_brush_color(items[4][str(i) + "brushcolor"])
qgpoly.setPen(self.pen)
qgpoly.setBrush(self.brush)
self.addItem(qgpoly)
def open(self, fileopen):
data = []
xmlReader=QtCore.QXmlStreamReader(fileopen)
xmlReader.setDevice(fileopen)
while not xmlReader.atEnd() :
if xmlReader.name() != "" :
print("name",xmlReader.name() )
if xmlReader.isStartElement() :
if xmlReader.name()== "GraphicsItem" :
print("GraphicsItem start")
if xmlReader.attributes().value("type") == "rect" :
rect = QtWidgets.QGraphicsRectItem()
while xmlReader.readNextStartElement() :
if xmlReader.name()== "shape" :
x=float(xmlReader.attributes().value("x"))
y=float(xmlReader.attributes().value("y"))
w=float(xmlReader.attributes().value("width"))
h=float(xmlReader.attributes().value("height"))
rect.setRect(x,y,w,h)
if xmlReader.name()== "style" :
p_color = xmlReader.attributes().value("pen-color")
line = float(xmlReader.attributes().value("pen-line"))
width = float(xmlReader.attributes().value("pen-width"))
b_color = xmlReader.attributes().value("brush-color")
fill = float(xmlReader.attributes().value("brush-fill"))
pen = QtGui.QPen(QtGui.QColor(p_color))
pen.setWidth(int(width))
pen.setStyle(int(line))
brush = QtGui.QBrush(QtGui.QColor(b_color))
brush.setStyle(int(fill))
rect.setPen(pen)
rect.setBrush(brush)
xmlReader.readNext()
data.append(rect)
print("RECT ADDED")
elif xmlReader.attributes().value("type") == "ellipse":
ellipse = QtWidgets.QGraphicsEllipseItem()
while xmlReader.readNextStartElement() :
if xmlReader.name()== "shape" :
x=float(xmlReader.attributes().value("x"))
y=float(xmlReader.attributes().value("y"))
w=float(xmlReader.attributes().value("width"))
h=float(xmlReader.attributes().value("height"))
ellipse.setRect(x,y,w,h)
if xmlReader.name()== "style" :
p_color = xmlReader.attributes().value("pen-color")
line = float(xmlReader.attributes().value("pen-line"))
width = float(xmlReader.attributes().value("pen-width"))
b_color = xmlReader.attributes().value("brush-color")
fill = float(xmlReader.attributes().value("brush-fill"))
pen = QtGui.QPen(QtGui.QColor(p_color))
pen.setWidth(int(width))
pen.setStyle(int(line))
brush = QtGui.QBrush(QtGui.QColor(b_color))
brush.setStyle(int(fill))
ellipse.setPen(pen)
ellipse.setBrush(brush)
xmlReader.readNext()
data.append(ellipse)
print("ELLIPSE ADDED")
elif xmlReader.attributes().value("type") == "line":
line = QtWidgets.QGraphicsLineItem()
while xmlReader.readNextStartElement() :
if xmlReader.name()== "shape" :
x1=float(xmlReader.attributes().value("x1"))
y1=float(xmlReader.attributes().value("y1"))
x2=float(xmlReader.attributes().value("x2"))
y2=float(xmlReader.attributes().value("y2"))
line.setLine(x1,y1,x2,y2)
if xmlReader.name()== "style" :
p_color = xmlReader.attributes().value("pen-color")
l = float(xmlReader.attributes().value("pen-line"))
width = float(xmlReader.attributes().value("pen-width"))
pen = QtGui.QPen(QtGui.QColor(p_color))
pen.setWidth(int(width))
pen.setStyle(int(l))
line.setPen(pen)
xmlReader.readNext()
data.append(line)
print("LINE ADDED")
elif xmlReader.attributes().value("type") == "polygon":
polygon = QtWidgets.QGraphicsPolygonItem()
while xmlReader.readNextStartElement() :
if xmlReader.name()== "shape" :
points = self.__findParams(r"([-?+?0-9.,]+)", xmlReader.attributes().value("points"))
graphPoints = []
for point in points:
p = point.split(',')
graphPoints.append(QtCore.QPointF(float(p[0]), float(p[1])))
poly = QtGui.QPolygonF(graphPoints)
polygon.setPolygon(poly)
if xmlReader.name()== "style" :
p_color = xmlReader.attributes().value("pen-color")
l = float(xmlReader.attributes().value("pen-line"))
width = float(xmlReader.attributes().value("pen-width"))
b_color = xmlReader.attributes().value("brush-color")
fill = float(xmlReader.attributes().value("brush-fill"))
pen = QtGui.QPen(QtGui.QColor(p_color))
pen.setWidth(int(width))
pen.setStyle(int(l))
brush = QtGui.QBrush(QtGui.QColor(b_color))
brush.setStyle(int(fill))
polygon.setPen(pen)
polygon.setBrush(brush)
xmlReader.readNext()
data.append(polygon)
print("polygon ADDED")
elif xmlReader.attributes().value("type") == "text":
text = QtWidgets.QGraphicsTextItem()
while xmlReader.readNextStartElement() :
if xmlReader.name()== "shape" :
x=float(xmlReader.attributes().value("x"))
y=float(xmlReader.attributes().value("y"))
text.setPos(x,y)
if xmlReader.name()== "text-data" :
t = xmlReader.attributes().value("text")
font_family = xmlReader.attributes().value("font-family")
font_size = int(xmlReader.attributes().value("font-size"))
font_weight = int(xmlReader.attributes().value("font-weight"))
font_style = int(xmlReader.attributes().value("font-style"))
font = QtGui.QFont()
font.setFamily(font_family)
font.setPointSize(font_size)
font.setWeight(font_weight)
font.setStyle(font_style)
text.setPlainText(t)
text.setFont(font)
xmlReader.readNext()
data.append(text)
print("TEXT ADDED")
xmlReader.readNext()
return data
