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)>')