def testRenderLineLayerDataDefined(self):
""" test that rendering a line symbol with data defined enabled layer works"""
lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp')
lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr')
QgsProject.instance().addMapLayer(lines_layer)
layer = QgsSimpleLineSymbolLayer()
layer.setDataDefinedProperty(QgsSymbolLayer.PropertyLayerEnabled, QgsProperty.fromExpression("Name='Highway'"))
layer.setColor(QColor(100, 150, 150))
layer.setWidth(5)
symbol = QgsLineSymbol()
symbol.changeSymbolLayer(0, layer)
lines_layer.setRenderer(QgsSingleSymbolRenderer(symbol))
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-133, 22, -70, 52))
ms.setLayers([lines_layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(ms)
renderchecker.setControlPathPrefix('symbol_layer')
renderchecker.setControlName('expected_linelayer_ddenabled')
self.assertTrue(renderchecker.runTest('linelayer_ddenabled'))
QgsProject.instance().removeMapLayer(lines_layer)
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 testRenderNoCluster(self):
self.layer.renderer().setTolerance(1)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlPathPrefix('displacement_renderer')
renderchecker.setControlName('expected_displacement_no_cluster')
self.assertTrue(renderchecker.runTest('displacement_no_cluster'))
def renderCheck(self, mismatch=0, colortol=0, imgpath='', grpprefix=''):
"""Check rendered map canvas or existing image against control image
:mismatch: number of pixels different from control, and still valid
:colortol: maximum difference for each color component including alpha
:imgpath: existing image; if present, skips rendering canvas
:grpprefix: compare test image/rendering against different test group
"""
if not grpprefix:
grpprefix = self._TestGroupPrefix
chk = QgsMultiRenderChecker()
chk.setControlPathPrefix('expected_' + grpprefix)
chk.setControlName(self._Test)
if imgpath:
chk.setRenderedImage(imgpath)
ms = self._MapSettings # class settings
if self._TestMapSettings is not None:
ms = self._TestMapSettings # per test settings
chk.setMapSettings(ms)
chk.setColorTolerance(colortol)
# noinspection PyUnusedLocal
res = chk.runTest(self._Test, mismatch)
if PALREPORT and not res: # don't report ok checks
testname = self._TestGroup + ' . ' + self._Test
PALREPORTS[testname] = chk.report()
msg = '\nRender check failed for "{0}"'.format(self._Test)
return res, msg
def testRenderWithin(self):
self.layer.renderer().setTolerance(10)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlPathPrefix('cluster_renderer')
renderchecker.setControlName('expected_cluster_cluster')
self.assertTrue(renderchecker.runTest('expected_cluster_cluster'))
def testRenderFillLayerDataDefined(self):
""" test that rendering a fill symbol with data defined enabled layer works"""
polys_shp = os.path.join(TEST_DATA_DIR, 'polys.shp')
polys_layer = QgsVectorLayer(polys_shp, 'Polygons', 'ogr')
QgsProject.instance().addMapLayer(polys_layer)
layer = QgsSimpleFillSymbolLayer()
layer.setDataDefinedProperty("enabled", QgsDataDefined("Name='Lake'"))
layer.setBorderStyle(Qt.NoPen)
layer.setColor(QColor(100, 150, 150))
symbol = QgsFillSymbol()
symbol.changeSymbolLayer(0, layer)
polys_layer.setRenderer(QgsSingleSymbolRenderer(symbol))
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-133, 22, -70, 52))
ms.setLayers([polys_layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(ms)
renderchecker.setControlPathPrefix('symbol_layer')
renderchecker.setControlName('expected_filllayer_ddenabled')
self.assertTrue(renderchecker.runTest('filllayer_ddenabled'))
QgsProject.instance().removeMapLayer(polys_layer)
def testRenderGrid(self):
self.layer.renderer().setTolerance(10)
self.layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlPathPrefix('displacement_renderer')
renderchecker.setControlName('expected_displacement_grid')
self.assertTrue(renderchecker.runTest('expected_displacement_grid'))
def testRender(self):
# test no features are rendered
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlPathPrefix('null_renderer')
renderchecker.setControlName('expected_nullrenderer_render')
result = renderchecker.runTest('nullrenderer_render')
assert result
def testSelected(self):
# select a feature and render
self.layer.select([1, 2, 3])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlPathPrefix('null_renderer')
renderchecker.setControlName('expected_nullrenderer_selected')
result = renderchecker.runTest('nullrenderer_selected')
assert result
def testRenderWithin(self):
layer, renderer, mapsettings = self._setUp()
layer.renderer().setTolerance(10)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('displacement_renderer')
renderchecker.setControlName('expected_displacement_cluster')
res = renderchecker.runTest('expected_displacement_cluster')
self.report += renderchecker.report()
self.assertTrue(res)
self._tearDown(layer)
def checkImage(self, name, reference_image, rendered_image, size_tolerance=0):
checker = QgsMultiRenderChecker()
checker.setControlPathPrefix("layout_exporter")
checker.setControlName("expected_layoutexporter_" + reference_image)
checker.setRenderedImage(rendered_image)
checker.setColorTolerance(2)
checker.setSizeTolerance(size_tolerance, size_tolerance)
result = checker.runTest(name, 20)
self.report += checker.report()
print((self.report))
return result
def testRenderGridAdjust(self):
layer, renderer, mapsettings = self._setUp()
layer.renderer().setTolerance(10)
layer.renderer().setCircleRadiusAddition(5)
layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid)
layer.renderer().setCircleColor(QColor())
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('displacement_renderer')
renderchecker.setControlName('expected_displacement_adjust_grid')
res = renderchecker.runTest('expected_displacement_adjust_grid')
self.report += renderchecker.report()
self.assertTrue(res)
self._tearDown(layer)
def imageCheck(self, name, reference_image, image):
self.report += "<h2>Render {}</h2>\n".format(name)
temp_dir = QDir.tempPath() + '/'
file_name = temp_dir + 'annotation_' + name + ".png"
image.save(file_name, "PNG")
checker = QgsMultiRenderChecker()
checker.setControlPathPrefix("annotations")
checker.setControlName("expected_" + reference_image)
checker.setRenderedImage(file_name)
checker.setColorTolerance(2)
result = checker.runTest(name, 20)
self.report += checker.report()
print((self.report))
return result
def testClusterRingLabels(self):
layer, renderer, mapsettings = self._setUp()
layer.renderer().setTolerance(10)
layer.renderer().setLabelAttributeName('Class')
layer.renderer().setLabelDistanceFactor(0.35)
f = QgsFontUtils.getStandardTestFont('Bold', 14)
layer.renderer().setLabelFont(f)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('displacement_renderer')
renderchecker.setControlName('expected_displacement_cluster_ring_labels')
res = renderchecker.runTest('expected_displacement_cluster_ring_labels')
self.report += renderchecker.report()
self.assertTrue(res)
self._tearDown(layer)
def testClusterConcentricLabelsDifferentSizesFarther(self):
layer, renderer, mapsettings = self._setUp()
renderer.setEmbeddedRenderer(self._create_categorized_renderer())
layer.renderer().setTolerance(10)
layer.renderer().setLabelAttributeName('Class')
layer.renderer().setLabelDistanceFactor(1)
f = QgsFontUtils.getStandardTestFont('Bold', 14)
layer.renderer().setLabelFont(f)
layer.renderer().setPlacement(QgsPointDisplacementRenderer.ConcentricRings)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('displacement_renderer')
renderchecker.setControlName('expected_displacement_cluster_concentric_labels_diff_size_farther')
res = renderchecker.runTest('expected_displacement_cluster_concentric_labels_diff_size_farther')
self.report += renderchecker.report()
self.assertTrue(res)
self._tearDown(layer)
def testRenderVariables(self):
""" test rendering with expression variables in marker """
self.layer.renderer().setTolerance(10)
old_marker = self.layer.renderer().clusterSymbol().clone()
new_marker = QgsMarkerSymbol.createSimple({'color': '#ffff00', 'size': '3', 'outline_style': 'no'})
new_marker.symbolLayer(0).setDataDefinedProperty(QgsSymbolLayer.PropertyFillColor, QgsProperty.fromExpression('@cluster_color'))
new_marker.symbolLayer(0).setDataDefinedProperty(QgsSymbolLayer.PropertySize, QgsProperty.fromExpression('@cluster_size*2'))
self.layer.renderer().setClusterSymbol(new_marker)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlPathPrefix('cluster_renderer')
renderchecker.setControlName('expected_cluster_variables')
result = renderchecker.runTest('expected_cluster_variables')
self.layer.renderer().setClusterSymbol(old_marker)
self.assertTrue(result)
def testClusterConcentricLabelsDifferentSizesFarther(self):
layer, renderer, mapsettings = self._setUp()
renderer.setEmbeddedRenderer(self._create_categorized_renderer())
layer.renderer().setTolerance(10)
layer.renderer().setLabelAttributeName('Class')
layer.renderer().setLabelDistanceFactor(1)
f = QgsFontUtils.getStandardTestFont('Bold', 14)
layer.renderer().setLabelFont(f)
layer.renderer().setPlacement(
QgsPointDisplacementRenderer.ConcentricRings)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('displacement_renderer')
renderchecker.setControlName(
'expected_displacement_cluster_concentric_labels_diff_size_farther'
)
res = renderchecker.runTest(
'expected_displacement_cluster_concentric_labels_diff_size_farther'
)
self.report += renderchecker.report()
self.assertTrue(res)
self._tearDown(layer)
def testRenderVariables(self):
""" test rendering with expression variables in marker """
layer, renderer, mapsettings = self._setUp()
layer.renderer().setTolerance(10)
old_marker = layer.renderer().centerSymbol().clone()
new_marker = QgsMarkerSymbol.createSimple({'color': '#ffff00', 'size': '3', 'outline_style': 'no'})
new_marker.symbolLayer(0).setDataDefinedProperty(QgsSymbolLayer.PropertyFillColor,
QgsProperty.fromExpression('@cluster_color'))
new_marker.symbolLayer(0).setDataDefinedProperty(QgsSymbolLayer.PropertySize,
QgsProperty.fromExpression('@cluster_size*2'))
layer.renderer().setCenterSymbol(new_marker)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('displacement_renderer')
renderchecker.setControlName('expected_displacement_variables')
result = renderchecker.runTest('expected_displacement_variables')
self.report += renderchecker.report()
layer.renderer().setCenterSymbol(old_marker)
self.assertTrue(result)
self._tearDown(layer)
def testDataDefinedOpacity(self):
poly_shp = os.path.join(TEST_DATA_DIR, 'polys.shp')
poly_layer = QgsVectorLayer(poly_shp, 'Polys', 'ogr')
self.assertTrue(poly_layer.isValid())
layer = QgsSimpleFillSymbolLayer()
layer.setStrokeStyle(Qt.NoPen)
layer.setColor(QColor(200, 250, 50))
layer.setDataDefinedProperty(
QgsSymbolLayer.PropertyFillColor,
QgsProperty.fromExpression("if(Name='Dam', 'red', 'green')"))
layer.setDataDefinedProperty(
QgsSymbolLayer.PropertyStrokeColor,
QgsProperty.fromExpression("if(Name='Dam', 'magenta', 'blue')"))
symbol = QgsFillSymbol()
symbol.changeSymbolLayer(0, layer)
symbol.setDataDefinedProperty(
QgsSymbol.PropertyOpacity,
QgsProperty.fromExpression("if(\"Value\" >10, 25, 50)"))
poly_layer.setRenderer(QgsSingleSymbolRenderer(symbol))
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-118.5, 19.0, -81.4, 50.4))
ms.setLayers([poly_layer])
# Test rendering
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(ms)
renderchecker.setControlPathPrefix('symbol_simplefill')
renderchecker.setControlName('expected_simplefill_ddopacity')
res = renderchecker.runTest('expected_simplefill_ddopacity')
self.report += renderchecker.report()
self.assertTrue(res)
def test_render_paint_effect(self):
"""
Test rendering layers as a group with paint effect
"""
vl1 = QgsVectorLayer(TEST_DATA_DIR + '/lines.shp')
self.assertTrue(vl1.isValid())
vl2 = QgsVectorLayer(TEST_DATA_DIR + '/points.shp')
self.assertTrue(vl2.isValid())
options = QgsGroupLayer.LayerOptions(QgsCoordinateTransformContext())
group_layer = QgsGroupLayer('group', options)
group_layer.setChildLayers([vl2, vl1])
drop_shadow = QgsDropShadowEffect()
drop_shadow.setBlurLevel(0)
drop_shadow.setOpacity(1)
drop_shadow.setColor(QColor(255, 0, 255))
drop_shadow.setOffsetDistance(3)
effect_stack = QgsEffectStack()
effect_stack.appendEffect(drop_shadow)
effect_stack.appendEffect(QgsDrawSourceEffect())
group_layer.setPaintEffect(effect_stack)
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(600, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(group_layer.crs())
mapsettings.setExtent(group_layer.extent())
mapsettings.setLayers([group_layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('group_layer')
renderchecker.setControlName('expected_group_paint_effect')
result = renderchecker.runTest('expected_group_paint_effect')
TestQgsGroupLayer.report += renderchecker.report()
self.assertTrue(result)
def testRender(self):
layer = QgsPointCloudLayer(
unitTestDataPath() + '/point_clouds/ept/sunshine-coast/ept.json',
'test', 'ept')
self.assertTrue(layer.isValid())
renderer = QgsPointCloudExtentRenderer()
layer.setRenderer(renderer)
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(layer.crs())
mapsettings.setExtent(QgsRectangle(498061, 7050991, 498069, 7050999))
mapsettings.setLayers([layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('pointcloudrenderer')
renderchecker.setControlName('expected_extent_render')
result = renderchecker.runTest('expected_extent_render')
TestQgsPointCloudExtentRenderer.report += renderchecker.report()
self.assertTrue(result)
def testRenderBlendMode(self):
layer = QgsPointCloudLayer(unitTestDataPath() + '/point_clouds/ept/rgb/ept.json', 'test', 'ept')
self.assertTrue(layer.isValid())
layer.renderer().setPointSize(2)
layer.renderer().setPointSizeUnit(QgsUnitTypes.RenderMillimeters)
layer.setBlendMode(QPainter.CompositionMode_ColorBurn)
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(layer.crs())
mapsettings.setExtent(QgsRectangle(497753.5, 7050887.5, 497754.6, 7050888.6))
mapsettings.setLayers([layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('pointcloudrenderer')
renderchecker.setControlName('expected_blendmode')
result = renderchecker.runTest('expected_blendmode')
TestQgsPointCloudRgbRenderer.report += renderchecker.report()
self.assertTrue(result)
def testRenderVariables(self):
""" test rendering with expression variables in marker """
self.layer.renderer().setTolerance(10)
old_marker = self.layer.renderer().centerSymbol().clone()
new_marker = QgsMarkerSymbol.createSimple({
'color': '#ffff00',
'size': '3',
'outline_style': 'no'
})
new_marker.symbolLayer(0).setDataDefinedProperty(
'color', QgsDataDefined('@cluster_color'))
new_marker.symbolLayer(0).setDataDefinedProperty(
'size', QgsDataDefined('@cluster_size*2'))
self.layer.renderer().setCenterSymbol(new_marker)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlPathPrefix('displacement_renderer')
renderchecker.setControlName('expected_displacement_variables')
result = renderchecker.runTest('expected_displacement_variables')
self.layer.renderer().setCenterSymbol(old_marker)
self.assertTrue(result)
def testRenderFiltered(self):
layer = QgsPointCloudLayer(
unitTestDataPath() + '/point_clouds/ept/sunshine-coast/ept.json',
'test', 'ept')
self.assertTrue(layer.isValid())
renderer = QgsPointCloudClassifiedRenderer()
renderer.setAttribute('Classification')
layer.setRenderer(renderer)
layer.renderer().setPointSize(2)
layer.renderer().setPointSizeUnit(QgsUnitTypes.RenderMillimeters)
layer.setSubsetString('NumberOfReturns > 1')
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(layer.crs())
mapsettings.setExtent(QgsRectangle(498061, 7050991, 498069, 7050999))
mapsettings.setLayers([layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('pointcloudrenderer')
renderchecker.setControlName('expected_classified_render_filtered')
result = renderchecker.runTest('expected_classified_render_filtered')
TestQgsPointCloudClassifiedRenderer.report += renderchecker.report()
self.assertTrue(result)
layer.setSubsetString('')
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('pointcloudrenderer')
renderchecker.setControlName('expected_classified_render_unfiltered')
result = renderchecker.runTest('expected_classified_render_unfiltered')
TestQgsPointCloudClassifiedRenderer.report += renderchecker.report()
self.assertTrue(result)
def testRenderWithPainterClipRegions(self):
raster_layer = QgsRasterLayer(
os.path.join(TEST_DATA_DIR, 'rgb256x256.png'))
self.assertTrue(raster_layer.isValid())
raster_layer.setCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(
QgsCoordinateReferenceSystem('EPSG:4326'))
mapsettings.setExtent(
QgsRectangle(0.0001451, -0.0001291, 0.0021493, -0.0021306))
mapsettings.setLayers([raster_layer])
region = QgsMapClippingRegion(
QgsGeometry.fromWkt(
'Polygon ((0.00131242078273144 -0.00059281669806561, 0.00066744230712249 -0.00110186995774045, 0.00065145110524788 -0.00152830200772984, 0.00141369839460392 -0.00189076925022083, 0.00210931567614912 -0.00094195793899443, 0.00169354442740946 -0.00067810310806349, 0.00131242078273144 -0.00059281669806561))'
))
region.setFeatureClip(
QgsMapClippingRegion.FeatureClippingType.ClipPainterOnly)
region2 = QgsMapClippingRegion(
QgsGeometry.fromWkt(
'Polygon ((0.00067010750743492 -0.0007740503193111, 0.00064612070462302 -0.00151764120648011, 0.00153629760897587 -0.00158693641460339, 0.0014909892036645 -0.00063812510337699, 0.00106722235398754 -0.00055816909400397, 0.00067010750743492 -0.0007740503193111))'
))
region2.setFeatureClip(
QgsMapClippingRegion.FeatureClippingType.ClipToIntersection)
mapsettings.addClippingRegion(region)
mapsettings.addClippingRegion(region2)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('rasterlayerrenderer')
renderchecker.setControlName('expected_painterclip_region')
result = renderchecker.runTest('expected_painterclip_region')
self.report += renderchecker.report()
self.assertTrue(result)
def testRenderBottomToTop(self):
layer = QgsPointCloudLayer(
unitTestDataPath() + '/point_clouds/ept/sunshine-coast/ept.json',
'test', 'ept')
self.assertTrue(layer.isValid())
renderer = QgsPointCloudAttributeByRampRenderer()
renderer.setAttribute('Intensity')
renderer.setMinimum(200)
renderer.setMaximum(1000)
ramp = QgsStyle.defaultStyle().colorRamp("Viridis")
shader = QgsColorRampShader(200, 1000, ramp)
shader.classifyColorRamp()
renderer.setColorRampShader(shader)
layer.setRenderer(renderer)
layer.renderer().setPointSize(6)
layer.renderer().setPointSizeUnit(QgsUnitTypes.RenderMillimeters)
layer.renderer().setDrawOrder2d(
QgsPointCloudRenderer.DrawOrder.BottomToTop)
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(layer.crs())
mapsettings.setExtent(QgsRectangle(498061, 7050991, 498069, 7050999))
mapsettings.setLayers([layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('pointcloudrenderer')
renderchecker.setControlName('expected_ramp_bottom_to_top')
result = renderchecker.runTest('expected_ramp_bottom_to_top')
TestQgsPointCloudAttributeByRampRenderer.report += renderchecker.report(
)
self.assertTrue(result)
def testRenderCrsTransform(self):
layer = QgsPointCloudLayer(
unitTestDataPath() + '/point_clouds/ept/sunshine-coast/ept.json',
'test', 'ept')
self.assertTrue(layer.isValid())
renderer = QgsPointCloudAttributeByRampRenderer()
renderer.setAttribute('Intensity')
renderer.setMinimum(200)
renderer.setMaximum(1000)
ramp = QgsStyle.defaultStyle().colorRamp("Viridis")
shader = QgsColorRampShader(200, 1000, ramp)
shader.classifyColorRamp()
renderer.setColorRampShader(shader)
layer.setRenderer(renderer)
layer.renderer().setPointSize(2)
layer.renderer().setPointSizeUnit(QgsUnitTypes.RenderMillimeters)
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(
QgsCoordinateReferenceSystem('EPSG:4326'))
mapsettings.setExtent(
QgsRectangle(152.980508492, -26.662023491, 152.980586020,
-26.662071137))
mapsettings.setLayers([layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('pointcloudrenderer')
renderchecker.setControlName('expected_ramp_render_crs_transform')
result = renderchecker.runTest('expected_ramp_render_crs_transform')
TestQgsPointCloudAttributeByRampRenderer.report += renderchecker.report(
)
self.assertTrue(result)
def testRenderCrsTransform(self):
layer = QgsPointCloudLayer(unitTestDataPath() + '/point_clouds/ept/sunshine-coast/ept.json', 'test', 'ept')
self.assertTrue(layer.isValid())
categories = QgsPointCloudRendererRegistry.classificationAttributeCategories(layer)
renderer = QgsPointCloudClassifiedRenderer('Classification', categories)
layer.setRenderer(renderer)
layer.renderer().setPointSize(2)
layer.renderer().setPointSizeUnit(QgsUnitTypes.RenderMillimeters)
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
mapsettings.setExtent(QgsRectangle(152.980508492, -26.662023491, 152.980586020, -26.662071137))
mapsettings.setLayers([layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('pointcloudrenderer')
renderchecker.setControlName('expected_classified_render_crs_transform')
result = renderchecker.runTest('expected_classified_render_crs_transform')
TestQgsPointCloudClassifiedRenderer.report += renderchecker.report()
self.assertTrue(result)
def test_reference_scale(self):
"""
Test rendering a layer with a reference scale set
"""
layer = QgsVectorLayer(os.path.join(TEST_DATA_DIR, 'lines.shp'), 'Lines', 'ogr')
self.assertTrue(layer.isValid())
sym1 = QgsLineSymbol.createSimple({'line_color': '#4dbf6f', 'line_width': 4, 'line_width_unit': "points"})
renderer = QgsSingleSymbolRenderer(sym1)
layer.setRenderer(renderer)
mapsettings = QgsMapSettings()
mapsettings.setDestinationCrs(layer.crs())
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setExtent(layer.extent())
mapsettings.setLayers([layer])
self.assertAlmostEqual(mapsettings.scale(), 22738556, -5)
# Setup rendering check
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('vectorlayerrenderer')
renderchecker.setControlName('expected_reference_scale_not_set')
result = renderchecker.runTest('expected_reference_scale_not_set')
self.report += renderchecker.report()
self.assertTrue(result)
# Set the reference scale as half the map scale -- the lines should be double as wide
# as their preset width
renderer.setReferenceScale(22738556 * 2)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('vectorlayerrenderer')
renderchecker.setControlName('expected_reference_scale_double')
result = renderchecker.runTest('expected_reference_scale_double')
self.report += renderchecker.report()
self.assertTrue(result)
# Set the reference scale as double the map scale -- the lines should be half as wide
# as their preset width
renderer.setReferenceScale(22738556 / 2)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('vectorlayerrenderer')
renderchecker.setControlName('expected_reference_scale_half')
result = renderchecker.runTest('expected_reference_scale_half')
self.report += renderchecker.report()
self.assertTrue(result)
def testRenderMultipleRenderersSelection(self):
"""
Test that selection colors only apply to main renderer
:return:
"""
poly_layer = QgsVectorLayer(os.path.join(TEST_DATA_DIR, 'polys.shp'))
self.assertTrue(poly_layer.isValid())
poly_layer.selectAll()
sym1 = QgsFillSymbol.createSimple({'color': '#ffaaff', 'outline_color': '#000000', 'outline_style': 'no'})
renderer = QgsSingleSymbolRenderer(sym1)
poly_layer.setRenderer(renderer)
# add secondary renderer, for rendering below
class Gen1(QgsFeatureRendererGenerator):
def id(self):
return 'Gen1'
def level(self):
return -2
def createRenderer(self):
renderer = QgsCategorizedSymbolRenderer()
renderer.setClassAttribute('Name')
sym1 = QgsFillSymbol.createSimple(
{'color': '#ffaaff', 'outline_color': '#33aa33', 'outline_width': '3'})
sym2 = QgsFillSymbol.createSimple(
{'color': '#ffaaff', 'outline_color': '#aa33aa', 'outline_width': '3'})
renderer.addCategory(QgsRendererCategory('Dam', sym1, 'Dam'))
renderer.addCategory(QgsRendererCategory('Lake', sym2, 'Lake'))
return renderer
poly_layer.addFeatureRendererGenerator(Gen1())
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
mapsettings.setExtent(QgsRectangle(-13875783.2, 2266009.4, -8690110.7, 6673344.5))
mapsettings.setLayers([poly_layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('vectorlayerrenderer')
renderchecker.setControlName('expected_multiple_renderers_selection')
result = renderchecker.runTest('expected_multiple_renderers_selection')
self.report += renderchecker.report()
self.assertTrue(result)
# also try with symbol levels
renderer.setUsingSymbolLevels(True)
poly_layer.setRenderer(renderer)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('vectorlayerrenderer')
renderchecker.setControlName('expected_multiple_renderers_selection')
result = renderchecker.runTest('expected_multiple_renderers_selection')
self.report += renderchecker.report()
self.assertTrue(result)
def testRenderMultipleRenderersAboveAndBelow(self):
poly_layer = QgsVectorLayer(os.path.join(TEST_DATA_DIR, 'polys.shp'))
self.assertTrue(poly_layer.isValid())
sym1 = QgsFillSymbol.createSimple({'color': '#ffaaff', 'outline_color': '#000000', 'outline_width': '1'})
renderer = QgsSingleSymbolRenderer(sym1)
poly_layer.setRenderer(renderer)
# add secondary renderer, for rendering below
class Gen1(QgsFeatureRendererGenerator):
def id(self):
return 'Gen1'
def level(self):
return 3
def createRenderer(self):
renderer = QgsCategorizedSymbolRenderer()
renderer.setClassAttribute('Name')
cf1 = QgsCentroidFillSymbolLayer()
cf1.setSubSymbol(QgsMarkerSymbol.createSimple(
{'color': '#33aa33', 'outline_style': 'no', 'size': '5'}))
sym1 = QgsFillSymbol([cf1])
cf2 = QgsCentroidFillSymbolLayer()
cf2.setSubSymbol(QgsMarkerSymbol.createSimple(
{'color': '#aa33aa', 'outline_style': 'no', 'size': '5'}))
sym2 = QgsFillSymbol([cf2])
renderer.addCategory(QgsRendererCategory('Dam', sym1, 'Dam'))
renderer.addCategory(QgsRendererCategory('Lake', sym2, 'Lake'))
return renderer
# add secondary renderer, for rendering below
class Gen2(QgsFeatureRendererGenerator):
def id(self):
return 'Gen2'
def level(self):
return 2
def createRenderer(self):
renderer = QgsCategorizedSymbolRenderer()
renderer.setClassAttribute('Value < 12')
cf1 = QgsCentroidFillSymbolLayer()
cf1.setSubSymbol(QgsMarkerSymbol.createSimple(
{'color': '#aa1111', 'outline_style': 'no', 'size': '8'}))
sym1 = QgsFillSymbol([cf1])
cf2 = QgsCentroidFillSymbolLayer()
cf2.setSubSymbol(QgsMarkerSymbol.createSimple(
{'color': '#1111dd', 'outline_style': 'no', 'size': '8'}))
sym2 = QgsFillSymbol([cf2])
renderer.addCategory(QgsRendererCategory('1', sym1, '1'))
renderer.addCategory(QgsRendererCategory('0', sym2, '0'))
return renderer
# add secondary renderer, for rendering below
class Gen1b(QgsFeatureRendererGenerator):
def id(self):
return 'Gen1b'
def level(self):
return -2
def createRenderer(self):
renderer = QgsCategorizedSymbolRenderer()
renderer.setClassAttribute('Name')
sym1 = QgsFillSymbol.createSimple(
{'color': '#ffaaff', 'outline_color': '#33aa33', 'outline_width': '3'})
sym2 = QgsFillSymbol.createSimple(
{'color': '#ffaaff', 'outline_color': '#aa33aa', 'outline_width': '3'})
renderer.addCategory(QgsRendererCategory('Dam', sym1, 'Dam'))
renderer.addCategory(QgsRendererCategory('Lake', sym2, 'Lake'))
return renderer
# add secondary renderer, for rendering below
class Gen2b(QgsFeatureRendererGenerator):
def id(self):
return 'Gen2b'
def level(self):
return -3
def createRenderer(self):
renderer = QgsCategorizedSymbolRenderer()
renderer.setClassAttribute('Value < 12')
sym1 = QgsFillSymbol.createSimple(
{'color': '#ffaaff', 'outline_color': '#aa1111', 'outline_width': '5'})
sym2 = QgsFillSymbol.createSimple(
{'color': '#ffaaff', 'outline_color': '#1111dd', 'outline_width': '5'})
renderer.addCategory(QgsRendererCategory('1', sym1, '1'))
renderer.addCategory(QgsRendererCategory('0', sym2, '0'))
return renderer
poly_layer.addFeatureRendererGenerator(Gen1())
poly_layer.addFeatureRendererGenerator(Gen2())
poly_layer.addFeatureRendererGenerator(Gen1b())
poly_layer.addFeatureRendererGenerator(Gen2b())
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
mapsettings.setExtent(QgsRectangle(-13875783.2, 2266009.4, -8690110.7, 6673344.5))
mapsettings.setLayers([poly_layer])
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('vectorlayerrenderer')
renderchecker.setControlName('expected_multiple_renderers_both_above_below')
result = renderchecker.runTest('expected_multiple_renderers_both_above_below')
self.report += renderchecker.report()
self.assertTrue(result)
# also try with symbol levels
renderer.setUsingSymbolLevels(True)
poly_layer.setRenderer(renderer)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('vectorlayerrenderer')
renderchecker.setControlName('expected_multiple_renderers_both_above_below')
result = renderchecker.runTest('expected_multiple_renderers_both_above_below')
self.report += renderchecker.report()
self.assertTrue(result)
def testIntersectionRuleBased(self):
"""
Test that rule based renderer using intersection clip paths correctly uses original feature area for rule
evaluation, not clipped area
"""
poly_layer = QgsVectorLayer(os.path.join(TEST_DATA_DIR, 'polys.shp'))
self.assertTrue(poly_layer.isValid())
sym1 = QgsFillSymbol.createSimple({
'color': '#ff00ff',
'outline_color': '#000000',
'outline_width': '1'
})
sym2 = QgsFillSymbol.createSimple({
'color': '#00ffff',
'outline_color': '#000000',
'outline_width': '1'
})
r1 = QgsRuleBasedRenderer.Rule(sym1, 0, 0, 'area($geometry)>25')
r2 = QgsRuleBasedRenderer.Rule(sym2, 0, 0, 'ELSE')
rootrule = QgsRuleBasedRenderer.Rule(None)
rootrule.appendChild(r1)
rootrule.appendChild(r2)
renderer = QgsRuleBasedRenderer(rootrule)
poly_layer.setRenderer(renderer)
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setDestinationCrs(
QgsCoordinateReferenceSystem('EPSG:3857'))
mapsettings.setExtent(
QgsRectangle(-13875783.2, 2266009.4, -8690110.7, 6673344.5))
mapsettings.setLayers([poly_layer])
mapsettings.setEllipsoid('')
region = QgsMapClippingRegion(
QgsGeometry.fromWkt(
'Polygon ((-11725957 5368254, -12222900 4807501, -12246014 3834025, -12014878 3496059, -11259833 3518307, -10751333 3621153, -10574129 4516741, -10847640 5194995, -11105742 5325957, -11725957 5368254))'
))
region.setFeatureClip(
QgsMapClippingRegion.FeatureClippingType.ClipToIntersection)
region2 = QgsMapClippingRegion(
QgsGeometry.fromWkt(
'Polygon ((-11032549 5421399, -11533344 4693167, -11086481 4229112, -11167378 3742984, -10616504 3553984, -10161936 3925771, -9618766 4668482, -9472380 5620753, -10115709 5965063, -11032549 5421399))'
))
region2.setFeatureClip(
QgsMapClippingRegion.FeatureClippingType.ClipToIntersection)
mapsettings.addClippingRegion(region)
mapsettings.addClippingRegion(region2)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('vectorlayerrenderer')
renderchecker.setControlName('expected_intersection_rule_based')
result = renderchecker.runTest('expected_intersection_rule_based')
self.report += renderchecker.report()
self.assertTrue(result)
# also try with symbol levels
renderer.setUsingSymbolLevels(True)
poly_layer.setRenderer(renderer)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('vectorlayerrenderer')
renderchecker.setControlName('expected_intersection_rule_based')
result = renderchecker.runTest('expected_intersection_rule_based')
self.report += renderchecker.report()
self.assertTrue(result)
def testMultiPoint(self):
"""
Test multipoint handling
"""
layer = QgsVectorLayer('Multipoint?field=cat:string', '', 'memory')
self.assertTrue(layer.isValid())
f = QgsFeature(layer.fields())
f.setAttributes(['a'])
f.setGeometry(QgsGeometry.fromWkt('MultiPoint(5 5, 5 6, 9 9)'))
layer.dataProvider().addFeature(f)
f.setAttributes(['b'])
f.setGeometry(QgsGeometry.fromWkt('MultiPoint(2 1, 2 2, 5 5)'))
layer.dataProvider().addFeature(f)
f.setAttributes(['c'])
f.setGeometry(QgsGeometry.fromWkt('MultiPoint(9 1)'))
layer.dataProvider().addFeature(f)
renderer = QgsPointDisplacementRenderer()
sym1 = QgsMarkerSymbol.createSimple({
'color': '#ff00ff',
'size': '3',
'outline_style': 'no'
})
sym_renderer = QgsCategorizedSymbolRenderer()
sym_renderer.setClassAttribute('cat')
sym1.setColor(QColor(255, 0, 0))
sym_renderer.addCategory(QgsRendererCategory('a', sym1.clone(), 'a'))
sym1.setColor(QColor(0, 255, 0))
sym_renderer.addCategory(QgsRendererCategory('b', sym1.clone(), 'b'))
sym1.setColor(QColor(0, 0, 255))
sym_renderer.addCategory(QgsRendererCategory('c', sym1.clone(), 'c'))
renderer.setEmbeddedRenderer(sym_renderer)
renderer.setCircleRadiusAddition(2)
renderer.setCircleWidth(1)
renderer.setCircleColor(QColor(0, 0, 0))
renderer.setCenterSymbol(
QgsMarkerSymbol.createSimple({
'color': '#ffff00',
'size': '3',
'outline_style': 'no'
}))
renderer.setToleranceUnit(QgsUnitTypes.RenderMapUnits)
renderer.setTolerance(2)
layer.setRenderer(renderer)
rendered_layers = [layer]
mapsettings = QgsMapSettings()
mapsettings.setOutputSize(QSize(400, 400))
mapsettings.setOutputDpi(96)
mapsettings.setExtent(QgsRectangle(0, 0, 10, 10))
mapsettings.setLayers(rendered_layers)
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(mapsettings)
renderchecker.setControlPathPrefix('displacement_renderer')
renderchecker.setControlName('expected_displacement_multipoint')
result = renderchecker.runTest('expected_displacement_multipoint')
self.report += renderchecker.report()
self.assertTrue(result)