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 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 testQgsGraduatedSymbolRenderer_2(self):
"""Test QgsGraduatedSymbolRenderer: Adding /removing/editing classes """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
symbol.setColor(QColor(255, 0, 0))
# Add class without start and end ranges
renderer.addClass(symbol.clone())
renderer.addClass(symbol.clone())
renderer.updateRangeLabel(1, 'Second range')
renderer.updateRangeLowerValue(1, 10.0)
renderer.updateRangeUpperValue(1, 25.0)
renderer.updateRangeRenderState(1, False)
symbol.setColor(QColor(0, 0, 255))
renderer.updateRangeSymbol(1, symbol.clone())
# Add as a rangeobject
symbol.setColor(QColor(0, 255, 0))
range = QgsRendererRange(20.0, 25.5, symbol.clone(), 'Third range',
False)
renderer.addClassRange(range)
# Add class by lower and upper
renderer.addClassLowerUpper(25.5, 30.5)
# (Update label for sorting tests)
renderer.updateRangeLabel(3, 'Another range')
self.assertEqual(
dumpRangeLabels(renderer.ranges()),
'(0.0 - 0.0,Second range,Third range,Another range,)',
'Added ranges labels not correct')
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)',
'Added ranges lower/upper values not correct')
# Check that clone function works
renderer2 = renderer.clone()
self.assertEqual(dumpGraduatedRenderer(renderer),
dumpGraduatedRenderer(renderer2),
"clone function doesn't replicate renderer properly")
# Check save and reload from Dom works
doc = QDomDocument()
element = renderer.save(doc)
renderer2 = QgsGraduatedSymbolRenderer.create(element)
self.assertEqual(
dumpGraduatedRenderer(renderer), dumpGraduatedRenderer(renderer2),
"Save/create from DOM doesn't replicate renderer properly")
# Check sorting
renderer.sortByLabel()
self.assertEqual(
dumpRangeList(renderer.ranges(), labelsOnly=True),
'(0.0 - 0.0,Another range,Second range,Third range,)',
'sortByLabel not correct')
renderer.sortByValue()
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)',
'sortByValue not correct')
renderer.sortByValue(Qt.DescendingOrder)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(25.5000-30.5000,20.0000-25.5000,10.0000-25.0000,0.0000-0.0000,)',
'sortByValue descending not correct')
# Check deleting
renderer.deleteClass(2)
self.assertEqual(dumpRangeBreaks(renderer.ranges()),
'(25.5000-30.5000,20.0000-25.5000,0.0000-0.0000,)',
'deleteClass not correct')
renderer.deleteAllClasses()
self.assertEqual(len(renderer.ranges()), 0,
"deleteAllClasses didn't delete all")
def testQgsRendererRangeLabelFormat_2(self):
"""Test QgsRendererRangeLabelFormat number format"""
format = QgsRendererRangeLabelFormat()
# Tests have precision, trim, value, expected
# (Note: Not sure what impact of locale is on these tests)
tests = (
(2, False, 1.0, '1.00'),
(2, True, 1.0, '1'),
(2, False, 1.234, '1.23'),
(2, True, 1.234, '1.23'),
(2, False, 1.236, '1.24'),
(2, False, -1.236, '-1.24'),
(2, False, -0.004, '0.00'),
(2, True, 1.002, '1'),
(2, True, 1.006, '1.01'),
(2, True, 1.096, '1.1'),
(3, True, 1.096, '1.096'),
(-2, True, 1496.45, '1500'),
(-2, True, 149.45, '100'),
(-2, True, 79.45, '100'),
(-2, True, 49.45, '0'),
(-2, True, -49.45, '0'),
(-2, True, -149.45, '-100'),
)
for f in tests:
precision, trim, value, expected = f
format.setPrecision(precision)
format.setTrimTrailingZeroes(trim)
result = format.formatNumber(value)
self.assertEqual(
result, expected,
"Number format error {0}:{1}:{2} => {3}".format(
precision, trim, value, result))
# Label tests - label format, expected result.
# Labels will be evaluated with lower=1.23 upper=2.34, precision=2
ltests = (
("%1 - %2", "1.23 - 2.34"),
("%1", "1.23"),
("%2", "2.34"),
("%2%", "2.34%"),
("%1%1", "1.231.23"),
("from %1 to %2 meters", "from 1.23 to 2.34 meters"),
("from %2 to %1 meters", "from 2.34 to 1.23 meters"),
)
format.setPrecision(2)
format.setTrimTrailingZeroes(False)
lower = 1.232
upper = 2.339
for t in ltests:
label, expected = t
format.setFormat(label)
result = format.labelForLowerUpper(lower, upper)
self.assertEqual(
result, expected,
"Label format error {0} => {1}".format(label, result))
range = QgsRendererRange()
range.setLowerValue(lower)
range.setUpperValue(upper)
label = ltests[0][0]
format.setFormat(label)
result = format.labelForRange(range)
self.assertEqual(
result, ltests[0][1],
"Label for range error {0} => {1}".format(label, result))
def renderizeXY(layer, field):
myTargetField = field
myRangeList = []
myOpacity = 1
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#D8D8D8'))
#QMessageBox.information(None,"DEBUG",str(myOpacity))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(-150.0, 0.0, mySymbol, "No level")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FFFFFF'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(0.1, 34.4, mySymbol, "< 35 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#238443'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(34.5, 39.4, mySymbol, "35 - 39 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#78C679'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(39.5, 44.4, mySymbol, "40 - 44 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#C2E699'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(44.5, 49.4, mySymbol, "45 - 49 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FFFFB2'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(49.5, 54.4, mySymbol, "50 - 54 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FECC5C'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(54.5, 59.4, mySymbol, "55 - 59 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FD8D3C'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(59.5, 64.4, mySymbol, "60 - 64 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FF0909'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(64.5, 69.4, mySymbol, "65 - 69 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#B30622'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(69.5, 74.4, mySymbol, "70 - 74 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#67033B'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(74.5, 79.4, mySymbol, "75 - 79 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#1C0054'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(79.5, 150.0, mySymbol, ">= 80 dB(A)")
myRangeList.append(myRange)
myRenderer = QgsGraduatedSymbolRenderer('', myRangeList)
myRenderer.setMode(QgsGraduatedSymbolRenderer.EqualInterval)
myRenderer.setClassAttribute(myTargetField)
layer.setRenderer(myRenderer)
#iface.legendInterface().refreshLayerSymbology(layer)
#layer.reload()
#iface.mapCanvas().refresh()
layer.triggerRepaint()
iface.layerTreeView().refreshLayerSymbology(layer.id())
def render_old(layer, field):
myTargetField = field
myRangeList = []
myOpacity = 1
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FFFFFF'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(-150.0, 0.0, mySymbol, "No level")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#C0FFC0'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(0.1, 34.9, mySymbol, "< 35 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#00CC00'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(35.0, 39.9, mySymbol, "35 - 40 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#005000'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(40.0, 44.9, mySymbol, "40 - 45 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FFFF00'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(45.0, 49.9, mySymbol, "45 - 50 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FFC74A'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(50.0, 54.9, mySymbol, "50 - 55 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FF6600'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(55.0, 59.9, mySymbol, "55 - 60 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FF3333'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(60.0, 64.9, mySymbol, "60 - 65 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#990033'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(65.0, 69.9, mySymbol, "65 - 70 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#AD9AD6'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(70.0, 74.9, mySymbol, "70 - 75 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#0000FF'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(75.0, 79.9, mySymbol, "75 - 80 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#000066'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(80.0, 150.0, mySymbol, "> 80 dB(A)")
myRangeList.append(myRange)
myRenderer = QgsGraduatedSymbolRenderer('', myRangeList)
myRenderer.setMode(QgsGraduatedSymbolRenderer.EqualInterval)
myRenderer.setClassAttribute(myTargetField)
layer.setRenderer(myRenderer)
#iface.legendInterface().refreshLayerSymbology(layer)
#layer.reload()
#iface.mapCanvas().refresh()
layer.triggerRepaint()
iface.layerTreeView().refreshLayerSymbology(layer.id())
def getColorClasses(self, symbol, nameLayer):
# Five classes as deafult
simb1 = symbol.clone()
simb2 = symbol.clone()
simb3 = symbol.clone()
simb4 = symbol.clone()
simb5 = symbol.clone()
simb1.setColor(QColor(0, 0, 255))
simb2.setColor(QColor(0, 255, 255))
simb3.setColor(QColor(0, 255, 0))
simb4.setColor(QColor(255, 255, 0))
simb5.setColor(QColor(165, 0, 0))
ranges = []
if "Pressure" in nameLayer:
ranges.append(QgsRendererRange(-10000, 20, simb1, "<20"))
ranges.append(QgsRendererRange(20, 30, simb2, "20-30"))
ranges.append(QgsRendererRange(30, 40, simb3, "30-40"))
ranges.append(QgsRendererRange(40, 50, simb4, "40-50"))
ranges.append(QgsRendererRange(50, 10000, simb5, ">50"))
elif "Node_Head" in nameLayer:
ranges.append(QgsRendererRange(-10000, 20, simb1, "<20"))
ranges.append(QgsRendererRange(20, 40, simb2, "20-40"))
ranges.append(QgsRendererRange(40, 60, simb3, "40-60"))
ranges.append(QgsRendererRange(60, 80, simb4, "60-80"))
ranges.append(QgsRendererRange(80, 10000, simb5, ">80"))
elif "Demand" in nameLayer:
ranges.append(QgsRendererRange(-10000, 5, simb1, "<5"))
ranges.append(QgsRendererRange(5, 10, simb2, "5-10"))
ranges.append(QgsRendererRange(10, 20, simb3, "10-20"))
ranges.append(QgsRendererRange(20, 40, simb4, "20-40"))
ranges.append(QgsRendererRange(40, 10000, simb5, ">40"))
elif "Node_Quality" in nameLayer:
ranges.append(QgsRendererRange(-10000, 0.25, simb1, "<0.25"))
ranges.append(QgsRendererRange(0.25, 0.5, simb2, "0.25-0.5"))
ranges.append(QgsRendererRange(0.5, 0.75, simb3, "0.5-0.75"))
ranges.append(QgsRendererRange(0.75, 1, simb4, "0.75-1"))
ranges.append(QgsRendererRange(1, 10000, simb5, ">1"))
elif "Flow" in nameLayer:
ranges.append(QgsRendererRange(-10000, 10, simb1, "<10"))
ranges.append(QgsRendererRange(10, 20, simb2, "10-20"))
ranges.append(QgsRendererRange(20, 50, simb3, "20-50"))
ranges.append(QgsRendererRange(50, 100, simb4, "50-100"))
ranges.append(QgsRendererRange(100, 10000, simb5, ">100"))
elif "Velocity" in nameLayer:
ranges.append(QgsRendererRange(-10000, 0.1, simb1, "<0.1"))
ranges.append(QgsRendererRange(0.1, 0.5, simb2, "0.1-0.5"))
ranges.append(QgsRendererRange(0.5, 1, simb3, "0.5-1"))
ranges.append(QgsRendererRange(1, 2, simb4, "1-2"))
ranges.append(QgsRendererRange(2, 10000, simb5, ">2"))
elif "HeadLoss" in nameLayer:
ranges.append(QgsRendererRange(-10000, 0.1, simb1, "<0.1"))
ranges.append(QgsRendererRange(0.1, 0.5, simb2, "0.1-0.5"))
ranges.append(QgsRendererRange(0.5, 1, simb3, "0.5-1"))
ranges.append(QgsRendererRange(1, 5, simb4, "1-5"))
ranges.append(QgsRendererRange(5, 10000, simb5, ">5"))
elif "Link_Quality" in nameLayer:
ranges.append(QgsRendererRange(-10000, 0.25, simb1, "<0.25"))
ranges.append(QgsRendererRange(0.25, 0.5, simb2, "0.25-0.5"))
ranges.append(QgsRendererRange(0.5, 0.75, simb3, "0.5-0.75"))
ranges.append(QgsRendererRange(0.75, 1, simb4, "0.75-1"))
ranges.append(QgsRendererRange(1, 10000, simb5, ">1"))
return ranges
def symbology_from_range(layer, min_val, max_val, color, title):
symbol = get_default_symbol(layer.geometryType())
symbol.setColor(color)
srange = QgsRendererRange(min_val, max_val, symbol, title)
return srange
def test_legend_key_to_expression(self):
renderer = QgsGraduatedSymbolRenderer()
renderer.setClassAttribute('field_name')
exp, ok = renderer.legendKeyToExpression('xxxx', None)
self.assertFalse(ok)
# no categories
exp, ok = renderer.legendKeyToExpression('0', None)
self.assertFalse(ok)
symbol_a = createMarkerSymbol()
renderer.addClassRange(QgsRendererRange(1, 2, symbol_a, 'a'))
symbol_b = createMarkerSymbol()
renderer.addClassRange(QgsRendererRange(5, 6, symbol_b, 'b'))
symbol_c = createMarkerSymbol()
renderer.addClassRange(
QgsRendererRange(15.5, 16.5, symbol_c, 'c', False))
exp, ok = renderer.legendKeyToExpression('0', None)
self.assertTrue(ok)
self.assertEqual(exp, "(field_name >= 1) AND (field_name <= 2)")
exp, ok = renderer.legendKeyToExpression('1', None)
self.assertTrue(ok)
self.assertEqual(exp, "(field_name >= 5) AND (field_name <= 6)")
exp, ok = renderer.legendKeyToExpression('2', None)
self.assertTrue(ok)
self.assertEqual(exp, "(field_name >= 15.5) AND (field_name <= 16.5)")
exp, ok = renderer.legendKeyToExpression('3', None)
self.assertFalse(ok)
layer = QgsVectorLayer(
"Point?field=field_name:double&field=fldint:integer", "addfeat",
"memory")
# with layer
exp, ok = renderer.legendKeyToExpression('2', layer)
self.assertTrue(ok)
self.assertEqual(
exp, """("field_name" >= 15.5) AND ("field_name" <= 16.5)""")
# with expression as attribute
renderer.setClassAttribute('log("field_name")')
exp, ok = renderer.legendKeyToExpression('0', None)
self.assertTrue(ok)
self.assertEqual(
exp, """(log("field_name") >= 1) AND (log("field_name") <= 2)""")
exp, ok = renderer.legendKeyToExpression('1', None)
self.assertTrue(ok)
self.assertEqual(
exp, """(log("field_name") >= 5) AND (log("field_name") <= 6)""")
exp, ok = renderer.legendKeyToExpression('2', None)
self.assertTrue(ok)
self.assertEqual(
exp,
"""(log("field_name") >= 15.5) AND (log("field_name") <= 16.5)""")
exp, ok = renderer.legendKeyToExpression('2', layer)
self.assertTrue(ok)
self.assertEqual(
exp,
"""(log("field_name") >= 15.5) AND (log("field_name") <= 16.5)""")
def updateRenderer(self, layer, attribute_vals, settings):
"""
Creates a renderer for the layer based on this, and applies it
The renderer uses GradientColourRamp to calculate the symbol colours
@param layer: the selected QgsVectorLayer object
"""
geometry = layer.geometryType()
# create a colour ramp based on colour range type, inverting symbols if required
ramp_type = int(settings['colour_range'])
invert = int(settings['invert_colour'])
ramp = self.getColourRamp(ramp_type, invert)
line_width = float(settings['line_width'])
# calculate ranges: EqualInterval = 0; Quantile = 1; Jenks = 2; StdDev = 3; Pretty = 4; Custom = 5
intervals = int(settings['intervals'])
mode = int(settings['interval_type'])
attribute = attribute_vals['name']
renderer = None
if mode < 3:
# set symbol type and line width
symbol = QgsSymbol.defaultSymbol(geometry)
if symbol:
if symbol.type() == 1: # line
symbol.setWidth(line_width)
elif symbol.type() == 2: # line
symbol = QgsFillSymbol.createSimple({
'style':
'solid',
'color':
'black',
'width_border':
'%s' % line_width
})
elif symbol.type() == 0: # point
symbol.setSize(line_width)
renderer = QgsGraduatedSymbolRenderer.createRenderer(
layer, attribute, intervals, mode, symbol, ramp)
renderer.setMode(mode)
renderer.setSourceColorRamp(ramp)
else:
# calculate range values individually based on custom settings
ranges = []
max_value = float(attribute_vals['max'])
min_value = float(attribute_vals['min'])
top_value = float(settings['top_value'])
bottom_value = float(settings['bottom_value'])
# calculate number of ranges depending on top/bottom difference from max/min:
# is there really a range there? Otherwise this will calculate 1 or even 2 ranges less
calc_intervals = intervals + 1
if top_value != max_value:
calc_intervals -= 1
if bottom_value != min_value:
calc_intervals -= 1
range_steps = [
r for r in np.linspace(bottom_value, top_value, calc_intervals)
]
if top_value != max_value:
range_steps.append(max_value)
if bottom_value != min_value:
range_steps.insert(0, min_value)
for i in range(0, len(range_steps) - 1):
symbol = QgsSymbol.defaultSymbol(geometry)
if symbol:
new_colour = ramp.color(
i / (float(len(range_steps)) - 2)).getRgb()
symbol.setColor(QColor(*new_colour))
symbol.setWidth(line_width)
label = "%s - %s" % (range_steps[i], range_steps[i + 1])
this_range = QgsRendererRange(range_steps[i],
range_steps[i + 1], symbol,
label)
ranges.append(this_range)
if ranges:
renderer = QgsGraduatedSymbolRenderer(attribute, ranges)
# renderer.setMode(5)
renderer.setSourceColorRamp(ramp)
# configure symbol levels to display in specific order
# the classic "reds on top" from space syntax, or the reverse
if renderer:
display_order = int(settings['display_order'])
renderer.setUsingSymbolLevels(True)
render_pass = 0
if display_order == 0:
for symbol in renderer.symbols(QgsRenderContext()):
for i in range(0, symbol.symbolLayerCount()):
symbol.symbolLayer(i).setRenderingPass(render_pass)
render_pass += 1
else:
for symbol in reversed(renderer.symbols(QgsRenderContext())):
for i in range(0, symbol.symbolLayerCount()):
symbol.symbolLayer(i).setRenderingPass(render_pass)
render_pass += 1
# set the symbols for monochrome ramp
# varying line width, point size or polygon pattern density
# doesn't use data column because it's not scaled according to line width values
# the width is calculated linearly between min and given value
if renderer:
if ramp_type == 3:
new_width = np.linspace(0.1, line_width, intervals)
step = intervals / 8.0 # this is usd for fill patterns
# color = QColor(ramp.color(0).getRgb()) # same as above
for i in range(0, intervals):
symbol = renderer.symbols(QgsRenderContext())[i]
if invert:
if symbol.type() == 1: # line
symbol.setWidth(new_width[(intervals - 1) - i])
elif symbol.type() == 0: # point
symbol.setSize(new_width[(intervals - 1) - i])
elif symbol.type() == 2: # polygon
dense = int(i / step)
if dense == 0:
style = 'solid'
else:
style = 'dense%s' % dense
symbol = QgsFillSymbol.createSimple({
'style':
style,
'color':
'black',
'width_border':
'%s' % new_width[(intervals - 1) - i]
})
else:
if symbol.type() == 1: # line
symbol.setWidth(new_width[i])
elif symbol.type() == 0: # point
symbol.setSize(new_width[i])
elif symbol.type() == 2: # polygon
dense = int(i / step)
if dense == 7:
style = 'solid'
else:
style = 'dense%s' % (7 - dense)
symbol = QgsFillSymbol.createSimple({
'style':
style,
'color':
'black',
'width_border':
'%s' % new_width[i]
})
renderer.updateRangeSymbol(i, symbol)
return renderer
def run(self):
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = ChoroMapDialog()
# clear the line edit widget and set the pushbutton callback
self.dlg.lineEdit.clear()
self.dlg.pushButton.clicked.connect(self.choose_folder)
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
#not used anymore
#i was doing the catagories manual before
"""
def interval_divide2(min, max, intervals):
assert intervals != 0
interval_size = (max - min) / intervals
result = []
start = min
end = min + interval_size
while True:
result.append([int(start), int(end)])
start = end + 1
end = end + interval_size
if len(result) == intervals:
break
return result
"""
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
layer = self.layer
QgsProject.instance().addMapLayers([layer])
vals = []
fld = self.dlg.comboBox_2.currentText()
for f in layer.getFeatures():
vals.append(f[fld])
colors = ['#f1eef6','#d0d1e6','#a6bddb','#74a9cf','#2b8cbe','#045a8d']
colors = ['#f1eef6','#bdc9e1','#74a9cf','#2b8cbe','#045a8d']
min = sorted(vals)[0]
max = sorted(vals)[-1]
step = (max-min)/len(colors)
rangeL = []
for color in colors:
cat = [min, min+step, color]
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
symbol.setColor(QColor(cat[2]))
qRange = QgsRendererRange(cat[0], cat[1], symbol, '{0:.1f}-{1:.1f}'.format(cat[0], cat[1]))
rangeL.append(qRange)
min = (min + step) + 0.1
renderer = QgsGraduatedSymbolRenderer(fld, rangeL)
layer.setRenderer(renderer)
layer.triggerRepaint()
def editNetworkLayer(self, progressBar, layerName, scenariosExpression,
networkExpression, variable, level, projectPath,
group, networkLinkShapePath, method, layerId,
expressionNetworkText, color):
"""
@summary: Get operators dictionary
@param layerName: Layer name
@type layerName: String
@param scenariosExpression: Scenarios expression
@type scenariosExpression: Stack object
@param networkExpression: Network expression
@type networkExpression: Stack object
@param variable: Variable to evaluate
@type variable: String
@param level: Level to evaluate (Total, Routes, Operators)
@type level: Level object
@param projectPath: Project path
@type projectPath: String
@param group: Project group
@type group: Layer group
@param networkLinkShapePath: Network link shape path
@type networkLinkShapePath: String
@return: Result of the layer creation
"""
if scenariosExpression is None:
QMessageBox.warning(None, "Network expression",
"There is not scenarios information.")
print("There is not scenarios information.")
return False
registry = QgsProject.instance()
layersCount = len(registry.mapLayers())
result, resultData, minValue, maxValue = self.network_data_access.create_network_memory(
layerName, scenariosExpression, networkExpression, variable, level,
projectPath)
progressBar.setValue(15)
if result:
# Source shape, name of the new shape, providerLib
layer = QgsVectorLayer(networkLinkShapePath,
layerName + "_network", 'ogr')
epsg = layer.crs().postgisSrid()
intMethod = 0 if method == "Color" else 1
rowCounter = len(resultData)
if not layer.isValid():
return False
feats = [feat for feat in layer.getFeatures()]
# Create a vector layer with data on Memory
memoryLayer = registry.mapLayer(layerId)
memory_data = memoryLayer.dataProvider()
joinedFieldName = "Result"
shpField = "Id"
attr = layer.dataProvider().fields().toList()
attr += [QgsField(joinedFieldName, QVariant.Double)]
progressBar.setValue(25)
memory_data.addAttributes(attr)
memory_data.addFeatures(feats)
num = 30
progressBar.setValue(num)
progressInterval = 70 / len(resultData)
memoryLayer.startEditing()
for rowItem in np.nditer(resultData):
value = 0
num += progressInterval
progressBar.setValue(num)
it = memoryLayer.getFeatures("LINKID = '{0}'".format(
str(rowItem['Id']).replace("b", "").replace("'", "")))
for id_feature in it:
memoryLayer.changeAttributeValue(
id_feature.id(),
memory_data.fieldNameIndex(joinedFieldName),
QVariant(round(float(rowItem['Result']), 2)))
memoryLayer.commitChanges()
myStyle = QgsStyle().defaultStyle()
defaultColorRampNames = myStyle.colorRampNames()
ramp = myStyle.colorRamp(defaultColorRampNames[0])
ranges = []
nCats = ramp.count()
rng = maxValue - minValue
nCats = 8
scale = QgsMapUnitScale(minValue, maxValue)
if method == "Color":
color1 = list(
map(lambda x: int(x), color['color1'].split(",")[0:3]))
color2 = list(
map(lambda x: int(x), color['color2'].split(",")[0:3]))
interpolatedColors = HP.linear_gradient(color1, color2, nCats)
for i in range(0, nCats):
v0 = minValue + rng / float(nCats) * i
v1 = minValue + rng / float(nCats) * (i + 1)
if method == "Color":
line = QgsSimpleLineSymbolLayer(
QColor(interpolatedColors['r'][i],
interpolatedColors['g'][i],
interpolatedColors['b'][i]))
line.setOffsetUnit(2)
line.setOffset(2)
line.setWidth(0.8)
symbol = QgsLineSymbol()
symbol.changeSymbolLayer(0, line)
myRange = QgsRendererRange(v0, v1, symbol, "")
elif method == "Size":
qcolor = QColor()
qcolor.setRgb(color)
line = QgsSimpleLineSymbolLayer(qcolor)
line.setOffsetUnit(2)
line.setOffset(0.7)
# Symbol
# symbolLine = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.ArrowHead)
# Mark line
# markLine = QgsMarkerLineSymbolLayer()
# markLine.setPlacement(4)
symbolo = QgsLineSymbol()
symbolo.changeSymbolLayer(0, line)
# symbolo.appendSymbolLayer(line)
myRange = QgsRendererRange(v0, v1, symbolo, "")
ranges.append(myRange)
# The first parameter refers to the name of the field that contains the calculated value (expression)
modeRender = QgsGraduatedSymbolRenderer.Mode(2)
renderer = QgsGraduatedSymbolRenderer(joinedFieldName, ranges)
renderer.setMode(modeRender)
renderer.setGraduatedMethod(intMethod)
if method == "Size":
renderer.setSymbolSizes(0.200000, 2.60000)
renderer.setSourceColorRamp(ramp)
memoryLayer.setRenderer(renderer)
typeLayer = "network"
fieldName = "LINKID"
networkExpressionText = str(scenariosExpression)
# Create XML File ".qtranus" with the parameters of the executions
if FileMXML.if_exist_xml_layers(projectPath):
if FileMXML.if_exist_layer(projectPath, memoryLayer.id()):
FileMXML.update_xml_file(memoryLayer.name(),
memoryLayer.id(),
scenariosExpression, variable,
networkExpression, projectPath,
expressionNetworkText, method,
level, color)
else:
FileMXML.add_layer_xml_file(memoryLayer.name(),
memoryLayer.id(),
scenariosExpression, variable,
networkExpression, projectPath,
expressionNetworkText,
shpField, typeLayer, method,
level, color)
else:
FileMXML.create_xml_file(memoryLayer.name(), memoryLayer.id(),
scenariosExpression, variable,
networkExpression, projectPath,
expressionNetworkText, shpField,
typeLayer, method, level, color)
#group.insertLayer((layersCount+1), memoryLayer)
progressBar.setValue(100)
return True
def processAlgorithm(self, parameters, context, feedback):
# Couche buffer :
input_featuresource = self.parameterAsSource(parameters, 'INPUT',
context)
# Buffer distance :
bufferdist = self.parameterAsDouble(parameters, 'BUFFERDIST', context)
# Check for cancelation
if feedback.isCanceled():
return {}
buffer_result = processing.run(
'native:buffer',
{
# Here we pass on the original parameter values of INPUT
# and BUFFER_OUTPUT to the buffer algorithm.
'INPUT': parameters['INPUT'],
'OUTPUT': parameters['BUFFER_OUTPUT'],
'DISTANCE': bufferdist,
'SEGMENTS': 10,
'DISSOLVE': True,
'END_CAP_STYLE': 0,
'JOIN_STYLE': 0,
'MITER_LIMIT': 10
},
# Because the buffer algorithm is being run as a step in
# another larger algorithm, the is_child_algorithm option
# should be set to True
is_child_algorithm=True,
#
# It's important to pass on the context and feedback objects to
# child algorithms, so that they can properly give feedback to
# users and handle cancelation requests.
context=context,
feedback=feedback)
# Check for cancelation
if feedback.isCanceled():
return {}
# Selection de la couche cable :
cables = QgsVectorLayer(
"/Users/pierre-loupgarrigues/Python JupyterLab/M2/pyqgis/Evaluation_pyqgis/data/cables.shp",
"cables", "ogr")
cables = iface.activeLayer()
# Séléction des cables en fonction des paramètres choisis :
cables.selectByExpression(
" \"capacite\" > '{}' AND \"mode_pose\" = '{}' ".format(
parameters[self.CAPACITE], parameters[self.MODE_DE_POSE]))
# Vérification :
selectionCapacite = self.parameterAsDouble(parameters, 'CAPACITE',
context)
print(selectionCapacite)
# Vérification :
selectionModeDePose = self.parameterAsString(parameters,
'MODE_DE_POSE', context)
print(selectionModeDePose)
# Sauvegarde de la séléction des cables :
cables_selection = processing.run(
'qgis:saveselectedfeatures',
{
'INPUT': cables,
#'OUTPUT':'memory:'
'OUTPUT': parameters['CABLES_OUTPUT']
},
context=context,
feedback=feedback,
is_child_algorithm=True)
mes_cables = cables_selection['OUTPUT']
### SYMBOLOGIE GRADUEE
nb_prises = (
('Faible', 0, 9, 'green'),
('Moyen_1', 10, 25, 'yellow'),
('Moyen_2', 26, 100, 'orange'),
('Eleve', 101, 1000000, 'red'),
)
# creation
ranges = []
for label, lower, upper, color in nb_prises:
symbol = QgsSymbol.defaultSymbol(cables.geometryType())
symbol.setColor(QColor(color))
rng = QgsRendererRange(lower, upper, symbol, label)
ranges.append(rng)
# create the renderer and assign it to a layer
expression = 'nb_prises' # field name
renderer = QgsGraduatedSymbolRenderer(expression, ranges)
cables.setRenderer(renderer)
# Return the results
return {
'BUFFER_OUTPUT': buffer_result['OUTPUT'],
'CABLES_OUTPUT': cables_selection['OUTPUT']
}
def testRendererRange(self):
self.assertEqual(QgsRendererRange().__repr__(), '<QgsRendererRange: 0 - 0>')
self.assertEqual(QgsRendererRange(1.0, 2.0, None, None).__repr__(), '<QgsRendererRange: 1 - 2>')
self.assertEqual(QgsRendererRange(1.0, 2.0, None, 'my class').__repr__(), '<QgsRendererRange: 1 - 2 (my class)>')
