def test_apply_add_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(
QgsAnnotationItemEditOperationAddNode('', QgsPoint(15, 16))),
Qgis.AnnotationItemEditOperationResult.Success)
self.assertEqual(
item.geometry().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 14.5 15.5, 14.5 16, 14.5 16.5, 14.5 17.5, 12 13))'
)
def testMainAnnotationLayerRendered(self):
""" test that main annotation layer is rendered above all other layers """
canvas = QgsMapCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
self.assertEqual(canvas.width(), 600)
self.assertEqual(canvas.height(), 400)
layer = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer", "memory")
sym3 = QgsFillSymbol.createSimple({'color': '#b200b2'})
layer.renderer().setSymbol(sym3)
canvas.setLayers([layer])
canvas.setExtent(QgsRectangle(10, 30, 20, 35))
canvas.show()
# need to wait until first redraw can occur (note that we first need to wait till drawing starts!)
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
self.assertTrue(
self.canvasImageCheck('empty_canvas', 'empty_canvas', canvas))
# add polygon to layer
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(layer.dataProvider().addFeatures([f]))
# refresh canvas
canvas.refresh()
canvas.waitWhileRendering()
# no annotation yet...
self.assertFalse(
self.canvasImageCheck('main_annotation_layer',
'main_annotation_layer', canvas))
annotation_layer = QgsProject.instance().mainAnnotationLayer()
annotation_layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
annotation_geom = QgsGeometry.fromRect(QgsRectangle(12, 30, 18, 33))
annotation = QgsAnnotationPolygonItem(
annotation_geom.constGet().clone())
sym3 = QgsFillSymbol.createSimple({
'color': '#ff0000',
'outline_style': 'no'
})
annotation.setSymbol(sym3)
annotation_layer.addItem(annotation)
# refresh canvas
canvas.refresh()
canvas.waitWhileRendering()
# annotation must be rendered over other layers
self.assertTrue(
self.canvasImageCheck('main_annotation_layer',
'main_annotation_layer', canvas))
annotation_layer.clear()
def testMainAnnotationLayer(self):
"""
Make sure main annotation layer is rendered in maps above all other layers
"""
p = QgsProject()
vl = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer", "memory")
sym3 = QgsFillSymbol.createSimple({'color': '#b200b2'})
vl.renderer().setSymbol(sym3)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.setFrameStrokeWidth(
QgsLayoutMeasurement(2, QgsUnitTypes.LayoutMillimeters))
map.setBackgroundEnabled(True)
map.setBackgroundColor(QColor(200, 255, 200))
map.zoomToExtent(QgsRectangle(10, 30, 20, 35))
map.setLayers([vl])
layout.addLayoutItem(map)
# add polygon to layer
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(vl.dataProvider().addFeatures([f]))
# no annotation yet...
checker = QgsLayoutChecker('composermap_annotation_empty', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
annotation_layer = p.mainAnnotationLayer()
annotation_layer.setCrs(QgsCoordinateReferenceSystem(4326))
annotation_geom = QgsGeometry.fromRect(QgsRectangle(12, 30, 18, 33))
annotation = QgsAnnotationPolygonItem(
annotation_geom.constGet().clone())
sym3 = QgsFillSymbol.createSimple({
'color': '#ff0000',
'outline_style': 'no'
})
annotation.setSymbol(sym3)
annotation_layer.addItem(annotation)
# annotation must be drawn above map layers
checker = QgsLayoutChecker('composermap_annotation_item', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
TestQgsLayoutMap.report += checker.report()
self.assertTrue(result, message)
def testItems(self):
layer = QgsAnnotationLayer('test', QgsAnnotationLayer.LayerOptions(QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
self.assertTrue(layer.isEmpty())
self.assertIsNone(layer.item('xxxx'))
self.assertIsNone(layer.item(''))
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.assertFalse(layer.isEmpty())
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.assertIsInstance(layer.item(polygon_item_id), QgsAnnotationPolygonItem)
self.assertIsInstance(layer.item(linestring_item_id), QgsAnnotationLineItem)
self.assertIsInstance(layer.item(marker_item_id), QgsAnnotationMarkerItem)
self.assertIsNone(layer.item('xxxx'))
self.assertIsNone(layer.item(''))
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)
self.assertTrue(layer.isEmpty())
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)))
self.assertEqual(len(layer.items()), 3)
layer.clear()
self.assertEqual(len(layer.items()), 0)
def testReadWriteXml(self):
doc = QDomDocument("testdoc")
elem = doc.createElement('test')
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)
self.assertTrue(item.writeXml(elem, doc, QgsReadWriteContext()))
s2 = QgsAnnotationPolygonItem.create()
self.assertTrue(s2.readXml(elem, QgsReadWriteContext()))
self.assertEqual(s2.geometry().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 12 13))')
self.assertEqual(s2.symbol()[0].color(), QColor(200, 100, 100))
self.assertEqual(s2.zIndex(), 11)
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 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 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 test_apply_edit(self):
"""
Test applying edits to a layer
"""
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)))
rc = QgsRenderContext()
self.assertCountEqual(
layer.itemsInBounds(QgsRectangle(1, 1, 20, 20), rc),
[polygon_item_id, linestring_item_id, marker_item_id])
# can't apply a move to an item which doesn't exist in the layer
self.assertEqual(
layer.applyEdit(
QgsAnnotationItemEditOperationMoveNode('xxx',
QgsVertexId(0, 0, 2),
QgsPoint(14, 15),
QgsPoint(19, 15))),
Qgis.AnnotationItemEditOperationResult.Invalid)
# apply move to polygon
self.assertEqual(
layer.applyEdit(
QgsAnnotationItemEditOperationMoveNode(polygon_item_id,
QgsVertexId(0, 0, 2),
QgsPoint(14, 15),
QgsPoint(19, 15))),
Qgis.AnnotationItemEditOperationResult.Success)
self.assertEqual(
layer.item(polygon_item_id).geometry().asWkt(),
'Polygon ((12 13, 14 13, 19 15, 12 13))')
# ensure that spatial index was updated
self.assertCountEqual(
layer.itemsInBounds(QgsRectangle(18, 1, 20, 16), rc),
[polygon_item_id])
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 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_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 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 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 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 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)
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 testMainAnnotationLayerCrs(self):
p = QgsProject()
self.assertEqual(p.crs(), p.mainAnnotationLayer().crs())
# main annotation layer should follow project crs
p.setCrs(QgsCoordinateReferenceSystem('EPSG:3111'))
self.assertEqual(p.crs(), p.mainAnnotationLayer().crs())
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.assertEqual(p.crs(), p.mainAnnotationLayer().crs())
# add an item, should lock in the crs for the main annotation layer
p.mainAnnotationLayer().addItem(
QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
]))))
p.setCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
self.assertEqual(p.mainAnnotationLayer().crs().authid(), 'EPSG:4326')
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 testRenderCurvePolygon(self):
cs = QgsCircularString()
cs.setPoints([
QgsPoint(12, 13.2),
QgsPoint(14, 13.4),
QgsPoint(14, 15),
QgsPoint(13, 15.1),
QgsPoint(12, 13.2)
])
cp = QgsCurvePolygon()
cp.setExteriorRing(cs)
item = QgsAnnotationPolygonItem(cp)
item.setSymbol(
QgsFillSymbol.createSimple({
'color': '200,100,100',
'outline_color': 'black',
'outline_width': '2'
}))
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:
item.render(rc, None)
finally:
painter.end()
self.assertTrue(
self.imageCheck('curvepolygon_item', 'curvepolygon_item', image))
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_rendered_item_results_remove_outdated(self):
"""
Test that outdated results are removed from rendered item result caches
"""
canvas = QgsMapCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
canvas.setCachingEnabled(True)
self.assertEqual(canvas.width(), 600)
self.assertEqual(canvas.height(), 400)
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
layer2 = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer2.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.setZIndex(2)
i2_id = layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setZIndex(3)
i3_id = layer2.addItem(item)
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
layer2.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
canvas.setLayers([layer, layer2])
canvas.setExtent(QgsRectangle(10, 10, 18, 18))
canvas.show()
# need to wait until first redraw can occur (note that we first need to wait till drawing starts!)
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
results = canvas.renderedItemResults()
self.assertCountEqual([i.itemId() for i in results.renderedItems()],
[i1_id, i2_id, i3_id])
# now try modifying an annotation in the layer -- it will redraw, and we don't want to reuse any previously
# cached rendered item results for this layer!
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(11.5, 13),
QgsPoint(12.5, 13),
QgsPoint(12.5, 13.5),
QgsPoint(11.5, 13)
])))
item.setZIndex(1)
layer.replaceItem(i1_id, item)
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
item = QgsAnnotationMarkerItem(QgsPoint(17, 18))
item.setZIndex(3)
layer2.replaceItem(i3_id, item)
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
results = canvas.renderedItemResults()
items_in_bounds = results.renderedAnnotationItemsInBounds(
QgsRectangle(10, 10, 15, 15))
self.assertCountEqual([i.itemId() for i in items_in_bounds],
[i1_id, i2_id])
items_in_bounds = results.renderedAnnotationItemsInBounds(
QgsRectangle(15, 15, 20, 20))
self.assertCountEqual([i.itemId() for i in items_in_bounds], [i3_id])
def test_rendered_items(self):
canvas = QgsMapCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
canvas.setCachingEnabled(True)
self.assertEqual(canvas.width(), 600)
self.assertEqual(canvas.height(), 400)
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
layer2 = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer2.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.setZIndex(2)
i2_id = layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setZIndex(3)
i3_id = layer2.addItem(item)
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
layer2.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
canvas.setLayers([layer, layer2])
canvas.setExtent(QgsRectangle(10, 10, 18, 18))
canvas.show()
# need to wait until first redraw can occur (note that we first need to wait till drawing starts!)
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
results = canvas.renderedItemResults()
self.assertCountEqual([i.itemId() for i in results.renderedItems()],
[i1_id, i2_id, i3_id])
# turn off a layer -- the other layer will be rendered direct from the cached version
canvas.setLayers([layer2])
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
results = canvas.renderedItemResults()
# only layer2 items should be present in results -- but these MUST be present while layer2 is visible in the canvas,
# even though the most recent canvas redraw used a cached version of layer2 and didn't actually have to redraw the layer
self.assertEqual([i.itemId() for i in results.renderedItems()],
[i3_id])
# turn layer 1 back on
canvas.setLayers([layer, layer2])
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
results = canvas.renderedItemResults()
# both layer1 and layer2 items should be present in results -- even though NEITHER of these layers were re-rendered,
# and instead we used precached renders of both layers
self.assertCountEqual([i.itemId() for i in results.renderedItems()],
[i1_id, i2_id, i3_id])
def testBasic(self):
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
])))
self.assertEqual(item.polygon().asWkt(),
'Polygon ((12 13, 14 13, 14 15, 12 13))')
item.setPolygon(
QgsPolygon(
QgsLineString([
QgsPoint(22, 23),
QgsPoint(24, 23),
QgsPoint(24, 25),
QgsPoint(22, 23)
])))
item.setZIndex(11)
self.assertEqual(item.polygon().asWkt(),
'Polygon ((22 23, 24 23, 24 25, 22 23))')
self.assertEqual(item.zIndex(), 11)
item.setSymbol(
QgsFillSymbol.createSimple({
'color': '200,100,100',
'outline_color': 'black'
}))
self.assertEqual(item.symbol()[0].color(), QColor(200, 100, 100))
def testRenderLayerWithReferenceScale(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)
layer.item(i1_id).setUseSymbologyReferenceScale(True)
layer.item(i1_id).setSymbologyReferenceScale(rc.rendererScale() * 2)
# note item 3 has use symbology reference scale set to false, so should be ignored
layer.item(i2_id).setUseSymbologyReferenceScale(False)
layer.item(i2_id).setSymbologyReferenceScale(rc.rendererScale() * 2)
layer.item(i3_id).setUseSymbologyReferenceScale(True)
layer.item(i3_id).setSymbologyReferenceScale(rc.rendererScale() * 2)
image = QImage(200, 200, QImage.Format_ARGB32)
image.setDotsPerMeterX(int(96 / 25.4 * 1000))
image.setDotsPerMeterY(int(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_reference_scale',
'layer_render_reference_scale', 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.4,12.4 : 12.6,13.6')
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 testRenderWithTransform(self):
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)
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)
layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setSymbol(
QgsMarkerSymbol.createSimple({
'color': '100,200,200',
'size': '6',
'outline_color': 'black'
}))
item.setZIndex(3)
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(300, 300))
settings.setFlag(QgsMapSettings.Antialiasing, False)
rc = QgsRenderContext.fromMapSettings(settings)
rc.setCoordinateTransform(
QgsCoordinateTransform(layer.crs(), 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:
renderer = layer.createMapRenderer(rc)
renderer.render()
finally:
painter.end()
self.assertTrue(
self.imageCheck('layer_render_transform', 'layer_render_transform',
image))
def testRenderWithTransform(self):
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(300, 300))
settings.setFlag(QgsMapSettings.Antialiasing, False)
rc = QgsRenderContext.fromMapSettings(settings)
rc.setCoordinateTransform(
QgsCoordinateTransform(layer.crs(), settings.destinationCrs(),
QgsProject.instance()))
rc.setExtent(rc.coordinateTransform().transformBoundingBox(
settings.extent(), QgsCoordinateTransform.ReverseTransform))
image = QImage(200, 200, QImage.Format_ARGB32)
image.setDotsPerMeterX(int(96 / 25.4 * 1000))
image.setDotsPerMeterY(int(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_transform', 'layer_render_transform',
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(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(2) for i in item_details
if i.itemId() == i3_id
][0], '11.94,12.94 : 12.06,13.06')
