def testConvertFromGraduatedRenderer(self):
# Test converting graduated renderer to rule based
# First, try with a field based category (id)
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer("id", ranges)
r = QgsRuleBasedRenderer.convertFromRenderer(g)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" >= 0.000000 AND "id" <= 1.000000')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" > 1.000000 AND "id" <= 2.000000')
# Next try with an expression based range
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer("id / 2", ranges)
r = QgsRuleBasedRenderer.convertFromRenderer(g)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '(id / 2) >= 0.000000 AND (id / 2) <= 1.000000')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '(id / 2) > 1.000000 AND (id / 2) <= 2.000000')
# Last try with an expression which is just a quoted field name
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer('"id"', ranges)
r = QgsRuleBasedRenderer.convertFromRenderer(g)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" >= 0.000000 AND "id" <= 1.000000')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" > 1.000000 AND "id" <= 2.000000')
def testConvertFromCategorisedRenderer(self):
# Test converting categorised renderer to rule based
# First, try with a field based category (id)
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "id 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "id 2"))
cats.append(QgsRendererCategory('a\'b', QgsMarkerSymbol(), "id a'b"))
cats.append(QgsRendererCategory('a\nb', QgsMarkerSymbol(), "id a\\nb"))
cats.append(QgsRendererCategory('a\\b', QgsMarkerSymbol(), "id a\\\\b"))
cats.append(QgsRendererCategory('a\tb', QgsMarkerSymbol(), "id a\\tb"))
cats.append(QgsRendererCategory(['c', 'd'], QgsMarkerSymbol(), "c/d"))
c = QgsCategorizedSymbolRenderer("id", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(len(r.rootRule().children()), 7)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(), '"id" = \'a\'\'b\'')
self.assertEqual(r.rootRule().children()[3].filterExpression(), '"id" = \'a\\nb\'')
self.assertEqual(r.rootRule().children()[4].filterExpression(), '"id" = \'a\\\\b\'')
self.assertEqual(r.rootRule().children()[5].filterExpression(), '"id" = \'a\\tb\'')
self.assertEqual(r.rootRule().children()[6].filterExpression(), '"id" IN (\'c\',\'d\')')
# Next try with an expression based category
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
cats.append(QgsRendererCategory([3, 4], QgsMarkerSymbol(), "result 3/4"))
c = QgsCategorizedSymbolRenderer("id + 1", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(len(r.rootRule().children()), 3)
self.assertEqual(r.rootRule().children()[0].filterExpression(), 'id + 1 = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(), 'id + 1 = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(), 'id + 1 IN (3,4)')
# Last try with an expression which is just a quoted field name
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
cats.append(QgsRendererCategory([3, 4], QgsMarkerSymbol(), "result 3/4"))
c = QgsCategorizedSymbolRenderer('"id"', cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(len(r.rootRule().children()), 3)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(), '"id" IN (3,4)')
def testConvertFromCategorisedRenderer(self):
# Test converting categorised renderer to rule based
# First, try with a field based category (id)
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "id 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "id 2"))
cats.append(QgsRendererCategory("a'b", QgsMarkerSymbol(), "id a'b"))
cats.append(QgsRendererCategory("a\nb", QgsMarkerSymbol(), "id a\\nb"))
cats.append(QgsRendererCategory("a\\b", QgsMarkerSymbol(), "id a\\\\b"))
cats.append(QgsRendererCategory("a\tb", QgsMarkerSymbol(), "id a\\tb"))
c = QgsCategorizedSymbolRenderer("id", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(), "\"id\" = 'a''b'")
self.assertEqual(r.rootRule().children()[3].filterExpression(), "\"id\" = 'a\\nb'")
self.assertEqual(r.rootRule().children()[4].filterExpression(), "\"id\" = 'a\\\\b'")
self.assertEqual(r.rootRule().children()[5].filterExpression(), "\"id\" = 'a\\tb'")
# Next try with an expression based category
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
c = QgsCategorizedSymbolRenderer("id + 1", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(r.rootRule().children()[0].filterExpression(), "id + 1 = 1")
self.assertEqual(r.rootRule().children()[1].filterExpression(), "id + 1 = 2")
# Last try with an expression which is just a quoted field name
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
c = QgsCategorizedSymbolRenderer('"id"', cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" = 2')
def testRefineWithCategories(self):
# Test refining rule with categories (refs #10815)
# First, try with a field based category (id)
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "id 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "id 2"))
c = QgsCategorizedSymbolRenderer("id", cats)
QgsRuleBasedRenderer.refineRuleCategories(self.r2, c)
assert self.r2.children()[0].filterExpression() == '"id" = 1'
assert self.r2.children()[1].filterExpression() == '"id" = 2'
# Next try with an expression based category
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
c = QgsCategorizedSymbolRenderer("id + 1", cats)
QgsRuleBasedRenderer.refineRuleCategories(self.r1, c)
assert self.r1.children()[0].filterExpression() == 'id + 1 = 1'
assert self.r1.children()[1].filterExpression() == 'id + 1 = 2'
# Last try with an expression which is just a quoted field name
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
c = QgsCategorizedSymbolRenderer('"id"', cats)
QgsRuleBasedRenderer.refineRuleCategories(self.r3, c)
assert self.r3.children()[0].filterExpression() == '"id" = 1'
assert self.r3.children()[1].filterExpression() == '"id" = 2'
def testRefineWithCategories(self):
# Test refining rule with categories (refs #10815)
# First, try with a field based category (id)
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "id 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "id 2"))
c = QgsCategorizedSymbolRenderer("id", cats)
QgsRuleBasedRenderer.refineRuleCategories(self.r2, c)
assert self.r2.children()[0].filterExpression() == '"id" = 1'
assert self.r2.children()[1].filterExpression() == '"id" = 2'
# Next try with an expression based category
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
c = QgsCategorizedSymbolRenderer("id + 1", cats)
QgsRuleBasedRenderer.refineRuleCategories(self.r1, c)
assert self.r1.children()[0].filterExpression() == 'id + 1 = 1'
assert self.r1.children()[1].filterExpression() == 'id + 1 = 2'
# Last try with an expression which is just a quoted field name
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
c = QgsCategorizedSymbolRenderer('"id"', cats)
QgsRuleBasedRenderer.refineRuleCategories(self.r3, c)
assert self.r3.children()[0].filterExpression() == '"id" = 1'
assert self.r3.children()[1].filterExpression() == '"id" = 2'
def testConvertFromCategorisedRenderer(self):
# Test converting categorised renderer to rule based
# First, try with a field based category (id)
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "id 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "id 2"))
cats.append(QgsRendererCategory('a\'b', QgsMarkerSymbol(), "id a'b"))
cats.append(QgsRendererCategory('a\nb', QgsMarkerSymbol(), "id a\\nb"))
cats.append(QgsRendererCategory('a\\b', QgsMarkerSymbol(), "id a\\\\b"))
cats.append(QgsRendererCategory('a\tb', QgsMarkerSymbol(), "id a\\tb"))
c = QgsCategorizedSymbolRenderer("id", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(), '"id" = \'a\'\'b\'')
self.assertEqual(r.rootRule().children()[3].filterExpression(), '"id" = \'a\\nb\'')
self.assertEqual(r.rootRule().children()[4].filterExpression(), '"id" = \'a\\\\b\'')
self.assertEqual(r.rootRule().children()[5].filterExpression(), '"id" = \'a\\tb\'')
# Next try with an expression based category
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
c = QgsCategorizedSymbolRenderer("id + 1", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(r.rootRule().children()[0].filterExpression(), 'id + 1 = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(), 'id + 1 = 2')
# Last try with an expression which is just a quoted field name
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
c = QgsCategorizedSymbolRenderer('"id"', cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" = 2')
def testRefineWithRanges(self):
# Test refining rule with ranges (refs #10815)
# First, try with a field based category (id)
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer("id", ranges)
QgsRuleBasedRenderer.refineRuleRanges(self.r2, g)
assert self.r2.children()[0].filterExpression() == '"id" >= 0.0000 AND "id" <= 1.0000'
assert self.r2.children()[1].filterExpression() == '"id" > 1.0000 AND "id" <= 2.0000'
# Next try with an expression based range
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer("id / 2", ranges)
QgsRuleBasedRenderer.refineRuleRanges(self.r1, g)
assert self.r1.children()[0].filterExpression() == '(id / 2) >= 0.0000 AND (id / 2) <= 1.0000'
assert self.r1.children()[1].filterExpression() == '(id / 2) > 1.0000 AND (id / 2) <= 2.0000'
# Last try with an expression which is just a quoted field name
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer('"id"', ranges)
QgsRuleBasedRenderer.refineRuleRanges(self.r3, g)
assert self.r3.children()[0].filterExpression() == '"id" >= 0.0000 AND "id" <= 1.0000'
assert self.r3.children()[1].filterExpression() == '"id" > 1.0000 AND "id" <= 2.0000'
def testRefineWithRanges(self):
# Test refining rule with ranges (refs #10815)
# First, try with a field based category (id)
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer("id", ranges)
QgsRuleBasedRenderer.refineRuleRanges(self.r2, g)
assert self.r2.children()[0].filterExpression() == '"id" >= 0.0000 AND "id" <= 1.0000'
assert self.r2.children()[1].filterExpression() == '"id" > 1.0000 AND "id" <= 2.0000'
# Next try with an expression based range
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer("id / 2", ranges)
QgsRuleBasedRenderer.refineRuleRanges(self.r1, g)
assert self.r1.children()[0].filterExpression() == '(id / 2) >= 0.0000 AND (id / 2) <= 1.0000'
assert self.r1.children()[1].filterExpression() == '(id / 2) > 1.0000 AND (id / 2) <= 2.0000'
# Last try with an expression which is just a quoted field name
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer('"id"', ranges)
QgsRuleBasedRenderer.refineRuleRanges(self.r3, g)
assert self.r3.children()[0].filterExpression() == '"id" >= 0.0000 AND "id" <= 1.0000'
assert self.r3.children()[1].filterExpression() == '"id" > 1.0000 AND "id" <= 2.0000'
def testConvertFromEmbedded(self):
"""
Test converting an embedded symbol renderer to a rule based renderer
"""
points_layer = QgsVectorLayer('Point', 'Polys', 'memory')
f = QgsFeature()
f.setGeometry(QgsGeometry.fromWkt('Point(-100 30)'))
f.setEmbeddedSymbol(
QgsMarkerSymbol.createSimple({
'name': 'triangle',
'size': 10,
'color': '#ff0000',
'outline_style': 'no'
}))
self.assertTrue(points_layer.dataProvider().addFeature(f))
f.setGeometry(QgsGeometry.fromWkt('Point(-110 40)'))
f.setEmbeddedSymbol(
QgsMarkerSymbol.createSimple({
'name': 'square',
'size': 7,
'color': '#00ff00',
'outline_style': 'no'
}))
self.assertTrue(points_layer.dataProvider().addFeature(f))
f.setGeometry(QgsGeometry.fromWkt('Point(-90 50)'))
f.setEmbeddedSymbol(None)
self.assertTrue(points_layer.dataProvider().addFeature(f))
renderer = QgsEmbeddedSymbolRenderer(
defaultSymbol=QgsMarkerSymbol.createSimple({
'name': 'star',
'size': 10,
'color': '#ff00ff',
'outline_style': 'no'
}))
points_layer.setRenderer(renderer)
rule_based = QgsRuleBasedRenderer.convertFromRenderer(
renderer, points_layer)
self.assertEqual(len(rule_based.rootRule().children()), 3)
rule_0 = rule_based.rootRule().children()[0]
self.assertEqual(rule_0.filterExpression(), '$id=1')
self.assertEqual(rule_0.label(), '1')
self.assertEqual(rule_0.symbol().color().name(), '#ff0000')
rule_1 = rule_based.rootRule().children()[1]
self.assertEqual(rule_1.filterExpression(), '$id=2')
self.assertEqual(rule_1.label(), '2')
self.assertEqual(rule_1.symbol().color().name(), '#00ff00')
rule_2 = rule_based.rootRule().children()[2]
self.assertEqual(rule_2.filterExpression(), 'ELSE')
self.assertEqual(rule_2.label(), 'All other features')
self.assertEqual(rule_2.symbol().color().name(), '#ff00ff')
def setUp(self):
myShpFile = os.path.join(TEST_DATA_DIR, 'rectangles.shp')
layer = QgsVectorLayer(myShpFile, 'Rectangles', 'ogr')
vfield = QgsField('fa_cy-fie+ld', QVariant.Int)
layer.addExpressionField('"id"', vfield)
QgsProject.instance().addMapLayer(layer)
# Create rulebased style
sym1 = QgsFillSymbol.createSimple({
'color': '#fdbf6f',
'outline_color': 'black'
})
sym2 = QgsFillSymbol.createSimple({
'color': '#71bd6c',
'outline_color': 'black'
})
sym3 = QgsFillSymbol.createSimple({
'color': '#1f78b4',
'outline_color': 'black'
})
self.r1 = QgsRuleBasedRenderer.Rule(sym1, 0, 0, '"id" = 1')
self.r2 = QgsRuleBasedRenderer.Rule(sym2, 0, 0, '"id" = 2')
self.r3 = QgsRuleBasedRenderer.Rule(sym3, 0, 0, 'ELSE')
rootrule = QgsRuleBasedRenderer.Rule(None)
rootrule.appendChild(self.r1)
rootrule.appendChild(self.r2)
rootrule.appendChild(self.r3)
layer.setRenderer(QgsRuleBasedRenderer(rootrule))
self.mapsettings = QgsMapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52))
rendered_layers = [layer]
self.mapsettings.setLayers(rendered_layers)
self.mapsettings_archive.append(self.mapsettings)
def setUp(self):
self.iface = get_iface()
myShpFile = os.path.join(TEST_DATA_DIR, 'rectangles.shp')
layer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
QgsProject.instance().addMapLayer(layer)
# Create rulebased style
sym1 = QgsFillSymbol.createSimple({
'color': '#fdbf6f',
'outline_color': 'black'
})
sym2 = QgsFillSymbol.createSimple({
'color': '#71bd6c',
'outline_color': 'black'
})
sym3 = QgsFillSymbol.createSimple({
'color': '#1f78b4',
'outline_color': 'black'
})
self.r1 = QgsRuleBasedRenderer.Rule(sym1, 0, 0, '"id" = 1')
self.r2 = QgsRuleBasedRenderer.Rule(sym2, 0, 0, '"id" = 2')
self.r3 = QgsRuleBasedRenderer.Rule(sym3, 0, 0, 'ELSE')
self.rootrule = QgsRuleBasedRenderer.Rule(None)
self.rootrule.appendChild(self.r1)
self.rootrule.appendChild(self.r2)
self.rootrule.appendChild(self.r3)
self.renderer = QgsRuleBasedRenderer(self.rootrule)
layer.setRenderer(self.renderer)
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52))
rendered_layers = [layer]
self.mapsettings.setLayers(rendered_layers)
def testWillRenderFeatureTwoElse(self):
"""Regression #21287, also test rulesForFeature since there were no tests any where and I've found a couple of issues"""
vl = self.mapsettings.layers()[0]
ft = vl.getFeature(0) # 'id' = 1
ctx = QgsRenderContext.fromMapSettings(self.mapsettings)
ctx.expressionContext().setFeature(ft)
# Create rulebased style
sym2 = QgsFillSymbol.createSimple({'color': '#71bd6c', 'outline_color': 'black'})
sym3 = QgsFillSymbol.createSimple({'color': '#1f78b4', 'outline_color': 'black'})
sym4 = QgsFillSymbol.createSimple({'color': '#ff00ff', 'outline_color': 'black'})
self.rx2 = QgsRuleBasedRenderer.Rule(sym2, 0, 0, '"id" = 200')
self.rx3 = QgsRuleBasedRenderer.Rule(sym3, 1000, 100000000, 'ELSE') # <<< - match this!
self.rx4 = QgsRuleBasedRenderer.Rule(sym4, 0.1, 999, 'ELSE')
rootrule = QgsRuleBasedRenderer.Rule(None)
rootrule.appendChild(self.rx2)
rootrule.appendChild(self.rx3)
rootrule.appendChild(self.rx4) # <- failed in regression #21287
vl.setRenderer(QgsRuleBasedRenderer(rootrule))
renderer = vl.renderer()
# Render with else rule and all activated
renderer.startRender(ctx, vl.fields())
self.assertTrue(renderer.willRenderFeature(ft, ctx))
# No context? All rules
self.assertEqual(len(rootrule.rulesForFeature(ft)), 2)
self.assertTrue(set(rootrule.rulesForFeature(ft)), set([self.rx3, self.rx4]))
# With context: only the matching one
self.assertEqual(len(rootrule.rulesForFeature(ft, ctx)), 1)
self.assertEqual(rootrule.rulesForFeature(ft, ctx)[0], self.rx3)
renderer.stopRender(ctx)
def testConvertFromGraduatedRenderer(self):
# Test converting graduated renderer to rule based
# First, try with a field based category (id)
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer("id", ranges)
r = QgsRuleBasedRenderer.convertFromRenderer(g)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'"id" >= 0.000000 AND "id" <= 1.000000')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'"id" > 1.000000 AND "id" <= 2.000000')
# Next try with an expression based range
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer("id / 2", ranges)
r = QgsRuleBasedRenderer.convertFromRenderer(g)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'(id / 2) >= 0.000000 AND (id / 2) <= 1.000000')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'(id / 2) > 1.000000 AND (id / 2) <= 2.000000')
# Last try with an expression which is just a quoted field name
ranges = []
ranges.append(QgsRendererRange(0, 1, QgsMarkerSymbol(), "0-1"))
ranges.append(QgsRendererRange(1, 2, QgsMarkerSymbol(), "1-2"))
g = QgsGraduatedSymbolRenderer('"id"', ranges)
r = QgsRuleBasedRenderer.convertFromRenderer(g)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'"id" >= 0.000000 AND "id" <= 1.000000')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'"id" > 1.000000 AND "id" <= 2.000000')
def color_depares(layer, isoBreaks):
# https://gis.stackexchange.com/a/282345
# DEPARE COLORS and LIMITS
# [land, intertidal, danger, shallow, deep]
limits = [0, 2, 5, 8]
limits = isoBreaks
landLimit = [-10e9, limits[0]]
intertidalLimit = [limits[0], limits[1]]
dangerLimit = [limits[1], limits[2]]
shallowLimit = [limits[2], limits[3]]
deepLimit = [limits[3], 10e9]
landColor = [248, 243, 161]
intertidalColor = [187, 217, 146]
dangerColor = [190, 229, 238]
shallowColor = [232, 246, 249]
deepColor = [255, 255, 255]
#
fullList = [[landLimit, landColor, 'land'],
[intertidalLimit, intertidalColor, 'intertidal'],
[dangerLimit, dangerColor, 'danger'],
[shallowLimit, shallowColor, 'shallow'],
[deepLimit, deepColor, 'deep']]
fullList.reverse()
#
print('depare!')
# layer = iface.activeLayer()
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
renderer = QgsRuleBasedRenderer(symbol)
#
for pair in fullList:
expression = ' if(\"dep_min\" < {}, True, None) '.format(pair[0][1])
color = pair[1]
label = '{} (>{})'.format(pair[2], pair[0][1])
rule_based_style(layer, symbol, renderer, label, expression, color)
renderer.rootRule().removeChildAt(0)
iface.layerTreeView().refreshLayerSymbology(layer.id())
def testUsedAttributes(self):
ctx = QgsRenderContext.fromMapSettings(self.mapsettings)
# Create rulebased style
sym2 = QgsFillSymbol.createSimple({'color': '#71bd6c', 'outline_color': 'black'})
sym3 = QgsFillSymbol.createSimple({'color': '#1f78b4', 'outline_color': 'black'})
self.rx2 = QgsRuleBasedRenderer.Rule(sym2, 0, 0, '"id" = 200')
self.rx3 = QgsRuleBasedRenderer.Rule(sym3, 1000, 100000000, 'ELSE')
rootrule = QgsRuleBasedRenderer.Rule(None)
rootrule.appendChild(self.rx2)
rootrule.appendChild(self.rx3)
renderer = QgsRuleBasedRenderer(rootrule)
self.assertCountEqual(renderer.usedAttributes(ctx), {'id'})
def addSymbol(self, expression):
renderer = self.layer.renderer()
symbolType = renderer.type()
if symbolType in ("nullSymbol", "invertedPolygonRenderer", "25dRenderer", "grassEdit", "heatmapRenderer", "pointCluster", "pointDisplacement"):
return False
elif symbolType == "singleSymbol":
sym = renderer.symbol()
sym_layer = QgsGeometryGeneratorSymbolLayer.create(
{'geometryModifier': expression})
sym_layer.setSymbolType(QgsSymbol.Line)
sym_layer.subSymbol().symbolLayer(0).setStrokeColor(QColor(0, 0, 0))
sym.appendSymbolLayer(sym_layer)
return True
elif symbolType in ("categorizedSymbol", "graduatedSymbol"):
for sym in renderer.symbols(QgsRenderContext.fromMapSettings(self.iface.mapCanvas().mapSettings())):
sym_layer = QgsGeometryGeneratorSymbolLayer.create(
{'geometryModifier': expression})
sym_layer.setSymbolType(QgsSymbol.Line)
sym_layer.subSymbol().symbolLayer(0).setStrokeColor(QColor(0, 0, 0))
sym.appendSymbolLayer(sym_layer)
return True
elif symbolType == "RuleRenderer":
qgsSymbols = [QgsMarkerSymbol, QgsLineSymbol, QgsFillSymbol]
sym = qgsSymbols[self.layer.geometryType()]()
sym_layer = QgsGeometryGeneratorSymbolLayer.create(
{'geometryModifier': expression})
sym_layer.setSymbolType(QgsSymbol.Line)
sym_layer.subSymbol().symbolLayer(0).setStrokeColor(QColor(0, 0, 0))
sym.changeSymbolLayer(0, sym_layer)
r = QgsRuleBasedRenderer.Rule(
sym, label="label connector", description="label connector")
renderer.rootRule().appendChild(r)
return True
def set_selection_based_style(layer, s_color, else_color):
# noinspection PyCallByClass
fill_for_selected = QgsFillSymbol.createSimple({'color': 'blue'})
fill_for_selected.setColor(s_color)
rule_s = QgsRuleBasedRenderer.Rule(fill_for_selected, label=tr(u"Selected"),
filterExp="is_selected()")
fill_for_else = fill_for_selected.clone()
fill_for_else.setColor(else_color)
rule_else = QgsRuleBasedRenderer.Rule(fill_for_else, label=tr(u"Not Selected"),
elseRule=True)
renderer = QgsRuleBasedRenderer(QgsRuleBasedRenderer.Rule(None))
root_rule = renderer.rootRule()
root_rule.appendChild(rule_s)
root_rule.appendChild(rule_else)
layer.setRenderer(renderer)
return layer
def testGroupAndElseRules(self):
vl = self.mapsettings.layers()[0]
# Create rulebased style
sym1 = QgsFillSymbol.createSimple({
'color': '#fdbf6f',
'outline_color': 'black'
})
sym2 = QgsFillSymbol.createSimple({
'color': '#71bd6c',
'outline_color': 'black'
})
sym3 = QgsFillSymbol.createSimple({
'color': '#1f78b4',
'outline_color': 'black'
})
self.rx1 = QgsRuleBasedRenderer.Rule(None, 0, 0, '"id" < 3')
self.rx2 = QgsRuleBasedRenderer.Rule(sym3, 0, 0, 'ELSE')
self.subrx1 = QgsRuleBasedRenderer.Rule(sym1, 0, 0, '"id" = 1')
self.subrx2 = QgsRuleBasedRenderer.Rule(sym2, 0, 0, '"id" = 2')
self.rx1.appendChild(self.subrx1)
self.rx1.appendChild(self.subrx2)
rootrule = QgsRuleBasedRenderer.Rule(None)
rootrule.appendChild(self.rx1)
rootrule.appendChild(self.rx2)
rootrule.children()[0].children()[0].setActive(False)
rootrule.children()[0].children()[1].setActive(False)
vl.setRenderer(QgsRuleBasedRenderer(rootrule))
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlName('expected_rulebased_group_else')
self.assertTrue(renderchecker.runTest('rulebased_group_else'))
def apply_style(layer, style, is_new, name):
"""Apply the style to a new or existing layer
:param layer: QGIS layer instance
:type layer: QgsVectorLayer
:param style: optional, dictionary with style properties: example {'color': [100, 50, 123], 'transparency': 0.5, 'stroke_width: 3 }
:type style: dict
:param is_new: True is the layer is a new layer
:type is_new: bool
:param name: name of the isochrone, if blank/None create a timestamp for the name if the layer is not new
:type name: str
"""
if style is None:
return
def _set_labeling():
pal_layer = QgsPalLayerSettings()
pal_layer.fieldName = 'value'
pal_layer.enabled = True
pal_layer.placementFlags = QgsLabeling.OnLine
pal_layer.placement = QgsPalLayerSettings.PerimeterCurved
text_format = pal_layer.format()
buffer = text_format.buffer()
buffer.setColor(QColor(255, 255, 255))
buffer.setOpacity(0.5)
buffer.setEnabled(True)
text_format.setBuffer(buffer)
pal_layer.setFormat(text_format)
labels = QgsVectorLayerSimpleLabeling(pal_layer)
return labels
def _set_rule(renderer):
root_rule = renderer.rootRule()
if is_new:
rule = root_rule.children()[0]
else:
rule = root_rule.children()[0].clone()
rule.setLabel(name)
expression = '"name" = {}'.format(QgsExpression.quotedString(name))
rule.setFilterExpression(expression)
rule.symbol().setColor(QColor(*style['color'], 255))
rule.symbol().setOpacity(1 - style['transparency'])
rule.symbol().symbolLayers()[0].setStrokeWidth(style['stroke_width'])
rule.symbol().symbolLayers()[0].setStrokeColor(QColor(255, 255, 255))
if not is_new:
root_rule.appendChild(rule)
if is_new: # Create the new style
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
renderer = QgsRuleBasedRenderer(symbol)
req = QgsFeatureRequest()
req.addOrderBy('"value"', False, False)
renderer.setOrderBy(req.orderBy())
renderer.setOrderByEnabled(True)
_set_rule(renderer)
# Delete first rule
layer.setRenderer(renderer)
labels = _set_labeling()
layer.setLabeling(labels)
layer.setCustomProperty("labeling/bufferDraw", True)
layer.setLabelsEnabled(True)
else:
# Check for rule based renderer, pass if not present
renderer = layer.renderer()
if isinstance(renderer, QgsRuleBasedRenderer):
_set_rule(renderer)
def get_style(self):
"""Get map styles. Get Fill color, label font, outline color.
This function takes layer as input and configures style dictionary
which is sent as HTTP request in order to adequatly represent
map style on GIS Cloud.
"""
LOGGER.debug('Started map_styles function')
if ISQGIS3:
self.scale_pixels = \
iface.mapCanvas().mapSettings().outputDpi() / 72
else:
self.scale_pixels = \
iface.mapCanvas().mapRenderer().outputDpi() / 72
self.unit_to_px = {
"MM": 3.78 * self.scale_pixels,
"Point": 1.33 * self.scale_pixels,
"Inch": 96 * self.scale_pixels,
# these two aren't yet supported by GC rendering,
# so defaulting them to value of 1 px
"MapUnit": None,
"RenderMetersInMapUnits": None
}
layer_fromlevel = 0
layer_tolevel = 0
if self.qgis_layer.hasScaleBasedVisibility():
dpi = iface.mainWindow().physicalDpiX()
max_scale_per_pixel = 156543.04
inches_per_meter = 39.37
factor = dpi * inches_per_meter * max_scale_per_pixel
if self.qgis_layer.minimumScale() > 0:
layer_fromlevel = int(
round(
math.log((factor / self.qgis_layer.minimumScale()), 2),
0))
if self.qgis_layer.maximumScale() > 0:
layer_tolevel = int(
round(
math.log((factor / self.qgis_layer.maximumScale()), 2),
0))
if not ISQGIS3:
# QGis2 has oposite logic with min/max scales
# so we need to switch them
(layer_tolevel, layer_fromlevel) = \
(layer_fromlevel, layer_tolevel)
styles = []
tmp_dir = self.gc_api.qgis_api.tmp_dir
if ISQGIS3:
renderer = QgsRuleBasedRenderer.convertFromRenderer(
self.qgis_layer.renderer())
else:
renderer = QgsRuleBasedRendererV2.convertFromRenderer(
self.qgis_layer.rendererV2())
for rule in renderer.rootRule().children():
symbol = rule.symbol()
sym_size = 0
if self.layer.type[0] == "point":
for layer_sym in symbol.symbolLayers():
temp_style = layer_sym.properties()
self.convert_units_to_px(temp_style)
if "size" in temp_style and \
float(temp_style["size"]) > sym_size:
sym_size = float(temp_style["size"])
is_first_sym = True
index = symbol.symbolLayerCount()
while index > 0:
index = index - 1
layer_sym = symbol.symbolLayer(index)
temp_style = layer_sym.properties()
self.convert_units_to_px(temp_style)
val_label = None
# in case of multiple symbolLayers()
# labels should be set only once
if is_first_sym:
if ISQGIS3:
if self.qgis_layer.labelsEnabled():
val_label = self.qgis_layer.labeling().settings()
else:
val_label = QgsPalLayerSettings()
val_label.readFromLayer(self.qgis_layer)
style = {}
line_style = "line_style"
line_width = 0
if self.layer.type[0] == "point":
size = int(round(sym_size)) + 2
md5 = hashlib.md5()
properties = str(temp_style) + self.dump_symbol_properties(
layer_sym.subSymbol())
md5.update(properties.encode('utf-8'))
symbol_file = "{}_{}.png".format(self.layer.id,
md5.hexdigest())
style['iconsoverlap'] = 2
style['url'] = {
"full_path": tmp_dir + '/' + symbol_file,
"file": symbol_file,
"symbol": symbol.clone(),
"size": QSize(size, size)
}
elif self.layer.type[0] == "line":
LOGGER.info('entered line_type part of function')
LOGGER.info(temp_style)
try:
if u'line_color' in temp_style:
style['color'] = ','.join(
temp_style[u'line_color'].split(',')[0:3])
style['bordercolor'] = style['color']
if u'line_width' in temp_style:
style['width'] = temp_style[u'line_width']
else:
style['width'] = '1'
line_width = float(style['width'])
except Exception:
LOGGER.info(
'Failed while mapping style for line vector layer',
exc_info=True)
if ('color' or 'bordercolor') not in style:
style['color'] = '0,0,0'
style['bordercolor'] = '0,0,0'
LOGGER.info('Style is{}'.format(style))
# VectorPolygonLayer styles -> dashed line
# and offset possibilities
elif self.layer.type[0] == "polygon":
line_style = "outline_style"
has_border = not ("outline_style" in temp_style
and temp_style["outline_style"] == "no")
if layer_sym.layerType() == 'SimpleFill':
if u'outline_color' in temp_style and has_border:
style['bordercolor'] = \
','.join(
temp_style[u'outline_color']
.split(',')[0:3])
if u'outline_width' in temp_style and has_border:
style['borderwidth'] = temp_style[u'outline_width']
if u'color' in temp_style and \
"style" in temp_style and \
temp_style["style"] == "solid":
style['color'] = ','.join(
temp_style[u'color'].split(',')[0:3])
elif layer_sym.layerType() == 'SimpleLine':
if u'line_color' in temp_style:
style['bordercolor'] = \
','.join(
temp_style[u'line_color']
.split(',')[0:3])
if u'line_width' in temp_style:
style['line_width'] = temp_style[u'line_width']
elif u'color1' in temp_style:
style['color'] = ','.join(
temp_style[u'color1'].split(',')[0:3])
style['borderwidth'] = '1'
if has_border:
style['bordercolor'] = '0,0,0'
else:
style['bordercolor'] = '0,0,0'
if has_border:
style['borderwidth'] = '1'
style['color'] = '0,0,0'
if "borderwidth" in style:
line_width = float(style['borderwidth'])
if (layer_sym.layerType() != "SimpleFill" and
layer_sym.layerType() != "SimpleLine") or \
("style" in temp_style and
not temp_style["style"] in ["solid", "no"]):
if layer_sym.layerType() != "SimpleFill":
temp_symbol = symbol.clone()
tmp_sym_layer = temp_symbol.symbolLayer(index)
while temp_symbol.symbolLayerCount() > 1:
if temp_symbol.symbolLayer(0) == tmp_sym_layer:
temp_symbol.deleteSymbolLayer(1)
else:
temp_symbol.deleteSymbolLayer(0)
else:
temp_style_hatch = temp_style.copy()
temp_style_hatch["outline_style"] = "no"
if ISQGIS3:
temp_symbol = QgsFillSymbol.createSimple(
temp_style_hatch)
else:
temp_symbol = QgsFillSymbolV2.createSimple(
temp_style_hatch)
properties = self.dump_symbol_properties(temp_symbol)
md5 = hashlib.md5()
md5.update(properties.encode('utf-8'))
symbol_file = "{}_{}.png"\
.format(self.layer.id, md5.hexdigest())
style['hatchUrl'] = {
"full_path": tmp_dir + '/' + symbol_file,
"file": symbol_file,
"symbol": temp_symbol,
"size": QSize(64, 64)
}
if "use_custom_dash" in temp_style and \
temp_style["use_custom_dash"] == '1':
style['dashed'] = temp_style[u'customdash'].replace(
';', ',')
if ("dashed" not in style and line_style in temp_style
and not temp_style[line_style] in ["solid", "no"]):
process_dash_param(temp_style[line_style], line_width,
style)
if ISQGIS3:
if val_label is not None:
label_format = val_label.format()
style['fontsize'] = label_format.size()
style['labelfield'] = val_label.fieldName.lower()
style['fontcolor'] = \
rgb_int2tuple(label_format.color().rgb())
if label_format.buffer().enabled():
style['outline'] = \
rgb_int2tuple(
label_format.buffer().color().rgb())
if self.qgis_layer.geometryType() == 1:
style['labelfield'] = ''
style['textfield'] = val_label.fieldName.lower()
if str(label_format.font().family()) in \
self.supported_fonts:
style['fontname'] = label_format.font().family()
else:
style['fontname'] = 'Arial'
LOGGER.info(
("Choosen font is not supported, " +
"so every font style has been changed " +
"to {0}").format(style['fontname']))
self.setup_label_offset(val_label, style)
else:
if val_label is not None and val_label.enabled:
style['fontsize'] = val_label.textFont.pointSize()
style['labelfield'] = val_label.fieldName.lower()
style['fontcolor'] = rgb_int2tuple(
val_label.textColor.rgb())
if val_label.bufferDraw:
style['outline'] = rgb_int2tuple(
val_label.bufferColor.rgb())
if self.qgis_layer.geometryType() == 1:
style['labelfield'] = ''
style['textfield'] = val_label.fieldName.lower()
if str(val_label.textFont.family()) in \
self.supported_fonts:
style['fontname'] = val_label.textFont.family()
else:
style['fontname'] = 'Arial'
LOGGER.info("Choosen font is not supported, so " +
"every font style has been changed " +
" to {0}".format(style['fontname']))
self.setup_label_offset(val_label, style)
if rule.filterExpression():
style['expression'] = rule.filterExpression().replace(
'"', '')
expression = self.qgis_layer.subsetString().replace('"', '')
if expression and expression != '':
if 'expression' in style and style['expression'] != '':
style['expression'] = "(" + \
style['expression'] + \
") AND (" + expression + ")"
else:
style['expression'] = expression
if rule.label():
style['label'] = rule.label()
style['showlabel'] = 't' \
if val_label is not None and \
'labelfield' in style \
else 'f'
style['visible'] = '1'
if self.qgis_layer.hasScaleBasedVisibility():
factor = dpi * inches_per_meter * max_scale_per_pixel
if ISQGIS3 and rule.minimumScale() > 0:
style['fromlevel'] = \
int(round(
math.log((factor / rule.minimumScale()), 2),
0))
elif layer_fromlevel > 0:
style['fromlevel'] = layer_fromlevel
if ISQGIS3 and rule.maximumScale() > 0:
style['tolevel'] = \
int(round(
math.log((factor / rule.maximumScale()), 2),
0))
elif layer_tolevel > 0:
style['tolevel'] = layer_tolevel
if 'borderwidth' in styles and \
style['borderwidth'] and \
float(style['borderwidth']) < 1:
style['borderwidth'] = '1'
key = "hatchUrl" if "hatchUrl" in style else "url"
if key in style:
asset = style[key]
self.layer.assets.append(asset)
LOGGER.info('URL for image upload: {}'.format(
asset["file"]))
style[key] = '/{}/qgis/map{}/{}'.format(
self.gc_api.user.user_md5, self.gc_api.map.map_id,
asset["file"])
styles.append(style)
is_first_sym = False
# all point styles are merged into one as we export the symbol
# so it's not required to iterrate symbolLayers()
if self.layer.type[0] == "point":
break
LOGGER.info('Styles function output {}'.format(styles))
LOGGER.debug('Finished map_styles function')
return styles
def testConvertFromCategorisedRendererNoLayer(self):
# Test converting categorised renderer to rule based
# First, try with a field based category (id)
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "id 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "id 2"))
cats.append(QgsRendererCategory('a\'b', QgsMarkerSymbol(), "id a'b"))
cats.append(QgsRendererCategory('a\nb', QgsMarkerSymbol(), "id a\\nb"))
cats.append(QgsRendererCategory('a\\b', QgsMarkerSymbol(),
"id a\\\\b"))
cats.append(QgsRendererCategory('a\tb', QgsMarkerSymbol(), "id a\\tb"))
cats.append(QgsRendererCategory(['c', 'd'], QgsMarkerSymbol(), "c/d"))
c = QgsCategorizedSymbolRenderer("id", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(len(r.rootRule().children()), 7)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'"id" = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(),
'"id" = \'a\'\'b\'')
self.assertEqual(r.rootRule().children()[3].filterExpression(),
'"id" = \'a\\nb\'')
self.assertEqual(r.rootRule().children()[4].filterExpression(),
'"id" = \'a\\\\b\'')
self.assertEqual(r.rootRule().children()[5].filterExpression(),
'"id" = \'a\\tb\'')
self.assertEqual(r.rootRule().children()[6].filterExpression(),
'"id" IN (\'c\',\'d\')')
# Next try with an expression based category
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
cats.append(
QgsRendererCategory([3, 4], QgsMarkerSymbol(), "result 3/4"))
c = QgsCategorizedSymbolRenderer("id + 1", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(len(r.rootRule().children()), 3)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'id + 1 = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'id + 1 = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(),
'id + 1 IN (3,4)')
# Last try with an expression which is just a quoted field name
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
cats.append(
QgsRendererCategory([3, 4], QgsMarkerSymbol(), "result 3/4"))
c = QgsCategorizedSymbolRenderer('"id"', cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(len(r.rootRule().children()), 3)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'"id" = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(),
'"id" IN (3,4)')
# Next try with a complex name -- in this case since we don't have a layer or
# actual field names available, we must assume the complex field name is actually an expression
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(),
"fa_cy-fie+ld 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(),
"fa_cy-fie+ld 2"))
c = QgsCategorizedSymbolRenderer("fa_cy-fie+ld", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'fa_cy-fie+ld = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'fa_cy-fie+ld = 2')
def processAlgorithm(self, parameters, context, feedback):
t_file = self.parameterAsVectorLayer(
parameters,
self.FILE_TABLE,
context
)
t_troncon = self.parameterAsVectorLayer(
parameters,
self.SEGMENTS_TABLE,
context
)
t_obs = self.parameterAsVectorLayer(
parameters,
self.OBSERVATIONS_TABLE,
context
)
t_regard = self.parameterAsVectorLayer(
parameters,
self.MANHOLES_TABLE,
context
)
g_regard = self.parameterAsVectorLayer(
parameters,
self.GEOM_MANHOLES,
context
)
g_troncon = self.parameterAsVectorLayer(
parameters,
self.GEOM_SEGMENT,
context
)
g_obs = self.parameterAsVectorLayer(
parameters,
self.GEOM_OBSERVATION,
context
)
v_regard = self.parameterAsVectorLayer(
parameters,
self.VIEW_MANHOLES_GEOLOCALIZED,
context
)
# define variables
variables = context.project().customVariables()
variables['itv_rerau_t_file'] = t_file.id()
variables['itv_rerau_t_troncon'] = t_troncon.id()
variables['itv_rerau_t_obs'] = t_obs.id()
variables['itv_rerau_t_regard'] = t_regard.id()
variables['itv_rerau_g_regard'] = g_regard.id()
variables['itv_rerau_g_troncon'] = g_troncon.id()
variables['itv_rerau_g_obs'] = g_obs.id()
context.project().setCustomVariables(variables)
# define relations
relations = [
{
'id': 'fk_obs_id_file',
'name': tr('Link File - Observation'),
'referencingLayer': t_obs.id(),
'referencingField': 'id_file',
'referencedLayer': t_file.id(),
'referencedField': 'id'
}, {
'id': 'fk_regard_id_file',
'name': tr('Link File - Manhole'),
'referencingLayer': t_regard.id(),
'referencingField': 'id_file',
'referencedLayer': t_file.id(),
'referencedField': 'id'
}, {
'id': 'fk_troncon_id_file',
'name': tr('Link File - Pipe segment'),
'referencingLayer': t_troncon.id(),
'referencingField': 'id_file',
'referencedLayer': t_file.id(),
'referencedField': 'id'
}, {
'id': 'fk_obs_id_troncon',
'name': tr('Link Pipe segment - Observation'),
'referencingLayer': t_obs.id(),
'referencingField': 'id_troncon',
'referencedLayer': t_troncon.id(),
'referencedField': 'id'
}, {
'id': 'fk_regard_id_geom_regard',
'name': tr('Link Manhole inspection - Reference'),
'referencingLayer': t_regard.id(),
'referencingField': 'id_geom_regard',
'referencedLayer': g_regard.id(),
'referencedField': 'id'
}, {
'id': 'fk_troncon_id_geom_trononc',
'name': tr('Link Pipe segment inspection - Reference'),
'referencingLayer': t_troncon.id(),
'referencingField': 'id_geom_troncon',
'referencedLayer': g_troncon.id(),
'referencedField': 'id'
}
]
relation_manager = context.project().relationManager()
for rel_def in relations:
feedback.pushInfo(
'Link: {}'.format(rel_def['name'])
)
rel = QgsRelation()
rel.setId(rel_def['id'])
rel.setName(rel_def['name'])
rel.setReferencingLayer(rel_def['referencingLayer'])
rel.setReferencedLayer(rel_def['referencedLayer'])
rel.addFieldPair(
rel_def['referencingField'],
rel_def['referencedField']
)
rel.setStrength(QgsRelation.Association)
relation_manager.addRelation(rel)
feedback.pushInfo(
'Count relations {}'.format(
len(relation_manager.relations())
)
)
joins = [
{
'layer': t_obs,
'targetField': 'id_troncon',
'joinLayer': t_troncon,
'joinField': 'id',
'fieldNamesSubset': ['ack']
}, {
'layer': g_obs,
'targetField': 'id',
'joinLayer': t_obs,
'joinField': 'id',
'fieldNamesSubset': []
}
]
for j_def in joins:
layer = j_def['layer']
join = QgsVectorLayerJoinInfo()
join.setJoinFieldName(j_def['joinField'])
join.setJoinLayerId(j_def['joinLayer'].id())
join.setTargetFieldName(j_def['targetField'])
if j_def['fieldNamesSubset']:
join.setJoinFieldNamesSubset(j_def['fieldNamesSubset'])
join.setUsingMemoryCache(False)
join.setPrefix('')
join.setEditable(False)
join.setCascadedDelete(False)
join.setJoinLayer(j_def['joinLayer'])
layer.addJoin(join)
layer.updateFields()
# load styles
styles = [
{
'layer': t_file,
'namedStyles': [
{
'file': 'itv_file_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_file_actions.qml',
'type': QgsMapLayer.Actions
}
]
}, {
'layer': t_troncon,
'namedStyles': [
{
'file': 'itv_troncon_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_troncon_table.qml',
'type': QgsMapLayer.AttributeTable
}
]
}, {
'layer': t_obs,
'namedStyles': [
{
'file': 'itv_obs_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_obs_table.qml',
'type': QgsMapLayer.AttributeTable
}
]
}, {
'layer': t_regard,
'namedStyles': [
{
'file': 'itv_regard_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_regard_forms.qml',
'type': QgsMapLayer.Forms
}, {
'file': 'itv_regard_table.qml',
'type': QgsMapLayer.AttributeTable
}
]
}, {
'layer': g_regard,
'namedStyles': [
{
'file': 'itv_geom_regard_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_geom_regard_symbology.qml',
'type': QgsMapLayer.Symbology
}
]
}, {
'layer': g_troncon,
'namedStyles': [
{
'file': 'itv_geom_troncon_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_geom_troncon_symbology.qml',
'type': QgsMapLayer.Symbology
}, {
'file': 'itv_geom_troncon_actions.qml',
'type': QgsMapLayer.Actions
}
]
}, {
'layer': g_obs,
'namedStyles': [
{
'file': 'itv_geom_obs_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_geom_obs_symbology.qml',
'type': QgsMapLayer.Symbology
}
]
}, {
'layer': v_regard,
'namedStyles': [
{
'file': 'itv_view_regard_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_view_regard_symbology.qml',
'type': QgsMapLayer.Symbology
}, {
'file': 'itv_view_regard_labeling.qml',
'type': QgsMapLayer.Labeling
}
]
}
]
for style in styles:
layer = style['layer']
for n_style in style['namedStyles']:
layer.loadNamedStyle(
resources_path('styles', n_style['file']),
categories=n_style['type']
)
# layer.saveStyleToDatabase('style', 'default style', True, '')
layer.triggerRepaint()
# Creation de la symbologie g_obs
g_obs_rules = (
'BAA', 'BAB', 'BAC', 'BAD', 'BAE', 'BAF', 'BAG', 'BAH',
'BAI', 'BAJ', 'BAK', 'BAL', 'BAM', 'BAN', 'BAO', 'BAP',
'BBA', 'BBB', 'BBC', 'BBD', 'BBE', 'BBF', 'BBG', 'BBH',
'BCA', 'BCB', 'BCC', 'BDA', 'BDB', 'BDC', 'BDD', 'BDE',
'BDF', 'BDG'
)
g_obs_rule_descs = {
'BAA': 'Déformation',
'BAB': 'Fissure',
'BAC': 'Rupture/Effondrement',
'BAD': 'Elt maçonnerie',
'BAE': 'Mortier manquant',
'BAF': 'Dégradation de surface',
'BAG': 'Branchement pénétrant',
'BAH': 'Raccordement défectueux',
'BAI': 'Joint étanchéité apparent',
'BAJ': 'Déplacement d\'assemblage',
'BAK': 'Défaut de révêtement',
'BAL': 'Réparation défectueuse',
'BAM': 'Défaut soudure',
'BAN': 'Conduite poreuse',
'BAO': 'Sol visible',
'BAP': 'Trou visible',
'BBA': 'Racines',
'BBB': 'Dépots Adhérents',
'BBC': 'Dépôts',
'BBD': 'Entrée de terre',
'BBE': 'Autres obstacles',
'BBF': 'Infiltration',
'BBG': 'Exfiltration',
'BBH': 'Vermine',
'BCA': 'Raccordement',
'BCB': 'Réparation',
'BCC': 'Courbure de collecteur',
'BDA': 'Photographie générale',
'BDB': 'Remarque générale',
'BDC': 'Inspection abandonnée',
'BDD': 'Niveau d\'eau',
'BDE': 'Ecoulement dans une canlisation entrante',
'BDF': 'Atmosphère canalisation',
'BDG': 'Perte de visibilité'
}
g_obs_rootrule = QgsRuleBasedRenderer.Rule(None)
rendering_pass_idx = len(g_obs_rules)
for rule in g_obs_rules:
# get svg path
svg_path = resources_path('styles', 'img_obs', rule + '.svg')
# create svg symbol layer
svg_symbol_layer = QgsSvgMarkerSymbolLayer(svg_path)
svg_symbol_layer.setRenderingPass(rendering_pass_idx)
# create white square symbol layer for the backend
simple_symbol_layer = QgsSimpleMarkerSymbolLayer(
shape=QgsSimpleMarkerSymbolLayerBase.Circle,
size=svg_symbol_layer.size(),
color=QColor('white'),
strokeColor=QColor('white')
)
simple_symbol_layer.setRenderingPass(rendering_pass_idx)
# create marker
svg_marker = QgsMarkerSymbol()
# set the backend symbol layer
svg_marker.changeSymbolLayer(0, simple_symbol_layer)
# add svg symbol layer
svg_marker.appendSymbolLayer(svg_symbol_layer)
# create rule
svg_rule = QgsRuleBasedRenderer.Rule(
svg_marker, 0, 10000,
QgsExpression.createFieldEqualityExpression('a', rule),
rule
)
if rule in g_obs_rule_descs:
svg_rule.setLabel(g_obs_rule_descs[rule])
svg_rule.setDescription('{}: {}'.format(
rule,
g_obs_rule_descs[rule]
))
# add rule
g_obs_rootrule.appendChild(svg_rule)
rendering_pass_idx -= 1
g_obs_rootrule.appendChild(
QgsRuleBasedRenderer.Rule(
QgsMarkerSymbol.createSimple(
{
'name': 'circle',
'color': '#0000b2',
'outline_color': '#0000b2',
'size': '1'
}
),
0, 10000, 'ELSE', 'Autres'
)
)
g_obs.setRenderer(QgsRuleBasedRenderer(g_obs_rootrule))
feedback.pushInfo('Project has been setup')
return {}
def testPointsUsedAttributes(self):
points_shp = os.path.join(TEST_DATA_DIR, 'points.shp')
points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr')
QgsProject.instance().addMapLayer(points_layer)
# Create rulebased style
sym1 = QgsMarkerSymbol()
l1 = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 5)
l1.setColor(QColor(255, 0, 0))
l1.setStrokeStyle(Qt.NoPen)
l1.setDataDefinedProperty(QgsSymbolLayer.PropertyAngle,
QgsProperty.fromField("Heading"))
sym1.changeSymbolLayer(0, l1)
sym2 = QgsMarkerSymbol()
l2 = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 5)
l2.setColor(QColor(0, 255, 0))
l2.setStrokeStyle(Qt.NoPen)
l2.setDataDefinedProperty(QgsSymbolLayer.PropertyAngle,
QgsProperty.fromField("Heading"))
sym2.changeSymbolLayer(0, l2)
sym3 = QgsMarkerSymbol()
l3 = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 5)
l3.setColor(QColor(0, 0, 255))
l3.setStrokeStyle(Qt.NoPen)
l3.setDataDefinedProperty(QgsSymbolLayer.PropertyAngle,
QgsProperty.fromField("Heading"))
sym3.changeSymbolLayer(0, l3)
r1 = QgsRuleBasedRenderer.Rule(sym1, 0, 0, '"Class" = \'B52\'')
r2 = QgsRuleBasedRenderer.Rule(sym2, 0, 0, '"Class" = \'Biplane\'')
r3 = QgsRuleBasedRenderer.Rule(sym3, 0, 0, '"Class" = \'Jet\'')
rootrule = QgsRuleBasedRenderer.Rule(None)
rootrule.appendChild(r1)
rootrule.appendChild(r2)
rootrule.appendChild(r3)
renderer = QgsRuleBasedRenderer(rootrule)
points_layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setOutputSize(QSize(400, 400))
ms.setOutputDpi(96)
ms.setExtent(QgsRectangle(-133, 22, -70, 52))
ms.setLayers([points_layer])
ctx = QgsRenderContext.fromMapSettings(ms)
ctx.expressionContext().appendScope(
points_layer.createExpressionContextScope())
# for symbol layer
self.assertCountEqual(l1.usedAttributes(ctx), {'Heading'})
# for symbol
self.assertCountEqual(sym1.usedAttributes(ctx), {'Heading'})
# for symbol renderer
self.assertCountEqual(renderer.usedAttributes(ctx),
{'Class', 'Heading'})
QgsProject.instance().removeMapLayer(points_layer)
def styleCreator(self, feature_geometry, layer_bound, utmSRID, id_attr,
id_value, spacing, crossX, crossY, scale, fontSize, font,
fontLL, llcolor, linwidth_geo, linwidth_utm,
linwidth_buffer_geo, linwidth_buffer_utm, geo_grid_color,
utm_grid_color, geo_grid_buffer_color,
utm_grid_buffer_color, masks_check):
"""Getting Input Data For Grid Generation"""
linwidth_buffer_utm += linwidth_utm
linwidth_buffer_geo += linwidth_geo
grid_spacing = spacing
geo_number_x = crossX
geo_number_y = crossY
fSize = fontSize
fontType = font
LLfontType = fontLL
#Defining CRSs Transformations
trLLUTM = QgsCoordinateTransform(
QgsCoordinateReferenceSystem('EPSG:4326'),
QgsCoordinateReferenceSystem('EPSG:' + str(utmSRID)),
QgsProject.instance())
trUTMLL = QgsCoordinateTransform(
QgsCoordinateReferenceSystem('EPSG:' + str(utmSRID)),
QgsCoordinateReferenceSystem('EPSG:4326'), QgsProject.instance())
#Transforming to Geographic and defining bounding boxes
feature_bbox = feature_geometry.boundingBox()
bound_UTM_bb = str(feature_bbox).replace(',', '').replace('>', '')
feature_geometry.transform(trUTMLL)
feature_geo_bbox = feature_geometry.boundingBox()
feature_bbox_or = feature_geometry.orientedMinimumBoundingBox()
geo_bound_bb = str(feature_geo_bbox).replace(',', '').replace('>', '')
oriented_geo_bb = str(feature_bbox_or).replace(',', '').replace(
'>', '').replace('((', '').replace('))', '')
#Defining UTM Grid Symbology Type
properties = {'color': 'black'}
grid_symb = QgsFillSymbol.createSimple(properties)
""" Creating UTM Grid """
extentsUTM = (float(bound_UTM_bb.split()[1]),
float(bound_UTM_bb.split()[2]),
float(bound_UTM_bb.split()[3]),
float(bound_UTM_bb.split()[4]))
extentsGeo = (float(geo_bound_bb.split()[1]),
float(geo_bound_bb.split()[2]),
float(geo_bound_bb.split()[3]),
float(geo_bound_bb.split()[4]))
if grid_spacing > 0:
UTM_num_x = floor(extentsUTM[2] / grid_spacing) - floor(
extentsUTM[0] / grid_spacing)
UTM_num_y = floor(extentsUTM[3] / grid_spacing) - floor(
extentsUTM[1] / grid_spacing)
if linwidth_buffer_utm != linwidth_utm:
#Generating Buffer Vertical Lines
for x in range(1, UTM_num_x + 1):
grid_symb = self.utm_Symb_Generator(
utmSRID, grid_spacing, trUTMLL, trLLUTM, grid_symb,
properties, UTM_num_x, UTM_num_y, x, 0, extentsGeo,
extentsUTM, linwidth_buffer_utm, utm_grid_buffer_color)
#Generating Buffer Horizontal Lines
for y in range(1, UTM_num_y + 1):
grid_symb = self.utm_Symb_Generator(
utmSRID, grid_spacing, trUTMLL, trLLUTM, grid_symb,
properties, UTM_num_x, UTM_num_y, 0, y, extentsGeo,
extentsUTM, linwidth_buffer_utm, utm_grid_buffer_color)
#Generating Vertical Lines
for x in range(1, UTM_num_x + 1):
grid_symb = self.utm_Symb_Generator(
utmSRID, grid_spacing, trUTMLL, trLLUTM, grid_symb,
properties, UTM_num_x, UTM_num_y, x, 0, extentsGeo,
extentsUTM, linwidth_utm, utm_grid_color)
#Generating Horizontal Lines
for y in range(1, UTM_num_y + 1):
grid_symb = self.utm_Symb_Generator(
utmSRID, grid_spacing, trUTMLL, trLLUTM, grid_symb,
properties, UTM_num_x, UTM_num_y, 0, y, extentsGeo,
extentsUTM, linwidth_utm, utm_grid_color)
""" Creating Geo Grid """
px = (round(extentsGeo[2], 6) -
round(extentsGeo[0], 6)) / (geo_number_x + 1)
py = (round(extentsGeo[3], 6) -
round(extentsGeo[1], 6)) / (geo_number_y + 1)
if linwidth_buffer_geo != linwidth_geo:
grid_symb = self.geoGridcreator(utmSRID, grid_symb, extentsGeo, px,
py, geo_number_x, geo_number_y,
scale, trLLUTM,
linwidth_buffer_geo,
geo_grid_buffer_color)
grid_symb = self.geoGridcreator(utmSRID, grid_symb, extentsGeo, px, py,
geo_number_x, geo_number_y, scale,
trLLUTM, linwidth_geo, geo_grid_color)
""" Rendering UTM and Geographic Grid """
#Changing UTM Grid Color
grid_symb.deleteSymbolLayer(0)
#Creating Rule Based Renderer (Rule For The Selected Feature, Root Rule)
symb_new = QgsRuleBasedRenderer.Rule(grid_symb)
symb_new.setFilterExpression('\"' + str(id_attr) + '\" = ' +
str(id_value))
symb_new.setLabel('layer')
#Appending rules to symbol root rule
root_symbol_rule = QgsRuleBasedRenderer.Rule(None)
root_symbol_rule.setFilterExpression('')
root_symbol_rule.appendChild(symb_new)
#Applying New Renderer
render_base = QgsRuleBasedRenderer(root_symbol_rule)
layer_bound.setRenderer(render_base)
"""Rendering outside area"""
#Duplicating original layer
layers_names = [
i.name() for i in QgsProject.instance().mapLayers().values()
]
if (layer_bound.name() + "_outside") not in layers_names:
outside_bound_layer = QgsVectorLayer(
layer_bound.source(),
layer_bound.name() + "_outside", layer_bound.providerType())
if layer_bound.providerType() == 'memory':
feats = [feat for feat in layer_bound.getFeatures()]
outside_bound_layer_data = outside_bound_layer.dataProvider()
outside_bound_layer_data.addFeatures(feats)
QgsProject.instance().addMapLayer(outside_bound_layer)
else:
outside_bound_layer = QgsProject.instance().mapLayersByName(
layer_bound.name() + "_outside")[0]
#Creating Rule Based Renderer (Rule For The Other Features)
properties = {'color': 'white'}
ext_grid_symb = QgsFillSymbol.createSimple(properties)
symb_out = QgsSimpleFillSymbolLayer()
symb_out.setFillColor(QColor('white'))
symb_out.setStrokeWidth(linwidth_utm)
ext_grid_symb.changeSymbolLayer(0, symb_out)
rule_out = QgsRuleBasedRenderer.Rule(ext_grid_symb)
rule_out.setFilterExpression('\"' + str(id_attr) + '\" = ' +
str(id_value))
rule_out.setLabel('outside')
root_symbol_rule_out = QgsRuleBasedRenderer.Rule(None)
root_symbol_rule_out.appendChild(rule_out)
render_base_out = QgsRuleBasedRenderer(root_symbol_rule_out)
new_renderer = QgsInvertedPolygonRenderer.convertFromRenderer(
render_base_out)
outside_bound_layer.setRenderer(new_renderer)
""" Labeling Geo Grid """
dx = [2.0, -11.0, -8.0, -3.6]
dx = [i * scale * fSize / 1.5 for i in dx]
dy = [1.7, -3.8, -0.8, -0.8]
dy = [i * scale * fSize / 1.5 for i in dy]
root_rule = self.geoGridlabelPlacer(extentsGeo, px, py, geo_number_x,
geo_number_y, dx, dy, fSize,
LLfontType, trLLUTM, llcolor,
scale, layer_bound, trUTMLL)
""" Labeling UTM Grid"""
dx = [-2.9, -2.9, -8.9, 2.0]
dx = [i * scale * fSize / 1.5 for i in dx]
dy = [1.4, -4.6, -0.5, -1.5]
dy = [i * scale * fSize / 1.5 for i in dy]
dy0 = [5.0, -7.2, -3.2, -4.2]
dy0 = [i * scale * fSize / 1.5 for i in dy0]
dy1 = [2.15, 1.2]
dy1 = [i * scale * fSize / 1.5 for i in dy1]
root_rule = self.utmGridlabelPlacer(root_rule, grid_spacing,
extentsGeo, extentsUTM, px, py,
UTM_num_x, UTM_num_y, trUTMLL,
trLLUTM, dx, dy, dy0, dy1, fSize,
fontType, scale, oriented_geo_bb,
layer_bound)
""" Activating Labels """
rules = QgsRuleBasedLabeling(root_rule)
layer_bound.setLabeling(rules)
layer_bound.setLabelsEnabled(True)
if masks_check:
self.apply_masks(layer_bound)
layer_bound.triggerRepaint()
return
def style_maps(layer,
style_by,
iface,
output_type='damages-rlzs',
perils=None,
add_null_class=False,
render_higher_on_top=False,
repaint=True,
use_sgc_style=False):
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
# see properties at:
# https://qgis.org/api/qgsmarkersymbollayerv2_8cpp_source.html#l01073
symbol.setOpacity(1)
if isinstance(symbol, QgsMarkerSymbol):
# do it only for the layer with points
symbol.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen))
style = get_style(layer, iface.messageBar())
# this is the default, as specified in the user settings
ramp = QgsGradientColorRamp(style['color_from'], style['color_to'])
style_mode = style['style_mode']
# in most cases, we override the user-specified setting, and use
# instead a setting that was required by scientists
if output_type in OQ_TO_LAYER_TYPES:
default_qgs_style = QgsStyle().defaultStyle()
default_color_ramp_names = default_qgs_style.colorRampNames()
if output_type in (
'damages-rlzs',
'avg_losses-rlzs',
'avg_losses-stats',
):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Jenks
else:
style_mode = 'Jenks'
ramp_type_idx = default_color_ramp_names.index('Reds')
symbol.setColor(QColor(RAMP_EXTREME_COLORS['Reds']['top']))
inverted = False
elif (output_type in ('gmf_data', 'ruptures')
or (output_type == 'hmaps' and not use_sgc_style)):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if output_type == 'ruptures':
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Pretty
else:
style_mode = 'PrettyBreaks'
else:
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.EqualInterval
else:
style_mode = 'EqualInterval'
ramp_type_idx = default_color_ramp_names.index('Spectral')
inverted = True
symbol.setColor(QColor(RAMP_EXTREME_COLORS['Reds']['top']))
elif output_type == 'hmaps' and use_sgc_style:
# FIXME: for SGC they were using size 10000 map units
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Pretty
else:
style_mode = 'PrettyBreaks'
try:
ramp_type_idx = default_color_ramp_names.index(
'SGC_Green2Red_Hmap_Color_Ramp')
except ValueError:
raise ValueError(
'Color ramp SGC_Green2Red_Hmap_Color_Ramp was '
'not found. Please import it from '
'Settings -> Style Manager, loading '
'svir/resources/sgc_green2red_hmap_color_ramp.xml')
inverted = False
registry = QgsApplication.symbolLayerRegistry()
symbol_props = {
'name': 'square',
'color': '0,0,0',
'color_border': '0,0,0',
'offset': '0,0',
'size': '1.5', # FIXME
'angle': '0',
}
square = registry.symbolLayerMetadata(
"SimpleMarker").createSymbolLayer(symbol_props)
symbol = QgsSymbol.defaultSymbol(layer.geometryType()).clone()
symbol.deleteSymbolLayer(0)
symbol.appendSymbolLayer(square)
symbol.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen))
elif output_type in ['asset_risk', 'input']:
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.EqualInterval
else:
style_mode = 'EqualInterval'
# exposure_strings = ['number', 'occupants', 'value']
# setting exposure colors by default
colors = {
'single': RAMP_EXTREME_COLORS['Blues']['top'],
'ramp_name': 'Blues'
}
inverted = False
if output_type == 'asset_risk':
damage_strings = perils
for damage_string in damage_strings:
if damage_string in style_by:
colors = {
'single':
RAMP_EXTREME_COLORS['Spectral']['top'],
'ramp_name': 'Spectral'
}
inverted = True
break
else: # 'input'
colors = {
'single': RAMP_EXTREME_COLORS['Greens']['top'],
'ramp_name': 'Greens'
}
symbol.symbolLayer(0).setShape(
QgsSimpleMarkerSymbolLayerBase.Square)
single_color = colors['single']
ramp_name = colors['ramp_name']
ramp_type_idx = default_color_ramp_names.index(ramp_name)
symbol.setColor(QColor(single_color))
else:
raise NotImplementedError(
'Undefined color ramp for output type %s' % output_type)
ramp = default_qgs_style.colorRamp(
default_color_ramp_names[ramp_type_idx])
if inverted:
ramp.invert()
# get unique values
fni = layer.fields().indexOf(style_by)
unique_values = layer.dataProvider().uniqueValues(fni)
num_unique_values = len(unique_values - {NULL})
if num_unique_values > 2:
if Qgis.QGIS_VERSION_INT < 31000:
renderer = QgsGraduatedSymbolRenderer.createRenderer(
layer, style_by, min(num_unique_values, style['classes']),
style_mode, symbol.clone(), ramp)
else:
renderer = QgsGraduatedSymbolRenderer(style_by, [])
# NOTE: the following returns an instance of one of the
# subclasses of QgsClassificationMethod
classification_method = \
QgsApplication.classificationMethodRegistry().method(
style_mode)
renderer.setClassificationMethod(classification_method)
renderer.updateColorRamp(ramp)
renderer.updateSymbols(symbol.clone())
renderer.updateClasses(
layer, min(num_unique_values, style['classes']))
if not use_sgc_style:
if Qgis.QGIS_VERSION_INT < 31000:
label_format = renderer.labelFormat()
# NOTE: the following line might be useful
# label_format.setTrimTrailingZeroes(True)
label_format.setPrecision(2)
renderer.setLabelFormat(label_format, updateRanges=True)
else:
renderer.classificationMethod().setLabelPrecision(2)
renderer.calculateLabelPrecision()
elif num_unique_values == 2:
categories = []
for unique_value in unique_values:
symbol = symbol.clone()
try:
symbol.setColor(
QColor(RAMP_EXTREME_COLORS[ramp_name]
['bottom' if unique_value ==
min(unique_values) else 'top']))
except Exception:
symbol.setColor(
QColor(style['color_from'] if unique_value ==
min(unique_values) else style['color_to']))
category = QgsRendererCategory(unique_value, symbol,
str(unique_value))
# entry for the list of category items
categories.append(category)
renderer = QgsCategorizedSymbolRenderer(style_by, categories)
else:
renderer = QgsSingleSymbolRenderer(symbol.clone())
if add_null_class and NULL in unique_values:
# add a class for NULL values
rule_renderer = QgsRuleBasedRenderer(symbol.clone())
root_rule = rule_renderer.rootRule()
not_null_rule = root_rule.children()[0].clone()
# strip parentheses from stringified color HSL
not_null_rule.setFilterExpression(
'%s IS NOT NULL' % QgsExpression.quotedColumnRef(style_by))
not_null_rule.setLabel('%s:' % style_by)
root_rule.appendChild(not_null_rule)
null_rule = root_rule.children()[0].clone()
null_rule.setSymbol(
QgsFillSymbol.createSimple({
'color': '160,160,160',
'style': 'diagonal_x'
}))
null_rule.setFilterExpression(
'%s IS NULL' % QgsExpression.quotedColumnRef(style_by))
null_rule.setLabel(tr('No points'))
root_rule.appendChild(null_rule)
if isinstance(renderer, QgsGraduatedSymbolRenderer):
# create value ranges
rule_renderer.refineRuleRanges(not_null_rule, renderer)
# remove default rule
elif isinstance(renderer, QgsCategorizedSymbolRenderer):
rule_renderer.refineRuleCategoris(not_null_rule, renderer)
for rule in rule_renderer.rootRule().children()[1].children():
label = rule.label()
# by default, labels are like:
# ('"collapse-structural-ASH_DRY_sum" >= 0.0000 AND
# "collapse-structural-ASH_DRY_sum" <= 2.3949')
first, second = label.split(" AND ")
bottom = first.rsplit(" ", 1)[1]
top = second.rsplit(" ", 1)[1]
simplified = "%s - %s" % (bottom, top)
rule.setLabel(simplified)
root_rule.removeChildAt(0)
renderer = rule_renderer
if render_higher_on_top:
renderer.setUsingSymbolLevels(True)
symbol_items = [item for item in renderer.legendSymbolItems()]
for i in range(len(symbol_items)):
sym = symbol_items[i].symbol().clone()
key = symbol_items[i].ruleKey()
for lay in range(sym.symbolLayerCount()):
sym.symbolLayer(lay).setRenderingPass(i)
renderer.setLegendSymbolItem(key, sym)
layer.setRenderer(renderer)
if not use_sgc_style:
layer.setOpacity(0.7)
if repaint:
layer.triggerRepaint()
iface.setActiveLayer(layer)
iface.zoomToActiveLayer()
# NOTE QGIS3: probably not needed
# iface.layerTreeView().refreshLayerSymbology(layer.id())
iface.mapCanvas().refresh()
def layer_to_QgsVectorLayer(
source_layer, # pylint: disable=too-many-locals,too-many-branches,too-many-statements
input_file,
context: Context,
fallback_crs=QgsCoordinateReferenceSystem(),
defer_layer_uri_set: bool = False):
"""
Converts a vector layer
"""
if source_layer.__class__.__name__ == 'CadFeatureLayer':
layer = source_layer.layer
else:
layer = source_layer
crs = CrsConverter.convert_crs(
layer.layer_extent.crs,
context) if layer.layer_extent else QgsCoordinateReferenceSystem()
if not crs.isValid():
crs = fallback_crs
subset_string = ''
if layer.selection_set:
subset_string = 'fid in ({})'.format(','.join(
[str(s) for s in layer.selection_set]))
elif layer.definition_query:
subset_string = ExpressionConverter.convert_esri_sql(
layer.definition_query)
base, _ = os.path.split(input_file)
uri, wkb_type, provider, encoding, file_name = VectorLayerConverter.get_uri(
source_layer=source_layer,
obj=layer,
base=base,
crs=crs,
subset=subset_string,
context=context)
if wkb_type is None or wkb_type == QgsWkbTypes.Unknown:
wkb_type = VectorLayerConverter.layer_to_wkb_type(layer)
context.layer_type_hint = wkb_type
if Qgis.QGIS_VERSION_INT >= 31600:
# try to get the layer name so that we can remove it from field references.
# e.g. if layer name is polys then qgis won't support to arcgis style "polys.field" format
parts = QgsProviderRegistry.instance().decodeUri(provider, uri)
context.main_layer_name = parts.get('layerName')
if not context.main_layer_name and provider == 'ogr':
context.main_layer_name = Path(parts['path']).stem
if context.main_layer_name:
subset_string = subset_string.replace(
context.main_layer_name + '.', '')
else:
context.main_layer_name = None
if provider == 'ogr' and (not file_name
or not os.path.exists(file_name)
) and context.invalid_layer_resolver:
res = context.invalid_layer_resolver(layer.name, uri, wkb_type)
uri = res.uri
provider = res.providerKey
if Qgis.QGIS_VERSION_INT >= 31000:
opts = QgsVectorLayer.LayerOptions()
if wkb_type is not None:
opts.fallbackWkbType = wkb_type
if provider == 'ogr' and subset_string:
uri += '|subset={}'.format(subset_string)
original_uri = uri
if defer_layer_uri_set:
uri = 'xxxxxxxxx' + uri
vl = QgsVectorLayer(uri, layer.name, provider, opts)
if defer_layer_uri_set:
vl.setCustomProperty('original_uri', original_uri)
else:
vl = QgsMemoryProviderUtils.createMemoryLayer(
layer.name, QgsFields(), wkb_type, crs)
# context.style_folder, _ = os.path.split(output_file)
if layer.renderer:
renderer = VectorRendererConverter.convert_renderer(
layer.renderer, context)
try:
if not renderer.usingSymbolLevels():
renderer.setUsingSymbolLevels(
layer.use_advanced_symbol_levels)
except AttributeError:
pass
if layer.use_page_definition_query:
filter_expression = '"{}" {} @atlas_pagename'.format(
layer.page_name_field, layer.page_name_match_operator)
root_rule = QgsRuleBasedRenderer.Rule(None)
# special case -- convert a simple renderer
if isinstance(renderer, QgsSingleSymbolRenderer):
filter_rule = QgsRuleBasedRenderer.Rule(
renderer.symbol().clone())
filter_rule.setFilterExpression(filter_expression)
filter_rule.setLabel(layer.name)
filter_rule.setDescription(layer.name)
root_rule.appendChild(filter_rule)
else:
source_rule_renderer = QgsRuleBasedRenderer.convertFromRenderer(
renderer)
filter_rule = QgsRuleBasedRenderer.Rule(None)
filter_rule.setFilterExpression(filter_expression)
filter_rule.setLabel('Current Atlas Page')
filter_rule.setDescription('Current Atlas Page')
root_rule.appendChild(filter_rule)
for child in source_rule_renderer.rootRule().children():
filter_rule.appendChild(child.clone())
renderer = QgsRuleBasedRenderer(root_rule)
if renderer:
vl.setRenderer(renderer)
vl.triggerRepaint()
else:
vl.setRenderer(QgsNullSymbolRenderer())
vl.triggerRepaint()
metadata = vl.metadata()
metadata.setAbstract(layer.description)
vl.setMetadata(metadata) #
# layer.zoom_max = "don't show when zoomed out beyond"
zoom_max = layer.zoom_max
# layer.zoom_min = "don't show when zoomed in beyond"
zoom_min = layer.zoom_min
enabled_scale_range = bool(zoom_max or zoom_min)
if zoom_max and zoom_min and zoom_min > zoom_max:
# inconsistent scale range -- zoom_max should be bigger number than zoom_min
zoom_min, zoom_max = zoom_max, zoom_min
# qgis minimum scale = don't show when zoomed out beyond, i.e. ArcGIS zoom_max
vl.setMinimumScale(
zoom_max if enabled_scale_range else layer.stored_zoom_max)
# qgis maximum scale = don't show when zoomed in beyond, i.e. ArcGIS zoom_min
vl.setMaximumScale(
zoom_min if enabled_scale_range else layer.stored_zoom_min)
vl.setScaleBasedVisibility(enabled_scale_range)
vl.setOpacity(1.0 - (layer.transparency or 0) / 100)
if layer.display_expression_properties and layer.display_expression_properties.expression and layer.display_expression_properties.expression_parser is not None:
vl.setDisplayExpression(
ExpressionConverter.convert(
layer.display_expression_properties.expression,
layer.display_expression_properties.expression_parser,
layer.display_expression_properties.advanced, context))
if Qgis.QGIS_VERSION_INT < 31000:
vl.setDataSource(uri, layer.name, provider)
if encoding:
vl.dataProvider().setEncoding(encoding)
if subset_string:
vl.setSubsetString(subset_string)
vl.setCrs(crs)
for e in layer.extensions:
if e.__class__.__name__ == 'ServerLayerExtension':
if 'CopyrightText' in e.properties.properties:
layer_credits = e.properties.properties['CopyrightText']
metadata = vl.metadata()
rights = metadata.rights()
rights.append(layer_credits)
metadata.setRights(rights)
vl.setMetadata(metadata)
LabelConverter.convert_annotation_collection(
layer.annotation_collection, dest_layer=vl, context=context)
vl.setLabelsEnabled(layer.labels_enabled)
DiagramConverter.convert_diagrams(layer.renderer,
dest_layer=vl,
context=context)
# setup joins
join_layer = VectorLayerConverter.add_joined_layer(
source_layer=layer,
input_file=input_file,
base_layer=vl,
context=context)
context.dataset_name = ''
vl.setLegend(QgsMapLayerLegend.defaultVectorLegend(vl))
if layer.hyperlinks:
VectorLayerConverter.convert_hyperlinks(layer.hyperlinks, vl)
vl.setDisplayExpression(
QgsExpression.quotedColumnRef(layer.display_field))
res = [vl]
if join_layer:
res.append(join_layer)
context.main_layer_name = None
return res
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 testConvertFromCategorisedRenderer(self):
# Test converting categorised renderer to rule based
vl = self.mapsettings.layers()[0]
# First, try with a field based category (id)
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "id 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "id 2"))
cats.append(QgsRendererCategory('a\'b', QgsMarkerSymbol(), "id a'b"))
cats.append(QgsRendererCategory('a\nb', QgsMarkerSymbol(), "id a\\nb"))
cats.append(QgsRendererCategory('a\\b', QgsMarkerSymbol(),
"id a\\\\b"))
cats.append(QgsRendererCategory('a\tb', QgsMarkerSymbol(), "id a\\tb"))
cats.append(QgsRendererCategory(['c', 'd'], QgsMarkerSymbol(), "c/d"))
c = QgsCategorizedSymbolRenderer("id", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c, vl)
self.assertEqual(len(r.rootRule().children()), 7)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'"id" = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(),
'"id" = \'a\'\'b\'')
self.assertEqual(r.rootRule().children()[3].filterExpression(),
'"id" = \'a\\nb\'')
self.assertEqual(r.rootRule().children()[4].filterExpression(),
'"id" = \'a\\\\b\'')
self.assertEqual(r.rootRule().children()[5].filterExpression(),
'"id" = \'a\\tb\'')
self.assertEqual(r.rootRule().children()[6].filterExpression(),
'"id" IN (\'c\',\'d\')')
# Next try with an expression based category
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
cats.append(
QgsRendererCategory([3, 4], QgsMarkerSymbol(), "result 3/4"))
c = QgsCategorizedSymbolRenderer("id + 1", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c, vl)
self.assertEqual(len(r.rootRule().children()), 3)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'id + 1 = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'id + 1 = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(),
'id + 1 IN (3,4)')
# Last try with an expression which is just a quoted field name
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(), "result 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(), "result 2"))
cats.append(
QgsRendererCategory([3, 4], QgsMarkerSymbol(), "result 3/4"))
c = QgsCategorizedSymbolRenderer('"id"', cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c, vl)
self.assertEqual(len(r.rootRule().children()), 3)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'"id" = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(),
'"id" IN (3,4)')
# Next try with a complex name
cats = []
cats.append(QgsRendererCategory(1, QgsMarkerSymbol(),
"fa_cy-fie+ld 1"))
cats.append(QgsRendererCategory(2, QgsMarkerSymbol(),
"fa_cy-fie+ld 2"))
c = QgsCategorizedSymbolRenderer("fa_cy-fie+ld", cats)
r = QgsRuleBasedRenderer.convertFromRenderer(c, vl)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'"fa_cy-fie+ld" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'"fa_cy-fie+ld" = 2')
def styleCreator(self, layer, index, id_attr, id_value, spacing, crossX,
crossY, scale, color, fontSize, font, fontLL, llcolor,
utmcheck):
"""Getting Input Data For Grid Generation"""
grid_spacing = spacing
geo_number_x = crossX
geo_number_y = crossY
fSize = fontSize
fontType = font
LLfontType = fontLL
#Loading feature
layer_bound = layer
query = '"' + str(id_attr) + '"=' + str(id_value)
layer_bound.selectByExpression(query, QgsVectorLayer.SelectBehavior(0))
feature_bound = layer_bound.selectedFeatures()[0]
layer_bound.removeSelection()
#Getting Feature Source CRS and Geometry
if utmcheck:
feature_geometry = feature_bound.geometry()
bound_UTM = layer_bound.crs().authid()
feature_bbox = feature_geometry.boundingBox()
bound_UTM_bb = str(feature_bbox).replace(',', '').replace('>', '')
# Transforming to Geographic
transform_feature = QgsCoordinateTransform(
QgsCoordinateReferenceSystem(bound_UTM),
QgsCoordinateReferenceSystem('EPSG:4674'),
QgsProject.instance())
feature_geometry.transform(transform_feature)
bound_sourcecrs = 'EPSG:4674'
feature_bbox = feature_geometry.boundingBox()
feature_bbox_or = feature_geometry.orientedMinimumBoundingBox()
else:
feature_geometry = feature_bound.geometry()
bound_sourcecrs = layer_bound.crs().authid()
feature_bbox = feature_geometry.boundingBox()
feature_bbox_or = feature_geometry.orientedMinimumBoundingBox()
geo_bound_bb = str(feature_bbox).replace(',', '').replace('>', '')
oriented_geo_bb = str(feature_bbox_or).replace(',', '').replace(
'>', '').replace('((', '').replace('))', '')
#Defining CRSs Transformations
inom = feature_bound[index]
if inom[0] == 'N':
bound_UTM = 'EPSG:319' + str(72 + int(inom[3:5]) - 18)
elif inom[0] == 'S':
bound_UTM = 'EPSG:319' + str(78 + int(inom[3:5]) - 18)
else:
iface.messageBar().pushMessage("Error",
"Invalid index attribute",
level=Qgis.Critical)
return
trLLUTM = QgsCoordinateTransform(
QgsCoordinateReferenceSystem(bound_sourcecrs),
QgsCoordinateReferenceSystem(bound_UTM), QgsProject.instance())
trUTMLL = QgsCoordinateTransform(
QgsCoordinateReferenceSystem(bound_UTM),
QgsCoordinateReferenceSystem(bound_sourcecrs),
QgsProject.instance())
#Defining UTM Grid Symbology Type
renderer = layer.renderer()
properties = {'color': 'black'}
grid_symb = QgsFillSymbol.createSimple(properties)
symb_out = QgsSimpleFillSymbolLayer()
symb_out.setStrokeColor(QColor('black'))
symb_out.setFillColor(QColor('white'))
symb_out.setStrokeWidth(0.05)
""" Creating UTM Grid """
if not utmcheck:
geo_UTM = feature_bound.geometry()
geo_UTM.transform(trLLUTM)
bound_UTM_bb = str(geo_UTM.boundingBox()).replace(',', '').replace(
'>', '')
xmin_UTM = float(bound_UTM_bb.split()[1])
ymin_UTM = float(bound_UTM_bb.split()[2])
xmax_UTM = float(bound_UTM_bb.split()[3])
ymax_UTM = float(bound_UTM_bb.split()[4])
if grid_spacing > 0:
UTM_num_x = floor(xmax_UTM / grid_spacing) - floor(
xmin_UTM / grid_spacing)
UTM_num_y = floor(ymax_UTM / grid_spacing) - floor(
ymin_UTM / grid_spacing)
#Generating Vertical Lines
for x in range(1, UTM_num_x + 1):
grid_symb = self.utm_symb_generator(
grid_spacing, trUTMLL, trLLUTM, grid_symb, properties,
geo_number_x, geo_number_y, UTM_num_x, UTM_num_y, x, 0,
geo_bound_bb, bound_UTM_bb, utmcheck)
#Generating Horizontal Lines
for y in range(1, UTM_num_y + 1):
grid_symb = self.utm_symb_generator(
grid_spacing, trUTMLL, trLLUTM, grid_symb, properties,
geo_number_x, geo_number_y, UTM_num_x, UTM_num_y, 0, y,
geo_bound_bb, bound_UTM_bb, utmcheck)
""" Creating Geo Grid """
grid_symb = self.geoGridcreator(grid_symb, geo_bound_bb, geo_number_x,
geo_number_y, scale, utmcheck, trLLUTM)
""" Rendering UTM and Geographic Grid """
#Changing UTM Grid Color
grid_symb.setColor(color)
grid_symb.changeSymbolLayer(0, symb_out)
#Creating Rule Based Renderer (Rule For The Other Features)
properties = {'color': 'white'}
ext_grid_symb = QgsFillSymbol.createSimple(properties)
symb_ot = QgsRuleBasedRenderer.Rule(ext_grid_symb)
symb_ot.setFilterExpression('\"' + str(id_attr) + '\" <> ' +
str(id_value))
symb_ot.setLabel('other')
#Creating Rule Based Renderer (Rule For The Selected Feature, Root Rule)
symb_new = QgsRuleBasedRenderer.Rule(grid_symb)
symb_new.setFilterExpression('\"' + str(id_attr) + '\" = ' +
str(id_value))
symb_new.setLabel('layer')
symb_new.appendChild(symb_ot)
#Applying New Renderer
render_base = QgsRuleBasedRenderer(symb_new)
new_renderer = QgsInvertedPolygonRenderer.convertFromRenderer(
render_base)
layer_bound.setRenderer(new_renderer)
""" Labeling Geo Grid """
if utmcheck:
dx = [
2 * scale * fSize / 1.5, -13.6 * scale * fSize / 1.5,
6 * scale * fSize / 1.5
]
dy = [1.7 * scale * fSize / 1.5, -3.8 * scale * fSize / 1.5]
else:
dx = [0.000018 * scale, -0.000120 * scale, 0.00005 * scale]
dy = [0.000015 * scale, -0.000040 * scale]
root_rule = self.geoGridlabelPlacer(geo_bound_bb, geo_number_x,
geo_number_y, dx, dy, fSize,
LLfontType, trLLUTM, trUTMLL,
llcolor, utmcheck, scale)
""" Labeling UTM Grid"""
if utmcheck:
dx = [-2.7, -9.7, -6.2, 5.4]
dx = [i * scale * fSize / 1.5 for i in dx]
dy = [2.5, -1.7, -0.5, -1.5]
dy = [i * scale * fSize / 1.5 for i in dy]
dy0 = [5.45, -4.8, -3.2, -4.2]
dy0 = [i * scale * fSize / 1.5 for i in dy0]
dy1 = [2.15, 1.2]
dy1 = [i * scale * fSize / 1.5 for i in dy1]
else:
dx = [-0.00003, -0.000107, -0.000070, 0.000060]
dx = [i * scale * fSize / 1.5 for i in dx]
dy = [0.000027, 0.000016, -0.000041, -0.000052]
dy = [i * scale * fSize / 1.5 for i in dy]
dy0 = [0.0000644, 0.000053, -0.000076, -0.000087]
dy0 = [i * scale * fSize / 1.5 for i in dy0]
dy1 = [0.000032, 0.000020]
dy1 = [i * scale * fSize / 1.5 for i in dy1]
root_rule = self.utmGridlabelPlacer(
root_rule, grid_spacing, geo_bound_bb, bound_UTM_bb, geo_number_x,
geo_number_y, UTM_num_x, UTM_num_y, trUTMLL, trLLUTM, dx, dy, dy0,
dy1, fSize, fontType, scale, utmcheck, oriented_geo_bb)
""" Activating Labels """
rules = QgsRuleBasedLabeling(root_rule)
layer.setLabeling(rules)
layer.setLabelsEnabled(True)
layer.triggerRepaint()
return
def extract_layers(self, tree):
"""Return a list of RFU layers."""
# Create vector layers..
l_vertex = QgsVectorLayer(r"Point?crs=epsg:4326&index=yes",
"Sommet RFU", r"memory")
l_edge = QgsVectorLayer(r"LineString?crs=epsg:4326&index=yes",
"Limite RFU", r"memory")
p_vertex = l_vertex.dataProvider()
p_edge = l_edge.dataProvider()
# Define default style renderer..
renderer_vertex = QgsRuleBasedRenderer(QgsMarkerSymbol())
vertex_root_rule = renderer_vertex.rootRule()
# Modified in v2.1 (som_nature replaced by som_typologie_nature) >>
vertex_rules = (
(("Borne, borne à puce, pierre, piquet, clou ou broche"),
("$id >= 0 AND \"som_typologie_nature\" IN ('Borne',"
"'Borne à puce', 'Pierre', 'Piquet', 'Clou ou broche')"),
r"#EC0000", 2.2),
(("Axe cours d'eau, axe fossé, haut de talus, pied de talus"),
("$id >= 0 AND \"som_typologie_nature\" IN ('Axe cours d\'\'eau',"
"'Axe fossé', 'Haut de talus', 'Pied de talus')"), r"#EE8012",
2.2), (("Angle de bâtiment, axe de mur, angle de mur, "
"angle de clôture, pylône et toute autre valeur"),
("$id >= 0 AND \"som_typologie_nature\" NOT IN ('Borne',"
"'Borne à puce', 'Pierre', 'Piquet', 'Clou ou broche',"
"'Axe cours d\'\'eau', 'Axe fossé', 'Haut de talus',"
"'Pied de talus')"), r"#9784EC", 2.2),
("Temporaire", r"$id < 0", "cyan",
2.4), ("Point nouveau à traiter car proche d'un existant",
r"point_rfu_proche is not null", "#bcff03", 3))
# >>
for label, expression, color, size in vertex_rules:
rule = vertex_root_rule.children()[0].clone()
rule.setLabel(label)
rule.setFilterExpression(expression)
rule.symbol().setColor(QColor(color))
rule.symbol().setSize(size)
vertex_root_rule.appendChild(rule)
vertex_root_rule.removeChildAt(0)
l_vertex.setRenderer(renderer_vertex)
renderer_edge = QgsRuleBasedRenderer(QgsLineSymbol())
edge_root_rule = renderer_edge.rootRule()
# Modified in v2.1 (lim_typologie_nature added) <<
edge_rules = (("Limite privée",
"$id >= 0 AND \"lim_typologie_nature\" = '" +
lim_typo_nat_vals[0] + "'", "#0A0AFF", 0.5),
("Limite naturelle",
"$id >= 0 AND \"lim_typologie_nature\" = '" +
lim_typo_nat_vals[1] + "'", "#aa876d", 0.5),
("Temporaire", "$id < 0", "cyan", 1))
# >>
for label, expression, color, width in edge_rules:
rule = edge_root_rule.children()[0].clone()
rule.setLabel(label)
rule.setFilterExpression(expression)
rule.symbol().setColor(QColor(color))
rule.symbol().setWidth(width)
edge_root_rule.appendChild(rule)
edge_root_rule.removeChildAt(0)
l_edge.setRenderer(renderer_edge)
# Add fields..
p_vertex.addAttributes(vtx_atts)
p_edge.addAttributes(edge_atts)
# Add features from xml tree..
# ..to vertex layer..
fts_vertex = []
for e in tree.findall(r"sommet"):
ft_vertex = QgsFeature()
ft_vertex.setGeometry(QgsGeometry.fromWkt(e.attrib[r"geometrie"]))
_id_noeud = int(e.attrib[r"id_noeud"])
_version = int(e.attrib[r"version"])
som_ge_createur = str(e.find(r"./som_ge_createur").text)
som_nature = str(e.find(r"./som_nature").text)
som_prec_rattcht = int(
e.find(r"./som_precision_rattachement").text)
som_coord_est = float(e.find(r"./som_coord_est").text)
som_coord_nord = float(e.find(r"./som_coord_nord").text)
som_repres_plane = str(e.find(r"./som_representation_plane").text)
som_tolerance = float(e.find(r"./som_tolerance").text)
# Field used to store the attestation_qualite value
# when modifying a vertex ("false" or "true")
attestation_qualite = "false"
som_delim_pub = str(e.find(r"./som_delimitation_publique").text)
som_typo_nature = str(e.find(r"./som_typologie_nature").text)
ft_vertex.setAttributes([
_id_noeud, _version, som_ge_createur, som_delim_pub,
som_typo_nature, som_nature, som_prec_rattcht, som_coord_est,
som_coord_nord, som_repres_plane, som_tolerance,
attestation_qualite, NULL
])
fts_vertex.append(ft_vertex)
# ..to edge layer..
fts_edge = []
for e in tree.findall(r"limite"):
ft_edge = QgsFeature()
ft_edge.setGeometry(QgsGeometry.fromWkt(e.attrib[r"geometrie"]))
_id_arc = int(e.attrib[r"id_arc"])
_version = int(e.attrib[r"version"])
lim_ge_createur = str(e.find(r"./lim_ge_createur").text)
lim_typo_nature = str(e.find(r"./lim_typologie_nature").text)
lim_delim_pub = str(e.find(r"./lim_delimitation_publique").text)
ft_edge.setAttributes([
_id_arc, _version, lim_ge_createur, lim_delim_pub,
lim_typo_nature
])
fts_edge.append(ft_edge)
# Add features to layers..
p_vertex.addFeatures(fts_vertex)
p_edge.addFeatures(fts_edge)
# Update fields..
l_vertex.updateFields()
l_edge.updateFields()
# Update layer's extent..
l_vertex.updateExtents()
l_edge.updateExtents()
# Check if valid..
if not l_vertex.isValid() or not l_edge.isValid():
raise Exception(
"Une erreur est survenue lors du chargement de la couche.")
# Then return layers..
return [l_vertex, l_edge]
def test_legend_key_to_expression(self):
root_rule = QgsRuleBasedRenderer.Rule(None)
renderer = QgsRuleBasedRenderer(root_rule)
exp, ok = renderer.legendKeyToExpression('xxxx', None)
self.assertFalse(ok)
exp, ok = renderer.legendKeyToExpression(root_rule.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(exp, 'TRUE')
rule2 = QgsRuleBasedRenderer.Rule(None, filterExp='"field_name" = 5')
rule3 = QgsRuleBasedRenderer.Rule(None,
maximumScale=2000,
filterExp='"field_name" = 6')
rule4 = QgsRuleBasedRenderer.Rule(None,
minimumScale=1000,
filterExp='"field_name" = 7')
rule5 = QgsRuleBasedRenderer.Rule(None,
minimumScale=3000,
maximumScale=1000)
root_rule.appendChild(rule2)
root_rule.appendChild(rule3)
root_rule.appendChild(rule4)
root_rule.appendChild(rule5)
exp, ok = renderer.legendKeyToExpression(root_rule.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(exp, 'TRUE')
exp, ok = renderer.legendKeyToExpression(rule2.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(exp, '"field_name" = 5')
exp, ok = renderer.legendKeyToExpression(rule3.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(exp, '("field_name" = 6) AND (@map_scale >= 2000)')
exp, ok = renderer.legendKeyToExpression(rule4.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(exp, '("field_name" = 7) AND (@map_scale <= 1000)')
exp, ok = renderer.legendKeyToExpression(rule5.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(exp, '(@map_scale <= 3000) AND (@map_scale >= 1000)')
rule6 = QgsRuleBasedRenderer.Rule(None,
filterExp='"field_name" = \'a\'')
rule4.appendChild(rule6)
exp, ok = renderer.legendKeyToExpression(rule6.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(
exp,
'("field_name" = \'a\') AND (("field_name" = 7) AND (@map_scale <= 1000))'
)
# group only rule
rule7 = QgsRuleBasedRenderer.Rule(None)
rule3.appendChild(rule7)
rule8 = QgsRuleBasedRenderer.Rule(None,
filterExp='"field_name" = \'c\'')
rule7.appendChild(rule8)
exp, ok = renderer.legendKeyToExpression(rule7.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(exp, '("field_name" = 6) AND (@map_scale >= 2000)')
exp, ok = renderer.legendKeyToExpression(rule8.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(
exp,
"""("field_name" = 'c') AND (("field_name" = 6) AND (@map_scale >= 2000))"""
)
# else rules
root_rule = QgsRuleBasedRenderer.Rule(None)
renderer = QgsRuleBasedRenderer(root_rule)
rule2 = QgsRuleBasedRenderer.Rule(None, filterExp='"field_name" = 5')
rule3 = QgsRuleBasedRenderer.Rule(None,
maximumScale=2000,
filterExp='"field_name" = 6')
rule4 = QgsRuleBasedRenderer.Rule(None, elseRule=True)
root_rule.appendChild(rule2)
root_rule.appendChild(rule3)
root_rule.appendChild(rule4)
exp, ok = renderer.legendKeyToExpression(root_rule.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(exp, 'TRUE')
exp, ok = renderer.legendKeyToExpression(rule2.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(exp, '"field_name" = 5')
exp, ok = renderer.legendKeyToExpression(rule3.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(exp, '("field_name" = 6) AND (@map_scale >= 2000)')
exp, ok = renderer.legendKeyToExpression(rule4.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(
exp,
'NOT (("field_name" = 5) OR (("field_name" = 6) AND (@map_scale >= 2000)))'
)
rule5 = QgsRuleBasedRenderer.Rule(None, filterExp='"field_name" = 11')
rule4.appendChild(rule5)
exp, ok = renderer.legendKeyToExpression(rule5.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(
exp,
'("field_name" = 11) AND (NOT (("field_name" = 5) OR (("field_name" = 6) AND (@map_scale >= 2000))))'
)
# isolated ELSE rule, with no siblings
root_rule = QgsRuleBasedRenderer.Rule(None)
renderer = QgsRuleBasedRenderer(root_rule)
rule2 = QgsRuleBasedRenderer.Rule(None, filterExp='"field_name" = 5')
rule3 = QgsRuleBasedRenderer.Rule(None,
maximumScale=2000,
filterExp='"field_name" = 6')
root_rule.appendChild(rule2)
root_rule.appendChild(rule3)
rule4 = QgsRuleBasedRenderer.Rule(None, elseRule=True)
rule3.appendChild(rule4)
exp, ok = renderer.legendKeyToExpression(rule4.ruleKey(), None)
self.assertTrue(ok)
self.assertEqual(
exp, '(TRUE) AND (("field_name" = 6) AND (@map_scale >= 2000))')