def testWidth(self):
ms = QgsMapSettings()
extent = QgsRectangle(100, 200, 100, 200)
ms.setExtent(extent)
ms.setOutputSize(QSize(400, 400))
context = QgsRenderContext.fromMapSettings(ms)
context.setScaleFactor(96 / 25.4) # 96 DPI
ms.setExtent(QgsRectangle(100, 150, 100, 150))
ms.setOutputDpi(ms.outputDpi() * 2)
context2 = QgsRenderContext.fromMapSettings(ms)
context2.setScaleFactor(300 / 25.4)
s = QgsFillSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.FirstVertex)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 10)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
self.assertEqual(marker_line.width(), 10)
self.assertAlmostEqual(marker_line.width(context), 37.795275590551185, 3)
self.assertAlmostEqual(marker_line.width(context2), 118.11023622047244, 3)
marker_line.subSymbol().setSizeUnit(QgsUnitTypes.RenderPixels)
self.assertAlmostEqual(marker_line.width(context), 10.0, 3)
self.assertAlmostEqual(marker_line.width(context2), 10.0, 3)
def testRenderMarkerLayerDisabled(self):
""" test that rendering a marker symbol with disabled layer works"""
layer = QgsSimpleMarkerSymbolLayer()
layer.setEnabled(False)
symbol = QgsMarkerSymbol()
symbol.changeSymbolLayer(0, layer)
image = QImage(200, 200, QImage.Format_RGB32)
painter = QPainter()
ms = QgsMapSettings()
geom = QgsGeometry.fromWkt('Point (1 2)')
f = QgsFeature()
f.setGeometry(geom)
extent = QgsRectangle(0, 0, 4, 4)
ms.setExtent(extent)
ms.setOutputSize(image.size())
context = QgsRenderContext.fromMapSettings(ms)
context.setPainter(painter)
context.setScaleFactor(96 / 25.4) # 96 DPI
painter.begin(image)
image.fill(QColor(255, 255, 255))
symbol.startRender(context)
symbol.renderFeature(f, context)
symbol.stopRender(context)
painter.end()
self.assertTrue(self.imageCheck('symbol_layer', 'symbollayer_disabled', image))
def testSimpleMarkerRotation(self):
symbol = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayerBase.Star, color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0), size=10)
symbol.setAngle(50)
dom, root = self.symbolToSld(symbol)
# print( "Simple marker rotation: " + root.ownerDocument().toString())
self.assertStaticRotation(root, '50')
def testRenderMarkerLayerDataDefined(self):
""" test that rendering a marker symbol with data defined enabled layer works"""
points_shp = os.path.join(TEST_DATA_DIR, 'points.shp')
points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr')
QgsProject.instance().addMapLayer(points_layer)
layer = QgsSimpleMarkerSymbolLayer()
layer.setDataDefinedProperty(QgsSymbolLayer.PropertyLayerEnabled, QgsProperty.fromExpression("Class='Biplane'"))
layer.setColor(QColor(100, 150, 150))
layer.setSize(5)
layer.setStrokeStyle(Qt.NoPen)
symbol = QgsMarkerSymbol()
symbol.changeSymbolLayer(0, layer)
points_layer.setRenderer(QgsSingleSymbolRenderer(symbol))
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-133, 22, -70, 52))
ms.setLayers([points_layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(ms)
renderchecker.setControlPathPrefix('symbol_layer')
renderchecker.setControlName('expected_markerlayer_ddenabled')
self.assertTrue(renderchecker.runTest('markerlayer_ddenabled'))
QgsProject.instance().removeMapLayer(points_layer)
def testSimpleMarkerUnitDefault(self):
symbol = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayerBase.Star, color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0), size=10)
symbol.setStrokeWidth(3)
symbol.setOffset(QPointF(5, 10))
dom, root = self.symbolToSld(symbol)
# print("Simple marker unit mm: " + root.ownerDocument().toString())
# Check the size has been rescaled to pixels
self.assertStaticSize(root, '36')
# Check the same happened to the stroke width
self.assertStrokeWidth(root, 2, 11)
self.assertStaticDisplacement(root, 18, 36)
def testSimpleMarkerSymbolLayer(self):
symbol = QgsSimpleMarkerSymbolLayer(
'star', QColor(255, 0, 0), QColor(0, 255, 0), 10)
symbol.setAngle(50)
dom = QDomDocument()
root = dom.createElement("FakeRoot")
dom.appendChild(root)
symbol.toSld(dom, root, {})
# print "This is the dom: " + dom.toString()
# Check the rotation element is a literal, not a
rotation = root.elementsByTagName('se:Rotation').item(0)
literal = rotation.firstChild()
self.assertEquals("ogc:Literal", literal.nodeName())
self.assertEquals('50', literal.firstChild().nodeValue())
def testRingFilter(self):
# test filtering rings during rendering
s = QgsFillSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.FirstVertex)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line.clone())
self.assertEqual(s.symbolLayer(0).ringFilter(), QgsLineSymbolLayer.AllRings)
s.symbolLayer(0).setRingFilter(QgsLineSymbolLayer.ExteriorRingOnly)
self.assertEqual(s.symbolLayer(0).ringFilter(), QgsLineSymbolLayer.ExteriorRingOnly)
s2 = s.clone()
self.assertEqual(s2.symbolLayer(0).ringFilter(), QgsLineSymbolLayer.ExteriorRingOnly)
doc = QDomDocument()
context = QgsReadWriteContext()
element = QgsSymbolLayerUtils.saveSymbol('test', s, doc, context)
s2 = QgsSymbolLayerUtils.loadSymbol(element, context)
self.assertEqual(s2.symbolLayer(0).ringFilter(), QgsLineSymbolLayer.ExteriorRingOnly)
# rendering test
s3 = QgsFillSymbol()
s3.deleteSymbolLayer(0)
s3.appendSymbolLayer(
QgsMarkerLineSymbolLayer())
s3.symbolLayer(0).setRingFilter(QgsLineSymbolLayer.ExteriorRingOnly)
s3.symbolLayer(0).setAverageAngleLength(0)
g = QgsGeometry.fromWkt('Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))')
rendered_image = self.renderGeometry(s3, g)
assert self.imageCheck('markerline_exterioronly', 'markerline_exterioronly', rendered_image)
s3.symbolLayer(0).setRingFilter(QgsLineSymbolLayer.InteriorRingsOnly)
g = QgsGeometry.fromWkt('Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))')
rendered_image = self.renderGeometry(s3, g)
assert self.imageCheck('markerline_interioronly', 'markerline_interioronly', rendered_image)
def testForceRHR(self):
# test forcing right hand rule during rendering
s = QgsFillSymbol()
s.deleteSymbolLayer(0)
s.appendSymbolLayer(
QgsSimpleFillSymbolLayer(color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0)))
self.assertFalse(s.forceRHR())
s.setForceRHR(True)
self.assertTrue(s.forceRHR())
s.setForceRHR(False)
self.assertFalse(s.forceRHR())
s.setForceRHR(True)
doc = QDomDocument()
context = QgsReadWriteContext()
element = QgsSymbolLayerUtils.saveSymbol('test', s, doc, context)
s2 = QgsSymbolLayerUtils.loadSymbol(element, context)
self.assertTrue(s2.forceRHR())
# rendering test
s3 = QgsFillSymbol()
s3.deleteSymbolLayer(0)
s3.appendSymbolLayer(
QgsSimpleFillSymbolLayer(color=QColor(255, 200, 200), strokeColor=QColor(0, 255, 0), strokeWidth=2))
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.FirstVertex)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
s3.appendSymbolLayer(marker_line)
g = QgsGeometry.fromWkt('Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))')
rendered_image = self.renderGeometry(s3, g)
assert self.imageCheck('force_rhr_off', 'polygon_forcerhr_off', rendered_image)
s3.setForceRHR(True)
rendered_image = self.renderGeometry(s3, g)
assert self.imageCheck('force_rhr_on', 'polygon_forcerhr_on', rendered_image)
def testMarkerAverageAngleCenter(self):
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsTemplatedLineSymbolLayerBase.CentralPoint)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
marker_line.setAverageAngleLength(60)
line_symbol = QgsLineSymbol()
line_symbol.changeSymbolLayer(0, marker_line)
s.appendSymbolLayer(marker_line.clone())
g = QgsGeometry.fromWkt('LineString(0 0, 10 10, 10 0)')
rendered_image = self.renderGeometry(s, g)
assert self.imageCheck('markerline_center_average_angle', 'markerline_center_average_angle', rendered_image)
def testNoPoint(self):
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsTemplatedLineSymbolLayerBase.Interval)
marker_line.setOffsetAlongLine(1000)
marker_line.setIntervalUnit(QgsUnitTypes.RenderMapUnits)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Circle, 4)
marker.setColor(QColor(255, 0, 0, 100))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
line_symbol = QgsLineSymbol()
line_symbol.changeSymbolLayer(0, marker_line)
s.appendSymbolLayer(marker_line.clone())
g = QgsGeometry.fromWkt('LineString(0 0, 0 10, 10 10)')
rendered_image = self.renderGeometry(s, g)
assert self.imageCheck('markerline_none', 'markerline_none', rendered_image)
def testAngle(self):
# test angle and setAngle
# create a marker symbol with a single layer
markerSymbol = QgsMarkerSymbol()
markerSymbol.deleteSymbolLayer(0)
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.Star,
color=QColor(255, 0, 0),
strokeColor=QColor(0, 255, 0),
size=10,
angle=90))
self.assertEqual(markerSymbol.angle(), 90)
markerSymbol.setAngle(100)
self.assertEqual(markerSymbol.angle(), 100)
self.assertEqual(markerSymbol.symbolLayer(0).angle(), 100)
# add additional layers
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.Star,
color=QColor(255, 0, 0),
strokeColor=QColor(0, 255, 0),
size=10,
angle=130))
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.Star,
color=QColor(255, 0, 0),
strokeColor=QColor(0, 255, 0),
size=10,
angle=150))
# should take first layer's angle
self.assertEqual(markerSymbol.angle(), 100)
markerSymbol.setAngle(10)
self.assertEqual(markerSymbol.angle(), 10)
# layer angles should maintain relative angle
self.assertEqual(markerSymbol.symbolLayer(0).angle(), 10)
self.assertEqual(markerSymbol.symbolLayer(1).angle(), 40)
self.assertEqual(markerSymbol.symbolLayer(2).angle(), 60)
def testSizeUnit(self):
# test sizeUnit and setSizeUnit
# create a marker symbol with a single layer
markerSymbol = QgsMarkerSymbol()
markerSymbol.deleteSymbolLayer(0)
markerSymbol.appendSymbolLayer(QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.Star, color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0), size=10))
self.assertEqual(markerSymbol.sizeUnit(), QgsUnitTypes.RenderMillimeters)
markerSymbol.setSizeUnit(QgsUnitTypes.RenderMapUnits)
self.assertEqual(markerSymbol.sizeUnit(), QgsUnitTypes.RenderMapUnits)
self.assertEqual(markerSymbol.symbolLayer(0).sizeUnit(), QgsUnitTypes.RenderMapUnits)
# add additional layers
markerSymbol.appendSymbolLayer(QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.Star, color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0), size=10))
markerSymbol.appendSymbolLayer(QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.Star, color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0), size=30))
# should now be mixed size units
self.assertEqual(markerSymbol.sizeUnit(), QgsUnitTypes.RenderUnknownUnit)
markerSymbol.setSizeUnit(QgsUnitTypes.RenderPixels)
self.assertEqual(markerSymbol.sizeUnit(), QgsUnitTypes.RenderPixels)
# all layers should have size unit set
self.assertEqual(markerSymbol.symbolLayer(0).sizeUnit(), QgsUnitTypes.RenderPixels)
self.assertEqual(markerSymbol.symbolLayer(1).sizeUnit(), QgsUnitTypes.RenderPixels)
self.assertEqual(markerSymbol.symbolLayer(2).sizeUnit(), QgsUnitTypes.RenderPixels)
def testRingFilter(self):
# test filtering rings during rendering
s = QgsFillSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.FirstVertex)
marker = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line.clone())
self.assertEqual(
s.symbolLayer(0).ringFilter(), QgsLineSymbolLayer.AllRings)
s.symbolLayer(0).setRingFilter(QgsLineSymbolLayer.ExteriorRingOnly)
self.assertEqual(
s.symbolLayer(0).ringFilter(), QgsLineSymbolLayer.ExteriorRingOnly)
s2 = s.clone()
self.assertEqual(
s2.symbolLayer(0).ringFilter(),
QgsLineSymbolLayer.ExteriorRingOnly)
doc = QDomDocument()
context = QgsReadWriteContext()
element = QgsSymbolLayerUtils.saveSymbol('test', s, doc, context)
s2 = QgsSymbolLayerUtils.loadSymbol(element, context)
self.assertEqual(
s2.symbolLayer(0).ringFilter(),
QgsLineSymbolLayer.ExteriorRingOnly)
# rendering test
s3 = QgsFillSymbol()
s3.deleteSymbolLayer(0)
s3.appendSymbolLayer(QgsMarkerLineSymbolLayer())
s3.symbolLayer(0).setRingFilter(QgsLineSymbolLayer.ExteriorRingOnly)
s3.symbolLayer(0).setAverageAngleLength(0)
g = QgsGeometry.fromWkt(
'Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))'
)
rendered_image = self.renderGeometry(s3, g)
assert self.imageCheck('markerline_exterioronly',
'markerline_exterioronly', rendered_image)
s3.symbolLayer(0).setRingFilter(QgsLineSymbolLayer.InteriorRingsOnly)
g = QgsGeometry.fromWkt(
'Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))'
)
rendered_image = self.renderGeometry(s3, g)
assert self.imageCheck('markerline_interioronly',
'markerline_interioronly', rendered_image)
def testSizeMapUnitScale(self):
# test sizeMapUnitScale and setSizeMapUnitScale
# create a marker symbol with a single layer
markerSymbol = QgsMarkerSymbol()
markerSymbol.deleteSymbolLayer(0)
markerSymbol.appendSymbolLayer(QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.Star, color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0), size=10))
markerSymbol.symbolLayer(0).setSizeMapUnitScale(QgsMapUnitScale(10000, 20000))
self.assertEqual(markerSymbol.sizeMapUnitScale(), QgsMapUnitScale(10000, 20000))
markerSymbol.setSizeMapUnitScale(QgsMapUnitScale(1000, 2000))
self.assertEqual(markerSymbol.sizeMapUnitScale(), QgsMapUnitScale(1000, 2000))
self.assertEqual(markerSymbol.symbolLayer(0).sizeMapUnitScale(), QgsMapUnitScale(1000, 2000))
# add additional layers
markerSymbol.appendSymbolLayer(QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.Star, color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0), size=10))
markerSymbol.appendSymbolLayer(QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.Star, color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0), size=30))
# should take first layer's map unit scale
self.assertEqual(markerSymbol.sizeMapUnitScale(), QgsMapUnitScale(1000, 2000))
markerSymbol.setSizeMapUnitScale(QgsMapUnitScale(3000, 4000))
self.assertEqual(markerSymbol.sizeMapUnitScale(), QgsMapUnitScale(3000, 4000))
# all layers should have size unit set
self.assertEqual(markerSymbol.symbolLayer(0).sizeMapUnitScale(), QgsMapUnitScale(3000, 4000))
self.assertEqual(markerSymbol.symbolLayer(1).sizeMapUnitScale(), QgsMapUnitScale(3000, 4000))
self.assertEqual(markerSymbol.symbolLayer(2).sizeMapUnitScale(), QgsMapUnitScale(3000, 4000))
def testSimpleMarkerUnitPixels(self):
symbol = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayerBase.Star,
color=QColor(255, 0, 0),
strokeColor=QColor(0, 255, 0),
size=10)
symbol.setStrokeWidth(3)
symbol.setOffset(QPointF(5, 10))
symbol.setOutputUnit(QgsUnitTypes.RenderPixels)
dom, root = self.symbolToSld(symbol)
# print("Marker unit mm: " + root.ownerDocument().toString())
# Check the size has not been rescaled
self.assertStaticSize(root, '10')
# Check the same happened to the stroke width
self.assertStrokeWidth(root, 2, 3)
self.assertStaticDisplacement(root, 5, 10)
def testSimpleMarkerUnitPixels(self):
symbol = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayerBase.Star, color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0), size=10)
symbol.setStrokeWidth(3)
symbol.setOffset(QPointF(5, 10))
symbol.setOutputUnit(QgsUnitTypes.RenderPixels)
dom, root = self.symbolToSld(symbol)
# print("Marker unit mm: " + root.ownerDocument().toString())
# Check the size has not been rescaled
self.assertStaticSize(root, '10')
# Check the same happened to the stroke width
self.assertStrokeWidth(root, 2, 3)
self.assertStaticDisplacement(root, 5, 10)
def testForceRHR(self):
# test forcing right hand rule during rendering
s = QgsFillSymbol()
s.deleteSymbolLayer(0)
s.appendSymbolLayer(
QgsSimpleFillSymbolLayer(color=QColor(255, 0, 0),
strokeColor=QColor(0, 255, 0)))
self.assertFalse(s.forceRHR())
s.setForceRHR(True)
self.assertTrue(s.forceRHR())
s.setForceRHR(False)
self.assertFalse(s.forceRHR())
s.setForceRHR(True)
doc = QDomDocument()
context = QgsReadWriteContext()
element = QgsSymbolLayerUtils.saveSymbol('test', s, doc, context)
s2 = QgsSymbolLayerUtils.loadSymbol(element, context)
self.assertTrue(s2.forceRHR())
# rendering test
s3 = QgsFillSymbol()
s3.deleteSymbolLayer(0)
s3.appendSymbolLayer(
QgsSimpleFillSymbolLayer(color=QColor(255, 200, 200),
strokeColor=QColor(0, 255, 0),
strokeWidth=2))
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.FirstVertex)
marker = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
s3.appendSymbolLayer(marker_line)
g = QgsGeometry.fromWkt(
'Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))'
)
rendered_image = self.renderGeometry(s3, g)
assert self.imageCheck('force_rhr_off', 'polygon_forcerhr_off',
rendered_image)
s3.setForceRHR(True)
rendered_image = self.renderGeometry(s3, g)
assert self.imageCheck('force_rhr_on', 'polygon_forcerhr_on',
rendered_image)
def testSimpleMarkerUnitDefault(self):
symbol = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayerBase.Star, color=QColor(255, 0, 0), strokeColor=QColor(0, 255, 0), size=10)
symbol.setStrokeWidth(3)
symbol.setOffset(QPointF(5, 10))
dom, root = self.symbolToSld(symbol)
# print("Simple marker unit mm: " + root.ownerDocument().toString())
# Check the size has been rescaled to pixels
self.assertStaticSize(root, '36')
# Check the same happened to the stroke width
self.assertStrokeWidth(root, 2, 11)
self.assertStaticDisplacement(root, 18, 36)
def testMultiplePlacements(self):
line_symbol = QgsLineSymbol()
line_symbol.deleteSymbolLayer(0)
line_symbol.appendSymbolLayer(
QgsMarkerLineSymbolLayer())
line_symbol[0].setPlacements(Qgis.MarkerLinePlacements(Qgis.MarkerLinePlacement.FirstVertex | Qgis.MarkerLinePlacement.LastVertex))
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
line_symbol[0].setSubSymbol(marker_symbol)
g = QgsGeometry.fromWkt('LineString(0 0, 10 0, 10 10, 0 10)')
rendered_image = self.renderGeometry(line_symbol, g)
assert self.imageCheck('markerline_multiple_placement', 'markerline_multiple_placement', rendered_image)
def testInnerVerticesPolygon(self):
fill_symbol = QgsFillSymbol()
fill_symbol.deleteSymbolLayer(0)
fill_symbol.appendSymbolLayer(
QgsMarkerLineSymbolLayer())
fill_symbol[0].setPlacements(Qgis.MarkerLinePlacements(Qgis.MarkerLinePlacement.InnerVertices))
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
fill_symbol[0].setSubSymbol(marker_symbol)
g = QgsGeometry.fromWkt('Polygon((0 0, 10 0, 10 10, 0 10, 0 0))')
rendered_image = self.renderGeometry(fill_symbol, g)
assert self.imageCheck('markerline_inner_vertices_polygon', 'markerline_inner_vertices_polygon', rendered_image)
def setStyleLayer(self, layer):
if self.dlg.checkBox_mask.isChecked(): # only border
if layer.geometryType(
) == QgsWkbTypes.PolygonGeometry or layer.geometryType(
) == QgsWkbTypes.LineGeometry:
properties = {
'color': self.mColor.name(),
'outline_width': '0.6'
}
symbol_layer = QgsSimpleLineSymbolLayer.create(properties)
layer.renderer().symbols(
QgsRenderContext())[0].changeSymbolLayer(0, symbol_layer)
elif layer.geometryType() == QgsWkbTypes.PointGeometry:
properties = {
'size': '2',
'color': self.mColor.name(),
'outline_color': self.mColor.name(),
'outline_width': '0.6'
}
symbol_layer = QgsSimpleMarkerSymbolLayer.create(properties)
layer.renderer().symbols(
QgsRenderContext())[0].changeSymbolLayer(0, symbol_layer)
else:
if self.colorIndex > (len(self.colorValues) - 1):
self.colorIndex = 0
color = QColor(self.colorValues[self.colorIndex])
self.colorIndex += 1
if layer.geometryType() == QgsWkbTypes.PolygonGeometry:
layer.renderer().symbols(
QgsRenderContext())[0].symbolLayer(0).setStrokeWidth(0.4)
layer.renderer().symbols(
QgsRenderContext())[0].symbolLayer(0).setBrushStyle(
Qt.Dense4Pattern)
layer.renderer().symbols(
QgsRenderContext())[0].symbolLayer(0).setFillColor(color)
layer.setFeatureBlendMode(13)
self.iface.layerTreeView().refreshLayerSymbology(layer.id())
def testFirstLastVertexRespectMultipart(self):
line_symbol = QgsLineSymbol()
line_symbol.deleteSymbolLayer(0)
line_symbol.appendSymbolLayer(
QgsMarkerLineSymbolLayer())
line_symbol[0].setPlacements(Qgis.MarkerLinePlacements(Qgis.MarkerLinePlacement.FirstVertex | Qgis.MarkerLinePlacement.LastVertex))
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
line_symbol[0].setSubSymbol(marker_symbol)
line_symbol[0].setPlaceOnEveryPart(False)
g = QgsGeometry.fromWkt('MultiLineString((0 0, 10 0, 10 10, 0 10),(3 3, 7 3, 7 7, 3 7))')
rendered_image = self.renderGeometry(line_symbol, g)
assert self.imageCheck('markerline_first_last_respect_multipart', 'markerline_first_last_respect_multipart', rendered_image)
def testCenterSegment(self):
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsTemplatedLineSymbolLayerBase.SegmentCenter)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
line_symbol = QgsLineSymbol()
line_symbol.changeSymbolLayer(0, marker_line)
s.appendSymbolLayer(marker_line.clone())
g = QgsGeometry.fromWkt('LineString(0 0, 10 0, 0 10)')
rendered_image = self.renderGeometry(s, g)
assert self.imageCheck('markerline_segmentcenter', 'markerline_segmentcenter', rendered_image)
def testCompoundCurveInnerVertices(self):
# test rendering compound curve with markers at inner vertices and curve points
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.InnerVertices)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line.clone())
# rendering test
g = QgsGeometry.fromWkt('CompoundCurve (CircularString (2606642.3863534671254456 1228883.61571401031687856, 2606656.45901552261784673 1228882.30281259422190487, 2606652.60236761253327131 1228873.80998155777342618, 2606643.65822671446949244 1228875.45110832806676626, 2606642.3863534671254456 1228883.65674217976629734))')
self.assertFalse(g.isNull())
rendered_image = self.renderGeometry(s, g)
self.assertTrue(self.imageCheck('markerline_compoundcurve_inner_vertices', 'markerline_compoundcurve_inner_vertices', rendered_image))
def testNoPoint(self):
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsTemplatedLineSymbolLayerBase.Interval)
marker_line.setOffsetAlongLine(1000)
marker_line.setIntervalUnit(QgsUnitTypes.RenderMapUnits)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Circle, 4)
marker.setColor(QColor(255, 0, 0, 100))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
line_symbol = QgsLineSymbol()
line_symbol.changeSymbolLayer(0, marker_line)
s.appendSymbolLayer(marker_line.clone())
g = QgsGeometry.fromWkt('LineString(0 0, 0 10, 10 10)')
rendered_image = self.renderGeometry(s, g)
assert self.imageCheck('markerline_none', 'markerline_none', rendered_image)
def testMarkerAverageAngleRing(self):
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsTemplatedLineSymbolLayerBase.Interval)
marker_line.setInterval(6)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
marker_line.setAverageAngleLength(60)
line_symbol = QgsLineSymbol()
line_symbol.changeSymbolLayer(0, marker_line)
s.appendSymbolLayer(marker_line.clone())
g = QgsGeometry.fromWkt('LineString(0 0, 0 10, 10 10, 10 0, 0 0)')
rendered_image = self.renderGeometry(s, g)
assert self.imageCheck('markerline_ring_average_angle', 'markerline_ring_average_angle', rendered_image)
def append_SimpleMarkerSymbolLayer(symbol, layer):
"""
Appends a SimpleMarkerSymbolLayer to a symbol
"""
marker_type = marker_type_to_qgis_type(layer.type)
size = points_to_mm(layer.size)
out = QgsSimpleMarkerSymbolLayer(marker_type, size)
color = symbol_color_to_qcolor(layer.color)
if marker_type in ('circle', 'square', 'diamond'):
out.setColor(color)
else:
out.setStrokeColor(color)
out.setEnabled(layer.enabled)
out.setLocked(layer.locked)
out.setOffset(
QPointF(points_to_mm(layer.x_offset), points_to_mm(layer.y_offset)))
if layer.outline_enabled:
outline_color = symbol_color_to_qcolor(layer.outline_color)
if marker_type in ('circle', 'square', 'diamond'):
out.setStrokeColor(outline_color)
out.setStrokeWidth(points_to_mm(layer.outline_width))
else:
# for stroke-only symbols, we need to add the outline as an additional
# symbol layer
outline_layer = QgsSimpleMarkerSymbolLayer(marker_type, size)
outline_layer.setStrokeColor(outline_color)
outline_layer.setStrokeWidth(points_to_mm(layer.outline_width))
symbol.appendSymbolLayer(outline_layer)
symbol.appendSymbolLayer(out)
def append_SimpleMarkerSymbolLayer(symbol, layer: SimpleMarkerSymbolLayer,
context: Context):
"""
Appends a SimpleMarkerSymbolLayer to a symbol
"""
marker_type = marker_type_to_qgis_type(layer.type)
out = QgsSimpleMarkerSymbolLayer(marker_type,
context.convert_size(layer.size))
out.setSizeUnit(context.units)
color = symbol_color_to_qcolor(layer.color)
stroke_only_symbol = layer.type not in ('circle', 'square', 'diamond')
if not stroke_only_symbol:
out.setColor(color)
else:
out.setStrokeColor(color)
out.setEnabled(layer.enabled)
out.setLocked(layer.locked)
out.setOffset(
QPointF(context.convert_size(layer.x_offset),
-context.convert_size(layer.y_offset)))
out.setOffsetUnit(context.units)
if layer.outline_enabled:
outline_color = symbol_color_to_qcolor(layer.outline_color)
if not stroke_only_symbol:
out.setStrokeColor(outline_color)
if not layer.color.is_null:
# Better match to how ESRI renders this if we divide the outline width by 2,
# because ESRI renders the stroke below the symbol. Maybe we should split this
# into two layers?
out.setStrokeWidth(
context.convert_size(layer.outline_width / 2))
else:
out.setStrokeWidth(context.convert_size(layer.outline_width))
out.setStrokeWidthUnit(context.units)
else:
# for stroke-only symbols, we need to add the outline as an additional
# symbol layer
outline_layer = QgsSimpleMarkerSymbolLayer(
marker_type, context.convert_size(layer.size))
outline_layer.setSizeUnit(context.units)
outline_layer.setStrokeColor(outline_color)
outline_layer.setStrokeWidth(
context.convert_size(layer.outline_width))
outline_layer.setStrokeWidthUnit(context.units)
symbol.appendSymbolLayer(outline_layer)
elif not stroke_only_symbol:
out.setStrokeStyle(Qt.NoPen)
symbol.appendSymbolLayer(out)
def testRenderMarkerLayerDataDefined(self):
""" test that rendering a marker symbol with data defined enabled layer works"""
points_shp = os.path.join(TEST_DATA_DIR, 'points.shp')
points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr')
QgsProject.instance().addMapLayer(points_layer)
layer = QgsSimpleMarkerSymbolLayer()
layer.setDataDefinedProperty(
QgsSymbolLayer.PropertyLayerEnabled,
QgsProperty.fromExpression("Class='Biplane'"))
layer.setColor(QColor(100, 150, 150))
layer.setSize(5)
layer.setStrokeStyle(Qt.NoPen)
symbol = QgsMarkerSymbol()
symbol.changeSymbolLayer(0, layer)
points_layer.setRenderer(QgsSingleSymbolRenderer(symbol))
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-133, 22, -70, 52))
ms.setLayers([points_layer])
# Test usedAttributes
ctx = QgsRenderContext.fromMapSettings(ms)
ctx.expressionContext().appendScope(
points_layer.createExpressionContextScope())
# for symbol layer
self.assertCountEqual(layer.usedAttributes(ctx), {'Class'})
# for symbol
self.assertCountEqual(symbol.usedAttributes(ctx), {'Class'})
# for symbol renderer
self.assertCountEqual(points_layer.renderer().usedAttributes(ctx),
{'Class'})
# Test rendering
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(ms)
renderchecker.setControlPathPrefix('symbol_layer')
renderchecker.setControlName('expected_markerlayer_ddenabled')
self.assertTrue(renderchecker.runTest('markerlayer_ddenabled'))
QgsProject.instance().removeMapLayer(points_layer)
def append_SimpleMarkerSymbolLayer(symbol, layer: SimpleMarkerSymbolLayer):
"""
Appends a SimpleMarkerSymbolLayer to a symbol
"""
marker_type = marker_type_to_qgis_type(layer.type)
out = QgsSimpleMarkerSymbolLayer(marker_type, layer.size)
out.setSizeUnit(QgsUnitTypes.RenderPoints)
color = symbol_color_to_qcolor(layer.color)
stroke_only_symbol = layer.type not in ('circle', 'square', 'diamond')
if not stroke_only_symbol:
out.setColor(color)
else:
out.setStrokeColor(color)
out.setEnabled(layer.enabled)
out.setLocked(layer.locked)
# TODO ArcGIS does not have the same offset/rotation linkages as QGIS does!
out.setOffset(QPointF(layer.x_offset, layer.y_offset))
out.setOffsetUnit(QgsUnitTypes.RenderPoints)
if layer.outline_enabled:
outline_color = symbol_color_to_qcolor(layer.outline_color)
if not stroke_only_symbol:
out.setStrokeColor(outline_color)
# Better match to how ESRI renders this if we divide the outline width by 2,
# because ESRI renders the stroke below the symbol. Maybe we should split this
# into two layers?
out.setStrokeWidth(layer.outline_width / 2)
out.setStrokeWidthUnit(QgsUnitTypes.RenderPoints)
else:
# for stroke-only symbols, we need to add the outline as an additional
# symbol layer
outline_layer = QgsSimpleMarkerSymbolLayer(marker_type, layer.size)
outline_layer.setSizeUnit(QgsUnitTypes.RenderPoints)
outline_layer.setStrokeColor(outline_color)
outline_layer.setStrokeWidth(layer.outline_width)
outline_layer.setStrokeWidthUnit(QgsUnitTypes.RenderPoints)
symbol.appendSymbolLayer(outline_layer)
elif not stroke_only_symbol:
out.setStrokeStyle(Qt.NoPen)
symbol.appendSymbolLayer(out)
def testMultiCurve(self):
# test rendering multi curve with markers at vertices and curve points
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.Vertex)
marker = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line.clone())
marker_line2 = QgsMarkerLineSymbolLayer(True)
marker_line2.setPlacement(QgsMarkerLineSymbolLayer.CurvePoint)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Square,
4)
marker.setColor(QColor(0, 255, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line2.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line2.clone())
# rendering test
g = QgsGeometry.fromWkt(
'MultiCurve (CompoundCurve (CircularString (2606668.74491960229352117 1228910.0701227153185755, 2606667.84593895543366671 1228899.48981202743016183, 2606678.70285907341167331 1228879.78139015776105225, 2606701.64743852475658059 1228866.43043032777495682, 2606724.96578619908541441 1228864.70617623627185822)),LineString (2606694.16802780656144023 1228913.44624055083841085, 2606716.84054400492459536 1228890.51009044284000993, 2606752.43112175865098834 1228906.59175890940241516))'
)
self.assertFalse(g.isNull())
rendered_image = self.renderGeometry(s, g)
self.assertTrue(
self.imageCheck('markerline_multicurve', 'markerline_multicurve',
rendered_image))
def createSymbolLayer(self, map: dict) -> QgsSymbolLayer:
return QgsSimpleMarkerSymbolLayer()
def testMultiSurve(self):
# test rendering multisurface with markers at vertices and curve points
s = QgsFillSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.Vertex)
marker = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line.clone())
marker_line2 = QgsMarkerLineSymbolLayer(True)
marker_line2.setPlacement(QgsMarkerLineSymbolLayer.CurvePoint)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Square,
4)
marker.setColor(QColor(0, 255, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line2.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line2.clone())
# rendering test
g = QgsGeometry.fromWkt(
'MultiSurface (CurvePolygon (CompoundCurve (CircularString (2606664.83926784340292215 1228868.83649749564938247, 2606666.84044930292293429 1228872.22980518848635256, 2606668.05855975672602654 1228875.62311288132332265, 2606674.45363963954150677 1228870.05460794945247471, 2606680.58769585331901908 1228866.00874108518473804, 2606680.7182076876051724 1228865.05165429995395243, 2606679.97864062618464231 1228864.61661485210061073, 2606671.93041084241122007 1228867.87941071065142751, 2606664.83926784340292215 1228868.79299355088733137),(2606664.83926784340292215 1228868.79299355088733137, 2606664.83926784340292215 1228868.83649749564938247))),Polygon ((2606677.23432376980781555 1228875.74241803237237036, 2606674.27243852382525802 1228874.75512295053340495, 2606675.61874999897554517 1228871.97274590120650828, 2606678.84989754017442465 1228870.35717213083989918, 2606680.64497950719669461 1228873.31905737658962607, 2606677.23432376980781555 1228875.74241803237237036)))'
)
self.assertFalse(g.isNull())
rendered_image = self.renderGeometry(s, g)
self.assertTrue(
self.imageCheck('markerline_multisurface',
'markerline_multisurface', rendered_image))
def testCurvePolygon(self):
# test rendering curve polygon with markers at vertices and curve points
s = QgsFillSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.Vertex)
marker = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line.clone())
marker_line2 = QgsMarkerLineSymbolLayer(True)
marker_line2.setPlacement(QgsMarkerLineSymbolLayer.CurvePoint)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Square,
4)
marker.setColor(QColor(0, 255, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line2.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line2.clone())
# rendering test
g = QgsGeometry.fromWkt(
'CurvePolygon (CompoundCurve (CircularString (2606711.1353147104382515 1228875.77055342611856759, 2606715.00784672703593969 1228870.79158369055949152, 2606721.16240653907880187 1228873.35022091586142778),(2606721.16240653907880187 1228873.35022091586142778, 2606711.1353147104382515 1228875.77055342611856759)))'
)
self.assertFalse(g.isNull())
rendered_image = self.renderGeometry(s, g)
self.assertTrue(
self.imageCheck('markerline_curvepolygon',
'markerline_curvepolygon', rendered_image))
def processAlgorithm(self, parameters, context, feedback):
t_file = self.parameterAsVectorLayer(
parameters,
self.FILE_TABLE,
context
)
t_troncon = self.parameterAsVectorLayer(
parameters,
self.SEGMENTS_TABLE,
context
)
t_obs = self.parameterAsVectorLayer(
parameters,
self.OBSERVATIONS_TABLE,
context
)
t_regard = self.parameterAsVectorLayer(
parameters,
self.MANHOLES_TABLE,
context
)
g_regard = self.parameterAsVectorLayer(
parameters,
self.GEOM_MANHOLES,
context
)
g_troncon = self.parameterAsVectorLayer(
parameters,
self.GEOM_SEGMENT,
context
)
g_obs = self.parameterAsVectorLayer(
parameters,
self.GEOM_OBSERVATION,
context
)
v_regard = self.parameterAsVectorLayer(
parameters,
self.VIEW_MANHOLES_GEOLOCALIZED,
context
)
# define variables
variables = context.project().customVariables()
variables['itv_rerau_t_file'] = t_file.id()
variables['itv_rerau_t_troncon'] = t_troncon.id()
variables['itv_rerau_t_obs'] = t_obs.id()
variables['itv_rerau_t_regard'] = t_regard.id()
variables['itv_rerau_g_regard'] = g_regard.id()
variables['itv_rerau_g_troncon'] = g_troncon.id()
variables['itv_rerau_g_obs'] = g_obs.id()
context.project().setCustomVariables(variables)
# define relations
relations = [
{
'id': 'fk_obs_id_file',
'name': tr('Link File - Observation'),
'referencingLayer': t_obs.id(),
'referencingField': 'id_file',
'referencedLayer': t_file.id(),
'referencedField': 'id'
}, {
'id': 'fk_regard_id_file',
'name': tr('Link File - Manhole'),
'referencingLayer': t_regard.id(),
'referencingField': 'id_file',
'referencedLayer': t_file.id(),
'referencedField': 'id'
}, {
'id': 'fk_troncon_id_file',
'name': tr('Link File - Pipe segment'),
'referencingLayer': t_troncon.id(),
'referencingField': 'id_file',
'referencedLayer': t_file.id(),
'referencedField': 'id'
}, {
'id': 'fk_obs_id_troncon',
'name': tr('Link Pipe segment - Observation'),
'referencingLayer': t_obs.id(),
'referencingField': 'id_troncon',
'referencedLayer': t_troncon.id(),
'referencedField': 'id'
}, {
'id': 'fk_regard_id_geom_regard',
'name': tr('Link Manhole inspection - Reference'),
'referencingLayer': t_regard.id(),
'referencingField': 'id_geom_regard',
'referencedLayer': g_regard.id(),
'referencedField': 'id'
}, {
'id': 'fk_troncon_id_geom_trononc',
'name': tr('Link Pipe segment inspection - Reference'),
'referencingLayer': t_troncon.id(),
'referencingField': 'id_geom_troncon',
'referencedLayer': g_troncon.id(),
'referencedField': 'id'
}
]
relation_manager = context.project().relationManager()
for rel_def in relations:
feedback.pushInfo(
'Link: {}'.format(rel_def['name'])
)
rel = QgsRelation()
rel.setId(rel_def['id'])
rel.setName(rel_def['name'])
rel.setReferencingLayer(rel_def['referencingLayer'])
rel.setReferencedLayer(rel_def['referencedLayer'])
rel.addFieldPair(
rel_def['referencingField'],
rel_def['referencedField']
)
rel.setStrength(QgsRelation.Association)
relation_manager.addRelation(rel)
feedback.pushInfo(
'Count relations {}'.format(
len(relation_manager.relations())
)
)
joins = [
{
'layer': t_obs,
'targetField': 'id_troncon',
'joinLayer': t_troncon,
'joinField': 'id',
'fieldNamesSubset': ['ack']
}, {
'layer': g_obs,
'targetField': 'id',
'joinLayer': t_obs,
'joinField': 'id',
'fieldNamesSubset': []
}
]
for j_def in joins:
layer = j_def['layer']
join = QgsVectorLayerJoinInfo()
join.setJoinFieldName(j_def['joinField'])
join.setJoinLayerId(j_def['joinLayer'].id())
join.setTargetFieldName(j_def['targetField'])
if j_def['fieldNamesSubset']:
join.setJoinFieldNamesSubset(j_def['fieldNamesSubset'])
join.setUsingMemoryCache(False)
join.setPrefix('')
join.setEditable(False)
join.setCascadedDelete(False)
join.setJoinLayer(j_def['joinLayer'])
layer.addJoin(join)
layer.updateFields()
# load styles
styles = [
{
'layer': t_file,
'namedStyles': [
{
'file': 'itv_file_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_file_actions.qml',
'type': QgsMapLayer.Actions
}
]
}, {
'layer': t_troncon,
'namedStyles': [
{
'file': 'itv_troncon_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_troncon_table.qml',
'type': QgsMapLayer.AttributeTable
}
]
}, {
'layer': t_obs,
'namedStyles': [
{
'file': 'itv_obs_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_obs_table.qml',
'type': QgsMapLayer.AttributeTable
}
]
}, {
'layer': t_regard,
'namedStyles': [
{
'file': 'itv_regard_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_regard_forms.qml',
'type': QgsMapLayer.Forms
}, {
'file': 'itv_regard_table.qml',
'type': QgsMapLayer.AttributeTable
}
]
}, {
'layer': g_regard,
'namedStyles': [
{
'file': 'itv_geom_regard_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_geom_regard_symbology.qml',
'type': QgsMapLayer.Symbology
}
]
}, {
'layer': g_troncon,
'namedStyles': [
{
'file': 'itv_geom_troncon_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_geom_troncon_symbology.qml',
'type': QgsMapLayer.Symbology
}, {
'file': 'itv_geom_troncon_actions.qml',
'type': QgsMapLayer.Actions
}
]
}, {
'layer': g_obs,
'namedStyles': [
{
'file': 'itv_geom_obs_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_geom_obs_symbology.qml',
'type': QgsMapLayer.Symbology
}
]
}, {
'layer': v_regard,
'namedStyles': [
{
'file': 'itv_view_regard_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_view_regard_symbology.qml',
'type': QgsMapLayer.Symbology
}, {
'file': 'itv_view_regard_labeling.qml',
'type': QgsMapLayer.Labeling
}
]
}
]
for style in styles:
layer = style['layer']
for n_style in style['namedStyles']:
layer.loadNamedStyle(
resources_path('styles', n_style['file']),
categories=n_style['type']
)
# layer.saveStyleToDatabase('style', 'default style', True, '')
layer.triggerRepaint()
# Creation de la symbologie g_obs
g_obs_rules = (
'BAA', 'BAB', 'BAC', 'BAD', 'BAE', 'BAF', 'BAG', 'BAH',
'BAI', 'BAJ', 'BAK', 'BAL', 'BAM', 'BAN', 'BAO', 'BAP',
'BBA', 'BBB', 'BBC', 'BBD', 'BBE', 'BBF', 'BBG', 'BBH',
'BCA', 'BCB', 'BCC', 'BDA', 'BDB', 'BDC', 'BDD', 'BDE',
'BDF', 'BDG'
)
g_obs_rule_descs = {
'BAA': 'Déformation',
'BAB': 'Fissure',
'BAC': 'Rupture/Effondrement',
'BAD': 'Elt maçonnerie',
'BAE': 'Mortier manquant',
'BAF': 'Dégradation de surface',
'BAG': 'Branchement pénétrant',
'BAH': 'Raccordement défectueux',
'BAI': 'Joint étanchéité apparent',
'BAJ': 'Déplacement d\'assemblage',
'BAK': 'Défaut de révêtement',
'BAL': 'Réparation défectueuse',
'BAM': 'Défaut soudure',
'BAN': 'Conduite poreuse',
'BAO': 'Sol visible',
'BAP': 'Trou visible',
'BBA': 'Racines',
'BBB': 'Dépots Adhérents',
'BBC': 'Dépôts',
'BBD': 'Entrée de terre',
'BBE': 'Autres obstacles',
'BBF': 'Infiltration',
'BBG': 'Exfiltration',
'BBH': 'Vermine',
'BCA': 'Raccordement',
'BCB': 'Réparation',
'BCC': 'Courbure de collecteur',
'BDA': 'Photographie générale',
'BDB': 'Remarque générale',
'BDC': 'Inspection abandonnée',
'BDD': 'Niveau d\'eau',
'BDE': 'Ecoulement dans une canlisation entrante',
'BDF': 'Atmosphère canalisation',
'BDG': 'Perte de visibilité'
}
g_obs_rootrule = QgsRuleBasedRenderer.Rule(None)
rendering_pass_idx = len(g_obs_rules)
for rule in g_obs_rules:
# get svg path
svg_path = resources_path('styles', 'img_obs', rule + '.svg')
# create svg symbol layer
svg_symbol_layer = QgsSvgMarkerSymbolLayer(svg_path)
svg_symbol_layer.setRenderingPass(rendering_pass_idx)
# create white square symbol layer for the backend
simple_symbol_layer = QgsSimpleMarkerSymbolLayer(
shape=QgsSimpleMarkerSymbolLayerBase.Circle,
size=svg_symbol_layer.size(),
color=QColor('white'),
strokeColor=QColor('white')
)
simple_symbol_layer.setRenderingPass(rendering_pass_idx)
# create marker
svg_marker = QgsMarkerSymbol()
# set the backend symbol layer
svg_marker.changeSymbolLayer(0, simple_symbol_layer)
# add svg symbol layer
svg_marker.appendSymbolLayer(svg_symbol_layer)
# create rule
svg_rule = QgsRuleBasedRenderer.Rule(
svg_marker, 0, 10000,
QgsExpression.createFieldEqualityExpression('a', rule),
rule
)
if rule in g_obs_rule_descs:
svg_rule.setLabel(g_obs_rule_descs[rule])
svg_rule.setDescription('{}: {}'.format(
rule,
g_obs_rule_descs[rule]
))
# add rule
g_obs_rootrule.appendChild(svg_rule)
rendering_pass_idx -= 1
g_obs_rootrule.appendChild(
QgsRuleBasedRenderer.Rule(
QgsMarkerSymbol.createSimple(
{
'name': 'circle',
'color': '#0000b2',
'outline_color': '#0000b2',
'size': '1'
}
),
0, 10000, 'ELSE', 'Autres'
)
)
g_obs.setRenderer(QgsRuleBasedRenderer(g_obs_rootrule))
feedback.pushInfo('Project has been setup')
return {}
def testMarkerDataDefinedAngleLine(self):
"""Test issue https://github.com/qgis/QGIS/issues/38716"""
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setRotateSymbols(True)
marker_line.setPlacement(QgsTemplatedLineSymbolLayerBase.CentralPoint)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Arrow,
10)
marker.setAngle(90)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
line_symbol = QgsLineSymbol()
line_symbol.changeSymbolLayer(0, marker_line)
s.appendSymbolLayer(marker_line.clone())
g = QgsGeometry.fromWkt('LineString(0 0, 10 10, 20 20)')
rendered_image = self.renderGeometry(s, g)
assert self.imageCheck('markerline_center_angle_dd',
'markerline_center_angle_dd', rendered_image)
# Now with DD
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setRotateSymbols(True)
marker_line.setPlacement(QgsTemplatedLineSymbolLayerBase.CentralPoint)
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Arrow,
10)
# Note: set this to a different value than the reference test (90)
marker.setAngle(30)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
# This is the same value of the reference test
marker_symbol.setDataDefinedAngle(QgsProperty.fromExpression('90'))
marker_line.setSubSymbol(marker_symbol)
line_symbol = QgsLineSymbol()
line_symbol.changeSymbolLayer(0, marker_line)
s.appendSymbolLayer(marker_line.clone())
g = QgsGeometry.fromWkt('LineString(0 0, 10 10, 20 20)')
rendered_image = self.renderGeometry(s, g)
assert self.imageCheck('markerline_center_angle_dd',
'markerline_center_angle_dd', rendered_image)
def testDataDefinedAnglePolygon(self):
# test rendering curve polygon with markers at vertices and curve points
s = QgsFillSymbol()
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.SegmentCenter)
marker = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker.setAngle(90)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line.clone())
g = QgsGeometry.fromWkt(
'Polygon (LineString (0 5, 5 0, 10 5, 5 10, 0 5))')
self.assertFalse(g.isNull())
# rendering test with non data-defined angle
rendered_image = self.renderGeometry(s, g)
self.assertTrue(
self.imageCheck('markerline_datadefinedanglepolygon',
'markerline_datadefinedanglepolygon',
rendered_image))
s = QgsFillSymbol()
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.SegmentCenter)
marker = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker.setAngle(38)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_symbol.setDataDefinedAngle(QgsProperty.fromExpression('90'))
marker_line.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line.clone())
# rendering test with data-defined angle
rendered_image = self.renderGeometry(s, g)
self.assertTrue(
self.imageCheck('markerline_datadefinedanglepolygon',
'markerline_datadefinedanglepolygon',
rendered_image))
def testDataDefinedOpacity(self):
line_shp = os.path.join(TEST_DATA_DIR, 'lines.shp')
line_layer = QgsVectorLayer(line_shp, 'Lines', 'ogr')
self.assertTrue(line_layer.isValid())
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
marker_line = QgsMarkerLineSymbolLayer(True)
marker_line.setPlacement(QgsTemplatedLineSymbolLayerBase.CentralPoint)
simple_marker = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayer.Circle, 10)
simple_marker.setColor(QColor(0, 255, 0))
simple_marker.setStrokeColor(QColor(255, 0, 0))
simple_marker.setStrokeWidth(1)
simple_marker.setDataDefinedProperty(
QgsSymbolLayer.PropertyFillColor,
QgsProperty.fromExpression("if(Name='Arterial', 'red', 'green')"))
simple_marker.setDataDefinedProperty(
QgsSymbolLayer.PropertyStrokeColor,
QgsProperty.fromExpression(
"if(Name='Arterial', 'magenta', 'blue')"))
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, simple_marker)
marker_symbol.setOpacity(0.5)
marker_line.setSubSymbol(marker_symbol)
s.appendSymbolLayer(marker_line.clone())
s.setDataDefinedProperty(
QgsSymbol.PropertyOpacity,
QgsProperty.fromExpression("if(\"Value\" = 1, 25, 50)"))
line_layer.setRenderer(QgsSingleSymbolRenderer(s))
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-118.5, 19.0, -81.4, 50.4))
ms.setLayers([line_layer])
# Test rendering
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(ms)
renderchecker.setControlPathPrefix('symbol_markerline')
renderchecker.setControlName('expected_markerline_ddopacity')
res = renderchecker.runTest('expected_markerline_ddopacity')
self.report += renderchecker.report()
self.assertTrue(res)
def testSimple(self):
s = QgsFillSymbol()
s.deleteSymbolLayer(0)
random_fill = QgsRandomMarkerFillSymbolLayer(10, seed=481523)
marker = QgsSimpleMarkerSymbolLayer(
QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
random_fill.setSubSymbol(marker_symbol)
s.appendSymbolLayer(random_fill.clone())
self.assertEqual(s.symbolLayer(0).pointCount(), 10)
self.assertEqual(s.symbolLayer(0).seed(), 481523)
s.symbolLayer(0).setPointCount(5)
s.symbolLayer(0).setSeed(42)
self.assertEqual(s.symbolLayer(0).pointCount(), 5)
self.assertEqual(s.symbolLayer(0).seed(), 42)
s2 = s.clone()
self.assertEqual(s2.symbolLayer(0).pointCount(), 5)
self.assertEqual(s2.symbolLayer(0).seed(), 42)
doc = QDomDocument()
context = QgsReadWriteContext()
element = QgsSymbolLayerUtils.saveSymbol('test', s, doc, context)
s2 = QgsSymbolLayerUtils.loadSymbol(element, context)
self.assertEqual(s2.symbolLayer(0).pointCount(), 5)
self.assertEqual(s2.symbolLayer(0).seed(), 42)
# rendering test
s3 = QgsFillSymbol()
s3.deleteSymbolLayer(0)
s3.appendSymbolLayer(random_fill.clone())
g = QgsGeometry.fromWkt(
'Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))'
)
rendered_image = self.renderGeometry(s3, g)
self.assertTrue(
self.imageCheck('randommarkerfill', 'randommarkerfill',
rendered_image))
s3.symbolLayer(0).setPointCount(3)
g = QgsGeometry.fromWkt(
'Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))'
)
rendered_image = self.renderGeometry(s3, g)
self.assertTrue(
self.imageCheck('randommarkerfill_3', 'randommarkerfill_3',
rendered_image))
s3.symbolLayer(0).setSeed(12783)
g = QgsGeometry.fromWkt(
'Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))'
)
rendered_image = self.renderGeometry(s3, g)
self.assertTrue(
self.imageCheck('randommarkerfill_seed', 'randommarkerfill_seed',
rendered_image))
# random seed
s3.symbolLayer(0).setSeed(0)
g = QgsGeometry.fromWkt(
'Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))'
)
rendered_image = self.renderGeometry(s3, g)
self.assertFalse(
self.imageCheck('randommarkerfill_seed',
'randommarkerfill_seed',
rendered_image,
expect_fail=True))
# density-based count
s3.symbolLayer(0).setSeed(1)
s3.symbolLayer(0).setCountMethod(
QgsRandomMarkerFillSymbolLayer.DensityBasedCount)
s3.symbolLayer(0).setPointCount(5)
s3.symbolLayer(0).setDensityArea(250) # 250 square millimeter
g = QgsGeometry.fromWkt(
'Polygon((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1),(8 8, 9 8, 9 9, 8 9, 8 8))'
)
rendered_image = self.renderGeometry(s3, g)
self.assertTrue(
self.imageCheck('randommarkerfill_densitybasedcount',
'randommarkerfill_densitybasedcount',
rendered_image))
def testPointsUsedAttributes(self):
points_shp = os.path.join(TEST_DATA_DIR, 'points.shp')
points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr')
QgsProject.instance().addMapLayer(points_layer)
# Create rulebased style
sym1 = QgsMarkerSymbol()
l1 = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 5)
l1.setColor(QColor(255, 0, 0))
l1.setStrokeStyle(Qt.NoPen)
l1.setDataDefinedProperty(QgsSymbolLayer.PropertyAngle, QgsProperty.fromField("Heading"))
sym1.changeSymbolLayer(0, l1)
sym2 = QgsMarkerSymbol()
l2 = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 5)
l2.setColor(QColor(0, 255, 0))
l2.setStrokeStyle(Qt.NoPen)
l2.setDataDefinedProperty(QgsSymbolLayer.PropertyAngle, QgsProperty.fromField("Heading"))
sym2.changeSymbolLayer(0, l2)
sym3 = QgsMarkerSymbol()
l3 = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 5)
l3.setColor(QColor(0, 0, 255))
l3.setStrokeStyle(Qt.NoPen)
l3.setDataDefinedProperty(QgsSymbolLayer.PropertyAngle, QgsProperty.fromField("Heading"))
sym3.changeSymbolLayer(0, l3)
r1 = QgsRuleBasedRenderer.Rule(sym1, 0, 0, '"Class" = \'B52\'')
r2 = QgsRuleBasedRenderer.Rule(sym2, 0, 0, '"Class" = \'Biplane\'')
r3 = QgsRuleBasedRenderer.Rule(sym3, 0, 0, '"Class" = \'Jet\'')
rootrule = QgsRuleBasedRenderer.Rule(None)
rootrule.appendChild(r1)
rootrule.appendChild(r2)
rootrule.appendChild(r3)
renderer = QgsRuleBasedRenderer(rootrule)
points_layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-133, 22, -70, 52))
ms.setLayers([points_layer])
ctx = QgsRenderContext.fromMapSettings(ms)
ctx.expressionContext().appendScope(points_layer.createExpressionContextScope())
# for symbol layer
self.assertCountEqual(l1.usedAttributes(ctx), {'Heading'})
# for symbol
self.assertCountEqual(sym1.usedAttributes(ctx), {'Heading'})
# for symbol renderer
self.assertCountEqual(renderer.usedAttributes(ctx), {'Class', 'Heading'})
QgsProject.instance().removeMapLayer(points_layer)
def testPointsUsedAttributes(self):
points_shp = os.path.join(TEST_DATA_DIR, 'points.shp')
points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr')
QgsProject.instance().addMapLayer(points_layer)
cats = []
sym1 = QgsMarkerSymbol()
l1 = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 5)
l1.setColor(QColor(255, 0, 0))
l1.setStrokeStyle(Qt.NoPen)
l1.setDataDefinedProperty(QgsSymbolLayer.PropertyAngle,
QgsProperty.fromField("Heading"))
sym1.changeSymbolLayer(0, l1)
cats.append(QgsRendererCategory("B52", sym1, "B52"))
sym2 = QgsMarkerSymbol()
l2 = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 5)
l2.setColor(QColor(0, 255, 0))
l2.setStrokeStyle(Qt.NoPen)
l2.setDataDefinedProperty(QgsSymbolLayer.PropertyAngle,
QgsProperty.fromField("Heading"))
sym2.changeSymbolLayer(0, l2)
cats.append(QgsRendererCategory("Biplane", sym2, "Biplane"))
sym3 = QgsMarkerSymbol()
l3 = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 5)
l3.setColor(QColor(0, 0, 255))
l3.setStrokeStyle(Qt.NoPen)
l3.setDataDefinedProperty(QgsSymbolLayer.PropertyAngle,
QgsProperty.fromField("Heading"))
sym3.changeSymbolLayer(0, l3)
cats.append(QgsRendererCategory("Jet", sym3, "Jet"))
renderer = QgsCategorizedSymbolRenderer("Class", cats)
points_layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-133, 22, -70, 52))
ms.setLayers([points_layer])
ctx = QgsRenderContext.fromMapSettings(ms)
ctx.expressionContext().appendScope(
points_layer.createExpressionContextScope())
# for symbol layer
self.assertCountEqual(l1.usedAttributes(ctx), {'Heading'})
# for symbol
self.assertCountEqual(sym1.usedAttributes(ctx), {'Heading'})
# for symbol renderer
self.assertCountEqual(renderer.usedAttributes(ctx),
{'Class', 'Heading'})
QgsProject.instance().removeMapLayer(points_layer)
