def _create_categorized_renderer(self):
cat_renderer = QgsCategorizedSymbolRenderer(attrName='Class')
sym1 = QgsMarkerSymbol.createSimple({'color': '#ff00ff', 'size': '6', 'outline_style': 'no'})
cat1 = QgsRendererCategory('Biplane', sym1, 'Big')
cat_renderer.addCategory(cat1)
sym2 = QgsMarkerSymbol.createSimple({'color': '#ff00ff', 'size': '3', 'outline_style': 'no'})
cat2 = QgsRendererCategory(['B52', 'Jet'], sym2, 'Smaller')
cat_renderer.addCategory(cat2)
return cat_renderer
def legend_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer("Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)", "points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPoint(QgsPointXY(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPoint(QgsPointXY(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRenderer("attr", [QgsRendererCategory(1, QgsMarkerSymbol.createSimple({"color": "255,0,0"}), "red"),
QgsRendererCategory(2, QgsMarkerSymbol.createSimple({"color": "0,0,255"}), "blue")])
ptLayer.setRenderer(r)
QgsProject.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.layers
layers = [ptLayer] + layers
self.mAtlasMap.setLayers(layers)
self.mOverview.setLayers(layers)
# add a legend
legend = QgsComposerLegend(self.mComposition)
legend.moveBy(200, 100)
# sets the legend filter parameter
legend.setComposerMap(self.mAtlasMap)
legend.setLegendFilterOutAtlas(True)
self.mComposition.addComposerLegend(legend)
self.mAtlas.beginRender()
self.mAtlas.prepareForFeature(0)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_legend', self.mComposition)
myTestResult, myMessage = checker.testComposition()
assert myTestResult
self.mAtlas.endRender()
# restore state
self.mAtlasMap.setLayers([layers[1]])
self.mComposition.removeComposerItem(legend)
QgsProject.instance().removeMapLayer(ptLayer.id())
def setUp(self):
self.iface = get_iface()
polys_shp = os.path.join(TEST_DATA_DIR, "polys.shp")
points_shp = os.path.join(TEST_DATA_DIR, "points.shp")
lines_shp = os.path.join(TEST_DATA_DIR, "lines.shp")
self.polys_layer = QgsVectorLayer(polys_shp, "Polygons", "ogr")
self.points_layer = QgsVectorLayer(points_shp, "Points", "ogr")
self.lines_layer = QgsVectorLayer(lines_shp, "Lines", "ogr")
QgsMapLayerRegistry.instance().addMapLayer(self.polys_layer)
QgsMapLayerRegistry.instance().addMapLayer(self.lines_layer)
QgsMapLayerRegistry.instance().addMapLayer(self.points_layer)
# Create style
sym1 = QgsFillSymbol.createSimple({"color": "#fdbf6f"})
sym2 = QgsLineSymbol.createSimple({"color": "#fdbf6f"})
sym3 = QgsMarkerSymbol.createSimple({"color": "#fdbf6f"})
self.polys_layer.setRenderer(QgsSingleSymbolRenderer(sym1))
self.lines_layer.setRenderer(QgsSingleSymbolRenderer(sym2))
self.points_layer.setRenderer(QgsSingleSymbolRenderer(sym3))
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-133, 22, -70, 52))
def setUp(self):
self.iface = get_iface()
polys_shp = os.path.join(TEST_DATA_DIR, 'polys.shp')
points_shp = os.path.join(TEST_DATA_DIR, 'points.shp')
lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.polys_layer = QgsVectorLayer(polys_shp, 'Polygons', 'ogr')
self.points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr')
self.lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr')
QgsProject.instance().addMapLayer(self.polys_layer)
QgsProject.instance().addMapLayer(self.lines_layer)
QgsProject.instance().addMapLayer(self.points_layer)
# Create style
sym1 = QgsFillSymbol.createSimple({'color': '#fdbf6f', 'outline_color': 'black'})
sym2 = QgsLineSymbol.createSimple({'color': '#fdbf6f'})
sym3 = QgsMarkerSymbol.createSimple({'color': '#fdbf6f', 'outline_color': 'black'})
self.polys_layer.setRenderer(QgsSingleSymbolRenderer(sym1))
self.lines_layer.setRenderer(QgsSingleSymbolRenderer(sym2))
self.points_layer.setRenderer(QgsSingleSymbolRenderer(sym3))
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-133, 22, -70, 52))
def testConvert(self):
""" test renderer conversion """
# same type, should clone
r = QgsPointClusterRenderer()
self._setProperties(r)
c = QgsPointClusterRenderer.convertFromRenderer(r)
self._checkProperties(c)
# test conversion from displacement renderer
r = QgsPointDisplacementRenderer()
r.setTolerance(5)
r.setToleranceUnit(QgsUnitTypes.RenderMapUnits)
r.setToleranceMapUnitScale(QgsMapUnitScale(5, 15))
m = QgsMarkerSymbol()
m.setColor(QColor(0, 255, 0))
r.setCenterSymbol(m)
sym1 = QgsMarkerSymbol.createSimple({'color': '#fdbf6f'})
renderer = QgsSingleSymbolRenderer(sym1)
r.setEmbeddedRenderer(renderer)
# want to keep as many settings as possible when converting between cluster and displacement renderer
d = QgsPointClusterRenderer.convertFromRenderer(r)
self.assertEqual(d.tolerance(), 5)
self.assertEqual(d.toleranceUnit(), QgsUnitTypes.RenderMapUnits)
self.assertEqual(d.toleranceMapUnitScale(), QgsMapUnitScale(5, 15))
self.assertEqual(d.clusterSymbol().color(), QColor(0, 255, 0))
self.assertEqual(d.embeddedRenderer().symbol().color().name(), '#fdbf6f')
def createMarkerSymbol():
symbol = QgsMarkerSymbol.createSimple({
"color": "100,150,50",
"name": "square",
"size": "3.0"
})
return symbol
def testInitialSizeSymbolMapUnits(self):
"""Test initial size of legend with a symbol size in map units"""
point_path = os.path.join(TEST_DATA_DIR, 'points.shp')
point_layer = QgsVectorLayer(point_path, 'points', 'ogr')
QgsProject.instance().addMapLayers([point_layer])
marker_symbol = QgsMarkerSymbol.createSimple({'color': '#ff0000', 'outline_style': 'no', 'size': '5', 'size_unit': 'MapUnit'})
point_layer.setRenderer(QgsSingleSymbolRenderer(marker_symbol))
s = QgsMapSettings()
s.setLayers([point_layer])
layout = QgsLayout(QgsProject.instance())
layout.initializeDefaults()
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(20, 20, 80, 80))
map.setFrameEnabled(True)
map.setLayers([point_layer])
layout.addLayoutItem(map)
map.setExtent(point_layer.extent())
legend = QgsLayoutItemLegend(layout)
legend.setTitle("Legend")
legend.attemptSetSceneRect(QRectF(120, 20, 80, 80))
legend.setFrameEnabled(True)
legend.setFrameStrokeWidth(QgsLayoutMeasurement(2))
legend.setBackgroundColor(QColor(200, 200, 200))
legend.setTitle('')
layout.addLayoutItem(legend)
legend.setLinkedMap(map)
checker = QgsLayoutChecker(
'composer_legend_mapunits', layout)
checker.setControlPathPrefix("composer_legend")
result, message = checker.testLayout()
self.assertTrue(result, message)
# resize with non-top-left reference point
legend.setResizeToContents(False)
legend.setReferencePoint(QgsLayoutItem.LowerRight)
legend.attemptMove(QgsLayoutPoint(120, 90))
legend.attemptResize(QgsLayoutSize(50, 60))
self.assertEqual(legend.positionWithUnits().x(), 120.0)
self.assertEqual(legend.positionWithUnits().y(), 90.0)
self.assertAlmostEqual(legend.pos().x(), 70, -1)
self.assertAlmostEqual(legend.pos().y(), 30, -1)
legend.setResizeToContents(True)
legend.updateLegend()
self.assertEqual(legend.positionWithUnits().x(), 120.0)
self.assertEqual(legend.positionWithUnits().y(), 90.0)
self.assertAlmostEqual(legend.pos().x(), 91, -1)
self.assertAlmostEqual(legend.pos().y(), 71, -1)
QgsProject.instance().removeMapLayers([point_layer.id()])
def setUp(self):
myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
self.layer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
QgsProject.instance().addMapLayer(self.layer)
self.renderer = QgsPointClusterRenderer()
sym1 = QgsMarkerSymbol.createSimple({'color': '#ff00ff', 'size': '3', 'outline_style': 'no'})
renderer = QgsSingleSymbolRenderer(sym1)
self.renderer.setEmbeddedRenderer(renderer)
self.renderer.setClusterSymbol(QgsMarkerSymbol.createSimple({'color': '#ffff00', 'size': '3', 'outline_style': 'no'}))
self.layer.setRenderer(self.renderer)
rendered_layers = [self.layer]
self.mapsettings = QgsMapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-123, 18, -70, 52))
self.mapsettings.setLayers(rendered_layers)
def _setProperties(self, r):
""" set properties for a renderer for testing with _checkProperties"""
r.setTolerance(5)
r.setToleranceUnit(QgsUnitTypes.RenderMapUnits)
r.setToleranceMapUnitScale(QgsMapUnitScale(5, 15))
m = QgsMarkerSymbol()
m.setColor(QColor(0, 255, 0))
r.setClusterSymbol(m)
sym1 = QgsMarkerSymbol.createSimple({'color': '#fdbf6f'})
renderer = QgsSingleSymbolRenderer(sym1)
r.setEmbeddedRenderer(renderer)
def testSetGetSymbol(self):
button = QgsSymbolButton()
symbol = QgsMarkerSymbol.createSimple({})
symbol.setColor(QColor(255, 0, 0))
signal_spy = QSignalSpy(button.changed)
button.setSymbol(symbol)
self.assertEqual(len(signal_spy), 1)
r = button.symbol()
self.assertEqual(r.color(), QColor(255, 0, 0))
def setUp(self):
myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
self.layer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(self.layer)
self.renderer = QgsPointDisplacementRenderer()
sym1 = QgsMarkerSymbol.createSimple({'color': '#ff00ff', 'size': '3', 'outline_style': 'no'})
renderer = QgsSingleSymbolRenderer(sym1)
self.renderer.setEmbeddedRenderer(renderer)
self.renderer.setCircleRadiusAddition(2)
self.renderer.setCircleWidth(1)
self.renderer.setCircleColor(QColor(0, 0, 0))
self.renderer.setCenterSymbol(QgsMarkerSymbol.createSimple({'color': '#ffff00', 'size': '3', 'outline_style': 'no'}))
self.layer.setRenderer(self.renderer)
rendered_layers = [self.layer.id()]
self.mapsettings = QgsMapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-123, 18, -70, 52))
self.mapsettings.setLayers(rendered_layers)
def testSymbolToFromMimeData(self):
"""
Test converting symbols to and from mime data
"""
symbol = QgsMarkerSymbol.createSimple({})
symbol.setColor(QColor(255, 0, 255))
self.assertFalse(QgsSymbolLayerUtils.symbolFromMimeData(None))
self.assertFalse(QgsSymbolLayerUtils.symbolToMimeData(None))
mime = QgsSymbolLayerUtils.symbolToMimeData(symbol)
self.assertTrue(mime is not None)
symbol2 = QgsSymbolLayerUtils.symbolFromMimeData(mime)
self.assertTrue(symbol2 is not None)
self.assertEqual(symbol2.color().name(), symbol.color().name())
def testMarkLineUnitDefault(self):
symbol = QgsMarkerLineSymbolLayer()
symbol.setSubSymbol(QgsMarkerSymbol.createSimple({"color": "#ffffff", "size": "3"}))
symbol.setInterval(5)
symbol.setOffset(5)
dom, root = self.symbolToSld(symbol)
# print ("Mark line mm: \n" + dom.toString())
# size of the mark
self.assertStaticSize(root, "11")
# gap and offset
self.assertStaticGap(root, "18")
self.assertStaticPerpendicularOffset(root, "18")
def testSettingSymbolType(self):
button = QgsSymbolButton()
button.setSymbolType(QgsSymbol.Marker)
symbol = QgsMarkerSymbol.createSimple({})
symbol.setColor(QColor(255, 0, 0))
button.setSymbol(symbol)
# if same symbol type, existing symbol should be kept
button.setSymbolType(QgsSymbol.Marker)
self.assertEqual(button.symbol(), symbol)
# if setting different symbol type, symbol should be reset to new type
button.setSymbolType(QgsSymbol.Fill)
self.assertTrue(isinstance(button.symbol(), QgsFillSymbol))
def testMarkLineUnitPixels(self):
symbol = QgsMarkerLineSymbolLayer()
symbol.setSubSymbol(QgsMarkerSymbol.createSimple({"color": "#ffffff", "size": "3"}))
symbol.setInterval(5)
symbol.setOffset(5)
symbol.setOutputUnit(QgsUnitTypes.RenderPixels)
dom, root = self.symbolToSld(symbol)
# print ("Mark line px: \n" + dom.toString())
# size of the mark
self.assertStaticSize(root, "3")
# gap and offset
self.assertStaticGap(root, "5")
self.assertStaticPerpendicularOffset(root, "5")
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 test_point_ordered_symbol_bound_offset(self):
# Test ordered placements for point using symbol bounds offset
self.layer = TestQgsPalLabeling.loadFeatureLayer('point_ordered_placement')
# Make a big symbol
symbol = QgsMarkerSymbol.createSimple({'color': '31,120,180,255',
'outline_color': '0,0,0,0',
'outline_style': 'solid',
'size': '10',
'name': 'rectangle',
'size_unit': 'MM'})
renderer = QgsSingleSymbolRenderer(symbol)
self.layer.setRenderer(renderer)
self._TestMapSettings = self.cloneMapSettings(self._MapSettings)
self.lyr.placement = QgsPalLayerSettings.OrderedPositionsAroundPoint
self.lyr.dist = 2
self.lyr.offsetType = QgsPalLayerSettings.FromSymbolBounds
self.checkTest()
self.removeMapLayer(self.layer)
self.layer = None
def _setProperties(self, r):
""" set properties for a renderer for testing with _checkProperties"""
r.setLabelAttributeName('name')
f = QgsFontUtils.getStandardTestFont('Bold Oblique', 14)
r.setLabelFont(f)
r.setMinimumLabelScale(50000)
r.setLabelColor(QColor(255, 0, 0))
r.setTolerance(5)
r.setToleranceUnit(QgsUnitTypes.RenderMapUnits)
r.setToleranceMapUnitScale(QgsMapUnitScale(5, 15))
r.setCircleWidth(15)
r.setCircleColor(QColor(0, 255, 0))
r.setCircleRadiusAddition(2.5)
r.setPlacement(QgsPointDisplacementRenderer.ConcentricRings)
m = QgsMarkerSymbol()
m.setColor(QColor(0, 255, 0))
r.setCenterSymbol(m)
sym1 = QgsMarkerSymbol.createSimple({'color': '#fdbf6f'})
renderer = QgsSingleSymbolRenderer(sym1)
r.setEmbeddedRenderer(renderer)
def testInitialSizeSymbolMapUnits(self):
"""Test initial size of legend with a symbol size in map units"""
point_path = os.path.join(TEST_DATA_DIR, 'points.shp')
point_layer = QgsVectorLayer(point_path, 'points', 'ogr')
QgsProject.instance().addMapLayers([point_layer])
marker_symbol = QgsMarkerSymbol.createSimple({'color': '#ff0000', 'outline_style': 'no', 'size': '5', 'size_unit': 'MapUnit'})
point_layer.setRenderer(QgsSingleSymbolRenderer(marker_symbol))
s = QgsMapSettings()
s.setLayers([point_layer])
layout = QgsLayout(QgsProject.instance())
layout.initializeDefaults()
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(20, 20, 80, 80))
map.setFrameEnabled(True)
map.setLayers([point_layer])
layout.addLayoutItem(map)
map.setExtent(point_layer.extent())
legend = QgsLayoutItemLegend(layout)
legend.attemptSetSceneRect(QRectF(120, 20, 80, 80))
legend.setFrameEnabled(True)
legend.setFrameStrokeWidth(QgsLayoutMeasurement(2))
legend.setBackgroundColor(QColor(200, 200, 200))
legend.setTitle('')
layout.addLayoutItem(legend)
legend.setMap(map)
checker = QgsLayoutChecker(
'composer_legend_mapunits', layout)
checker.setControlPathPrefix("composer_legend")
result, message = checker.testLayout()
self.assertTrue(result, message)
QgsProject.instance().removeMapLayers([point_layer.id()])
def testInitialSizeSymbolMapUnits(self):
"""Test initial size of legend with a symbol size in map units"""
point_path = os.path.join(TEST_DATA_DIR, "points.shp")
point_layer = QgsVectorLayer(point_path, "points", "ogr")
QgsProject.instance().addMapLayers([point_layer])
marker_symbol = QgsMarkerSymbol.createSimple(
{"color": "#ff0000", "outline_style": "no", "size": "5", "size_unit": "MapUnit"}
)
point_layer.setRenderer(QgsSingleSymbolRenderer(marker_symbol))
s = QgsMapSettings()
s.setLayers([point_layer])
s.setCrsTransformEnabled(False)
composition = QgsComposition(s, QgsProject.instance())
composition.setPaperSize(297, 210)
composer_map = QgsComposerMap(composition, 20, 20, 80, 80)
composer_map.setFrameEnabled(True)
composition.addComposerMap(composer_map)
composer_map.setNewExtent(point_layer.extent())
legend = QgsComposerLegend(composition)
legend.setSceneRect(QRectF(120, 20, 80, 80))
legend.setFrameEnabled(True)
legend.setFrameOutlineWidth(2)
legend.setBackgroundColor(QColor(200, 200, 200))
legend.setTitle("")
composition.addComposerLegend(legend)
legend.setComposerMap(composer_map)
checker = QgsCompositionChecker("composer_legend_mapunits", composition)
checker.setControlPathPrefix("composer_legend")
result, message = checker.testComposition()
self.assertTrue(result, message)
QgsProject.instance().removeMapLayers([point_layer.id()])
def testInitialSizeSymbolMapUnits(self):
"""Test initial size of legend with a symbol size in map units"""
point_path = os.path.join(TEST_DATA_DIR, 'points.shp')
point_layer = QgsVectorLayer(point_path, 'points', 'ogr')
QgsProject.instance().addMapLayers([point_layer])
marker_symbol = QgsMarkerSymbol.createSimple({'color': '#ff0000', 'outline_style': 'no', 'size': '5', 'size_unit': 'MapUnit'})
point_layer.setRenderer(QgsSingleSymbolRenderer(marker_symbol))
s = QgsMapSettings()
s.setLayers([point_layer])
composition = QgsComposition(QgsProject.instance())
composition.setPaperSize(297, 210)
composer_map = QgsComposerMap(composition, 20, 20, 80, 80)
composer_map.setFrameEnabled(True)
composer_map.setLayers([point_layer])
composition.addComposerMap(composer_map)
composer_map.setNewExtent(point_layer.extent())
legend = QgsComposerLegend(composition)
legend.setSceneRect(QRectF(120, 20, 80, 80))
legend.setFrameEnabled(True)
legend.setFrameStrokeWidth(2)
legend.setBackgroundColor(QColor(200, 200, 200))
legend.setTitle('')
composition.addComposerLegend(legend)
legend.setComposerMap(composer_map)
checker = QgsCompositionChecker(
'composer_legend_mapunits', composition)
checker.setControlPathPrefix("composer_legend")
result, message = checker.testComposition()
self.assertTrue(result, message)
QgsProject.instance().removeMapLayers([point_layer.id()])
def test_point_ordered_symbol_bound_offset(self):
# Test ordered placements for point using symbol bounds offset
self.layer = TestQgsPalLabeling.loadFeatureLayer("point_ordered_placement")
# Make a big symbol
symbol = QgsMarkerSymbol.createSimple(
{
"color": "31,120,180,255",
"outline_color": "0,0,0,0",
"outline_style": "solid",
"size": "10",
"name": "rectangle",
"size_unit": "MM",
}
)
renderer = QgsSingleSymbolRenderer(symbol)
self.layer.setRenderer(renderer)
self._TestMapSettings = self.cloneMapSettings(self._MapSettings)
self.lyr.placement = QgsPalLayerSettings.OrderedPositionsAroundPoint
self.lyr.dist = 2
self.lyr.offsetType = QgsPalLayerSettings.FromSymbolBounds
self.checkTest()
self.removeMapLayer(self.layer)
self.layer = None
def testSetColor(self):
button = QgsSymbolButton()
symbol = QgsMarkerSymbol.createSimple({})
symbol.setColor(QColor(255, 255, 0))
button.setSymbol(symbol)
signal_spy = QSignalSpy(button.changed)
button.setColor(QColor(0, 255, 0))
self.assertEqual(len(signal_spy), 1)
r = button.symbol()
self.assertEqual(r.color().name(), QColor(0, 255, 0).name())
# set same color, should not emit signal
button.setColor(QColor(0, 255, 0))
self.assertEqual(len(signal_spy), 1)
# color with transparency - should be stripped
button.setColor(QColor(0, 255, 0, 100))
r = button.symbol()
self.assertEqual(r.color(), QColor(0, 255, 0))
def test_render_via_job_with_transform(self):
"""
Test rendering an annotation layer via a map render job
"""
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(11.5, 13),
QgsPoint(12, 13),
QgsPoint(12, 13.5),
QgsPoint(11.5, 13)
])))
item.setSymbol(
QgsFillSymbol.createSimple({
'color': '200,100,100',
'outline_color': 'black',
'outline_width': '2'
}))
item.setZIndex(1)
i1_id = layer.addItem(item)
item = QgsAnnotationLineItem(
QgsLineString(
[QgsPoint(11, 13),
QgsPoint(12, 13),
QgsPoint(12, 15)]))
item.setSymbol(
QgsLineSymbol.createSimple({
'color': '#ffff00',
'line_width': '3'
}))
item.setZIndex(2)
i2_id = layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setSymbol(
QgsMarkerSymbol.createSimple({
'color': '100,200,200',
'size': '6',
'outline_color': 'black'
}))
item.setZIndex(3)
i3_id = layer.addItem(item)
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings = QgsMapSettings()
settings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
settings.setExtent(QgsRectangle(1250958, 1386945, 1420709, 1532518))
settings.setOutputSize(QSize(200, 200))
settings.setLayers([layer])
job = QgsMapRendererSequentialJob(settings)
job.start()
job.waitForFinished()
# check rendered item results
item_results = job.takeRenderedItemResults()
item_details = item_results.renderedItems()
self.assertEqual(len(item_details), 3)
self.assertEqual([i.layerId() for i in item_details], [layer.id()] * 3)
self.assertCountEqual([i.itemId() for i in item_details],
[i1_id, i2_id, i3_id])
# bounds should be in map crs
self.assertEqual(
[
QgsGeometry.fromRect(i.boundingBox()).asWkt(0)
for i in item_details if i.itemId() == i1_id
][0],
'Polygon ((1280174 1459732, 1335834 1459732, 1335834 1516914, 1280174 1516914, 1280174 1459732))'
)
self.assertEqual(
[
QgsGeometry.fromRect(i.boundingBox()).asWkt(0)
for i in item_details if i.itemId() == i2_id
][0],
'Polygon ((1224514 1459732, 1335834 1459732, 1335834 1689200, 1224514 1689200, 1224514 1459732))'
)
expected = 'Polygon ((1325786 1449684, 1345882 1449684, 1345882 1469780, 1325786 1469780, 1325786 1449684))'
result = [
QgsGeometry.fromRect(i.boundingBox()).asWkt(0)
for i in item_details if i.itemId() == i3_id
][0]
self.assertTrue(
compareWkt(result, expected, tol=1000),
"mismatch Expected:\n{}\nGot:\n{}\n".format(expected, result))
def run(self):
global almacen
#coloco el puntero arriba del todo
QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint(
QgsProject.instance().layerTreeRoot(), 0)
#genero una lista con los sistemas de referencia
misdatos = [["Etrs89 Zona30 (25830)", "25830"],
["Etrs89 Zona29 (25829)", "25829"],
["ED50 Zona30 (23030)", "23030"],
["ED50_Zona29 (23029)", "23029"],
["WGS84 geograficas sexagesimales(4326)", "4326"],
["WGS84 geograficas centesimales(4326)", "4258"]]
self.dlg.comboBox_src.clear()
for element in misdatos:
self.dlg.comboBox_src.addItem(element[0])
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
#leo la cache
rutacache = os.path.join(QgsApplication.qgisSettingsDirPath(),
r"python\plugins\zoomSigmena\cache.txt")
if os.path.isfile(rutacache) == True:
filecache = open(rutacache, "r")
filecacheleido = filecache.readlines()
try:
import ast
almacen = ast.literal_eval((filecacheleido[0].replace(
'\n', '')).replace(" [[",
"[[").replace("]] ",
"]]")) #.split(','))
cache_utm = int(almacen[0])
cache_geo = int(almacen[1])
cache_escala = almacen[2]
print(cache_escala)
print(almacen)
#miscomarcas=(filecacheleido[3].replace('\n','')).strip('][').split(',') #convierto una str en una list
#mismunicipios=ast.literal_eval((filecacheleido[4].replace('\n','')).replace(" [[","[[").replace("]] ","]]"))#.split(',')) #convierto una str en una list
filecache.close()
except:
print("esta no encuentra el file cache")
self.dlg.lineEdit_escala.setText(str(cache_escala))
self.dlg.checkBox_utm.setChecked(cache_utm)
self.dlg.checkBox_geo.setChecked(cache_geo)
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
def deg_to_dms(deg, type='lat'):
decimals, number = math.modf(deg)
d = int(number)
m = int(decimals * 60)
s = (deg - d - m / 60) * 3600.00
compass = {'lat': ('N', 'S'), 'lon': ('E', 'W')}
compass_str = compass[type][0 if d >= 0 else 1]
return '{}º{}\'{:.2f}"{}'.format(abs(d), abs(m), abs(s),
compass_str)
#saco de aqui variables que estan en las cajitas
src_seleccionado = self.dlg.comboBox_src.currentIndex()
# Get the coordinates and scale factor from the dialog
x = self.dlg.XX.text() ##displayText()
y = self.dlg.YY.text() ##displayText()
escala = self.dlg.lineEdit_escala.text()
x = x.replace(',', '.')
y = y.replace(',', '.')
escala = int(escala.replace('.', ''))
src = misdatos[int(src_seleccionado)][1]
if src == "4326":
latext = y
longtext = x
lag = float(latext.split()[0])
lam = float(latext.split()[1])
las = float(latext.split()[2])
log = float(longtext.split()[0])
lom = float(longtext.split()[1])
los = float(longtext.split()[2])
lon = -1 * (log + (lom / 60) + (los / 3600))
lat = lag + (lam / 60) + (las / 3600)
x = float(lon)
y = float(lat)
print(x)
print(y)
huso = 30
destinoProj = pyproj.Proj(proj="utm",
zone=huso,
ellps="WGS84",
units="m")
origenProj = pyproj.Proj(proj='longlat',
ellps='WGS84',
datum='WGS84')
UTM_X, UTM_Y = pyproj.transform(origenProj, destinoProj, lon,
lat)
if src == "4258":
print("por el camino adecuado")
lat = float(y)
lonn = float(x)
lon = -1.0 * lonn
print(lat)
print(lon)
huso = 30
destinoProj = pyproj.Proj(proj="utm",
zone=huso,
ellps="WGS84",
units="m")
origenProj = pyproj.Proj(proj='longlat',
ellps='WGS84',
datum='WGS84')
UTM_X, UTM_Y = pyproj.transform(origenProj, destinoProj, lon,
lat)
print(UTM_X)
print(UTM_Y)
x = lon
y = lat
#creo una capa temporal con las coordenadas
# create layer
vl2 = QgsVectorLayer("Point?crs=EPSG:" + src, "Zoom", "memory")
pr2 = vl2.dataProvider()
vl2.startEditing()
# add fields
pr2.addAttributes([
QgsField("x", QVariant.Double),
QgsField("y", QVariant.Double),
QgsField("xx", QVariant.String),
QgsField("yy", QVariant.String),
QgsField("xxx", QVariant.Double),
QgsField("yyy", QVariant.Double)
])
vl2.updateFields()
# tell the vector layer to fetch changes from the provider
#$add a feature
fet = QgsFeature()
print("punto")
print(x)
print(y)
fet.setGeometry(
QgsGeometry.fromPointXY(QgsPointXY(float(x), float(y))))
if src == "25830":
huso = 30
origenProj = pyproj.Proj(proj="utm",
zone=huso,
ellps="WGS84",
units="m")
destinoProj = pyproj.Proj(proj='longlat',
ellps='WGS84',
datum='WGS84')
xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y)
xx = (deg_to_dms(xxx, 'lon'))
yy = (deg_to_dms(yyy))
if src == "25829":
huso = 29
origenProj = pyproj.Proj(proj="utm",
zone=huso,
ellps="WGS84",
units="m")
destinoProj = pyproj.Proj(proj='longlat',
ellps='WGS84',
datum='WGS84')
xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y)
xx = (deg_to_dms(xxx, 'lon'))
yy = (deg_to_dms(yyy))
if src == "23030":
huso = 30
origenProj = pyproj.Proj(proj="utm",
zone=huso,
ellps="intl",
units="m")
destinoProj = pyproj.Proj(proj='longlat',
ellps='WGS84',
datum='WGS84')
xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y)
xx = (deg_to_dms(xxx, 'lon'))
yy = (deg_to_dms(yyy))
if src == "23029":
huso = 29
origenProj = pyproj.Proj(proj="utm",
zone=huso,
ellps="intl",
units="m")
destinoProj = pyproj.Proj(proj='longlat',
ellps='WGS84',
datum='WGS84')
xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y)
xx = (deg_to_dms(xxx, 'lon'))
yy = (deg_to_dms(yyy))
#para que lo pase a utms en pantalla
if src == "4326":
x = int(UTM_X)
y = int(UTM_Y)
#xx=longtext
#yy=latext
huso = 30
origenProj = pyproj.Proj(proj="utm",
zone=huso,
ellps="intl",
units="m")
destinoProj = pyproj.Proj(proj='longlat',
ellps='WGS84',
datum='WGS84')
xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y)
xx = (deg_to_dms(xxx, 'lon'))
yy = (deg_to_dms(yyy))
#para que lo pase a utms en pantalla
if src == "4258":
x = int(UTM_X)
y = int(UTM_Y)
xxx = lon
yyy = lat
xx = (deg_to_dms(xxx, 'lon'))
yy = (deg_to_dms(yyy))
fet.setAttributes(
[float(x),
float(y),
str(xx),
str(yy),
float(xxx),
float(yyy)])
pr2.addFeatures([fet])
#cambio la simbologia
symbol = QgsMarkerSymbol.createSimple({
'name': 'circle',
'color': 'red',
'size': '3',
})
vl2.renderer().setSymbol(symbol)
# update layer's extent when new features have been added
# because change of extent in provider is not propagated to the layer
layer_settings = QgsPalLayerSettings()
text_format = QgsTextFormat()
text_format.setFont(QFont("Arial", 12))
text_format.setSize(12)
text_format.setColor(QColor("Orange"))
layer_settings.setFormat(text_format)
layer_settings.placement = 1
layer_settings.xOffset = 0.0
layer_settings.yOffset = 10.0
mostrar = True
if self.dlg.checkBox_utm.isChecked(
) and self.dlg.checkBox_geo.isChecked():
layer_settings.fieldName = '''concat('X: ',"X",' Y: ',"Y",'\n','Lon: ',"xx",' Lat: ',"yy" )'''
almacen = [1, 1]
else:
if self.dlg.checkBox_utm.isChecked():
layer_settings.fieldName = '''concat('X: ',"X",' Y: ',"Y" )'''
almacen = [1, 0]
print("caso1")
if self.dlg.checkBox_geo.isChecked():
layer_settings.fieldName = '''concat('Lon: ',"xx",' Lat: ',"yy" )'''
almacen = [0, 1]
print("caso2")
if not self.dlg.checkBox_utm.isChecked(
) and not self.dlg.checkBox_geo.isChecked():
mostrar = False
almacen = [0, 0]
print("caso3")
print("almacen despues de etiquetar", almacen)
layer_settings.isExpression = True
print(mostrar)
layer_settings.enabled = mostrar
layer_settings = QgsVectorLayerSimpleLabeling(layer_settings)
vl2.setLabelsEnabled(True)
vl2.setLabeling(layer_settings)
vl2.triggerRepaint()
# update layer's extent when new features have been added
# because change of extent in provider is not propagated to the layer
vl2.updateExtents()
vl2.commitChanges()
vl2.updateExtents()
canvas = self.iface.mapCanvas()
canvas.setExtent(vl2.extent())
crsSrc = QgsCoordinateReferenceSystem('EPSG:' + str(src))
crsDest = QgsProject.instance().crs()
if crsSrc != crsDest:
xform = QgsCoordinateTransform(crsSrc, crsDest,
QgsProject.instance())
canvas.setExtent(xform.transform(vl2.extent()))
self.iface.mapCanvas().zoomScale(escala)
#self.limpiar_pressed()
almacen.append(escala)
#lo escribo en el txt, mavhacando lo que ya tenia
f = open(rutacache, "w")
escribir = str(almacen)
f.write(escribir)
f.close()
print(almacen)
QgsProject.instance().addMapLayer(vl2)
def add_design_to_map(qris_project, item, node):
"""adds designs to the map"""
# Establish paths to layers
design_id = item.data(item_code['feature_id'])
subset_string = ("design_id = " + str(design_id))
design_name = item.text()
geopackage_path = qris_project.project_designs.geopackage_path(
qris_project.project_path)
designs_layer = QgsVectorLayer(geopackage_path + "|layername=designs",
"Designs", "ogr")
structure_types_layer = QgsVectorLayer(
geopackage_path + "|layername=structure_types", "Structure Types",
"ogr")
phases_layer = QgsVectorLayer(geopackage_path + "|layername=phases",
"Implementation Phases", "ogr")
zoi_layer = QgsVectorLayer(geopackage_path + "|layername=zoi", "ZOI",
"ogr")
zoi_types_layer = QgsVectorLayer(geopackage_path + "|layername=zoi_types",
"ZOI", "ogr")
complexes_layer = QgsVectorLayer(geopackage_path + "|layername=complexes",
"Complexes", "ogr")
structure_points_layer = QgsVectorLayer(
geopackage_path + "|layername=structure_points", "Structures", "ogr")
structure_lines_layer = QgsVectorLayer(
geopackage_path + "|layername=structure_lines", "Structures", "ogr")
# Get the structure geometry type
# Could also do this with SQL
design_iterator = designs_layer.getFeatures(
QgsFeatureRequest().setFilterFid(design_id))
design_feature = next(design_iterator)
structure_geometry = design_feature['structure_geometry']
def add_design_table(display_name, table_name, qml_name, read_only,
group_node):
"""A handy way to add design layers and tables to the map"""
if not any([c.name() == display_name for c in group_node.children()]):
layer = QgsProject.instance().addMapLayer(
QgsVectorLayer(geopackage_path + "|layername=" + table_name,
display_name, "ogr"), False)
if qml_name:
layer_qml = os.path.join(symbology_path, 'symbology', qml_name)
layer.loadNamedStyle(layer_qml)
if read_only:
layer.setReadOnly()
group_node.addLayer(layer)
# Summary tables (views)
if any([c.name() == "Low-Tech Tables" for c in node.children()]):
# if is there set it to the design node
table_node = next(n for n in node.children()
if n.name() == "Low-Tech Tables")
else:
# if not add the node as a group
table_node = node.addGroup("Low-Tech Tables")
table_node.setExpanded(False)
# Summary tables (views)
if any([c.name() == "Summary Tables" for c in table_node.children()]):
# if is there set it to the design node
summary_node = next(n for n in table_node.children()
if n.name() == "Summary Tables")
else:
# if not add the node as a group
summary_node = table_node.addGroup("Summary Tables")
summary_node.setExpanded(False)
add_design_table('Structure Totals - Points',
'qry_total_structures_points', None, True, summary_node)
add_design_table('Structure Totals - Lines', 'qry_total_structures_lines',
None, True, summary_node)
add_design_table('Structure Summary - Points',
'qry_structure_summary_points', None, True, summary_node)
add_design_table('Structure Summary - Lines',
'qry_structure_summary_lines', None, True, summary_node)
add_design_table('Complexes Summary - Points',
'qry_complexes_by_type_points', None, True, summary_node)
add_design_table('Complexes Summary - Lines',
'qry_complexes_by_type_lines', None, True, summary_node)
add_design_table('ZOI Summary', 'qry_zoi_summary', None, True,
summary_node)
# Lookup Tables
if any([c.name() == "Lookup Tables" for c in table_node.children()]):
# if is there set it to the design node
lookup_node = next(n for n in table_node.children()
if n.name() == "Lookup Tables")
else:
# if not add the node as a group
lookup_node = table_node.addGroup("Lookup Tables")
lookup_node.setExpanded(False)
add_design_table('Design Status', 'lkp_design_status',
'lkp_design_status.qml', True, lookup_node)
add_design_table('Phase Action', 'lkp_phase_action',
'lkp_phase_action.qml', True, lookup_node)
add_design_table('ZOI Influence', 'lkp_zoi_influence',
'lkp_zoi_influence.qml', True, lookup_node)
add_design_table('ZOI Stage', 'lkp_zoi_stage', 'lkp_zoi_stage.qml', True,
lookup_node)
add_design_table('Structure Mimics', 'lkp_structure_mimics',
'lkp_structure_mimics.qml', True, lookup_node)
# Add Design Tables
if any([c.name() == "Design Tables" for c in table_node.children()]):
# if is there set it to the design node
design_tables_node = next(n for n in table_node.children()
if n.name() == "Design Tables")
else:
# if not add the node as a group
design_tables_node = table_node.addGroup("Design Tables")
design_tables_node.setExpanded(False)
# Check if the designs table has been added and if not add it.
add_design_table('Designs', 'designs', 'designs.qml', False,
design_tables_node)
add_design_table('Structure Types', 'structure_types',
'structure_types.qml', False, design_tables_node)
add_design_table('ZOI Types', 'zoi_types', 'zoi_types.qml', False,
design_tables_node)
add_design_table('Phases', 'phases', 'phases.qml', False,
design_tables_node)
# Check if the design node is already added
design_group_name = str(design_id) + "-" + item.text()
if any([c.name() == design_group_name for c in node.children()]):
# if is there set it to the design node
design_node = next(n for n in node.children()
if n.name() == design_group_name)
else:
# if not add the node as a group
design_node = node.addGroup(design_group_name)
# Add structures
structure_layer_name = str(design_id) + "-Structures"
if structure_geometry == 'Point':
# Start setting custom symbology
# TODO Refactor into a functio
unique_values = []
for feature in structure_types_layer.getFeatures():
values = (feature["fid"], feature["name"])
unique_values.append(values)
categories = []
for value in unique_values:
layer_style = {}
layer_style["color"] = '%d, %d, %d' % (randrange(
0, 256), randrange(0, 256), randrange(0, 256))
layer_style['size'] = '3'
layer_style['outline_color'] = 'black'
symbol_layer = QgsMarkerSymbol.createSimple(layer_style)
category = QgsRendererCategory(str(value[0]), symbol_layer,
value[1])
categories.append(category)
renderer = QgsCategorizedSymbolRenderer('structure_type_id',
categories)
if not any(
[c.name() == structure_layer_name
for c in design_node.children()]):
# Adding the type suffix as I could see adding qml that symbolizes on other attributes
structure_points_qml = os.path.join(symbology_path, 'symbology',
'structure_points.qml')
structure_points_layer.loadNamedStyle(structure_points_qml)
QgsExpressionContextUtils.setLayerVariable(structure_points_layer,
'parent_id', design_id)
structure_points_layer.setSubsetString(subset_string)
QgsProject.instance().addMapLayer(structure_points_layer, False)
structure_points_layer.setName(structure_layer_name)
design_node.addLayer(structure_points_layer)
layer_node = design_node.findLayer(structure_points_layer.id())
layer_node.setExpanded(False)
else:
structure_points_layer = QgsProject.instance().mapLayersByName(
structure_layer_name)[0]
if renderer is not None:
structure_points_layer.setRenderer(renderer)
structure_points_layer.triggerRepaint()
else:
# Add line structures
# Start setting custom symbology
# TODO Refactor into a function
unique_values = []
for feature in structure_types_layer.getFeatures():
values = (feature["fid"], feature["name"])
unique_values.append(values)
categories = []
for value in unique_values:
layer_style = {}
layer_style["color"] = '%d, %d, %d' % (randrange(
0, 256), randrange(0, 256), randrange(0, 256))
layer_style['width'] = '1'
layer_style['capstyle'] = 'round'
symbol_layer = QgsLineSymbol.createSimple(layer_style)
category = QgsRendererCategory(str(value[0]), symbol_layer,
value[1])
categories.append(category)
renderer = QgsCategorizedSymbolRenderer('structure_type_id',
categories)
# end custom symbology
if not any(
[c.name() == structure_layer_name
for c in design_node.children()]):
structures_lines_qml = os.path.join(symbology_path, 'symbology',
'structure_lines.qml')
structure_lines_layer.loadNamedStyle(structures_lines_qml)
QgsExpressionContextUtils.setLayerVariable(structure_lines_layer,
'parent_id', design_id)
structure_lines_layer.setSubsetString(subset_string)
QgsProject.instance().addMapLayer(structure_lines_layer, False)
structure_lines_layer.setName(structure_layer_name)
design_node.addLayer(structure_lines_layer)
layer_node = design_node.findLayer(structure_lines_layer.id())
layer_node.setExpanded(False)
else:
structure_lines_layer = QgsProject.instance().mapLayersByName(
structure_layer_name)[0]
if renderer is not None:
structure_lines_layer.setRenderer(renderer)
structure_lines_layer.triggerRepaint()
# Add zoi
zoi_layer_name = str(design_id) + "-ZOI"
# TODO Refactor into a function
# TODO Refactor into sql query
unique_values = []
for feature in zoi_types_layer.getFeatures():
values = (feature["fid"], feature["name"])
unique_values.append(values)
categories = []
for value in unique_values:
layer_style = {}
alpha = 60
layer_style["color"] = "{}, {}, {}, {}".format(randrange(0, 256),
randrange(0, 256),
randrange(0, 256),
alpha)
layer_style["outline_width"] = '0.50'
layer_style["outline_style"] = 'dash'
symbol_layer = QgsFillSymbol.createSimple(layer_style)
category = QgsRendererCategory(str(value[0]), symbol_layer, value[1])
categories.append(category)
renderer = QgsCategorizedSymbolRenderer('influence_type_id', categories)
# End custom symbology
# check for the zoi layer, and if it is not there symbolize and add it
if not any([c.name() == zoi_layer_name for c in design_node.children()]):
zoi_qml = os.path.join(symbology_path, 'symbology', 'zoi.qml')
zoi_layer.loadNamedStyle(zoi_qml)
QgsExpressionContextUtils.setLayerVariable(zoi_layer, 'parent_id',
design_id)
zoi_layer.setSubsetString(subset_string)
QgsProject.instance().addMapLayer(zoi_layer, False)
zoi_layer.setName(zoi_layer_name)
design_node.addLayer(zoi_layer)
layer_node = design_node.findLayer(zoi_layer.id())
layer_node.setExpanded(False)
else:
zoi_layer = QgsProject.instance().mapLayersByName(zoi_layer_name)[0]
if renderer is not None:
zoi_layer.setRenderer(renderer)
zoi_layer.triggerRepaint()
# Add complexes
complex_layer_name = str(design_id) + "-Complexes"
if not any(
[c.name() == complex_layer_name for c in design_node.children()]):
complex_qml = os.path.join(symbology_path, 'symbology',
'complexes.qml')
complexes_layer.loadNamedStyle(complex_qml)
QgsExpressionContextUtils.setLayerVariable(complexes_layer,
'parent_id', design_id)
complexes_layer.setSubsetString(subset_string)
QgsProject.instance().addMapLayer(complexes_layer, False)
complexes_layer.setName(complex_layer_name)
design_node.addLayer(complexes_layer)
def testInitialSizeSymbolMapUnits(self):
"""Test initial size of legend with a symbol size in map units"""
point_path = os.path.join(TEST_DATA_DIR, 'points.shp')
point_layer = QgsVectorLayer(point_path, 'points', 'ogr')
QgsProject.instance().addMapLayers([point_layer])
marker_symbol = QgsMarkerSymbol.createSimple({
'color': '#ff0000',
'outline_style': 'no',
'size': '5',
'size_unit': 'MapUnit'
})
point_layer.setRenderer(QgsSingleSymbolRenderer(marker_symbol))
s = QgsMapSettings()
s.setLayers([point_layer])
layout = QgsLayout(QgsProject.instance())
layout.initializeDefaults()
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(20, 20, 80, 80))
map.setFrameEnabled(True)
map.setLayers([point_layer])
layout.addLayoutItem(map)
map.setExtent(point_layer.extent())
legend = QgsLayoutItemLegend(layout)
legend.setTitle("Legend")
legend.attemptSetSceneRect(QRectF(120, 20, 80, 80))
legend.setFrameEnabled(True)
legend.setFrameStrokeWidth(QgsLayoutMeasurement(2))
legend.setBackgroundColor(QColor(200, 200, 200))
legend.setTitle('')
layout.addLayoutItem(legend)
legend.setLinkedMap(map)
checker = QgsLayoutChecker('composer_legend_mapunits', layout)
checker.setControlPathPrefix("composer_legend")
result, message = checker.testLayout()
self.assertTrue(result, message)
# resize with non-top-left reference point
legend.setResizeToContents(False)
legend.setReferencePoint(QgsLayoutItem.LowerRight)
legend.attemptMove(QgsLayoutPoint(120, 90))
legend.attemptResize(QgsLayoutSize(50, 60))
self.assertEqual(legend.positionWithUnits().x(), 120.0)
self.assertEqual(legend.positionWithUnits().y(), 90.0)
self.assertAlmostEqual(legend.pos().x(), 70, -1)
self.assertAlmostEqual(legend.pos().y(), 30, -1)
legend.setResizeToContents(True)
legend.updateLegend()
self.assertEqual(legend.positionWithUnits().x(), 120.0)
self.assertEqual(legend.positionWithUnits().y(), 90.0)
self.assertAlmostEqual(legend.pos().x(), 91, -1)
self.assertAlmostEqual(legend.pos().y(), 71, -1)
QgsProject.instance().removeMapLayers([point_layer.id()])
def setUp(self):
# Create some simple symbols
self.fill_symbol = QgsFillSymbol.createSimple({'color': '#ffffff', 'outline_color': 'black'})
self.line_symbol = QgsLineSymbol.createSimple({'color': '#ffffff', 'line_width': '3'})
self.marker_symbol = QgsMarkerSymbol.createSimple({'color': '#ffffff', 'size': '3', 'outline_color': 'black'})
self.report = "<h1>Python QgsSymbol Tests</h1>\n"
def testRenderWithTransform(self):
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(11.5, 13),
QgsPoint(12, 13),
QgsPoint(12, 13.5),
QgsPoint(11.5, 13)
])))
item.setSymbol(
QgsFillSymbol.createSimple({
'color': '200,100,100',
'outline_color': 'black',
'outline_width': '2'
}))
item.setZIndex(1)
layer.addItem(item)
item = QgsAnnotationLineStringItem(
QgsLineString(
[QgsPoint(11, 13),
QgsPoint(12, 13),
QgsPoint(12, 15)]))
item.setSymbol(
QgsLineSymbol.createSimple({
'color': '#ffff00',
'line_width': '3'
}))
item.setZIndex(2)
layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPointXY(12, 13))
item.setSymbol(
QgsMarkerSymbol.createSimple({
'color': '100,200,200',
'size': '6',
'outline_color': 'black'
}))
item.setZIndex(3)
layer.addItem(item)
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings = QgsMapSettings()
settings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
settings.setExtent(QgsRectangle(1250958, 1386945, 1420709, 1532518))
settings.setOutputSize(QSize(300, 300))
settings.setFlag(QgsMapSettings.Antialiasing, False)
rc = QgsRenderContext.fromMapSettings(settings)
rc.setCoordinateTransform(
QgsCoordinateTransform(layer.crs(), settings.destinationCrs(),
QgsProject.instance()))
image = QImage(200, 200, QImage.Format_ARGB32)
image.setDotsPerMeterX(96 / 25.4 * 1000)
image.setDotsPerMeterY(96 / 25.4 * 1000)
image.fill(QColor(255, 255, 255))
painter = QPainter(image)
rc.setPainter(painter)
try:
renderer = layer.createMapRenderer(rc)
renderer.render()
finally:
painter.end()
self.assertTrue(
self.imageCheck('layer_render_transform', 'layer_render_transform',
image))
def testRenderLayerWithReferenceScale(self):
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.assertTrue(layer.isValid())
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
])))
item.setSymbol(
QgsFillSymbol.createSimple({
'color': '200,100,100',
'outline_color': 'black',
'outline_width': '2'
}))
item.setZIndex(3)
i1_id = layer.addItem(item)
item = QgsAnnotationLineItem(
QgsLineString(
[QgsPoint(11, 13),
QgsPoint(12, 13),
QgsPoint(12, 15)]))
item.setSymbol(
QgsLineSymbol.createSimple({
'color': '#ffff00',
'line_width': '3'
}))
item.setZIndex(2)
i2_id = layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setSymbol(
QgsMarkerSymbol.createSimple({
'color': '100,200,200',
'size': '6',
'outline_color': 'black'
}))
item.setZIndex(1)
i3_id = layer.addItem(item)
settings = QgsMapSettings()
settings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings.setExtent(QgsRectangle(10, 10, 18, 18))
settings.setOutputSize(QSize(300, 300))
settings.setFlag(QgsMapSettings.Antialiasing, False)
rc = QgsRenderContext.fromMapSettings(settings)
layer.item(i1_id).setUseSymbologyReferenceScale(True)
layer.item(i1_id).setSymbologyReferenceScale(rc.rendererScale() * 2)
# note item 3 has use symbology reference scale set to false, so should be ignored
layer.item(i2_id).setUseSymbologyReferenceScale(False)
layer.item(i2_id).setSymbologyReferenceScale(rc.rendererScale() * 2)
layer.item(i3_id).setUseSymbologyReferenceScale(True)
layer.item(i3_id).setSymbologyReferenceScale(rc.rendererScale() * 2)
image = QImage(200, 200, QImage.Format_ARGB32)
image.setDotsPerMeterX(int(96 / 25.4 * 1000))
image.setDotsPerMeterY(int(96 / 25.4 * 1000))
image.fill(QColor(255, 255, 255))
painter = QPainter(image)
rc.setPainter(painter)
try:
renderer = layer.createMapRenderer(rc)
renderer.render()
finally:
painter.end()
self.assertTrue(
self.imageCheck('layer_render_reference_scale',
'layer_render_reference_scale', image))
# also check details of rendered items
item_details = renderer.takeRenderedItemDetails()
self.assertEqual([i.layerId() for i in item_details], [layer.id()] * 3)
self.assertCountEqual([i.itemId() for i in item_details],
[i1_id, i2_id, i3_id])
self.assertEqual(
[i.boundingBox() for i in item_details if i.itemId() == i1_id][0],
QgsRectangle(12, 13, 14, 15))
self.assertEqual(
[i.boundingBox() for i in item_details if i.itemId() == i2_id][0],
QgsRectangle(11, 13, 12, 15))
self.assertEqual([
i.boundingBox().toString(1) for i in item_details
if i.itemId() == i3_id
][0], '11.4,12.4 : 12.6,13.6')
def legend_test(self):
self.atlas_map.setAtlasDriven(True)
self.atlas_map.setAtlasScalingMode(QgsLayoutItemMap.Auto)
self.atlas_map.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer(
"Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)",
"points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRenderer("attr", [
QgsRendererCategory(
1,
QgsMarkerSymbol.createSimple({
"color": "255,0,0",
'outline_color': 'black'
}), "red"),
QgsRendererCategory(
2,
QgsMarkerSymbol.createSimple({
"color": "0,0,255",
'outline_color': 'black'
}), "blue")
])
ptLayer.setRenderer(r)
QgsProject.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.layers
layers = [ptLayer] + layers
self.atlas_map.setLayers(layers)
self.overview.setLayers(layers)
# add a legend
legend = QgsLayoutItemLegend(self.layout)
legend.attemptMove(QgsLayoutPoint(200, 100))
# sets the legend filter parameter
legend.setLinkedMap(self.atlas_map)
legend.setLegendFilterOutAtlas(True)
self.layout.addLayoutItem(legend)
self.atlas.beginRender()
self.atlas.seekTo(0)
self.mLabel1.adjustSizeToText()
checker = QgsLayoutChecker('atlas_legend', self.layout)
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.assertTrue(myTestResult, myMessage)
self.atlas.endRender()
# restore state
self.atlas_map.setLayers([layers[1]])
self.layout.removeLayoutItem(legend)
QgsProject.instance().removeMapLayer(ptLayer.id())
def setUp(self):
#Create some simple symbols
self.fill_symbol = QgsFillSymbol.createSimple({'color': '#ffffff'})
self.line_symbol = QgsLineSymbol.createSimple({'color': '#ffffff', 'line_width': '3'})
self.marker_symbol = QgsMarkerSymbol.createSimple({'color': '#ffffff', 'size': '3'})
self.report = "<h1>Python QgsSymbol Tests</h1>\n"
def testLegendRenderWithMapTheme(self):
"""Test rendering legends linked to map themes"""
QgsProject.instance().removeAllMapLayers()
point_path = os.path.join(TEST_DATA_DIR, 'points.shp')
point_layer = QgsVectorLayer(point_path, 'points', 'ogr')
line_path = os.path.join(TEST_DATA_DIR, 'lines.shp')
line_layer = QgsVectorLayer(line_path, 'lines', 'ogr')
QgsProject.instance().clear()
QgsProject.instance().addMapLayers([point_layer, line_layer])
marker_symbol = QgsMarkerSymbol.createSimple({'color': '#ff0000', 'outline_style': 'no', 'size': '5'})
point_layer.setRenderer(QgsSingleSymbolRenderer(marker_symbol))
point_layer.styleManager().addStyleFromLayer("red")
line_symbol = QgsLineSymbol.createSimple({'color': '#ff0000', 'line_width': '2'})
line_layer.setRenderer(QgsSingleSymbolRenderer(line_symbol))
line_layer.styleManager().addStyleFromLayer("red")
red_record = QgsMapThemeCollection.MapThemeRecord()
point_red_record = QgsMapThemeCollection.MapThemeLayerRecord(point_layer)
point_red_record.usingCurrentStyle = True
point_red_record.currentStyle = 'red'
red_record.addLayerRecord(point_red_record)
line_red_record = QgsMapThemeCollection.MapThemeLayerRecord(line_layer)
line_red_record.usingCurrentStyle = True
line_red_record.currentStyle = 'red'
red_record.addLayerRecord(line_red_record)
QgsProject.instance().mapThemeCollection().insert('red', red_record)
marker_symbol1 = QgsMarkerSymbol.createSimple({'color': '#0000ff', 'outline_style': 'no', 'size': '5'})
marker_symbol2 = QgsMarkerSymbol.createSimple(
{'color': '#0000ff', 'name': 'diamond', 'outline_style': 'no', 'size': '5'})
marker_symbol3 = QgsMarkerSymbol.createSimple(
{'color': '#0000ff', 'name': 'rectangle', 'outline_style': 'no', 'size': '5'})
point_layer.setRenderer(QgsCategorizedSymbolRenderer('Class', [QgsRendererCategory('B52', marker_symbol1, ''),
QgsRendererCategory('Biplane', marker_symbol2,
''),
QgsRendererCategory('Jet', marker_symbol3, ''),
]))
point_layer.styleManager().addStyleFromLayer("blue")
line_symbol = QgsLineSymbol.createSimple({'color': '#0000ff', 'line_width': '2'})
line_layer.setRenderer(QgsSingleSymbolRenderer(line_symbol))
line_layer.styleManager().addStyleFromLayer("blue")
blue_record = QgsMapThemeCollection.MapThemeRecord()
point_blue_record = QgsMapThemeCollection.MapThemeLayerRecord(point_layer)
point_blue_record.usingCurrentStyle = True
point_blue_record.currentStyle = 'blue'
blue_record.addLayerRecord(point_blue_record)
line_blue_record = QgsMapThemeCollection.MapThemeLayerRecord(line_layer)
line_blue_record.usingCurrentStyle = True
line_blue_record.currentStyle = 'blue'
blue_record.addLayerRecord(line_blue_record)
QgsProject.instance().mapThemeCollection().insert('blue', blue_record)
layout = QgsLayout(QgsProject.instance())
layout.initializeDefaults()
map1 = QgsLayoutItemMap(layout)
map1.attemptSetSceneRect(QRectF(20, 20, 80, 80))
map1.setFrameEnabled(True)
map1.setLayers([point_layer, line_layer])
layout.addLayoutItem(map1)
map1.setExtent(point_layer.extent())
map1.setFollowVisibilityPreset(True)
map1.setFollowVisibilityPresetName('red')
map2 = QgsLayoutItemMap(layout)
map2.attemptSetSceneRect(QRectF(20, 120, 80, 80))
map2.setFrameEnabled(True)
map2.setLayers([point_layer, line_layer])
layout.addLayoutItem(map2)
map2.setExtent(point_layer.extent())
map2.setFollowVisibilityPreset(True)
map2.setFollowVisibilityPresetName('blue')
legend = QgsLayoutItemLegend(layout)
legend.setTitle("Legend")
legend.attemptSetSceneRect(QRectF(120, 20, 80, 80))
legend.setFrameEnabled(True)
legend.setFrameStrokeWidth(QgsLayoutMeasurement(2))
legend.setBackgroundColor(QColor(200, 200, 200))
legend.setTitle('')
layout.addLayoutItem(legend)
legend.setLinkedMap(map1)
legend2 = QgsLayoutItemLegend(layout)
legend2.setTitle("Legend")
legend2.attemptSetSceneRect(QRectF(120, 120, 80, 80))
legend2.setFrameEnabled(True)
legend2.setFrameStrokeWidth(QgsLayoutMeasurement(2))
legend2.setBackgroundColor(QColor(200, 200, 200))
legend2.setTitle('')
layout.addLayoutItem(legend2)
legend2.setLinkedMap(map2)
checker = QgsLayoutChecker(
'composer_legend_theme', layout)
checker.setControlPathPrefix("composer_legend")
result, message = checker.testLayout()
TestQgsLayoutItemLegend.report += checker.report()
self.assertTrue(result, message)
QgsProject.instance().clear()
def run(self):
#coloco el puntero arriba del todo
#QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0 )
#genero una lista con los campos de la capa selecionada
layer = iface.activeLayer()
if layer is None:
iface.messageBar().pushMessage("ATENCION",
"Selecciona una capa de puntos",
duration=10)
if layer.wkbType() == 1 or layer.wkbType() == 1001:
prov = layer.dataProvider()
field_names = [field.name() for field in prov.fields()]
self.dlg.mycomboBox.clear()
for element in field_names:
self.dlg.mycomboBox.addItem(element)
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
global index_campo_seleccionado
distanciaminima = int(self.dlg.lineEdit_distancia.text())
# "layer" is a QgsVectorLayer instance
layer = iface.activeLayer()
idx = layer.fields().indexFromName("distanc")
if idx == -1:
print("ya existe")
res = layer.dataProvider().addAttributes(
[QgsField("distanc", QVariant.String)])
#layer.addAttribute(QgsField("valido", QVariant.String))
layer.updateFields()
features = layer.getFeatures()
for feature in features:
# retrieve every feature with its geometry and attributes
#print("Feature ID: ", feature.id())
# fetch geometry
# show some information about the feature geometry
geom = feature.geometry()
geomSingleType = QgsWkbTypes.isSingleType(geom.wkbType())
if geom.type() == QgsWkbTypes.PointGeometry:
punto = geom.asPoint()
x = punto.x()
y = punto.y()
#print("analizo los puntos",x,y)
features2 = layer.getFeatures()
for feature2 in features2:
geom2 = feature2.geometry()
punto2 = geom2.asPoint()
x3 = punto2.x()
y3 = punto2.y()
d = ((x3 - x)**2 + (y3 - y)**2)**0.5
if d < distanciaminima:
if feature2.id() == feature.id():
pass
else:
layer.startEditing()
feature.setAttribute("distanc", 'no')
print(feature2.id())
layer.updateFeature(feature)
#Call commit to save the changes
layer.commitChanges()
categorias = []
sym = QgsMarkerSymbol.createSimple({
'name': 'circle',
'color': 'red',
'size': '3'
})
categoria = QgsRendererCategory("no", sym, "No cumple")
categorias.append(categoria)
sym = QgsMarkerSymbol.createSimple({
'name': 'circle',
'color': 'blue',
'size': '2'
})
categoria = QgsRendererCategory("", sym, "Cumple")
categorias.append(categoria)
renderer = QgsCategorizedSymbolRenderer("distanc", categorias)
layer.setRenderer(renderer)
# update layer's extent when new features have been added
# because change of extent in provider is not propagated to the layer
#Configure label settings
settings = QgsPalLayerSettings()
settings.fieldName = field_names[
index_campo_seleccionado] #'name'
textFormat = QgsTextFormat()
textFormat.setSize(10)
settings.setFormat(textFormat)
#create and append a new rule
root = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings())
rule = QgsRuleBasedLabeling.Rule(settings)
#rule.setDescription(fieldName)
rule.setFilterExpression(''' "distanc" = 'no' ''')
root.appendChild(rule)
#Apply label configuration
rules = QgsRuleBasedLabeling(root)
layer.setLabeling(rules)
layer.setLabelsEnabled(True)
layer.triggerRepaint()
else:
iface.messageBar().pushMessage("ATENCION",
"Selecciona una capa de puntos",
duration=10)
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)
def create_basic_qgis_project(project_path=None, project_name=None):
"""
Create a basic QGIS project with OSM background and a simple vector layer.
:return: Project file path on successful creation of a new project, None otherwise
"""
if project_path is None:
project_path = get_new_qgis_project_filepath(project_name=project_name)
if project_path is None:
return False
new_project = QgsProject()
crs = QgsCoordinateReferenceSystem()
crs.createFromString("EPSG:3857")
new_project.setCrs(crs)
new_project.setFileName(project_path)
osm_url = "crs=EPSG:3857&type=xyz&zmin=0&zmax=19&url=http://tile.openstreetmap.org/{z}/{x}/{y}.png"
osm_layer = QgsRasterLayer(osm_url, "OpenStreetMap", "wms")
new_project.addMapLayer(osm_layer)
mem_uri = "Point?crs=epsg:3857"
mem_layer = QgsVectorLayer(mem_uri, "Survey points", "memory")
res = mem_layer.dataProvider().addAttributes([
QgsField("date", QVariant.DateTime),
QgsField("notes", QVariant.String),
QgsField("photo", QVariant.String),
])
mem_layer.updateFields()
vector_fname, err = save_vector_layer_as_gpkg(
mem_layer, os.path.dirname(project_path))
if err:
QMessageBox.warning(None, "Error Creating New Project",
f"Couldn't save vector layer to:\n{vector_fname}")
vector_layer = QgsVectorLayer(vector_fname, "Survey", "ogr")
symbol = QgsMarkerSymbol.createSimple({
'name': 'circle',
'color': '#d73027',
'size': '3',
"outline_color": '#e8e8e8',
'outline_style': 'solid',
'outline_width': '0.4'
})
vector_layer.renderer().setSymbol(symbol)
fid_ws = QgsEditorWidgetSetup("Hidden", {})
vector_layer.setEditorWidgetSetup(0, fid_ws)
datetime_config = {
'allow_null': True,
'calendar_popup': True,
'display_format': 'yyyy-MM-dd HH:mm:ss',
'field_format': 'yyyy-MM-dd HH:mm:ss',
'field_iso_format': False
}
datetime_ws = QgsEditorWidgetSetup("DateTime", datetime_config)
vector_layer.setEditorWidgetSetup(1, datetime_ws)
photo_config = {
'DocumentViewer': 1,
'DocumentViewerHeight': 0,
'DocumentViewerWidth': 0,
'FileWidget': True,
'FileWidgetButton': True,
'FileWidgetFilter': '',
'RelativeStorage': 1,
'StorageMode': 0,
'PropertyCollection': {
'name': NULL,
'properties': {},
'type': 'collection'
},
}
photo_ws = QgsEditorWidgetSetup("ExternalResource", photo_config)
vector_layer.setEditorWidgetSetup(3, photo_ws)
new_project.addMapLayer(vector_layer)
write_success = new_project.write()
if not write_success:
QMessageBox.warning(None, "Error Creating New Project",
f"Couldn't create new project:\n{project_path}")
return None
return project_path
def test_render_via_job(self):
"""
Test rendering an annotation layer via a map render job
"""
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(11.5, 13),
QgsPoint(12, 13),
QgsPoint(12, 13.5),
QgsPoint(11.5, 13)
])))
item.setSymbol(
QgsFillSymbol.createSimple({
'color': '200,100,100',
'outline_color': 'black',
'outline_width': '2'
}))
item.setZIndex(1)
i1_id = layer.addItem(item)
item = QgsAnnotationLineItem(
QgsLineString(
[QgsPoint(11, 13),
QgsPoint(12, 13),
QgsPoint(12, 15)]))
item.setSymbol(
QgsLineSymbol.createSimple({
'color': '#ffff00',
'line_width': '3'
}))
item.setZIndex(2)
i2_id = layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setSymbol(
QgsMarkerSymbol.createSimple({
'color': '100,200,200',
'size': '6',
'outline_color': 'black'
}))
item.setZIndex(3)
i3_id = layer.addItem(item)
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings = QgsMapSettings()
settings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings.setExtent(QgsRectangle(10, 10, 18, 18))
settings.setOutputSize(QSize(200, 200))
settings.setLayers([layer])
job = QgsMapRendererParallelJob(settings)
job.start()
job.waitForFinished()
# check rendered item results
item_results = job.takeRenderedItemResults()
item_details = item_results.renderedItems()
self.assertEqual(len(item_details), 3)
self.assertEqual([i.layerId() for i in item_details], [layer.id()] * 3)
self.assertCountEqual([i.itemId() for i in item_details],
[i1_id, i2_id, i3_id])
self.assertCountEqual([
i.itemId() for i in item_results.renderedAnnotationItemsInBounds(
QgsRectangle(0, 0, 1, 1))
], [])
self.assertCountEqual([
i.itemId() for i in item_results.renderedAnnotationItemsInBounds(
QgsRectangle(10, 10, 11, 18))
], [i2_id])
self.assertCountEqual([
i.itemId() for i in item_results.renderedAnnotationItemsInBounds(
QgsRectangle(10, 10, 12, 18))
], [i1_id, i2_id, i3_id])
# bounds should be in map crs
self.assertEqual(
[i.boundingBox() for i in item_details if i.itemId() == i1_id][0],
QgsRectangle(11.5, 13, 12, 13.5))
self.assertEqual(
[i.boundingBox() for i in item_details if i.itemId() == i2_id][0],
QgsRectangle(11, 13, 12, 15))
self.assertEqual([
i.boundingBox().toString(1) for i in item_details
if i.itemId() == i3_id
][0], '11.5,12.5 : 12.5,13.5')
def setStyle(self, layer, name):
if name == "":
return
stylePath = os.path.join(os.path.dirname(os.path.dirname(__file__)),
"layerStyles")
# user style
qmlPath = os.path.join(stylePath, name + "_user.qml")
if os.path.exists(qmlPath):
layer.loadNamedStyle(qmlPath)
return
# default style
qmlPath = os.path.join(stylePath, name + ".qml.bak")
if os.path.exists(qmlPath):
layer.loadNamedStyle(qmlPath)
svgPath = os.path.join(stylePath, name + ".svg")
if os.path.exists(svgPath):
if layer.geometryType() == 0: # Point
svg_style = dict()
svg_style['name'] = svgPath
svg_style['size'] = str(7)
if name == "demands":
svg_style['fill'] = '#9a1313'
symbol_layer = QgsSvgMarkerSymbolLayer.create(svg_style)
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
symbol.changeSymbolLayer(0, symbol_layer)
renderer = QgsSingleSymbolRenderer(symbol)
else: # Line
symbol = QgsLineSymbol().createSimple({})
symbol.deleteSymbolLayer(0)
# Line
lineSymbol = QgsSimpleLineSymbolLayer()
lineSymbol.setWidthUnit(2) # Pixels
lineSymbol.setWidth(1.5)
if name == "pipes":
lineSymbol.setColor(QColor("#0f1291"))
symbol.appendSymbolLayer(lineSymbol)
# Symbol
marker = QgsMarkerSymbol.createSimple({})
marker.deleteSymbolLayer(0)
svg_props = dict()
svg_props['name'] = svgPath
size = 5
if name == "pipes":
size = 0
svg_props['size'] = str(size)
svg_props['offset'] = '-0.5,-0.5'
svg_props['offset_unit'] = 'Pixel'
markerSymbol = QgsSvgMarkerSymbolLayer.create(svg_props)
marker.appendSymbolLayer(markerSymbol)
# Final Symbol
finalMarker = QgsMarkerLineSymbolLayer()
finalMarker.setSubSymbol(marker)
finalMarker.setPlacement(QgsMarkerLineSymbolLayer.CentralPoint)
symbol.appendSymbolLayer(finalMarker)
if name == "pipes":
prop = QgsProperty()
prop.setExpressionString(
"if(IniStatus is NULL, 0,if(IniStatus !='CV', 0,5))")
symbol.symbolLayer(1).setDataDefinedProperty(
9, prop) # 9 = PropertyWidth
renderer = QgsSingleSymbolRenderer(symbol)
layer.setRenderer(renderer)
def testBasic(self):
props = QgsVectorLayerElevationProperties(None)
self.assertEqual(props.zScale(), 1)
self.assertEqual(props.zOffset(), 0)
self.assertFalse(props.extrusionEnabled())
self.assertEqual(props.extrusionHeight(), 0)
self.assertFalse(props.hasElevation())
self.assertEqual(props.clamping(), Qgis.AltitudeClamping.Terrain)
self.assertEqual(props.binding(), Qgis.AltitudeBinding.Centroid)
props.setZOffset(0.5)
props.setZScale(2)
props.setClamping(Qgis.AltitudeClamping.Relative)
props.setBinding(Qgis.AltitudeBinding.Vertex)
props.setExtrusionHeight(10)
props.setExtrusionEnabled(True)
self.assertEqual(props.zScale(), 2)
self.assertEqual(props.zOffset(), 0.5)
self.assertEqual(props.extrusionHeight(), 10)
self.assertTrue(props.hasElevation())
self.assertTrue(props.extrusionEnabled())
self.assertEqual(props.clamping(), Qgis.AltitudeClamping.Relative)
self.assertEqual(props.binding(), Qgis.AltitudeBinding.Vertex)
sym = QgsLineSymbol.createSimple({
'outline_color': '#ff4433',
'outline_width': 0.5
})
props.setProfileLineSymbol(sym)
self.assertEqual(props.profileLineSymbol().color().name(), '#ff4433')
sym = QgsFillSymbol.createSimple({
'color': '#ff4455',
'outline_width': 0.5
})
props.setProfileFillSymbol(sym)
self.assertEqual(props.profileFillSymbol().color().name(), '#ff4455')
sym = QgsMarkerSymbol.createSimple({
'color': '#ff1122',
'outline_width': 0.5
})
props.setProfileMarkerSymbol(sym)
self.assertEqual(props.profileMarkerSymbol().color().name(), '#ff1122')
doc = QDomDocument("testdoc")
elem = doc.createElement('test')
props.writeXml(elem, doc, QgsReadWriteContext())
props2 = QgsVectorLayerElevationProperties(None)
props2.readXml(elem, QgsReadWriteContext())
self.assertEqual(props2.zScale(), 2)
self.assertEqual(props2.zOffset(), 0.5)
self.assertEqual(props2.clamping(), Qgis.AltitudeClamping.Relative)
self.assertEqual(props2.binding(), Qgis.AltitudeBinding.Vertex)
self.assertEqual(props2.extrusionHeight(), 10)
self.assertTrue(props2.extrusionEnabled())
self.assertEqual(props2.profileLineSymbol().color().name(), '#ff4433')
self.assertEqual(props2.profileFillSymbol().color().name(), '#ff4455')
self.assertEqual(props2.profileMarkerSymbol().color().name(),
'#ff1122')
def testRenderWithTransform(self):
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
item = QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(11.5, 13),
QgsPoint(12, 13),
QgsPoint(12, 13.5),
QgsPoint(11.5, 13)
])))
item.setSymbol(
QgsFillSymbol.createSimple({
'color': '200,100,100',
'outline_color': 'black',
'outline_width': '2'
}))
item.setZIndex(1)
i1_id = layer.addItem(item)
item = QgsAnnotationLineItem(
QgsLineString(
[QgsPoint(11, 13),
QgsPoint(12, 13),
QgsPoint(12, 15)]))
item.setSymbol(
QgsLineSymbol.createSimple({
'color': '#ffff00',
'line_width': '3'
}))
item.setZIndex(2)
i2_id = layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setSymbol(
QgsMarkerSymbol.createSimple({
'color': '100,200,200',
'size': '6',
'outline_color': 'black'
}))
item.setZIndex(3)
i3_id = layer.addItem(item)
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings = QgsMapSettings()
settings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
settings.setExtent(QgsRectangle(1250958, 1386945, 1420709, 1532518))
settings.setOutputSize(QSize(300, 300))
settings.setFlag(QgsMapSettings.Antialiasing, False)
rc = QgsRenderContext.fromMapSettings(settings)
rc.setCoordinateTransform(
QgsCoordinateTransform(layer.crs(), settings.destinationCrs(),
QgsProject.instance()))
rc.setExtent(rc.coordinateTransform().transformBoundingBox(
settings.extent(), QgsCoordinateTransform.ReverseTransform))
image = QImage(200, 200, QImage.Format_ARGB32)
image.setDotsPerMeterX(int(96 / 25.4 * 1000))
image.setDotsPerMeterY(int(96 / 25.4 * 1000))
image.fill(QColor(255, 255, 255))
painter = QPainter(image)
rc.setPainter(painter)
try:
renderer = layer.createMapRenderer(rc)
renderer.render()
finally:
painter.end()
self.assertTrue(
self.imageCheck('layer_render_transform', 'layer_render_transform',
image))
# also check details of rendered items
item_details = renderer.takeRenderedItemDetails()
self.assertEqual([i.layerId() for i in item_details], [layer.id()] * 3)
self.assertCountEqual([i.itemId() for i in item_details],
[i1_id, i2_id, i3_id])
self.assertEqual(
[i.boundingBox() for i in item_details if i.itemId() == i1_id][0],
QgsRectangle(11.5, 13, 12, 13.5))
self.assertEqual(
[i.boundingBox() for i in item_details if i.itemId() == i2_id][0],
QgsRectangle(11, 13, 12, 15))
self.assertEqual([
i.boundingBox().toString(2) for i in item_details
if i.itemId() == i3_id
][0], '11.94,12.94 : 12.06,13.06')
def processAlgorithm(self, parameters, context, feedback):
project = QgsProject()
project.setFileName(
os.path.join(parameters[self.FOLDER], "all-outputs-qgis.qgs"))
project.setCrs(QgsCoordinateReferenceSystem('EPSG:27700'))
def getMaxValue(layer, fieldname):
maxfound = float("-inf")
for f in layer.getFeatures():
attr = f.attribute(fieldname)
assert attr >= 0
if attr > maxfound:
maxfound = attr
return maxfound
with open(
os.path.join(parameters[self.FOLDER],
"all-town-metadata.json")) as f:
metadata = json.load(f)
classmethods = {
'quantile': QgsClassificationQuantile,
'jenks': QgsClassificationJenks,
'equal': QgsClassificationEqualInterval
}
html = ""
output = []
views_sorted_by_mode = sorted(metadata["views"],
key=lambda v: v["mode"])
for view in views_sorted_by_mode:
keysymbol = u'🔑'
viewname = view["label"]
keysign = ""
if viewname.find(keysymbol) != -1:
viewname = viewname.replace(keysymbol, '', 1)
keysign = "*** "
viewname = keysign + view["mode"] + " " + viewname
html += f"""
<h2>{viewname}</h2>
{view["description"]}
<ul>
"""
for layer in view["layers"]:
layername = viewname + " - " + layer["scalar_field_units"]
layerpath = os.path.join(parameters[self.FOLDER],
layer["file"])
vlayer = QgsVectorLayer(layerpath, layername, "ogr")
if not vlayer.isValid():
feedback.pushInfo("Layer failed to load: " + layerpath)
else:
context.temporaryLayerStore().addMapLayer(vlayer)
html += f"""<li><b>file:</b> {layer["file"]}"""
if "symbol_field" in layer:
html += f"""<ul>
<li><b>symbol field:</b> {layer["symbol_field"]}
</ul>
"""
categories = []
scalar_fieldname = layer["scalar_field"]
maxvalue = getMaxValue(vlayer, scalar_fieldname)
feedback.pushInfo("Max value for %s is %f" %
(scalar_fieldname, maxvalue))
for formality in ["I", "F"]:
for severity, colour in [(3, 'red'), (2, 'yellow'),
(1, 'green')]:
colour = {
("I", "red"): "#FF0000",
("I", "yellow"): "#FFFF00",
("I", "green"): "#00FF00",
("F", "red"): "#FF9999",
("F", "yellow"): "#FFFF66",
("F", "green"): "#99FF99",
}[(formality, colour)]
symbol_code = "%s%d" % (formality, severity)
if formality == "F":
symbol = QgsMarkerSymbol.createSimple({
'color':
colour,
'size':
'3',
'outline_color':
'#888888'
})
else:
assert (formality == "I")
symbol = QgsMarkerSymbol.createSimple({
'color':
colour,
'size':
'3',
'outline_color':
'#000000',
'name':
'star'
})
objTransf = QgsSizeScaleTransformer(
QgsSizeScaleTransformer.Flannery,
0, #minvalue
maxvalue, #maxvalue
3, #minsize
10, #maxsize
0, #nullsize
1) #exponent
objProp = QgsProperty()
objProp.setField(scalar_fieldname)
objProp.setTransformer(objTransf)
symbol.setDataDefinedSize(objProp)
label = {
"F": "Formal",
"I": "Informal"
}[formality] + " " + {
3: "Major",
2: "Secondary",
1: "Tertiary"
}[severity]
cat = QgsRendererCategory(
symbol_code, symbol, label, True)
categories.append(cat)
renderer = QgsCategorizedSymbolRenderer(
"Crossings", categories)
renderer.setClassAttribute(layer["symbol_field"])
vlayer.setRenderer(renderer)
else:
html += f"""<ul>
<li><b>field:</b> {layer["scalar_field"]}
<li><b>units:</b> {layer["scalar_field_units"]}
<li><b>recommended classification:</b> {layer["classes"]}
</ul>
"""
default_style = QgsStyle().defaultStyle()
color_ramp = default_style.colorRamp('bt')
renderer = QgsGraduatedSymbolRenderer()
renderer.setClassAttribute(layer["scalar_field"])
classmethod = classmethods[layer["classes"]]()
renderer.setClassificationMethod(classmethod)
renderer.updateClasses(vlayer, 5)
renderer.updateColorRamp(color_ramp)
vlayer.setRenderer(renderer)
project.addMapLayer(vlayer)
feedback.pushInfo("Loaded " + layerpath)
html += "</ul>"
project.write()
town = views_sorted_by_mode[0]["town"]
with open(os.path.join(parameters[self.FOLDER], "metadata.html"),
"w") as htmlfile:
htmlfile.write(
f"<html><head><title>{town} metadata</title></head><body><h1>{town}</h1>{html}</body></html>"
)
return {self.OUTPUT: output}
def testPasteSymbol(self):
button = QgsSymbolButton()
button.setSymbolType(QgsSymbol.Marker)
symbol = QgsMarkerSymbol.createSimple({})
symbol.setColor(QColor(255, 0, 0))
button.setSymbol(symbol)
button2 = QgsSymbolButton()
button2.setSymbolType(QgsSymbol.Marker)
symbol2 = QgsMarkerSymbol.createSimple({})
symbol2.setColor(QColor(0, 255, 0))
button2.setSymbol(symbol2)
button.copySymbol()
button2.pasteSymbol()
self.assertEqual(button2.symbol().color(), QColor(255, 0, 0))
# try pasting incompatible symbol
button2.setSymbolType(QgsSymbol.Fill)
fill_symbol = QgsFillSymbol.createSimple({})
fill_symbol.setColor(QColor(0, 0, 255))
button2.setSymbol(fill_symbol)
button.copySymbol() # copied a marker symbol
button2.pasteSymbol() # should have no effect
self.assertEqual(button2.symbol(), fill_symbol)
def legend_test(self):
self.atlas_map.setAtlasDriven(True)
self.atlas_map.setAtlasScalingMode(QgsLayoutItemMap.Auto)
self.atlas_map.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer("Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)", "points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRenderer("attr", [QgsRendererCategory(1, QgsMarkerSymbol.createSimple({"color": "255,0,0", 'outline_color': 'black'}), "red"),
QgsRendererCategory(2, QgsMarkerSymbol.createSimple({"color": "0,0,255", 'outline_color': 'black'}), "blue")])
ptLayer.setRenderer(r)
QgsProject.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.layers
layers = [ptLayer] + layers
self.atlas_map.setLayers(layers)
self.overview.setLayers(layers)
# add a legend
legend = QgsLayoutItemLegend(self.layout)
legend.setTitle("Legend")
legend.attemptMove(QgsLayoutPoint(200, 100))
# sets the legend filter parameter
legend.setLinkedMap(self.atlas_map)
legend.setLegendFilterOutAtlas(True)
self.layout.addLayoutItem(legend)
self.atlas.beginRender()
self.atlas.seekTo(0)
self.mLabel1.adjustSizeToText()
checker = QgsLayoutChecker('atlas_legend', self.layout)
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.assertTrue(myTestResult, myMessage)
self.atlas.endRender()
# restore state
self.atlas_map.setLayers([layers[1]])
self.layout.removeLayoutItem(legend)
QgsProject.instance().removeMapLayer(ptLayer.id())
