def mkGraduatedRenderer(layer,
fieldname,
color_ramp,
nb_classes=5,
classif_method=QgsGraduatedSymbolRenderer.Jenks):
# classif = QgsClassificationQuantile()
# classes = classif.classes(layer,fieldname,nb_classes)
renderer = QgsGraduatedSymbolRenderer(attrName=fieldname)
renderer.setSourceColorRamp(color_ramp)
renderer.updateClasses(layer, classif_method, nb_classes)
# renderer.setGraduatedMethod(QgsGraduatedSymbolRenderer.GraduatedColor)
# renderer.setClassificationMethod(classif)
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.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 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 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 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 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])
