def testUsedAttributes(self): renderer = QgsGraduatedSymbolRenderer() ctx = QgsRenderContext() # attribute can contain either attribute name or an expression. # Sometimes it is not possible to distinguish between those two, # e.g. "a - b" can be both a valid attribute name or expression. # Since we do not have access to fields here, the method should return both options. renderer.setClassAttribute("value") self.assertEqual(renderer.usedAttributes(ctx), {"value"}) renderer.setClassAttribute("value - 1") self.assertEqual(renderer.usedAttributes(ctx), {"value", "value - 1"}) renderer.setClassAttribute("valuea - valueb") self.assertEqual(renderer.usedAttributes(ctx), {"valuea", "valuea - valueb", "valueb"})
def btn_display_style_clicked(self): style = self.cbo_display_style.currentText() self.params.pipes_vlay.loadNamedStyle( os.path.join(QML_FILEPATH, qml_files[style]['Pipes'])) self.params.junctions_vlay.loadNamedStyle( os.path.join(QML_FILEPATH, qml_files[style]['Junctions'])) if style == 'Results': #TODO: soft code renderer = QgsGraduatedSymbolRenderer() renderer.updateClasses(self.params.junctions_vlay, renderer.Pretty, 8) renderer.updateClasses(self.params.pipes_vlay, renderer.Pretty, 5) self.params.pipes_vlay.triggerRepaint() self.params.junctions_vlay.triggerRepaint()
def displayIrrepResults(setupObject, fieldName): colourList = [ '#FFFFBF', '#F4FAA7', '#EAF792', '#DAF57A', '#CAF266', '#B6F051', '#A0ED3B', '#86EB28', '#6DE815', '#4CE600' ] puLayer = QgsVectorLayer(setupObject.puPath, 'Planning units', 'ogr') irrepLayer = QgsVectorLayer(setupObject.puPath, fieldName, 'ogr') provider = puLayer.dataProvider() puFeatures = puLayer.getFeatures() graduatedFieldOrder = provider.fieldNameIndex(fieldName) maxCountScore = 0 #This will be used to set highest value in legend for puFeature in puFeatures: puAttributes = puFeature.attributes() puCountScore = puAttributes[graduatedFieldOrder] if puCountScore > maxCountScore: maxCountScore = puCountScore rangeList = list() minValue = 0 incValue = float(maxCountScore) / 10 for aValue in range(0, 10): maxValue = minValue + incValue if aValue == 9: maxValue = maxCountScore myColour = colourList[aValue] mySymbol = QgsFillSymbol.createSimple({ 'style': 'solid', 'color': myColour, 'color_border': myColour }) theRange = QgsRendererRange(minValue, maxValue, mySymbol, str(minValue) + ' - ' + str(maxValue)) minValue = maxValue rangeList.insert(0, theRange) myRenderer = QgsGraduatedSymbolRenderer('', rangeList) myRenderer.setMode(QgsGraduatedSymbolRenderer.EqualInterval) myRenderer.setClassAttribute(fieldName) irrepLayer.setRenderer(myRenderer) QgsProject.instance().addMapLayer(irrepLayer) iface.mapCanvas().refresh()
def displayDistributionMaps(setupObject, distShapeFilePathName, abundValuesDict, legendType, selectedFeatIDList): colourDict = makeColourDict() colourKey = 1 for featID in selectedFeatIDList: rangeList = list() colourList = colourDict[colourKey] colourKey += 1 if colourKey > len(list(colourDict.keys())): colourKey = 1 aDistLayerName = setupObject.targetDict[int(featID)][0] aDistLayer = QgsVectorLayer(distShapeFilePathName, aDistLayerName, 'ogr') aDistLayerFieldName = 'F_' + str(featID) aFeatAbundValueTupleList = abundValuesDict[featID] if legendType == 'equal_interval': legendValCatList = calcEqualIntervalLegendClasses( setupObject, aFeatAbundValueTupleList) if legendType == 'equal_area': legendValCatList = calcEqualAreaLegendClasses( setupObject, aFeatAbundValueTupleList) for aValue in range(0, 5): minValue = legendValCatList[aValue] maxValue = legendValCatList[aValue + 1] myColour = colourList[aValue] mySymbol = QgsFillSymbol.createSimple({ 'style': 'solid', 'color': myColour, 'color_border': myColour }) theRange = QgsRendererRange(minValue, maxValue, mySymbol, str(minValue) + ' - ' + str(maxValue)) rangeList.insert(0, theRange) myRenderer = QgsGraduatedSymbolRenderer('', rangeList) myRenderer.setMode(QgsGraduatedSymbolRenderer.EqualInterval) myRenderer.setClassAttribute(aDistLayerFieldName) aDistLayer.setRenderer(myRenderer) aDistLayer.setOpacity(0.6) QgsProject.instance().addMapLayer(aDistLayer) iface.mapCanvas().refresh()
def renderNetwork(self, output_network, distances): # Settings catchment_threshold = int(max(distances)) # settings for 10 color ranges depending on the radius color_ranges = ((0, (0.1 * catchment_threshold), '#ff0000'), ((0.1 * catchment_threshold), (0.2 * catchment_threshold), '#ff5100'), ((0.2 * catchment_threshold), (0.3 * catchment_threshold), '#ff9900'), ((0.3 * catchment_threshold), (0.4 * catchment_threshold), '#ffc800'), ((0.4 * catchment_threshold), (0.5 * catchment_threshold), '#ffee00'), ((0.5 * catchment_threshold), (0.6 * catchment_threshold), '#a2ff00'), ((0.6 * catchment_threshold), (0.7 * catchment_threshold), '#00ff91'), ((0.7 * catchment_threshold), (0.8 * catchment_threshold), '#00f3ff'), ((0.8 * catchment_threshold), (0.9 * catchment_threshold), '#0099ff'), ((0.9 * catchment_threshold), (1 * catchment_threshold), '#0033ff')) # list with all color ranges ranges = [] # for each range create a symbol with its respective color for lower, upper, color in color_ranges: symbol = QgsSymbol.defaultSymbol(output_network.geometryType()) symbol.setColor(QColor(color)) symbol.setWidth(0.5) range = QgsRendererRange(lower, upper, symbol, str(lower) + ' - ' + str(upper)) ranges.append(range) # create renderer based on ranges and apply to network renderer = QgsGraduatedSymbolRenderer('min_dist', ranges) output_network.setRenderer(renderer) # add network to the canvas QgsProject.instance().addMapLayer(output_network)
def testQgsGraduatedSymbolRenderer_3(self): """Test QgsGraduatedSymbolRenderer: Reading attribute data, calculating classes """ # Create a renderer renderer = QgsGraduatedSymbolRenderer() symbol = createMarkerSymbol() renderer.setSourceSymbol(symbol.clone()) # Test retrieving data values from a layer ml = createMemoryLayer((1.2, 0.5, 5.0, 1.0, 1.0, 1.2)) # ... by attribute renderer.setClassAttribute("value") self.assertEqual(renderer.classAttribute(), "value", "Error in set/get classAttribute") data = renderer.getDataValues(ml) datastr = ':'.join([str(x) for x in data]) self.assertEqual(datastr, '1.2:0.5:5.0:1.0:1.0:1.2', "Error returning field data") # ... by expression renderer.setClassAttribute('"value"*"value"') self.assertEqual(renderer.classAttribute(), '"value"*"value"', "Error in set/get classAttribute") data = renderer.getDataValues(ml) datastr = ':'.join([str(x) for x in data]) self.assertEqual(datastr, '1.44:0.25:25.0:1.0:1.0:1.44', "Error returning field expression") renderer.setClassAttribute("value") # Equal interval calculations renderer.updateClasses(ml, renderer.EqualInterval, 3) self.assertEqual(dumpRangeBreaks(renderer.ranges()), '(0.5000-2.0000,2.0000-3.5000,3.5000-5.0000,)', 'Equal interval classification not correct') # Quantile classes renderer.updateClasses(ml, renderer.Quantile, 3) self.assertEqual(dumpRangeBreaks(renderer.ranges()), '(0.5000-1.0000,1.0000-1.2000,1.2000-5.0000,)', 'Quantile classification not correct') renderer.updateClasses(ml, renderer.Quantile, 4) self.assertEqual( dumpRangeBreaks(renderer.ranges()), '(0.5000-1.0000,1.0000-1.1000,1.1000-1.2000,1.2000-5.0000,)', 'Quantile classification not correct')
def __init__(self, crs): uri = "LineString?crs=%s" % crsString(crs) provider = QgsProviderRegistry.instance().createProvider('memory', uri) provider.addAttributes(LRS_QUALITY_FIELDS.toList()) uri = provider.dataSourceUri() super(LrsQualityLayer, self).__init__(uri, 'LRS quality', 'memory') # min, max, color, label styles = [[0, 10, QColor(Qt.green), '0 - 10 % error'], [10, 30, QColor(Qt.blue), '10 - 30 % error'], [30, 1000000, QColor(Qt.red), '> 30 % error']] ranges = [] for style in styles: symbol = QgsSymbol.defaultSymbol(QgsWkbTypes.LineGeometry) symbol.setColor(style[2]) range = QgsRendererRange(style[0], style[1], symbol, style[3]) ranges.append(range) renderer = QgsGraduatedSymbolRenderer('err_perc', ranges) self.setRenderer(renderer)
def layerFromPath(lineFilePath: str, rootGroup: QgsLayerTreeGroup, project: QgsLayerTreeGroup) -> None: lineFileBasename = os.path.splitext(os.path.basename(lineFilePath))[0] lineLayer = QgsVectorLayer(lineFilePath, lineFileBasename, 'ogr') # Get number of features (range of Sequence#, number of renderer color classes) driver = ogr.GetDriverByName('ESRI Shapefile') dataSource = driver.Open(lineFilePath, 0) # 0 means read-only. 1 means writeable. layer = dataSource.GetLayer() dataSource = None #Setup graduated color renderer based on year targetField = 'Year' renderer = QgsGraduatedSymbolRenderer('', [QgsRendererRange()]) renderer.setClassAttribute(targetField) lineLayer.setRenderer(renderer) #Get viridis color ramp style = QgsStyle().defaultStyle() defaultColorRampNames = style.colorRampNames() viridisIndex = defaultColorRampNames.index('Viridis') viridisColorRamp = style.colorRamp( defaultColorRampNames[viridisIndex]) #Spectral color ramp #Dynamically recalculate number of classes and colors renderer.updateColorRamp(viridisColorRamp) yearsRange = list(range(1972, 2020)) classCount = len(yearsRange) renderer.updateClasses(lineLayer, QgsGraduatedSymbolRenderer.EqualInterval, classCount) #Set graduated color renderer based on Sequence# for i in range(classCount): #[1972-2019], 2020 not included targetField = 'DateUnix' year = yearsRange[i] renderer.updateRangeLowerValue(i, year) renderer.updateRangeUpperValue(i, year) project.addMapLayer(lineLayer, False) rootGroup.insertLayer(0, lineLayer)
def updateSymbology(self): if self._layer and self._layer.isValid(): att_values = [ f[self.target_field] for f in self._layer.dataProvider().getFeatures() ] intervs = self._intervalValues(att_values) colors = self._colorValues() range_list = [] for v_min, v_max, col in zip(intervs[:-1], intervs[1:], colors): symbol = QgsSymbol.defaultSymbol(self._layer.geometryType()) symbol.setColor(col) symbol.setWidth(self.LINE_WIDTH_PIX) label = '{:0.2f}%->{:0.2f}%'.format(v_min, v_max) range_ = QgsRendererRange(v_min, v_max, symbol, label) range_list.append(range_) renderer = QgsGraduatedSymbolRenderer('', range_list) renderer.setMode(QgsGraduatedSymbolRenderer.Custom) renderer.setClassAttribute(self.target_field) self._layer.setRendererV2(renderer) self._layer.triggerRepaint()
def renderingUpdate(layers, colors, interval, fld, starting_lower, upper, classLimit): for layer in layers: range_list = [] lower = starting_lower upper_interval = lower + interval for c in colors: cat = [lower, upper_interval, c.name()] sym = QgsSymbol.defaultSymbol(layer.geometryType()) sym.setColor(c) sym.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen)) rng = QgsRendererRange(cat[0], cat[1], sym, '{0:.1f}-{1:.1f}'.format(cat[0], cat[1])) range_list.append(rng) lower = lower + interval if lower == classLimit: upper_interval = upper else: upper_interval = lower + interval renderer = QgsGraduatedSymbolRenderer(fld, range_list) renderer.setMode(QgsGraduatedSymbolRenderer.Custom) layer.setRenderer(renderer) layer.triggerRepaint()
def setStyle(self, idx): """Set layer style. :param int idx: style (combobox) index """ try: style = self._style[idx] except (IndexError, KeyError): return None if 'file' in style: # QML style stylePath = style['file'] if not os.path.isfile(stylePath): raise StyleError( self.tr("Style '{}' not found").format(stylePath)) self.loadNamedStyle(stylePath) elif 'colorramp' in style: if not self._renderer: # symbol (store transparent) symbol = QgsSymbol.defaultSymbol(self.geometryType()) symbol.symbolLayer(0).setStrokeColor(QColor("transparent")) # renderer self._renderer = QgsGraduatedSymbolRenderer() self._renderer.setSourceSymbol(symbol) print(self._renderer.sourceSymbol()) self._renderer.setClassAttribute(style['attribute']) self._renderer.setMode( QgsGraduatedSymbolRenderer.EqualInterval) self._renderer.updateClasses( self, QgsGraduatedSymbolRenderer.EqualInterval, style['classes']) self.setRenderer(self._renderer) self._renderer.updateColorRamp(style['colorramp']) else: raise StyleError(self.tr("Undefined style"))
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 setGraduadedPalette(self, layer, field, setRender, nameLayer): renderer = layer.renderer() prop = QgsProperty() # Set arrows and node icon visibility (only when layer is opened) # Links icon visibility are assigned when style is applied in Utils if setRender: # Just opened a layer # SimpleSymbol (first time) symbol = renderer.symbol() if symbol.type() == 1: # line self.setArrowsVisibility(symbol, layer, prop, field) else: # point self.setNodesVisibility(prop, symbol) else: # GraduatedSymbol (other times) symbols = renderer.symbols(QgsRenderContext()) for symbol in symbols: if symbol.type() == 1: # line self.setArrowsVisibility(symbol, layer, prop, field) if "Flow" in layer.name(): field = "abs(" + field + ")" # Set graduated colors if setRender: # Just opened a layer # Has previous render saved? hasRender = False dictRend = self.Renders.get(self.Scenario) if dictRend is None: dictRend = self.Renders.get("Base") # default if dictRend is not None: ranges = dictRend.get( self.getLayerPath(layer).replace( "_" + self.Scenario + "_", "_Base_")) if ranges is not None: hasRender = True else: ranges = dictRend.get(self.getLayerPath(layer)) if ranges is not None: hasRender = True else: dictRend = self.Renders.get("Base") # default if dictRend is not None: ranges = dictRend.get( self.getLayerPath(layer).replace( "_" + self.Scenario + "_", "_Base_")) if ranges is not None: hasRender = True # Apply render if hasRender: renderer = QgsGraduatedSymbolRenderer(field, ranges) else: ranges = self.getColorClasses(symbol, nameLayer) if len(ranges) > 0: renderer = QgsGraduatedSymbolRenderer(field, ranges) else: mode = QgsGraduatedSymbolRenderer.EqualInterval # Quantile classes = 5 ramp = { 'color1': '0,0,255,255', 'color2': '255,0,0,255', 'stops': '0.25;0,255,255,255:0.50;0,255,0,255:0.75;255,255,0,255' } colorRamp = QgsVectorGradientColorRamp.create(ramp) self.iface.setActiveLayer(layer) renderer = QgsGraduatedSymbolRenderer.createRenderer( layer, field, classes, mode, symbol, colorRamp) myFormat = renderer.labelFormat() myFormat.setPrecision(2) myFormat.setTrimTrailingZeroes(True) renderer.setLabelFormat(myFormat, True) else: renderer.setClassAttribute(field) layer.setRenderer(renderer) layer.triggerRepaint()
def make_flow_sym_renderer(self, layer, field_name, ranges_colors=None): feats = layer.getFeatures() min_val = sys.float_info.max max_val = -min_val # Find values range for feat in feats: attr = feat.attribute(field_name) val = float(attr) if val < min_val: min_val = val if val > max_val: max_val = val # Define colors if ranges_colors is None: ranges_colors = [] colors = [ QColor(0, 255, 0), QColor(128, 255, 0), QColor(255, 255, 0), QColor(255, 128, 0), QColor(255, 0, 0)] intv_nr = len(colors) intv = (max_val - min_val) / intv_nr for c in range(intv_nr): vrange = [min_val + intv * c, min_val + intv * (c + 1)] if c == len(colors) - 1: vrange[1] = max_val ranges_colors.append([vrange, colors[c]]) range_list = [] for range_col in ranges_colors: r_min = range_col[0][0] r_max = range_col[0][1] title = str(r_min) + ' - ' + str(r_max) range_list.append(symbology_from_range(layer, r_min, r_max, range_col[1], title)) renderer = QgsGraduatedSymbolRenderer(field_name, range_list) # Line symbol = QgsLineSymbol().createSimple({}) symbol.deleteSymbolLayer(0) line_sym_lay = QgsSimpleLineSymbolLayer() line_sym_lay.setWidth(0.2) symbol.appendSymbolLayer(line_sym_lay) # Define arrows for flow and velocities if u'Link flow' in layer.name() in layer.name(): self.marker_sym = QgsMarkerSymbol.createSimple({'name': 'triangle', 'color': 'black'}) data_def_angle = QgsProperty() data_def_angle_exp =\ 'case ' \ 'when "' + field_name + '" >= 0 ' \ 'then degrees(azimuth( start_point( $geometry), end_point($geometry))) ' \ 'else ' \ 'case ' \ 'when degrees(azimuth( start_point( $geometry), end_point($geometry))) < 180 ' \ 'then degrees(azimuth( start_point( $geometry), end_point($geometry))) + 180 ' \ 'else ' \ 'degrees(azimuth( start_point( $geometry), end_point($geometry))) - 180 ' \ 'end ' \ 'end' data_def_angle.setExpressionString(data_def_angle_exp) data_def_angle.setActive(True) self.marker_sym.setDataDefinedAngle(data_def_angle) # Size: 0 if attribute = 0 data_def_size = QgsProperty() data_def_size_exp =\ 'case ' \ 'when "' + field_name + '" = 0 ' \ 'then 0 ' \ 'else ' \ '2 ' \ 'end' data_def_size.setExpressionString(data_def_size_exp) data_def_size.setActive(True) self.marker_sym.setDataDefinedSize(data_def_size) marker_sym_lay = QgsMarkerLineSymbolLayer() marker_sym_lay.setColor(QColor(0, 0, 0)) marker_sym_lay.setFillColor(QColor(0, 0, 0)) marker_sym_lay.setPlacement(QgsMarkerLineSymbolLayer.CentralPoint) marker_sym_lay.setRotateMarker(False) marker_sym_lay.setSubSymbol(self.marker_sym) self.marker_sym.appendSymbolLayer(marker_sym_lay) symbol.appendSymbolLayer(marker_sym_lay) # renderer.setSourceSymbol(symbol) renderer.updateSymbols(symbol) return renderer
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 _apply_symbology_fixed_divisions(self, layer, field, tbl_name, schema, min_v, max_v, steps): """Finds the amount of levels that is necessary to describe the layer, a maximum of 20 different levels is set. Parameters ---------- layer: QgsVectorLayer field: str tbl_name: str schema: str min_v: float max_v: float steps: int """ str_values = False if min_v is not None and max_v is not None: distinct_values = list(np.arange(min_v, max_v, steps)) elif not str_values: distinct = self.db.get_distinct(tbl_name, field, schema) if len(distinct) == 1: return distinct_values = [] distinct_count = [] for value, count in distinct: if value is None: continue distinct_values.append(value) distinct_count.append(count) if len(distinct_values) > 20: distinct_values.sort() temp_list = [] for val in range(0, len(distinct_values), int(np.floor(len(distinct_values)/20))): temp_list.append(distinct_values[val]) if temp_list[-1] != distinct_values[-1]: temp_list.append(distinct_values[-1]) distinct_values = temp_list if isinstance(distinct_values[0], str): str_values = True colors = self._create_colors(len(distinct_values)) if len(distinct_values) > 19 and not str_values: range_list = [] for i in range(len(distinct_values) - 1): red, green, blue = colors[i] range_list.append(self._make_symbology(layer, distinct_values[i], distinct_values[i + 1], str(distinct_values[i]) + ' - ' + str(distinct_values[i + 1]), QColor(int(red*255),int(green*255), int(blue*255), 128) ) ) renderer = QgsGraduatedSymbolRenderer(field, range_list) renderer.setMode(QgsGraduatedSymbolRenderer.Custom ) else: categories = [] for i in range(len(distinct_values)): symbol = QgsSymbol.defaultSymbol(layer.geometryType()) red, green, blue = colors[i] symbol.setColor(QColor(int(red*255),int(green*255), int(blue*255), 128)) symbol.symbolLayer(0).setStrokeColor(QColor(int(red*255),int(green*255), int(blue*255), 128)) category = QgsRendererCategory(str(distinct_values[i]), symbol, str(distinct_values[i])) categories.append(category) renderer = QgsCategorizedSymbolRenderer(field, categories) #renderer.setMode(QgsCategorizedSymbolRenderer.Custom) layer.setRenderer(renderer)
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 testQgsGraduatedSymbolRenderer_1(self): """Test QgsGraduatedSymbolRenderer: Basic get/set functions """ # Create a renderer renderer = QgsGraduatedSymbolRenderer() symbol = createMarkerSymbol() renderer.setSourceSymbol(symbol.clone()) self.assertEqual(symbol.dump(), renderer.sourceSymbol().dump(), "Get/set renderer source symbol") attr = '"value"*"value"' renderer.setClassAttribute(attr) self.assertEqual(attr, renderer.classAttribute(), "Get/set renderer class attribute") for m in ( QgsGraduatedSymbolRenderer.Custom, QgsGraduatedSymbolRenderer.EqualInterval, QgsGraduatedSymbolRenderer.Quantile, QgsGraduatedSymbolRenderer.Jenks, QgsGraduatedSymbolRenderer.Pretty, QgsGraduatedSymbolRenderer.StdDev, ): renderer.setMode(m) self.assertEqual(m, renderer.mode(), "Get/set renderer mode") format = createLabelFormat() renderer.setLabelFormat(format) self.assertEqual( dumpLabelFormat(format), dumpLabelFormat(renderer.labelFormat()), "Get/set renderer label format") ramp = createColorRamp() renderer.setSourceColorRamp(ramp) self.assertEqual( dumpColorRamp(ramp), dumpColorRamp(renderer.sourceColorRamp()), "Get/set renderer color ramp") renderer.setInvertedColorRamp(True) self.assertTrue(renderer.invertedColorRamp(), "Get/set renderer inverted color ramp") renderer.setInvertedColorRamp(False) self.assertFalse(renderer.invertedColorRamp(), "Get/set renderer inverted color ramp") renderer.setSourceColorRamp(ramp) self.assertEqual( dumpColorRamp(ramp), dumpColorRamp(renderer.sourceColorRamp()), "Get/set renderer color ramp") # test for classificatio with varying size renderer.setGraduatedMethod(QgsGraduatedSymbolRenderer.GraduatedSize) renderer.setSourceColorRamp(None) renderer.addClassLowerUpper(0, 2) renderer.addClassLowerUpper(2, 4) renderer.addClassLowerUpper(4, 6) renderer.setSymbolSizes(2, 13) self.assertEqual(renderer.maxSymbolSize(), 13) self.assertEqual(renderer.minSymbolSize(), 2) refSizes = [2, (13 + 2) * .5, 13] ctx = QgsRenderContext() for idx, symbol in enumerate(renderer.symbols(ctx)): self.assertEqual(symbol.size(), refSizes[idx])
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 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 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 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 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 processAlgorithm(self, parameters, context, feedback): project = QgsProject() project.setFileName( os.path.join(parameters[self.FOLDER], "all-outputs-qgis.qgs")) project.setCrs(QgsCoordinateReferenceSystem('EPSG:27700')) def getMaxValue(layer, fieldname): maxfound = float("-inf") for f in layer.getFeatures(): attr = f.attribute(fieldname) assert attr >= 0 if attr > maxfound: maxfound = attr return maxfound with open( os.path.join(parameters[self.FOLDER], "all-town-metadata.json")) as f: metadata = json.load(f) classmethods = { 'quantile': QgsClassificationQuantile, 'jenks': QgsClassificationJenks, 'equal': QgsClassificationEqualInterval } html = "" output = [] views_sorted_by_mode = sorted(metadata["views"], key=lambda v: v["mode"]) for view in views_sorted_by_mode: keysymbol = u'🔑' viewname = view["label"] keysign = "" if viewname.find(keysymbol) != -1: viewname = viewname.replace(keysymbol, '', 1) keysign = "*** " viewname = keysign + view["mode"] + " " + viewname html += f""" <h2>{viewname}</h2> {view["description"]} <ul> """ for layer in view["layers"]: layername = viewname + " - " + layer["scalar_field_units"] layerpath = os.path.join(parameters[self.FOLDER], layer["file"]) vlayer = QgsVectorLayer(layerpath, layername, "ogr") if not vlayer.isValid(): feedback.pushInfo("Layer failed to load: " + layerpath) else: context.temporaryLayerStore().addMapLayer(vlayer) html += f"""<li><b>file:</b> {layer["file"]}""" if "symbol_field" in layer: html += f"""<ul> <li><b>symbol field:</b> {layer["symbol_field"]} </ul> """ categories = [] scalar_fieldname = layer["scalar_field"] maxvalue = getMaxValue(vlayer, scalar_fieldname) feedback.pushInfo("Max value for %s is %f" % (scalar_fieldname, maxvalue)) for formality in ["I", "F"]: for severity, colour in [(3, 'red'), (2, 'yellow'), (1, 'green')]: colour = { ("I", "red"): "#FF0000", ("I", "yellow"): "#FFFF00", ("I", "green"): "#00FF00", ("F", "red"): "#FF9999", ("F", "yellow"): "#FFFF66", ("F", "green"): "#99FF99", }[(formality, colour)] symbol_code = "%s%d" % (formality, severity) if formality == "F": symbol = QgsMarkerSymbol.createSimple({ 'color': colour, 'size': '3', 'outline_color': '#888888' }) else: assert (formality == "I") symbol = QgsMarkerSymbol.createSimple({ 'color': colour, 'size': '3', 'outline_color': '#000000', 'name': 'star' }) objTransf = QgsSizeScaleTransformer( QgsSizeScaleTransformer.Flannery, 0, #minvalue maxvalue, #maxvalue 3, #minsize 10, #maxsize 0, #nullsize 1) #exponent objProp = QgsProperty() objProp.setField(scalar_fieldname) objProp.setTransformer(objTransf) symbol.setDataDefinedSize(objProp) label = { "F": "Formal", "I": "Informal" }[formality] + " " + { 3: "Major", 2: "Secondary", 1: "Tertiary" }[severity] cat = QgsRendererCategory( symbol_code, symbol, label, True) categories.append(cat) renderer = QgsCategorizedSymbolRenderer( "Crossings", categories) renderer.setClassAttribute(layer["symbol_field"]) vlayer.setRenderer(renderer) else: html += f"""<ul> <li><b>field:</b> {layer["scalar_field"]} <li><b>units:</b> {layer["scalar_field_units"]} <li><b>recommended classification:</b> {layer["classes"]} </ul> """ default_style = QgsStyle().defaultStyle() color_ramp = default_style.colorRamp('bt') renderer = QgsGraduatedSymbolRenderer() renderer.setClassAttribute(layer["scalar_field"]) classmethod = classmethods[layer["classes"]]() renderer.setClassificationMethod(classmethod) renderer.updateClasses(vlayer, 5) renderer.updateColorRamp(color_ramp) vlayer.setRenderer(renderer) project.addMapLayer(vlayer) feedback.pushInfo("Loaded " + layerpath) html += "</ul>" project.write() town = views_sorted_by_mode[0]["town"] with open(os.path.join(parameters[self.FOLDER], "metadata.html"), "w") as htmlfile: htmlfile.write( f"<html><head><title>{town} metadata</title></head><body><h1>{town}</h1>{html}</body></html>" ) return {self.OUTPUT: output}