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