def convertToPolygon(self, geom):
if QgsWkbTypes.geometryType(geom.wkbType(
)) == QgsWkbTypes.PointGeometry and geom.constGet().nCoordinates() < 3:
raise QgsProcessingException(
self.tr('Cannot convert from Point to Polygon').format(
QgsWkbTypes.displayString(geom.wkbType())))
elif QgsWkbTypes.geometryType(
geom.wkbType()) == QgsWkbTypes.PointGeometry:
# multipoint with at least 3 points
# TODO: mega inefficient - needs rework when geometry iterators land
# (but at least it doesn't lose Z/M values)
points = []
for g in geom.constGet().coordinateSequence():
for r in g:
for p in r:
points.append(p)
linestring = QgsLineString(points)
linestring.close()
p = QgsPolygon()
p.setExteriorRing(linestring)
return [QgsGeometry(p)]
elif QgsWkbTypes.geometryType(
geom.wkbType()) == QgsWkbTypes.LineGeometry:
if QgsWkbTypes.isMultiType(geom):
parts = []
for i in range(geom.constGet().numGeometries()):
p = QgsPolygon()
linestring = geom.constGet().geometryN(i).clone()
linestring.close()
p.setExteriorRing(linestring)
parts.append(QgsGeometry(p))
return QgsGeometry.collectGeometry(parts)
else:
# linestring to polygon
p = QgsPolygon()
linestring = geom.constGet().clone()
linestring.close()
p.setExteriorRing(linestring)
return [QgsGeometry(p)]
else:
#polygon
if QgsWkbTypes.isMultiType(geom):
return geom.asGeometryCollection()
else:
return [geom]
def test_render_via_job(self):
"""
Test rendering an annotation layer via a map render job
"""
layer = QgsAnnotationLayer('test', QgsAnnotationLayer.LayerOptions(QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
item = QgsAnnotationPolygonItem(
QgsPolygon(QgsLineString([QgsPoint(11.5, 13), QgsPoint(12, 13), QgsPoint(12, 13.5), QgsPoint(11.5, 13)])))
item.setSymbol(
QgsFillSymbol.createSimple({'color': '200,100,100', 'outline_color': 'black', 'outline_width': '2'}))
item.setZIndex(1)
i1_id = layer.addItem(item)
item = QgsAnnotationLineItem(QgsLineString([QgsPoint(11, 13), QgsPoint(12, 13), QgsPoint(12, 15)]))
item.setSymbol(QgsLineSymbol.createSimple({'color': '#ffff00', 'line_width': '3'}))
item.setZIndex(2)
i2_id = layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setSymbol(QgsMarkerSymbol.createSimple({'color': '100,200,200', 'size': '6', 'outline_color': 'black'}))
item.setZIndex(3)
i3_id = layer.addItem(item)
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings = QgsMapSettings()
settings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings.setExtent(QgsRectangle(10, 10, 18, 18))
settings.setOutputSize(QSize(200, 200))
settings.setLayers([layer])
job = QgsMapRendererParallelJob(settings)
job.start()
job.waitForFinished()
# check rendered item results
item_results = job.takeRenderedItemResults()
item_details = item_results.renderedItems()
self.assertEqual(len(item_details), 3)
self.assertEqual([i.layerId() for i in item_details], [layer.id()] * 3)
self.assertCountEqual([i.itemId() for i in item_details], [i1_id, i2_id, i3_id])
self.assertCountEqual(
[i.itemId() for i in item_results.renderedAnnotationItemsInBounds(QgsRectangle(0, 0, 1, 1))], [])
self.assertCountEqual(
[i.itemId() for i in item_results.renderedAnnotationItemsInBounds(QgsRectangle(10, 10, 11, 18))], [i2_id])
self.assertCountEqual(
[i.itemId() for i in item_results.renderedAnnotationItemsInBounds(QgsRectangle(10, 10, 12, 18))],
[i1_id, i2_id, i3_id])
# bounds should be in map crs
self.assertEqual([i.boundingBox() for i in item_details if i.itemId() == i1_id][0],
QgsRectangle(11.5, 13, 12, 13.5))
self.assertEqual([i.boundingBox() for i in item_details if i.itemId() == i2_id][0],
QgsRectangle(11, 13, 12, 15))
self.assertEqual([i.boundingBox().toString(1) for i in item_details if i.itemId() == i3_id][0],
'11.5,12.5 : 12.5,13.5')
def getGeomPolygonRing(rings, idRing):
# rings = [ QgsPointXY ]
ringPoints = [QgsPoint(p)
for p in rings[idRing]] # [ QgsPoint ]
line = QgsLineString(ringPoints)
del ringPoints[:]
polygon = QgsPolygon()
polygon.setExteriorRing(line)
del line
return QgsGeometry(polygon)
def testRenderLayer(self):
layer = QgsAnnotationLayer('test', QgsAnnotationLayer.LayerOptions(QgsProject.instance().transformContext()))
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.assertTrue(layer.isValid())
item = QgsAnnotationPolygonItem(
QgsPolygon(QgsLineString([QgsPoint(12, 13), QgsPoint(14, 13), QgsPoint(14, 15), QgsPoint(12, 13)])))
item.setSymbol(
QgsFillSymbol.createSimple({'color': '200,100,100', 'outline_color': 'black', 'outline_width': '2'}))
item.setZIndex(3)
i1_id = layer.addItem(item)
item = QgsAnnotationLineItem(QgsLineString([QgsPoint(11, 13), QgsPoint(12, 13), QgsPoint(12, 15)]))
item.setSymbol(QgsLineSymbol.createSimple({'color': '#ffff00', 'line_width': '3'}))
item.setZIndex(2)
i2_id = layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setSymbol(QgsMarkerSymbol.createSimple({'color': '100,200,200', 'size': '6', 'outline_color': 'black'}))
item.setZIndex(1)
i3_id = layer.addItem(item)
settings = QgsMapSettings()
settings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings.setExtent(QgsRectangle(10, 10, 18, 18))
settings.setOutputSize(QSize(300, 300))
settings.setFlag(QgsMapSettings.Antialiasing, False)
rc = QgsRenderContext.fromMapSettings(settings)
image = QImage(200, 200, QImage.Format_ARGB32)
image.setDotsPerMeterX(96 / 25.4 * 1000)
image.setDotsPerMeterY(96 / 25.4 * 1000)
image.fill(QColor(255, 255, 255))
painter = QPainter(image)
rc.setPainter(painter)
try:
renderer = layer.createMapRenderer(rc)
renderer.render()
finally:
painter.end()
self.assertTrue(self.imageCheck('layer_render', 'layer_render', image))
# also check details of rendered items
item_details = renderer.takeRenderedItemDetails()
self.assertEqual([i.layerId() for i in item_details], [layer.id()] * 3)
self.assertCountEqual([i.itemId() for i in item_details], [i1_id, i2_id, i3_id])
self.assertEqual([i.boundingBox() for i in item_details if i.itemId() == i1_id][0],
QgsRectangle(12, 13, 14, 15))
self.assertEqual([i.boundingBox() for i in item_details if i.itemId() == i2_id][0],
QgsRectangle(11, 13, 12, 15))
self.assertEqual([i.boundingBox().toString(1) for i in item_details if i.itemId() == i3_id][0],
'11.7,12.7 : 12.3,13.3')
def create_polygon(outer, inners):
outer_line = create_line(outer, False)
qgs_pol = QgsPolygon()
qgs_pol.setExteriorRing(outer_line)
for inner in inners:
inner_line = create_line(inner, False)
qgs_pol.addInteriorRing(inner_line)
qgs_geom = QgsGeometry(qgs_pol)
return qgs_geom
def test_render_via_job_with_transform(self):
"""
Test rendering an annotation layer via a map render job
"""
layer = QgsAnnotationLayer('test', QgsAnnotationLayer.LayerOptions(QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
item = QgsAnnotationPolygonItem(
QgsPolygon(QgsLineString([QgsPoint(11.5, 13), QgsPoint(12, 13), QgsPoint(12, 13.5), QgsPoint(11.5, 13)])))
item.setSymbol(
QgsFillSymbol.createSimple({'color': '200,100,100', 'outline_color': 'black', 'outline_width': '2'}))
item.setZIndex(1)
i1_id = layer.addItem(item)
item = QgsAnnotationLineItem(QgsLineString([QgsPoint(11, 13), QgsPoint(12, 13), QgsPoint(12, 15)]))
item.setSymbol(QgsLineSymbol.createSimple({'color': '#ffff00', 'line_width': '3'}))
item.setZIndex(2)
i2_id = layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setSymbol(QgsMarkerSymbol.createSimple({'color': '100,200,200', 'size': '6', 'outline_color': 'black'}))
item.setZIndex(3)
i3_id = layer.addItem(item)
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings = QgsMapSettings()
settings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
settings.setExtent(QgsRectangle(1250958, 1386945, 1420709, 1532518))
settings.setOutputSize(QSize(200, 200))
settings.setLayers([layer])
job = QgsMapRendererSequentialJob(settings)
job.start()
job.waitForFinished()
# check rendered item results
item_results = job.takeRenderedItemResults()
item_details = item_results.renderedItems()
self.assertEqual(len(item_details), 3)
self.assertEqual([i.layerId() for i in item_details], [layer.id()] * 3)
self.assertCountEqual([i.itemId() for i in item_details], [i1_id, i2_id, i3_id])
# bounds should be in map crs
self.assertEqual(
[QgsGeometry.fromRect(i.boundingBox()).asWkt(0) for i in item_details if i.itemId() == i1_id][0],
'Polygon ((1280174 1459732, 1335834 1459732, 1335834 1516914, 1280174 1516914, 1280174 1459732))')
self.assertEqual(
[QgsGeometry.fromRect(i.boundingBox()).asWkt(0) for i in item_details if i.itemId() == i2_id][0],
'Polygon ((1224514 1459732, 1335834 1459732, 1335834 1689200, 1224514 1689200, 1224514 1459732))')
expected = 'Polygon ((1325786 1449684, 1345882 1449684, 1345882 1469780, 1325786 1469780, 1325786 1449684))'
result = [QgsGeometry.fromRect(i.boundingBox()).asWkt(0) for i in item_details if i.itemId() == i3_id][0]
self.assertTrue(compareWkt(result, expected, tol=1000), "mismatch Expected:\n{}\nGot:\n{}\n".format(expected,
result))
def test_apply_delete_node_edit(self):
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(14.5, 15.5),
QgsPoint(14.5, 16.5),
QgsPoint(14.5, 17.5),
QgsPoint(12, 13)
])))
self.assertEqual(
item.geometry().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 14.5 15.5, 14.5 16.5, 14.5 17.5, 12 13))'
)
self.assertEqual(
item.applyEdit(
QgsAnnotationItemEditOperationDeleteNode(
'', QgsVertexId(0, 0, 1), QgsPoint(14, 13))),
Qgis.AnnotationItemEditOperationResult.Success)
self.assertEqual(
item.geometry().asWkt(),
'Polygon ((12 13, 14 15, 14.5 15.5, 14.5 16.5, 14.5 17.5, 12 13))')
self.assertEqual(
item.applyEdit(
QgsAnnotationItemEditOperationDeleteNode(
'', QgsVertexId(0, 0, 2), QgsPoint(14.5, 15.5))),
Qgis.AnnotationItemEditOperationResult.Success)
self.assertEqual(
item.geometry().asWkt(),
'Polygon ((12 13, 14 15, 14.5 16.5, 14.5 17.5, 12 13))')
self.assertEqual(
item.applyEdit(
QgsAnnotationItemEditOperationDeleteNode(
'', QgsVertexId(0, 0, 7), QgsPoint(14, 15))),
Qgis.AnnotationItemEditOperationResult.Invalid)
self.assertEqual(
item.geometry().asWkt(),
'Polygon ((12 13, 14 15, 14.5 16.5, 14.5 17.5, 12 13))')
self.assertEqual(
item.applyEdit(
QgsAnnotationItemEditOperationDeleteNode(
'', QgsVertexId(0, 0, 0), QgsPoint(12, 13))),
Qgis.AnnotationItemEditOperationResult.Success)
self.assertEqual(
item.applyEdit(
QgsAnnotationItemEditOperationDeleteNode(
'', QgsVertexId(0, 0, 0), QgsPoint(12, 13))),
Qgis.AnnotationItemEditOperationResult.ItemCleared)
self.assertEqual(item.geometry().asWkt(), 'Polygon EMPTY')
def processPolygon(self):
if self.skipPoly:
return
interior_ring = []
poly = QgsPolygon()
outerLineStr = coord2ptsZ(self.outerPoly)
poly.setExteriorRing(outerLineStr)
if len(self.innerPoly) > 0:
for p in self.innerPoly:
innerLineStr = coord2ptsZ(p)
interior_ring.append(innerLineStr)
poly.setInteriorRings(interior_ring)
self.polygons.append(poly)
def testItems(self):
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
polygon_item_id = layer.addItem(
QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
]))))
linestring_item_id = layer.addItem(
QgsAnnotationLineItem(
QgsLineString(
[QgsPoint(11, 13),
QgsPoint(12, 13),
QgsPoint(12, 15)])))
marker_item_id = layer.addItem(
QgsAnnotationMarkerItem(QgsPoint(12, 13)))
self.assertEqual(len(layer.items()), 3)
self.assertIsInstance(layer.items()[polygon_item_id],
QgsAnnotationPolygonItem)
self.assertIsInstance(layer.items()[linestring_item_id],
QgsAnnotationLineItem)
self.assertIsInstance(layer.items()[marker_item_id],
QgsAnnotationMarkerItem)
self.assertFalse(layer.removeItem('xxxx'))
self.assertEqual(len(layer.items()), 3)
self.assertTrue(layer.removeItem(linestring_item_id))
self.assertEqual(len(layer.items()), 2)
self.assertIsInstance(layer.items()[polygon_item_id],
QgsAnnotationPolygonItem)
self.assertIsInstance(layer.items()[marker_item_id],
QgsAnnotationMarkerItem)
self.assertFalse(layer.removeItem(linestring_item_id))
self.assertTrue(layer.removeItem(polygon_item_id))
self.assertEqual(len(layer.items()), 1)
self.assertIsInstance(layer.items()[marker_item_id],
QgsAnnotationMarkerItem)
self.assertTrue(layer.removeItem(marker_item_id))
self.assertEqual(len(layer.items()), 0)
def getSurfaces(self, geometry):
surfaces = []
if isinstance(geometry, QgsGeometryCollection):
# collection
for i in range(geometry.numGeometries()):
surfaces.extend(self.getSurfaces(geometry.geometryN(i)))
else:
# not collection
if geometry.vertexCount() > 2:
surface = QgsPolygon()
surface.setExteriorRing(geometry.clone())
surfaces.append(surface)
return surfaces
def testReset(self):
layer = QgsAnnotationLayer('test', QgsAnnotationLayer.LayerOptions(QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
layer.addItem(QgsAnnotationPolygonItem(
QgsPolygon(QgsLineString([QgsPoint(12, 13), QgsPoint(14, 13), QgsPoint(14, 15), QgsPoint(12, 13)]))))
layer.addItem(QgsAnnotationLineItem(QgsLineString([QgsPoint(11, 13), QgsPoint(12, 13), QgsPoint(12, 15)])))
layer.addItem(QgsAnnotationMarkerItem(QgsPoint(12, 13)))
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
layer.setOpacity(0.5)
layer.reset()
self.assertEqual(len(layer.items()), 0)
self.assertEqual(layer.opacity(), 1.0)
self.assertFalse(layer.crs().isValid())
def get_qgs_feature(self):
"""Reconstruct the original QgsFeature with the new geometry.
:return: The new QgsFeature
:rtype: QgsFeature
"""
qgs_pol = QgsPolygon()
qgs_pol.setExteriorRing(self.rb_geom[0].qgs_geom.constGet().clone())
for rb_geom in self.rb_geom[1:]:
qgs_pol.addInteriorRing(rb_geom.qgs_geom.constGet().clone())
self.qgs_feature.setGeometry(qgs_pol)
return self.qgs_feature
def testItemsInBounds(self):
layer = QgsAnnotationLayer('test', QgsAnnotationLayer.LayerOptions(QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
item1uuid = layer.addItem(QgsAnnotationPolygonItem(
QgsPolygon(QgsLineString([QgsPoint(12, 13), QgsPoint(14, 13), QgsPoint(14, 15), QgsPoint(12, 13)]))))
item2uuid = layer.addItem(
QgsAnnotationLineItem(QgsLineString([QgsPoint(11, 13), QgsPoint(12, 13), QgsPoint(12, 150)])))
item3uuid = layer.addItem(QgsAnnotationMarkerItem(QgsPoint(120, 13)))
rc = QgsRenderContext()
self.assertFalse(layer.itemsInBounds(QgsRectangle(-10, -10, -9, 9), rc))
self.assertCountEqual(layer.itemsInBounds(QgsRectangle(12, 13, 14, 15), rc), [item1uuid, item2uuid])
self.assertCountEqual(layer.itemsInBounds(QgsRectangle(12, 130, 14, 150), rc), [item2uuid])
self.assertCountEqual(layer.itemsInBounds(QgsRectangle(110, 0, 120, 20), rc), [item3uuid])
def testReplaceItem(self):
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
polygon_item_id = layer.addItem(
QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
]))))
linestring_item_id = layer.addItem(
QgsAnnotationLineItem(
QgsLineString(
[QgsPoint(11, 13),
QgsPoint(12, 13),
QgsPoint(12, 15)])))
marker_item_id = layer.addItem(
QgsAnnotationMarkerItem(QgsPoint(12, 13)))
self.assertEqual(
layer.item(polygon_item_id).geometry().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 12 13))')
self.assertEqual(
layer.item(linestring_item_id).geometry().asWkt(),
'LineString (11 13, 12 13, 12 15)')
self.assertEqual(
layer.item(marker_item_id).geometry().asWkt(), 'POINT(12 13)')
layer.replaceItem(
linestring_item_id,
QgsAnnotationLineItem(
QgsLineString(
[QgsPoint(21, 13),
QgsPoint(22, 13),
QgsPoint(22, 15)])))
self.assertEqual(
layer.item(polygon_item_id).geometry().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 12 13))')
self.assertEqual(
layer.item(linestring_item_id).geometry().asWkt(),
'LineString (21 13, 22 13, 22 15)')
self.assertEqual(
layer.item(marker_item_id).geometry().asWkt(), 'POINT(12 13)')
def create_polygon(self):
"""
:return:
"""
self.point_to_list()
line_array = []
for point in self._local_list:
# point is a whitespace (any type!) delimited list of 4D coordinates
if point:
var = re.split(r'[\s\n\t]+', point)
line_array.append(
QgsPoint(self.set_point(var[1]), self.set_point(var[0])))
geom_poly = QgsPolygon(QgsLineString(line_array))
return QgsGeometry(geom_poly)
def test_transient_translate_operation(self):
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
])))
self.assertEqual(item.geometry().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 12 13))')
res = item.transientEditResults(
QgsAnnotationItemEditOperationTranslateItem('', 100, 200))
self.assertEqual(res.representativeGeometry().asWkt(),
'Polygon ((112 213, 114 213, 114 215, 112 213))')
def tzf_to_qgis_polygon(tzdata):
if not tzdata or len(tzdata) < 1:
return None
multi_poly = QgsMultiPolygon()
for tzpoly in tzdata:
holes = []
poly = QgsPolygon()
for x, part in enumerate(tzpoly):
if x == 0:
outer_ls = QgsLineString(part[0], part[1])
poly.setExteriorRing(outer_ls)
else:
hole_ls = QgsLineString(part[0], part[1])
holes.append(hole_ls)
poly.setInteriorRings(holes)
multi_poly.addGeometry(poly)
return (QgsGeometry(multi_poly))
def read_polygon(self, boundary):
"""Reads the specified polygon"""
g = QgsPolygon()
i = 0
for ring in boundary:
poly = []
for point in ring:
poly.append(point)
r = QgsLineString(poly)
if i == 0:
g.setExteriorRing(r)
else:
g.addInteriorRing(r)
i = 1
return g
def testReadWriteXml(self):
doc = QDomDocument("testdoc")
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
polygon_item_id = layer.addItem(
QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
]))))
linestring_item_id = layer.addItem(
QgsAnnotationLineItem(
QgsLineString(
[QgsPoint(11, 13),
QgsPoint(12, 13),
QgsPoint(12, 15)])))
marker_item_id = layer.addItem(
QgsAnnotationMarkerItem(QgsPoint(12, 13)))
elem = doc.createElement("maplayer")
self.assertTrue(layer.writeLayerXml(elem, doc, QgsReadWriteContext()))
layer2 = QgsAnnotationLayer(
'test2',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer2.readLayerXml(elem, QgsReadWriteContext()))
self.assertEqual(layer2.crs().authid(), 'EPSG:4326')
self.assertEqual(len(layer2.items()), 3)
self.assertIsInstance(layer2.items()[polygon_item_id],
QgsAnnotationPolygonItem)
self.assertIsInstance(layer2.items()[linestring_item_id],
QgsAnnotationLineItem)
self.assertIsInstance(layer2.items()[marker_item_id],
QgsAnnotationMarkerItem)
def testClone(self):
layer = QgsAnnotationLayer('test', QgsAnnotationLayer.LayerOptions(QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
polygon_item_id = layer.addItem(QgsAnnotationPolygonItem(
QgsPolygon(QgsLineString([QgsPoint(12, 13), QgsPoint(14, 13), QgsPoint(14, 15), QgsPoint(12, 13)]))))
linestring_item_id = layer.addItem(
QgsAnnotationLineItem(QgsLineString([QgsPoint(11, 13), QgsPoint(12, 13), QgsPoint(12, 15)])))
marker_item_id = layer.addItem(QgsAnnotationMarkerItem(QgsPoint(12, 13)))
layer2 = layer.clone()
self.assertEqual(len(layer2.items()), 3)
self.assertIsInstance(layer2.items()[polygon_item_id], QgsAnnotationPolygonItem)
# should not be the SAME instance of the item -- the item must have been cloned for the cloned layer!
self.assertNotEqual(layer.items()[polygon_item_id], layer2.items()[polygon_item_id])
self.assertIsInstance(layer2.items()[linestring_item_id], QgsAnnotationLineItem)
self.assertIsInstance(layer2.items()[marker_item_id], QgsAnnotationMarkerItem)
def test_transient_move_operation(self):
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
])))
self.assertEqual(item.geometry().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 12 13))')
res = item.transientEditResults(
QgsAnnotationItemEditOperationMoveNode('', QgsVertexId(0, 0, 1),
QgsPoint(14, 13),
QgsPoint(17, 18)))
self.assertEqual(res.representativeGeometry().asWkt(),
'Polygon ((12 13, 17 18, 14 15, 12 13))')
def test_transform(self):
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
])))
self.assertEqual(item.geometry().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 12 13))')
self.assertEqual(
item.applyEdit(
QgsAnnotationItemEditOperationTranslateItem('', 100, 200)),
Qgis.AnnotationItemEditOperationResult.Success)
self.assertEqual(item.geometry().asWkt(),
'Polygon ((112 213, 114 213, 114 215, 112 213))')
def testProjectMainAnnotationLayer(self):
p = QgsProject()
self.assertIsNotNone(p.mainAnnotationLayer())
# add some items to project annotation layer
polygon_item_id = p.mainAnnotationLayer().addItem(
QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
]))))
linestring_item_id = p.mainAnnotationLayer().addItem(
QgsAnnotationLineItem(
QgsLineString(
[QgsPoint(11, 13),
QgsPoint(12, 13),
QgsPoint(12, 15)])))
marker_item_id = p.mainAnnotationLayer().addItem(
QgsAnnotationMarkerItem(QgsPoint(12, 13)))
# save project to xml
tmpDir = QTemporaryDir()
tmpFile = "{}/project.qgs".format(tmpDir.path())
self.assertTrue(p.write(tmpFile))
# test that annotation layer is cleared with project
p.clear()
self.assertEqual(len(p.mainAnnotationLayer().items()), 0)
# check that main annotation layer is restored on project read
p2 = QgsProject()
self.assertTrue(p2.read(tmpFile))
self.assertEqual(len(p2.mainAnnotationLayer().items()), 3)
self.assertIsInstance(
p2.mainAnnotationLayer().items()[polygon_item_id],
QgsAnnotationPolygonItem)
self.assertIsInstance(
p2.mainAnnotationLayer().items()[linestring_item_id],
QgsAnnotationLineItem)
self.assertIsInstance(p2.mainAnnotationLayer().items()[marker_item_id],
QgsAnnotationMarkerItem)
def testRenderWithTransform(self):
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(11.5, 13),
QgsPoint(12, 13),
QgsPoint(12, 13.5),
QgsPoint(11.5, 13)
])))
item.setSymbol(
QgsFillSymbol.createSimple({
'color': '200,100,100',
'outline_color': 'black',
'outline_width': '2'
}))
settings = QgsMapSettings()
settings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
settings.setExtent(QgsRectangle(1250958, 1386945, 1420709, 1532518))
settings.setOutputSize(QSize(300, 300))
settings.setFlag(QgsMapSettings.Antialiasing, False)
rc = QgsRenderContext.fromMapSettings(settings)
rc.setCoordinateTransform(
QgsCoordinateTransform(QgsCoordinateReferenceSystem('EPSG:4326'),
settings.destinationCrs(),
QgsProject.instance()))
image = QImage(200, 200, QImage.Format_ARGB32)
image.setDotsPerMeterX(96 / 25.4 * 1000)
image.setDotsPerMeterY(96 / 25.4 * 1000)
image.fill(QColor(255, 255, 255))
painter = QPainter(image)
rc.setPainter(painter)
try:
item.render(rc, None)
finally:
painter.end()
self.assertTrue(
self.imageCheck('polygon_item_transform', 'polygon_item_transform',
image))
def splitPolygon(self, geom):
z_func = lambda x, y: self.valueOnSurface(x, y) or 0
cache = FunctionCacheXY(z_func)
z_func = cache.func
polygons = QgsMultiPolygon()
for poly in self._splitPolygon(geom):
p = QgsPolygon()
ring = QgsLineString()
for pt in poly[0]:
ring.addVertex(QgsPoint(pt.x(), pt.y(), z_func(pt.x(), pt.y())))
p.setExteriorRing(ring)
for bnd in poly[1:]:
ring = QgsLineString()
for pt in bnd:
ring.addVertex(QgsPoint(pt.x(), pt.y(), z_func(pt.x(), pt.y())))
p.addInteriorRing(ring)
polygons.addGeometry(p)
return QgsGeometry(polygons)
def __init__(self, i, j, qgs_points):
"""Constructor that initialize a Bend object.
:param: int i: start position of the vertice in the LineString to reduce
:param: int j: end position of the vertice in the LineString to reduce
:param: qgs_points: List of QgsPoint defining the bend
:return: None
:rtype: None
"""
self.i = i
self.j = j
self._qgs_points = qgs_points
self._qgs_geom_new_subline = None
self._qgs_geom_old_subline = None
self.qgs_geom_bend = QgsGeometry(QgsPolygon(
QgsLineString(qgs_points))) # QgsPolygon will close the polygon
self.area = self.qgs_geom_bend.area()
self.perimeter = self.qgs_geom_bend.length()
self.adj_area = Bend.calculate_adj_area(self.area, self.perimeter)
self.to_reduce = False
def test_nodes(self):
"""
Test nodes for item
"""
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
])))
# nodes shouldn't form a closed ring
self.assertEqual(item.nodes(), [
QgsAnnotationItemNode(QgsPointXY(12, 13),
Qgis.AnnotationItemNodeType.VertexHandle),
QgsAnnotationItemNode(QgsPointXY(14, 13),
Qgis.AnnotationItemNodeType.VertexHandle),
QgsAnnotationItemNode(QgsPointXY(14, 15),
Qgis.AnnotationItemNodeType.VertexHandle)
])
def testClone(self):
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
])))
item.setSymbol(
QgsFillSymbol.createSimple({
'color': '200,100,100',
'outline_color': 'black'
}))
item.setZIndex(11)
item2 = item.clone()
self.assertEqual(item2.geometry().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 12 13))')
self.assertEqual(item2.symbol()[0].color(), QColor(200, 100, 100))
self.assertEqual(item2.zIndex(), 11)
def test_apply_move_node_edit(self):
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
])))
self.assertEqual(item.geometry().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 12 13))')
self.assertEqual(
item.applyEdit(
QgsAnnotationItemEditOperationMoveNode('',
QgsVertexId(0, 0, 1),
QgsPoint(14, 13),
QgsPoint(17, 18))),
Qgis.AnnotationItemEditOperationResult.Success)
self.assertEqual(item.geometry().asWkt(),
'Polygon ((12 13, 17 18, 14 15, 12 13))')
self.assertEqual(
item.applyEdit(
QgsAnnotationItemEditOperationMoveNode('',
QgsVertexId(0, 0, 3),
QgsPoint(12, 13),
QgsPoint(19, 20))),
Qgis.AnnotationItemEditOperationResult.Success)
self.assertEqual(item.geometry().asWkt(),
'Polygon ((19 20, 17 18, 14 15, 19 20))')
self.assertEqual(
item.applyEdit(
QgsAnnotationItemEditOperationMoveNode('',
QgsVertexId(0, 0, 4),
QgsPoint(14, 15),
QgsPoint(19, 20))),
Qgis.AnnotationItemEditOperationResult.Invalid)
self.assertEqual(item.geometry().asWkt(),
'Polygon ((19 20, 17 18, 14 15, 19 20))')
def testExtent(self):
layer = QgsAnnotationLayer('test', QgsAnnotationLayer.LayerOptions(QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
layer.addItem(QgsAnnotationPolygonItem(
QgsPolygon(QgsLineString([QgsPoint(12, 13), QgsPoint(14, 13), QgsPoint(14, 15), QgsPoint(12, 13)]))))
layer.addItem(QgsAnnotationLineItem(QgsLineString([QgsPoint(11, 13), QgsPoint(12, 13), QgsPoint(12, 15)])))
layer.addItem(QgsAnnotationMarkerItem(QgsPoint(12, 13)))
extent = layer.extent()
self.assertEqual(extent.xMinimum(), 11.0)
self.assertEqual(extent.xMaximum(), 14.0)
self.assertEqual(extent.yMinimum(), 13.0)
self.assertEqual(extent.yMaximum(), 15.0)
# should have no effect -- item geometries are in layer crs
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
extent = layer.extent()
self.assertEqual(extent.xMinimum(), 11.0)
self.assertEqual(extent.xMaximum(), 14.0)
self.assertEqual(extent.yMinimum(), 13.0)
self.assertEqual(extent.yMaximum(), 15.0)
