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)) 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 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)) 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 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.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 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.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 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 displayGraduatedLayer(setupObject, fieldName, layerName, legendCode): colourDict = dict() colourDict[1] = [ '#C5C2C5', '#CDCEB4', '#DEDEA3', '#EEE894', '#FFFA8B', '#FFE273', '#FFAA52', '#FF8541', '#FF6D31', '#FF0000' ] colourDict[2] = [ '#FFFFCC', '#E3F3B5', '#C8E89E', '#A9DB8E', '#88CD80', '#68BE70', '#48AE60', '#2B9C50', '#158243', '#006837' ] colourList = colourDict[legendCode] puLayer = QgsVectorLayer(setupObject.puPath, 'Planning units', 'ogr') graduatedLayer = QgsVectorLayer(setupObject.puPath, layerName, '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 }) minValueDisplay = round(minValue, setupObject.decimalPlaces) maxValueDisplay = round(minValue + incValue, setupObject.decimalPlaces) theRange = QgsRendererRange( minValueDisplay, maxValueDisplay, mySymbol, str(minValueDisplay) + ' - ' + str(maxValueDisplay)) minValue = maxValue rangeList.insert(0, theRange) myRenderer = QgsGraduatedSymbolRenderer('', rangeList) myRenderer.setMode(QgsGraduatedSymbolRenderer.EqualInterval) myRenderer.setClassAttribute(fieldName) graduatedLayer.setRenderer(myRenderer) QgsProject.instance().addMapLayer(graduatedLayer) iface.mapCanvas().refresh()
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 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 testFilterNeedsGeometry(self): renderer = QgsGraduatedSymbolRenderer() renderer.setClassAttribute("value") self.assertFalse(renderer.filterNeedsGeometry()) renderer.setClassAttribute("$area") self.assertTrue(renderer.filterNeedsGeometry()) renderer.setClassAttribute("value - $area") self.assertTrue(renderer.filterNeedsGeometry())
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 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 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 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())
class LayerBase(QgsVectorLayer): """QGIS layer base class (read-only memory based). :param fileName: path to input file :param storageFormat: storage format for layer (Memory or SQLite) """ def __init__(self, fileName, storageFormat): self._fileName = fileName self._layerName = os.path.splitext(os.path.basename(self._fileName))[0] self.storageFormat = storageFormat # create point layer (WGS-84, EPSG:4326) super(LayerBase, self).__init__('Point?crs=epsg:4326', self._layerName, "memory") self._aliases = [] # list of attribute aliases self._provider = self.dataProvider() # import errors self._errs = {} # layer is empty, no data loaded self._loaded = False self.metadata = None # layer type not defined self.layerType = None # style self._style = Style() self._renderer = None def load(self, reader): """Load input data by specified reader. :param reader: reader class used for reading input data """ if self._loaded: return # data already loaded # create progress bar widget progressMessageBar = iface.messageBar().createMessage( self.tr("Loading data...")) progress = QtWidgets.QProgressBar() progress.setMaximum(100) progressMessageBar.layout().addWidget(progress) iface.messageBar().pushWidget(progressMessageBar, Qgis.Info) # load items as new point features (inform user about progress) i = 0 count = reader.count() start = time.clock() prev = None # previous feature self.startEditing() for item in reader: i += 1 if i == 1 and not self._aliases: # set attributes from data item if needed self._aliases = self._setAttrbsDefs( limit=item.keys(), defs=reader.attributeDefs()) feat = self._item2feat(item) if not feat: # error appeared continue feat.setId(i) self.addFeature(feat) if i % 100 == 0: percent = i / float(count) * 100 progress.setValue(percent) # add features (attributes recalculated if requested) self.commitChanges() if self.storageFormat != "memory": self._writeToOgrDataSource() self.reload() # finish import endtime = time.clock() - start progress.setValue(100) iface.messageBar().clearWidgets() if self._errs: # report errors if any iface.messageBar().pushMessage( self.tr("Info"), self. tr("{} invalid measurement(s) skipped (see message log for details)" ).format(sum(self._errs.values())), level=Qgis.Info, duration=5) for attr in list(self._errs.keys()): QgsMessageLog.logMessage( "{}: {} measurement(s) skipped (invalid {})".format( self._fileName, self._errs[attr], attr), tag=PLUGIN_NAME) # inform user about successful import iface.messageBar().pushMessage( self.tr("Data loaded"), self.tr("{} features loaded (in {:.2f} sec).").format( self.featureCount(), endtime), level=Qgis.Success, duration=3) # data loaded (avoid multiple imports) self._loaded = True # switch to read-only mode self.setReadOnly(True) def _writeToOgrDataSource(self): fileExt = self.storageFormat.lower() filePath = os.path.splitext(self._fileName)[0] + '.{}'.format(fileExt) writer, msg = QgsVectorFileWriter.writeAsVectorFormat( self, filePath, self._provider.encoding(), self._provider.crs(), driverName=self.storageFormat) if writer != QgsVectorFileWriter.NoError: raise LoadError( self.tr("Unable to create SQLite datasource: {}").format(msg)) # set datasource to new OGR datasource self.setDataSource(filePath, self._layerName, 'ogr') self._provider = self.dataProvider() # create metadata layer if self.metadata and 'table' in self.metadata: ds = ogr.Open(filePath, True) layer_name = self.metadata['table'] layer = ds.GetLayerByName(layer_name) if layer is None: layer = ds.CreateLayer(layer_name, None, ogr.wkbNone) layer_defn = layer.GetLayerDefn() if 'columns' in self.metadata: for key in self.metadata['columns']: field = ogr.FieldDefn(key, ogr.OFTString) layer.CreateField(field) feat = ogr.Feature(layer_defn) for key, value in list(self.metadata['columns'].items()): feat.SetField(key, value) layer.CreateFeature(feat) feat = None def _addError(self, etype): """Add error message. :param etype: error type (HDOP, SAT, ...) """ if etype not in self._errs: self._errs[etype] = 0 self._errs[etype] += 1 def _item2feat(self, item): """Create QgsFeature from data item. """ raise NotImplementedError() def _setAttrbsDefs(self, limit=[], defs=None): """Set attributes definition from CSV file if available. :param limit: limit to list of attributes :returns: list of aliases """ def addAttribute(row, attrbs, aliases): attrbs.append( QgsField(row['attribute'], eval("QVariant.{}".format(row['qtype'])))) if 'alias' in row and row['alias']: aliases.append(row['alias'].replace('_', ' ')) def processAttributes(csv_attrbs, limit): attrbs = [] aliases = [] if limit: # limit attributes based on input file (first feature) - ERS/PEI format specific for name in limit: # first try full name match found = False for row in csv_attrbs: if row['attribute'] == name: addAttribute(row, attrbs, aliases) found = True break if found: continue for row in csv_attrbs: # full name match is not required see # https://gitlab.com/opengeolabs/qgis-radiation-toolbox-plugin/issues/41#note_136183930 if row['attribute'] == name[:len( row['attribute'] )] or name == row['attribute'][:len(name)]: row_modified = copy.copy(row) row_modified[ 'attribute'] = name # force (full) attribute name from input file if row_modified['alias']: row_modified['alias'] = '{} ({})'.format( name, row_modified['alias']) addAttribute(row_modified, attrbs, aliases) break else: # add all attributes for row in csv_attrbs: addAttribute(row, attrbs, aliases) return attrbs, aliases if not defs: # predefined attributes (CSV file) # Safecast, ERS csv_file = self._attributesCSVFile() if not os.path.exists(csv_file): return [] with open(csv_file) as fd: csv_attrbs = list(csv.DictReader(fd, delimiter=';')) attrbs, aliases = processAttributes(csv_attrbs, limit) else: # data-driven attributes # PEI attrbs, aliases = processAttributes(defs, limit) if limit and len(attrbs) != len(limit): raise LoadError("Number of attributes differs {} vs {}".format( len(attrbs), len(limit))) if aliases and self.storageFormat != "memory": aliases.insert(0, "FID") # set attributes self._provider.addAttributes(attrbs) self.updateFields() return aliases def setAliases(self): """Set aliases """ for i in range(0, len(self._aliases)): self.setFieldAlias(i, self._aliases[i]) 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 style(self): """Get style. :return: style class """ return self._style def _attributesCSVFile(self): return os.path.join( os.path.dirname(__file__), os.path.splitext(inspect.getfile(self.__class__))[0] + '.csv')
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") value = '"value"*2' exp = QgsSymbolLayerUtils.fieldOrExpressionToExpression(value) valuestr = QgsSymbolLayerUtils.fieldOrExpressionFromExpression(exp) renderer.setRotationField(value) self.assertEqual(valuestr, renderer.rotationField(), "Get/set renderer rotation field") value = '"value"*3' exp = QgsSymbolLayerUtils.fieldOrExpressionToExpression(value) valuestr = QgsSymbolLayerUtils.fieldOrExpressionFromExpression(exp) renderer.setSizeScaleField(value) self.assertEqual(valuestr, renderer.sizeScaleField(), "Get/set renderer size scale field") renderer.setSourceColorRamp(ramp) self.assertEqual( dumpColorRamp(ramp), dumpColorRamp(renderer.sourceColorRamp()), "Get/set renderer color ramp") for sm in ( QgsSymbol.ScaleArea, QgsSymbol.ScaleDiameter, ): renderer.setScaleMethod(sm) self.assertEqual(str(sm), str(renderer.scaleMethod()), "Get/set renderer scale method") # 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.symbols2(ctx)): self.assertEqual(symbol.size(), refSizes[idx])
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 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") value = '"value"*2' exp = QgsSymbolLayerUtils.fieldOrExpressionToExpression(value) valuestr = QgsSymbolLayerUtils.fieldOrExpressionFromExpression(exp) renderer.setRotationField(value) self.assertEqual(valuestr, renderer.rotationField(), "Get/set renderer rotation field") value = '"value"*3' exp = QgsSymbolLayerUtils.fieldOrExpressionToExpression(value) valuestr = QgsSymbolLayerUtils.fieldOrExpressionFromExpression(exp) renderer.setSizeScaleField(value) self.assertEqual(valuestr, renderer.sizeScaleField(), "Get/set renderer size scale field") renderer.setSourceColorRamp(ramp) self.assertEqual(dumpColorRamp(ramp), dumpColorRamp(renderer.sourceColorRamp()), "Get/set renderer color ramp") for sm in ( QgsSymbol.ScaleArea, QgsSymbol.ScaleDiameter, ): renderer.setScaleMethod(sm) self.assertEqual(str(sm), str(renderer.scaleMethod()), "Get/set renderer scale method") # 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.symbols2(ctx)): self.assertEqual(symbol.size(), refSizes[idx])
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()