def testUsedAttributes(self):
renderer = QgsGraduatedSymbolRenderer()
ctx = QgsRenderContext()
# attribute can contain either attribute name or an expression.
# Sometimes it is not possible to distinguish between those two,
# e.g. "a - b" can be both a valid attribute name or expression.
# Since we do not have access to fields here, the method should return both options.
renderer.setClassAttribute("value")
self.assertEqual(renderer.usedAttributes(ctx), {"value"})
renderer.setClassAttribute("value - 1")
self.assertEqual(renderer.usedAttributes(ctx), {"value", "value - 1"})
renderer.setClassAttribute("valuea - valueb")
self.assertEqual(renderer.usedAttributes(ctx),
{"valuea", "valuea - valueb", "valueb"})
def btn_display_style_clicked(self):
style = self.cbo_display_style.currentText()
self.params.pipes_vlay.loadNamedStyle(
os.path.join(QML_FILEPATH, qml_files[style]['Pipes']))
self.params.junctions_vlay.loadNamedStyle(
os.path.join(QML_FILEPATH, qml_files[style]['Junctions']))
if style == 'Results': #TODO: soft code
renderer = QgsGraduatedSymbolRenderer()
renderer.updateClasses(self.params.junctions_vlay, renderer.Pretty,
8)
renderer.updateClasses(self.params.pipes_vlay, renderer.Pretty, 5)
self.params.pipes_vlay.triggerRepaint()
self.params.junctions_vlay.triggerRepaint()
def displayIrrepResults(setupObject, fieldName):
colourList = [
'#FFFFBF', '#F4FAA7', '#EAF792', '#DAF57A', '#CAF266', '#B6F051',
'#A0ED3B', '#86EB28', '#6DE815', '#4CE600'
]
puLayer = QgsVectorLayer(setupObject.puPath, 'Planning units', 'ogr')
irrepLayer = QgsVectorLayer(setupObject.puPath, fieldName, 'ogr')
provider = puLayer.dataProvider()
puFeatures = puLayer.getFeatures()
graduatedFieldOrder = provider.fieldNameIndex(fieldName)
maxCountScore = 0 #This will be used to set highest value in legend
for puFeature in puFeatures:
puAttributes = puFeature.attributes()
puCountScore = puAttributes[graduatedFieldOrder]
if puCountScore > maxCountScore:
maxCountScore = puCountScore
rangeList = list()
minValue = 0
incValue = float(maxCountScore) / 10
for aValue in range(0, 10):
maxValue = minValue + incValue
if aValue == 9:
maxValue = maxCountScore
myColour = colourList[aValue]
mySymbol = QgsFillSymbol.createSimple({
'style': 'solid',
'color': myColour,
'color_border': myColour
})
theRange = QgsRendererRange(minValue, maxValue, mySymbol,
str(minValue) + ' - ' + str(maxValue))
minValue = maxValue
rangeList.insert(0, theRange)
myRenderer = QgsGraduatedSymbolRenderer('', rangeList)
myRenderer.setMode(QgsGraduatedSymbolRenderer.EqualInterval)
myRenderer.setClassAttribute(fieldName)
irrepLayer.setRenderer(myRenderer)
QgsProject.instance().addMapLayer(irrepLayer)
iface.mapCanvas().refresh()
def displayDistributionMaps(setupObject, distShapeFilePathName,
abundValuesDict, legendType, selectedFeatIDList):
colourDict = makeColourDict()
colourKey = 1
for featID in selectedFeatIDList:
rangeList = list()
colourList = colourDict[colourKey]
colourKey += 1
if colourKey > len(list(colourDict.keys())):
colourKey = 1
aDistLayerName = setupObject.targetDict[int(featID)][0]
aDistLayer = QgsVectorLayer(distShapeFilePathName, aDistLayerName,
'ogr')
aDistLayerFieldName = 'F_' + str(featID)
aFeatAbundValueTupleList = abundValuesDict[featID]
if legendType == 'equal_interval':
legendValCatList = calcEqualIntervalLegendClasses(
setupObject, aFeatAbundValueTupleList)
if legendType == 'equal_area':
legendValCatList = calcEqualAreaLegendClasses(
setupObject, aFeatAbundValueTupleList)
for aValue in range(0, 5):
minValue = legendValCatList[aValue]
maxValue = legendValCatList[aValue + 1]
myColour = colourList[aValue]
mySymbol = QgsFillSymbol.createSimple({
'style': 'solid',
'color': myColour,
'color_border': myColour
})
theRange = QgsRendererRange(minValue, maxValue, mySymbol,
str(minValue) + ' - ' + str(maxValue))
rangeList.insert(0, theRange)
myRenderer = QgsGraduatedSymbolRenderer('', rangeList)
myRenderer.setMode(QgsGraduatedSymbolRenderer.EqualInterval)
myRenderer.setClassAttribute(aDistLayerFieldName)
aDistLayer.setRenderer(myRenderer)
aDistLayer.setOpacity(0.6)
QgsProject.instance().addMapLayer(aDistLayer)
iface.mapCanvas().refresh()
def renderNetwork(self, output_network, distances):
# Settings
catchment_threshold = int(max(distances))
# settings for 10 color ranges depending on the radius
color_ranges = ((0, (0.1 * catchment_threshold),
'#ff0000'), ((0.1 * catchment_threshold),
(0.2 * catchment_threshold), '#ff5100'),
((0.2 * catchment_threshold),
(0.3 * catchment_threshold),
'#ff9900'), ((0.3 * catchment_threshold),
(0.4 * catchment_threshold), '#ffc800'),
((0.4 * catchment_threshold),
(0.5 * catchment_threshold),
'#ffee00'), ((0.5 * catchment_threshold),
(0.6 * catchment_threshold), '#a2ff00'),
((0.6 * catchment_threshold),
(0.7 * catchment_threshold),
'#00ff91'), ((0.7 * catchment_threshold),
(0.8 * catchment_threshold), '#00f3ff'),
((0.8 * catchment_threshold),
(0.9 * catchment_threshold),
'#0099ff'), ((0.9 * catchment_threshold),
(1 * catchment_threshold), '#0033ff'))
# list with all color ranges
ranges = []
# for each range create a symbol with its respective color
for lower, upper, color in color_ranges:
symbol = QgsSymbol.defaultSymbol(output_network.geometryType())
symbol.setColor(QColor(color))
symbol.setWidth(0.5)
range = QgsRendererRange(lower, upper, symbol,
str(lower) + ' - ' + str(upper))
ranges.append(range)
# create renderer based on ranges and apply to network
renderer = QgsGraduatedSymbolRenderer('min_dist', ranges)
output_network.setRenderer(renderer)
# add network to the canvas
QgsProject.instance().addMapLayer(output_network)
def testQgsGraduatedSymbolRenderer_3(self):
"""Test QgsGraduatedSymbolRenderer: Reading attribute data, calculating classes """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
# Test retrieving data values from a layer
ml = createMemoryLayer((1.2, 0.5, 5.0, 1.0, 1.0, 1.2))
# ... by attribute
renderer.setClassAttribute("value")
self.assertEqual(renderer.classAttribute(), "value",
"Error in set/get classAttribute")
data = renderer.getDataValues(ml)
datastr = ':'.join([str(x) for x in data])
self.assertEqual(datastr, '1.2:0.5:5.0:1.0:1.0:1.2',
"Error returning field data")
# ... by expression
renderer.setClassAttribute('"value"*"value"')
self.assertEqual(renderer.classAttribute(), '"value"*"value"',
"Error in set/get classAttribute")
data = renderer.getDataValues(ml)
datastr = ':'.join([str(x) for x in data])
self.assertEqual(datastr, '1.44:0.25:25.0:1.0:1.0:1.44',
"Error returning field expression")
renderer.setClassAttribute("value")
# Equal interval calculations
renderer.updateClasses(ml, renderer.EqualInterval, 3)
self.assertEqual(dumpRangeBreaks(renderer.ranges()),
'(0.5000-2.0000,2.0000-3.5000,3.5000-5.0000,)',
'Equal interval classification not correct')
# Quantile classes
renderer.updateClasses(ml, renderer.Quantile, 3)
self.assertEqual(dumpRangeBreaks(renderer.ranges()),
'(0.5000-1.0000,1.0000-1.2000,1.2000-5.0000,)',
'Quantile classification not correct')
renderer.updateClasses(ml, renderer.Quantile, 4)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.5000-1.0000,1.0000-1.1000,1.1000-1.2000,1.2000-5.0000,)',
'Quantile classification not correct')
def __init__(self, crs):
uri = "LineString?crs=%s" % crsString(crs)
provider = QgsProviderRegistry.instance().createProvider('memory', uri)
provider.addAttributes(LRS_QUALITY_FIELDS.toList())
uri = provider.dataSourceUri()
super(LrsQualityLayer, self).__init__(uri, 'LRS quality', 'memory')
# min, max, color, label
styles = [[0, 10, QColor(Qt.green), '0 - 10 % error'],
[10, 30, QColor(Qt.blue), '10 - 30 % error'],
[30, 1000000, QColor(Qt.red), '> 30 % error']]
ranges = []
for style in styles:
symbol = QgsSymbol.defaultSymbol(QgsWkbTypes.LineGeometry)
symbol.setColor(style[2])
range = QgsRendererRange(style[0], style[1], symbol, style[3])
ranges.append(range)
renderer = QgsGraduatedSymbolRenderer('err_perc', ranges)
self.setRenderer(renderer)
def layerFromPath(lineFilePath: str, rootGroup: QgsLayerTreeGroup,
project: QgsLayerTreeGroup) -> None:
lineFileBasename = os.path.splitext(os.path.basename(lineFilePath))[0]
lineLayer = QgsVectorLayer(lineFilePath, lineFileBasename, 'ogr')
# Get number of features (range of Sequence#, number of renderer color classes)
driver = ogr.GetDriverByName('ESRI Shapefile')
dataSource = driver.Open(lineFilePath,
0) # 0 means read-only. 1 means writeable.
layer = dataSource.GetLayer()
dataSource = None
#Setup graduated color renderer based on year
targetField = 'Year'
renderer = QgsGraduatedSymbolRenderer('', [QgsRendererRange()])
renderer.setClassAttribute(targetField)
lineLayer.setRenderer(renderer)
#Get viridis color ramp
style = QgsStyle().defaultStyle()
defaultColorRampNames = style.colorRampNames()
viridisIndex = defaultColorRampNames.index('Viridis')
viridisColorRamp = style.colorRamp(
defaultColorRampNames[viridisIndex]) #Spectral color ramp
#Dynamically recalculate number of classes and colors
renderer.updateColorRamp(viridisColorRamp)
yearsRange = list(range(1972, 2020))
classCount = len(yearsRange)
renderer.updateClasses(lineLayer, QgsGraduatedSymbolRenderer.EqualInterval,
classCount)
#Set graduated color renderer based on Sequence#
for i in range(classCount): #[1972-2019], 2020 not included
targetField = 'DateUnix'
year = yearsRange[i]
renderer.updateRangeLowerValue(i, year)
renderer.updateRangeUpperValue(i, year)
project.addMapLayer(lineLayer, False)
rootGroup.insertLayer(0, lineLayer)
def updateSymbology(self):
if self._layer and self._layer.isValid():
att_values = [
f[self.target_field]
for f in self._layer.dataProvider().getFeatures()
]
intervs = self._intervalValues(att_values)
colors = self._colorValues()
range_list = []
for v_min, v_max, col in zip(intervs[:-1], intervs[1:], colors):
symbol = QgsSymbol.defaultSymbol(self._layer.geometryType())
symbol.setColor(col)
symbol.setWidth(self.LINE_WIDTH_PIX)
label = '{:0.2f}%->{:0.2f}%'.format(v_min, v_max)
range_ = QgsRendererRange(v_min, v_max, symbol, label)
range_list.append(range_)
renderer = QgsGraduatedSymbolRenderer('', range_list)
renderer.setMode(QgsGraduatedSymbolRenderer.Custom)
renderer.setClassAttribute(self.target_field)
self._layer.setRendererV2(renderer)
self._layer.triggerRepaint()
def renderingUpdate(layers, colors, interval, fld, starting_lower, upper,
classLimit):
for layer in layers:
range_list = []
lower = starting_lower
upper_interval = lower + interval
for c in colors:
cat = [lower, upper_interval, c.name()]
sym = QgsSymbol.defaultSymbol(layer.geometryType())
sym.setColor(c)
sym.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen))
rng = QgsRendererRange(cat[0], cat[1], sym,
'{0:.1f}-{1:.1f}'.format(cat[0], cat[1]))
range_list.append(rng)
lower = lower + interval
if lower == classLimit:
upper_interval = upper
else:
upper_interval = lower + interval
renderer = QgsGraduatedSymbolRenderer(fld, range_list)
renderer.setMode(QgsGraduatedSymbolRenderer.Custom)
layer.setRenderer(renderer)
layer.triggerRepaint()
def setStyle(self, idx):
"""Set layer style.
:param int idx: style (combobox) index
"""
try:
style = self._style[idx]
except (IndexError, KeyError):
return None
if 'file' in style:
# QML style
stylePath = style['file']
if not os.path.isfile(stylePath):
raise StyleError(
self.tr("Style '{}' not found").format(stylePath))
self.loadNamedStyle(stylePath)
elif 'colorramp' in style:
if not self._renderer:
# symbol (store transparent)
symbol = QgsSymbol.defaultSymbol(self.geometryType())
symbol.symbolLayer(0).setStrokeColor(QColor("transparent"))
# renderer
self._renderer = QgsGraduatedSymbolRenderer()
self._renderer.setSourceSymbol(symbol)
print(self._renderer.sourceSymbol())
self._renderer.setClassAttribute(style['attribute'])
self._renderer.setMode(
QgsGraduatedSymbolRenderer.EqualInterval)
self._renderer.updateClasses(
self, QgsGraduatedSymbolRenderer.EqualInterval,
style['classes'])
self.setRenderer(self._renderer)
self._renderer.updateColorRamp(style['colorramp'])
else:
raise StyleError(self.tr("Undefined style"))
def renderizeXY(layer, field):
myTargetField = field
myRangeList = []
myOpacity = 1
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#D8D8D8'))
#QMessageBox.information(None,"DEBUG",str(myOpacity))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(-150.0, 0.0, mySymbol, "No level")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FFFFFF'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(0.1, 34.4, mySymbol, "< 35 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#238443'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(34.5, 39.4, mySymbol, "35 - 39 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#78C679'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(39.5, 44.4, mySymbol, "40 - 44 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#C2E699'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(44.5, 49.4, mySymbol, "45 - 49 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FFFFB2'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(49.5, 54.4, mySymbol, "50 - 54 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FECC5C'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(54.5, 59.4, mySymbol, "55 - 59 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FD8D3C'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(59.5, 64.4, mySymbol, "60 - 64 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FF0909'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(64.5, 69.4, mySymbol, "65 - 69 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#B30622'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(69.5, 74.4, mySymbol, "70 - 74 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#67033B'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(74.5, 79.4, mySymbol, "75 - 79 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#1C0054'))
mySymbol.setOpacity(myOpacity)
myRange = QgsRendererRange(79.5, 150.0, mySymbol, ">= 80 dB(A)")
myRangeList.append(myRange)
myRenderer = QgsGraduatedSymbolRenderer('', myRangeList)
myRenderer.setMode(QgsGraduatedSymbolRenderer.EqualInterval)
myRenderer.setClassAttribute(myTargetField)
layer.setRenderer(myRenderer)
#iface.legendInterface().refreshLayerSymbology(layer)
#layer.reload()
#iface.mapCanvas().refresh()
layer.triggerRepaint()
iface.layerTreeView().refreshLayerSymbology(layer.id())
def render_old(layer, field):
myTargetField = field
myRangeList = []
myOpacity = 1
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FFFFFF'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(-150.0, 0.0, mySymbol, "No level")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#C0FFC0'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(0.1, 34.9, mySymbol, "< 35 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#00CC00'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(35.0, 39.9, mySymbol, "35 - 40 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#005000'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(40.0, 44.9, mySymbol, "40 - 45 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FFFF00'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(45.0, 49.9, mySymbol, "45 - 50 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FFC74A'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(50.0, 54.9, mySymbol, "50 - 55 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FF6600'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(55.0, 59.9, mySymbol, "55 - 60 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#FF3333'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(60.0, 64.9, mySymbol, "60 - 65 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#990033'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(65.0, 69.9, mySymbol, "65 - 70 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#AD9AD6'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(70.0, 74.9, mySymbol, "70 - 75 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#0000FF'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(75.0, 79.9, mySymbol, "75 - 80 dB(A)")
myRangeList.append(myRange)
# symbol
mySymbol = QgsSymbol.defaultSymbol(layer.geometryType())
mySymbol.setColor(QColor('#000066'))
mySymbol.setAlpha(myOpacity)
myRange = QgsRendererRange(80.0, 150.0, mySymbol, "> 80 dB(A)")
myRangeList.append(myRange)
myRenderer = QgsGraduatedSymbolRenderer('', myRangeList)
myRenderer.setMode(QgsGraduatedSymbolRenderer.EqualInterval)
myRenderer.setClassAttribute(myTargetField)
layer.setRenderer(myRenderer)
#iface.legendInterface().refreshLayerSymbology(layer)
#layer.reload()
#iface.mapCanvas().refresh()
layer.triggerRepaint()
iface.layerTreeView().refreshLayerSymbology(layer.id())
def setGraduadedPalette(self, layer, field, setRender, nameLayer):
renderer = layer.renderer()
prop = QgsProperty()
# Set arrows and node icon visibility (only when layer is opened)
# Links icon visibility are assigned when style is applied in Utils
if setRender: # Just opened a layer
# SimpleSymbol (first time)
symbol = renderer.symbol()
if symbol.type() == 1: # line
self.setArrowsVisibility(symbol, layer, prop, field)
else: # point
self.setNodesVisibility(prop, symbol)
else:
# GraduatedSymbol (other times)
symbols = renderer.symbols(QgsRenderContext())
for symbol in symbols:
if symbol.type() == 1: # line
self.setArrowsVisibility(symbol, layer, prop, field)
if "Flow" in layer.name():
field = "abs(" + field + ")"
# Set graduated colors
if setRender: # Just opened a layer
# Has previous render saved?
hasRender = False
dictRend = self.Renders.get(self.Scenario)
if dictRend is None:
dictRend = self.Renders.get("Base") # default
if dictRend is not None:
ranges = dictRend.get(
self.getLayerPath(layer).replace(
"_" + self.Scenario + "_", "_Base_"))
if ranges is not None:
hasRender = True
else:
ranges = dictRend.get(self.getLayerPath(layer))
if ranges is not None:
hasRender = True
else:
dictRend = self.Renders.get("Base") # default
if dictRend is not None:
ranges = dictRend.get(
self.getLayerPath(layer).replace(
"_" + self.Scenario + "_", "_Base_"))
if ranges is not None:
hasRender = True
# Apply render
if hasRender:
renderer = QgsGraduatedSymbolRenderer(field, ranges)
else:
ranges = self.getColorClasses(symbol, nameLayer)
if len(ranges) > 0:
renderer = QgsGraduatedSymbolRenderer(field, ranges)
else:
mode = QgsGraduatedSymbolRenderer.EqualInterval # Quantile
classes = 5
ramp = {
'color1':
'0,0,255,255',
'color2':
'255,0,0,255',
'stops':
'0.25;0,255,255,255:0.50;0,255,0,255:0.75;255,255,0,255'
}
colorRamp = QgsVectorGradientColorRamp.create(ramp)
self.iface.setActiveLayer(layer)
renderer = QgsGraduatedSymbolRenderer.createRenderer(
layer, field, classes, mode, symbol, colorRamp)
myFormat = renderer.labelFormat()
myFormat.setPrecision(2)
myFormat.setTrimTrailingZeroes(True)
renderer.setLabelFormat(myFormat, True)
else:
renderer.setClassAttribute(field)
layer.setRenderer(renderer)
layer.triggerRepaint()
def make_flow_sym_renderer(self, layer, field_name, ranges_colors=None):
feats = layer.getFeatures()
min_val = sys.float_info.max
max_val = -min_val
# Find values range
for feat in feats:
attr = feat.attribute(field_name)
val = float(attr)
if val < min_val:
min_val = val
if val > max_val:
max_val = val
# Define colors
if ranges_colors is None:
ranges_colors = []
colors = [
QColor(0, 255, 0),
QColor(128, 255, 0),
QColor(255, 255, 0),
QColor(255, 128, 0),
QColor(255, 0, 0)]
intv_nr = len(colors)
intv = (max_val - min_val) / intv_nr
for c in range(intv_nr):
vrange = [min_val + intv * c, min_val + intv * (c + 1)]
if c == len(colors) - 1:
vrange[1] = max_val
ranges_colors.append([vrange, colors[c]])
range_list = []
for range_col in ranges_colors:
r_min = range_col[0][0]
r_max = range_col[0][1]
title = str(r_min) + ' - ' + str(r_max)
range_list.append(symbology_from_range(layer, r_min, r_max, range_col[1], title))
renderer = QgsGraduatedSymbolRenderer(field_name, range_list)
# Line
symbol = QgsLineSymbol().createSimple({})
symbol.deleteSymbolLayer(0)
line_sym_lay = QgsSimpleLineSymbolLayer()
line_sym_lay.setWidth(0.2)
symbol.appendSymbolLayer(line_sym_lay)
# Define arrows for flow and velocities
if u'Link flow' in layer.name() in layer.name():
self.marker_sym = QgsMarkerSymbol.createSimple({'name': 'triangle', 'color': 'black'})
data_def_angle = QgsProperty()
data_def_angle_exp =\
'case ' \
'when "' + field_name + '" >= 0 ' \
'then degrees(azimuth( start_point( $geometry), end_point($geometry))) ' \
'else ' \
'case ' \
'when degrees(azimuth( start_point( $geometry), end_point($geometry))) < 180 ' \
'then degrees(azimuth( start_point( $geometry), end_point($geometry))) + 180 ' \
'else ' \
'degrees(azimuth( start_point( $geometry), end_point($geometry))) - 180 ' \
'end ' \
'end'
data_def_angle.setExpressionString(data_def_angle_exp)
data_def_angle.setActive(True)
self.marker_sym.setDataDefinedAngle(data_def_angle)
# Size: 0 if attribute = 0
data_def_size = QgsProperty()
data_def_size_exp =\
'case ' \
'when "' + field_name + '" = 0 ' \
'then 0 ' \
'else ' \
'2 ' \
'end'
data_def_size.setExpressionString(data_def_size_exp)
data_def_size.setActive(True)
self.marker_sym.setDataDefinedSize(data_def_size)
marker_sym_lay = QgsMarkerLineSymbolLayer()
marker_sym_lay.setColor(QColor(0, 0, 0))
marker_sym_lay.setFillColor(QColor(0, 0, 0))
marker_sym_lay.setPlacement(QgsMarkerLineSymbolLayer.CentralPoint)
marker_sym_lay.setRotateMarker(False)
marker_sym_lay.setSubSymbol(self.marker_sym)
self.marker_sym.appendSymbolLayer(marker_sym_lay)
symbol.appendSymbolLayer(marker_sym_lay)
# renderer.setSourceSymbol(symbol)
renderer.updateSymbols(symbol)
return renderer
def test_legend_key_to_expression(self):
renderer = QgsGraduatedSymbolRenderer()
renderer.setClassAttribute('field_name')
exp, ok = renderer.legendKeyToExpression('xxxx', None)
self.assertFalse(ok)
# no categories
exp, ok = renderer.legendKeyToExpression('0', None)
self.assertFalse(ok)
symbol_a = createMarkerSymbol()
renderer.addClassRange(QgsRendererRange(1, 2, symbol_a, 'a'))
symbol_b = createMarkerSymbol()
renderer.addClassRange(QgsRendererRange(5, 6, symbol_b, 'b'))
symbol_c = createMarkerSymbol()
renderer.addClassRange(
QgsRendererRange(15.5, 16.5, symbol_c, 'c', False))
exp, ok = renderer.legendKeyToExpression('0', None)
self.assertTrue(ok)
self.assertEqual(exp, "(field_name >= 1) AND (field_name <= 2)")
exp, ok = renderer.legendKeyToExpression('1', None)
self.assertTrue(ok)
self.assertEqual(exp, "(field_name >= 5) AND (field_name <= 6)")
exp, ok = renderer.legendKeyToExpression('2', None)
self.assertTrue(ok)
self.assertEqual(exp, "(field_name >= 15.5) AND (field_name <= 16.5)")
exp, ok = renderer.legendKeyToExpression('3', None)
self.assertFalse(ok)
layer = QgsVectorLayer(
"Point?field=field_name:double&field=fldint:integer", "addfeat",
"memory")
# with layer
exp, ok = renderer.legendKeyToExpression('2', layer)
self.assertTrue(ok)
self.assertEqual(
exp, """("field_name" >= 15.5) AND ("field_name" <= 16.5)""")
# with expression as attribute
renderer.setClassAttribute('log("field_name")')
exp, ok = renderer.legendKeyToExpression('0', None)
self.assertTrue(ok)
self.assertEqual(
exp, """(log("field_name") >= 1) AND (log("field_name") <= 2)""")
exp, ok = renderer.legendKeyToExpression('1', None)
self.assertTrue(ok)
self.assertEqual(
exp, """(log("field_name") >= 5) AND (log("field_name") <= 6)""")
exp, ok = renderer.legendKeyToExpression('2', None)
self.assertTrue(ok)
self.assertEqual(
exp,
"""(log("field_name") >= 15.5) AND (log("field_name") <= 16.5)""")
exp, ok = renderer.legendKeyToExpression('2', layer)
self.assertTrue(ok)
self.assertEqual(
exp,
"""(log("field_name") >= 15.5) AND (log("field_name") <= 16.5)""")
def _apply_symbology_fixed_divisions(self, layer, field, tbl_name, schema,
min_v, max_v, steps):
"""Finds the amount of levels that is necessary to describe the layer,
a maximum of 20 different levels is set.
Parameters
----------
layer: QgsVectorLayer
field: str
tbl_name: str
schema: str
min_v: float
max_v: float
steps: int
"""
str_values = False
if min_v is not None and max_v is not None:
distinct_values = list(np.arange(min_v, max_v, steps))
elif not str_values:
distinct = self.db.get_distinct(tbl_name, field, schema)
if len(distinct) == 1:
return
distinct_values = []
distinct_count = []
for value, count in distinct:
if value is None:
continue
distinct_values.append(value)
distinct_count.append(count)
if len(distinct_values) > 20:
distinct_values.sort()
temp_list = []
for val in range(0, len(distinct_values), int(np.floor(len(distinct_values)/20))):
temp_list.append(distinct_values[val])
if temp_list[-1] != distinct_values[-1]:
temp_list.append(distinct_values[-1])
distinct_values = temp_list
if isinstance(distinct_values[0], str):
str_values = True
colors = self._create_colors(len(distinct_values))
if len(distinct_values) > 19 and not str_values:
range_list = []
for i in range(len(distinct_values) - 1):
red, green, blue = colors[i]
range_list.append(self._make_symbology(layer, distinct_values[i],
distinct_values[i + 1],
str(distinct_values[i]) + ' - ' + str(distinct_values[i + 1]),
QColor(int(red*255),int(green*255), int(blue*255), 128) ) )
renderer = QgsGraduatedSymbolRenderer(field, range_list)
renderer.setMode(QgsGraduatedSymbolRenderer.Custom )
else:
categories = []
for i in range(len(distinct_values)):
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
red, green, blue = colors[i]
symbol.setColor(QColor(int(red*255),int(green*255), int(blue*255), 128))
symbol.symbolLayer(0).setStrokeColor(QColor(int(red*255),int(green*255), int(blue*255), 128))
category = QgsRendererCategory(str(distinct_values[i]), symbol, str(distinct_values[i]))
categories.append(category)
renderer = QgsCategorizedSymbolRenderer(field, categories)
#renderer.setMode(QgsCategorizedSymbolRenderer.Custom)
layer.setRenderer(renderer)
def updateRenderer(self, layer, attribute_vals, settings):
"""
Creates a renderer for the layer based on this, and applies it
The renderer uses GradientColourRamp to calculate the symbol colours
@param layer: the selected QgsVectorLayer object
"""
geometry = layer.geometryType()
# create a colour ramp based on colour range type, inverting symbols if required
ramp_type = int(settings['colour_range'])
invert = int(settings['invert_colour'])
ramp = self.getColourRamp(ramp_type, invert)
line_width = float(settings['line_width'])
# calculate ranges: EqualInterval = 0; Quantile = 1; Jenks = 2; StdDev = 3; Pretty = 4; Custom = 5
intervals = int(settings['intervals'])
mode = int(settings['interval_type'])
attribute = attribute_vals['name']
renderer = None
if mode < 3:
# set symbol type and line width
symbol = QgsSymbol.defaultSymbol(geometry)
if symbol:
if symbol.type() == 1: # line
symbol.setWidth(line_width)
elif symbol.type() == 2: # line
symbol = QgsFillSymbol.createSimple({
'style':
'solid',
'color':
'black',
'width_border':
'%s' % line_width
})
elif symbol.type() == 0: # point
symbol.setSize(line_width)
renderer = QgsGraduatedSymbolRenderer.createRenderer(
layer, attribute, intervals, mode, symbol, ramp)
renderer.setMode(mode)
renderer.setSourceColorRamp(ramp)
else:
# calculate range values individually based on custom settings
ranges = []
max_value = float(attribute_vals['max'])
min_value = float(attribute_vals['min'])
top_value = float(settings['top_value'])
bottom_value = float(settings['bottom_value'])
# calculate number of ranges depending on top/bottom difference from max/min:
# is there really a range there? Otherwise this will calculate 1 or even 2 ranges less
calc_intervals = intervals + 1
if top_value != max_value:
calc_intervals -= 1
if bottom_value != min_value:
calc_intervals -= 1
range_steps = [
r for r in np.linspace(bottom_value, top_value, calc_intervals)
]
if top_value != max_value:
range_steps.append(max_value)
if bottom_value != min_value:
range_steps.insert(0, min_value)
for i in range(0, len(range_steps) - 1):
symbol = QgsSymbol.defaultSymbol(geometry)
if symbol:
new_colour = ramp.color(
i / (float(len(range_steps)) - 2)).getRgb()
symbol.setColor(QColor(*new_colour))
symbol.setWidth(line_width)
label = "%s - %s" % (range_steps[i], range_steps[i + 1])
this_range = QgsRendererRange(range_steps[i],
range_steps[i + 1], symbol,
label)
ranges.append(this_range)
if ranges:
renderer = QgsGraduatedSymbolRenderer(attribute, ranges)
# renderer.setMode(5)
renderer.setSourceColorRamp(ramp)
# configure symbol levels to display in specific order
# the classic "reds on top" from space syntax, or the reverse
if renderer:
display_order = int(settings['display_order'])
renderer.setUsingSymbolLevels(True)
render_pass = 0
if display_order == 0:
for symbol in renderer.symbols(QgsRenderContext()):
for i in range(0, symbol.symbolLayerCount()):
symbol.symbolLayer(i).setRenderingPass(render_pass)
render_pass += 1
else:
for symbol in reversed(renderer.symbols(QgsRenderContext())):
for i in range(0, symbol.symbolLayerCount()):
symbol.symbolLayer(i).setRenderingPass(render_pass)
render_pass += 1
# set the symbols for monochrome ramp
# varying line width, point size or polygon pattern density
# doesn't use data column because it's not scaled according to line width values
# the width is calculated linearly between min and given value
if renderer:
if ramp_type == 3:
new_width = np.linspace(0.1, line_width, intervals)
step = intervals / 8.0 # this is usd for fill patterns
# color = QColor(ramp.color(0).getRgb()) # same as above
for i in range(0, intervals):
symbol = renderer.symbols(QgsRenderContext())[i]
if invert:
if symbol.type() == 1: # line
symbol.setWidth(new_width[(intervals - 1) - i])
elif symbol.type() == 0: # point
symbol.setSize(new_width[(intervals - 1) - i])
elif symbol.type() == 2: # polygon
dense = int(i / step)
if dense == 0:
style = 'solid'
else:
style = 'dense%s' % dense
symbol = QgsFillSymbol.createSimple({
'style':
style,
'color':
'black',
'width_border':
'%s' % new_width[(intervals - 1) - i]
})
else:
if symbol.type() == 1: # line
symbol.setWidth(new_width[i])
elif symbol.type() == 0: # point
symbol.setSize(new_width[i])
elif symbol.type() == 2: # polygon
dense = int(i / step)
if dense == 7:
style = 'solid'
else:
style = 'dense%s' % (7 - dense)
symbol = QgsFillSymbol.createSimple({
'style':
style,
'color':
'black',
'width_border':
'%s' % new_width[i]
})
renderer.updateRangeSymbol(i, symbol)
return renderer
def testQgsGraduatedSymbolRenderer_1(self):
"""Test QgsGraduatedSymbolRenderer: Basic get/set functions """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
self.assertEqual(symbol.dump(), renderer.sourceSymbol().dump(), "Get/set renderer source symbol")
attr = '"value"*"value"'
renderer.setClassAttribute(attr)
self.assertEqual(attr, renderer.classAttribute(), "Get/set renderer class attribute")
for m in (
QgsGraduatedSymbolRenderer.Custom,
QgsGraduatedSymbolRenderer.EqualInterval,
QgsGraduatedSymbolRenderer.Quantile,
QgsGraduatedSymbolRenderer.Jenks,
QgsGraduatedSymbolRenderer.Pretty,
QgsGraduatedSymbolRenderer.StdDev,
):
renderer.setMode(m)
self.assertEqual(m, renderer.mode(), "Get/set renderer mode")
format = createLabelFormat()
renderer.setLabelFormat(format)
self.assertEqual(
dumpLabelFormat(format),
dumpLabelFormat(renderer.labelFormat()),
"Get/set renderer label format")
ramp = createColorRamp()
renderer.setSourceColorRamp(ramp)
self.assertEqual(
dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
renderer.setInvertedColorRamp(True)
self.assertTrue(renderer.invertedColorRamp(),
"Get/set renderer inverted color ramp")
renderer.setInvertedColorRamp(False)
self.assertFalse(renderer.invertedColorRamp(),
"Get/set renderer inverted color ramp")
renderer.setSourceColorRamp(ramp)
self.assertEqual(
dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
# test for classificatio with varying size
renderer.setGraduatedMethod(QgsGraduatedSymbolRenderer.GraduatedSize)
renderer.setSourceColorRamp(None)
renderer.addClassLowerUpper(0, 2)
renderer.addClassLowerUpper(2, 4)
renderer.addClassLowerUpper(4, 6)
renderer.setSymbolSizes(2, 13)
self.assertEqual(renderer.maxSymbolSize(), 13)
self.assertEqual(renderer.minSymbolSize(), 2)
refSizes = [2, (13 + 2) * .5, 13]
ctx = QgsRenderContext()
for idx, symbol in enumerate(renderer.symbols(ctx)):
self.assertEqual(symbol.size(), refSizes[idx])
def editNetworkLayer(self, progressBar, layerName, scenariosExpression,
networkExpression, variable, level, projectPath,
group, networkLinkShapePath, method, layerId,
expressionNetworkText, color):
"""
@summary: Get operators dictionary
@param layerName: Layer name
@type layerName: String
@param scenariosExpression: Scenarios expression
@type scenariosExpression: Stack object
@param networkExpression: Network expression
@type networkExpression: Stack object
@param variable: Variable to evaluate
@type variable: String
@param level: Level to evaluate (Total, Routes, Operators)
@type level: Level object
@param projectPath: Project path
@type projectPath: String
@param group: Project group
@type group: Layer group
@param networkLinkShapePath: Network link shape path
@type networkLinkShapePath: String
@return: Result of the layer creation
"""
if scenariosExpression is None:
QMessageBox.warning(None, "Network expression",
"There is not scenarios information.")
print("There is not scenarios information.")
return False
registry = QgsProject.instance()
layersCount = len(registry.mapLayers())
result, resultData, minValue, maxValue = self.network_data_access.create_network_memory(
layerName, scenariosExpression, networkExpression, variable, level,
projectPath)
progressBar.setValue(15)
if result:
# Source shape, name of the new shape, providerLib
layer = QgsVectorLayer(networkLinkShapePath,
layerName + "_network", 'ogr')
epsg = layer.crs().postgisSrid()
intMethod = 0 if method == "Color" else 1
rowCounter = len(resultData)
if not layer.isValid():
return False
feats = [feat for feat in layer.getFeatures()]
# Create a vector layer with data on Memory
memoryLayer = registry.mapLayer(layerId)
memory_data = memoryLayer.dataProvider()
joinedFieldName = "Result"
shpField = "Id"
attr = layer.dataProvider().fields().toList()
attr += [QgsField(joinedFieldName, QVariant.Double)]
progressBar.setValue(25)
memory_data.addAttributes(attr)
memory_data.addFeatures(feats)
num = 30
progressBar.setValue(num)
progressInterval = 70 / len(resultData)
memoryLayer.startEditing()
for rowItem in np.nditer(resultData):
value = 0
num += progressInterval
progressBar.setValue(num)
it = memoryLayer.getFeatures("LINKID = '{0}'".format(
str(rowItem['Id']).replace("b", "").replace("'", "")))
for id_feature in it:
memoryLayer.changeAttributeValue(
id_feature.id(),
memory_data.fieldNameIndex(joinedFieldName),
QVariant(round(float(rowItem['Result']), 2)))
memoryLayer.commitChanges()
myStyle = QgsStyle().defaultStyle()
defaultColorRampNames = myStyle.colorRampNames()
ramp = myStyle.colorRamp(defaultColorRampNames[0])
ranges = []
nCats = ramp.count()
rng = maxValue - minValue
nCats = 8
scale = QgsMapUnitScale(minValue, maxValue)
if method == "Color":
color1 = list(
map(lambda x: int(x), color['color1'].split(",")[0:3]))
color2 = list(
map(lambda x: int(x), color['color2'].split(",")[0:3]))
interpolatedColors = HP.linear_gradient(color1, color2, nCats)
for i in range(0, nCats):
v0 = minValue + rng / float(nCats) * i
v1 = minValue + rng / float(nCats) * (i + 1)
if method == "Color":
line = QgsSimpleLineSymbolLayer(
QColor(interpolatedColors['r'][i],
interpolatedColors['g'][i],
interpolatedColors['b'][i]))
line.setOffsetUnit(2)
line.setOffset(2)
line.setWidth(0.8)
symbol = QgsLineSymbol()
symbol.changeSymbolLayer(0, line)
myRange = QgsRendererRange(v0, v1, symbol, "")
elif method == "Size":
qcolor = QColor()
qcolor.setRgb(color)
line = QgsSimpleLineSymbolLayer(qcolor)
line.setOffsetUnit(2)
line.setOffset(0.7)
# Symbol
# symbolLine = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayerBase.ArrowHead)
# Mark line
# markLine = QgsMarkerLineSymbolLayer()
# markLine.setPlacement(4)
symbolo = QgsLineSymbol()
symbolo.changeSymbolLayer(0, line)
# symbolo.appendSymbolLayer(line)
myRange = QgsRendererRange(v0, v1, symbolo, "")
ranges.append(myRange)
# The first parameter refers to the name of the field that contains the calculated value (expression)
modeRender = QgsGraduatedSymbolRenderer.Mode(2)
renderer = QgsGraduatedSymbolRenderer(joinedFieldName, ranges)
renderer.setMode(modeRender)
renderer.setGraduatedMethod(intMethod)
if method == "Size":
renderer.setSymbolSizes(0.200000, 2.60000)
renderer.setSourceColorRamp(ramp)
memoryLayer.setRenderer(renderer)
typeLayer = "network"
fieldName = "LINKID"
networkExpressionText = str(scenariosExpression)
# Create XML File ".qtranus" with the parameters of the executions
if FileMXML.if_exist_xml_layers(projectPath):
if FileMXML.if_exist_layer(projectPath, memoryLayer.id()):
FileMXML.update_xml_file(memoryLayer.name(),
memoryLayer.id(),
scenariosExpression, variable,
networkExpression, projectPath,
expressionNetworkText, method,
level, color)
else:
FileMXML.add_layer_xml_file(memoryLayer.name(),
memoryLayer.id(),
scenariosExpression, variable,
networkExpression, projectPath,
expressionNetworkText,
shpField, typeLayer, method,
level, color)
else:
FileMXML.create_xml_file(memoryLayer.name(), memoryLayer.id(),
scenariosExpression, variable,
networkExpression, projectPath,
expressionNetworkText, shpField,
typeLayer, method, level, color)
#group.insertLayer((layersCount+1), memoryLayer)
progressBar.setValue(100)
return True
def style_maps(layer,
style_by,
iface,
output_type='damages-rlzs',
perils=None,
add_null_class=False,
render_higher_on_top=False,
repaint=True,
use_sgc_style=False):
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
# see properties at:
# https://qgis.org/api/qgsmarkersymbollayerv2_8cpp_source.html#l01073
symbol.setOpacity(1)
if isinstance(symbol, QgsMarkerSymbol):
# do it only for the layer with points
symbol.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen))
style = get_style(layer, iface.messageBar())
# this is the default, as specified in the user settings
ramp = QgsGradientColorRamp(style['color_from'], style['color_to'])
style_mode = style['style_mode']
# in most cases, we override the user-specified setting, and use
# instead a setting that was required by scientists
if output_type in OQ_TO_LAYER_TYPES:
default_qgs_style = QgsStyle().defaultStyle()
default_color_ramp_names = default_qgs_style.colorRampNames()
if output_type in (
'damages-rlzs',
'avg_losses-rlzs',
'avg_losses-stats',
):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Jenks
else:
style_mode = 'Jenks'
ramp_type_idx = default_color_ramp_names.index('Reds')
symbol.setColor(QColor(RAMP_EXTREME_COLORS['Reds']['top']))
inverted = False
elif (output_type in ('gmf_data', 'ruptures')
or (output_type == 'hmaps' and not use_sgc_style)):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if output_type == 'ruptures':
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Pretty
else:
style_mode = 'PrettyBreaks'
else:
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.EqualInterval
else:
style_mode = 'EqualInterval'
ramp_type_idx = default_color_ramp_names.index('Spectral')
inverted = True
symbol.setColor(QColor(RAMP_EXTREME_COLORS['Reds']['top']))
elif output_type == 'hmaps' and use_sgc_style:
# FIXME: for SGC they were using size 10000 map units
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Pretty
else:
style_mode = 'PrettyBreaks'
try:
ramp_type_idx = default_color_ramp_names.index(
'SGC_Green2Red_Hmap_Color_Ramp')
except ValueError:
raise ValueError(
'Color ramp SGC_Green2Red_Hmap_Color_Ramp was '
'not found. Please import it from '
'Settings -> Style Manager, loading '
'svir/resources/sgc_green2red_hmap_color_ramp.xml')
inverted = False
registry = QgsApplication.symbolLayerRegistry()
symbol_props = {
'name': 'square',
'color': '0,0,0',
'color_border': '0,0,0',
'offset': '0,0',
'size': '1.5', # FIXME
'angle': '0',
}
square = registry.symbolLayerMetadata(
"SimpleMarker").createSymbolLayer(symbol_props)
symbol = QgsSymbol.defaultSymbol(layer.geometryType()).clone()
symbol.deleteSymbolLayer(0)
symbol.appendSymbolLayer(square)
symbol.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen))
elif output_type in ['asset_risk', 'input']:
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.EqualInterval
else:
style_mode = 'EqualInterval'
# exposure_strings = ['number', 'occupants', 'value']
# setting exposure colors by default
colors = {
'single': RAMP_EXTREME_COLORS['Blues']['top'],
'ramp_name': 'Blues'
}
inverted = False
if output_type == 'asset_risk':
damage_strings = perils
for damage_string in damage_strings:
if damage_string in style_by:
colors = {
'single':
RAMP_EXTREME_COLORS['Spectral']['top'],
'ramp_name': 'Spectral'
}
inverted = True
break
else: # 'input'
colors = {
'single': RAMP_EXTREME_COLORS['Greens']['top'],
'ramp_name': 'Greens'
}
symbol.symbolLayer(0).setShape(
QgsSimpleMarkerSymbolLayerBase.Square)
single_color = colors['single']
ramp_name = colors['ramp_name']
ramp_type_idx = default_color_ramp_names.index(ramp_name)
symbol.setColor(QColor(single_color))
else:
raise NotImplementedError(
'Undefined color ramp for output type %s' % output_type)
ramp = default_qgs_style.colorRamp(
default_color_ramp_names[ramp_type_idx])
if inverted:
ramp.invert()
# get unique values
fni = layer.fields().indexOf(style_by)
unique_values = layer.dataProvider().uniqueValues(fni)
num_unique_values = len(unique_values - {NULL})
if num_unique_values > 2:
if Qgis.QGIS_VERSION_INT < 31000:
renderer = QgsGraduatedSymbolRenderer.createRenderer(
layer, style_by, min(num_unique_values, style['classes']),
style_mode, symbol.clone(), ramp)
else:
renderer = QgsGraduatedSymbolRenderer(style_by, [])
# NOTE: the following returns an instance of one of the
# subclasses of QgsClassificationMethod
classification_method = \
QgsApplication.classificationMethodRegistry().method(
style_mode)
renderer.setClassificationMethod(classification_method)
renderer.updateColorRamp(ramp)
renderer.updateSymbols(symbol.clone())
renderer.updateClasses(
layer, min(num_unique_values, style['classes']))
if not use_sgc_style:
if Qgis.QGIS_VERSION_INT < 31000:
label_format = renderer.labelFormat()
# NOTE: the following line might be useful
# label_format.setTrimTrailingZeroes(True)
label_format.setPrecision(2)
renderer.setLabelFormat(label_format, updateRanges=True)
else:
renderer.classificationMethod().setLabelPrecision(2)
renderer.calculateLabelPrecision()
elif num_unique_values == 2:
categories = []
for unique_value in unique_values:
symbol = symbol.clone()
try:
symbol.setColor(
QColor(RAMP_EXTREME_COLORS[ramp_name]
['bottom' if unique_value ==
min(unique_values) else 'top']))
except Exception:
symbol.setColor(
QColor(style['color_from'] if unique_value ==
min(unique_values) else style['color_to']))
category = QgsRendererCategory(unique_value, symbol,
str(unique_value))
# entry for the list of category items
categories.append(category)
renderer = QgsCategorizedSymbolRenderer(style_by, categories)
else:
renderer = QgsSingleSymbolRenderer(symbol.clone())
if add_null_class and NULL in unique_values:
# add a class for NULL values
rule_renderer = QgsRuleBasedRenderer(symbol.clone())
root_rule = rule_renderer.rootRule()
not_null_rule = root_rule.children()[0].clone()
# strip parentheses from stringified color HSL
not_null_rule.setFilterExpression(
'%s IS NOT NULL' % QgsExpression.quotedColumnRef(style_by))
not_null_rule.setLabel('%s:' % style_by)
root_rule.appendChild(not_null_rule)
null_rule = root_rule.children()[0].clone()
null_rule.setSymbol(
QgsFillSymbol.createSimple({
'color': '160,160,160',
'style': 'diagonal_x'
}))
null_rule.setFilterExpression(
'%s IS NULL' % QgsExpression.quotedColumnRef(style_by))
null_rule.setLabel(tr('No points'))
root_rule.appendChild(null_rule)
if isinstance(renderer, QgsGraduatedSymbolRenderer):
# create value ranges
rule_renderer.refineRuleRanges(not_null_rule, renderer)
# remove default rule
elif isinstance(renderer, QgsCategorizedSymbolRenderer):
rule_renderer.refineRuleCategoris(not_null_rule, renderer)
for rule in rule_renderer.rootRule().children()[1].children():
label = rule.label()
# by default, labels are like:
# ('"collapse-structural-ASH_DRY_sum" >= 0.0000 AND
# "collapse-structural-ASH_DRY_sum" <= 2.3949')
first, second = label.split(" AND ")
bottom = first.rsplit(" ", 1)[1]
top = second.rsplit(" ", 1)[1]
simplified = "%s - %s" % (bottom, top)
rule.setLabel(simplified)
root_rule.removeChildAt(0)
renderer = rule_renderer
if render_higher_on_top:
renderer.setUsingSymbolLevels(True)
symbol_items = [item for item in renderer.legendSymbolItems()]
for i in range(len(symbol_items)):
sym = symbol_items[i].symbol().clone()
key = symbol_items[i].ruleKey()
for lay in range(sym.symbolLayerCount()):
sym.symbolLayer(lay).setRenderingPass(i)
renderer.setLegendSymbolItem(key, sym)
layer.setRenderer(renderer)
if not use_sgc_style:
layer.setOpacity(0.7)
if repaint:
layer.triggerRepaint()
iface.setActiveLayer(layer)
iface.zoomToActiveLayer()
# NOTE QGIS3: probably not needed
# iface.layerTreeView().refreshLayerSymbology(layer.id())
iface.mapCanvas().refresh()
def run(self):
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = ChoroMapDialog()
# clear the line edit widget and set the pushbutton callback
self.dlg.lineEdit.clear()
self.dlg.pushButton.clicked.connect(self.choose_folder)
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
#not used anymore
#i was doing the catagories manual before
"""
def interval_divide2(min, max, intervals):
assert intervals != 0
interval_size = (max - min) / intervals
result = []
start = min
end = min + interval_size
while True:
result.append([int(start), int(end)])
start = end + 1
end = end + interval_size
if len(result) == intervals:
break
return result
"""
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
layer = self.layer
QgsProject.instance().addMapLayers([layer])
vals = []
fld = self.dlg.comboBox_2.currentText()
for f in layer.getFeatures():
vals.append(f[fld])
colors = ['#f1eef6','#d0d1e6','#a6bddb','#74a9cf','#2b8cbe','#045a8d']
colors = ['#f1eef6','#bdc9e1','#74a9cf','#2b8cbe','#045a8d']
min = sorted(vals)[0]
max = sorted(vals)[-1]
step = (max-min)/len(colors)
rangeL = []
for color in colors:
cat = [min, min+step, color]
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
symbol.setColor(QColor(cat[2]))
qRange = QgsRendererRange(cat[0], cat[1], symbol, '{0:.1f}-{1:.1f}'.format(cat[0], cat[1]))
rangeL.append(qRange)
min = (min + step) + 0.1
renderer = QgsGraduatedSymbolRenderer(fld, rangeL)
layer.setRenderer(renderer)
layer.triggerRepaint()
def processAlgorithm(self, parameters, context, feedback):
# Couche buffer :
input_featuresource = self.parameterAsSource(parameters, 'INPUT',
context)
# Buffer distance :
bufferdist = self.parameterAsDouble(parameters, 'BUFFERDIST', context)
# Check for cancelation
if feedback.isCanceled():
return {}
buffer_result = processing.run(
'native:buffer',
{
# Here we pass on the original parameter values of INPUT
# and BUFFER_OUTPUT to the buffer algorithm.
'INPUT': parameters['INPUT'],
'OUTPUT': parameters['BUFFER_OUTPUT'],
'DISTANCE': bufferdist,
'SEGMENTS': 10,
'DISSOLVE': True,
'END_CAP_STYLE': 0,
'JOIN_STYLE': 0,
'MITER_LIMIT': 10
},
# Because the buffer algorithm is being run as a step in
# another larger algorithm, the is_child_algorithm option
# should be set to True
is_child_algorithm=True,
#
# It's important to pass on the context and feedback objects to
# child algorithms, so that they can properly give feedback to
# users and handle cancelation requests.
context=context,
feedback=feedback)
# Check for cancelation
if feedback.isCanceled():
return {}
# Selection de la couche cable :
cables = QgsVectorLayer(
"/Users/pierre-loupgarrigues/Python JupyterLab/M2/pyqgis/Evaluation_pyqgis/data/cables.shp",
"cables", "ogr")
cables = iface.activeLayer()
# Séléction des cables en fonction des paramètres choisis :
cables.selectByExpression(
" \"capacite\" > '{}' AND \"mode_pose\" = '{}' ".format(
parameters[self.CAPACITE], parameters[self.MODE_DE_POSE]))
# Vérification :
selectionCapacite = self.parameterAsDouble(parameters, 'CAPACITE',
context)
print(selectionCapacite)
# Vérification :
selectionModeDePose = self.parameterAsString(parameters,
'MODE_DE_POSE', context)
print(selectionModeDePose)
# Sauvegarde de la séléction des cables :
cables_selection = processing.run(
'qgis:saveselectedfeatures',
{
'INPUT': cables,
#'OUTPUT':'memory:'
'OUTPUT': parameters['CABLES_OUTPUT']
},
context=context,
feedback=feedback,
is_child_algorithm=True)
mes_cables = cables_selection['OUTPUT']
### SYMBOLOGIE GRADUEE
nb_prises = (
('Faible', 0, 9, 'green'),
('Moyen_1', 10, 25, 'yellow'),
('Moyen_2', 26, 100, 'orange'),
('Eleve', 101, 1000000, 'red'),
)
# creation
ranges = []
for label, lower, upper, color in nb_prises:
symbol = QgsSymbol.defaultSymbol(cables.geometryType())
symbol.setColor(QColor(color))
rng = QgsRendererRange(lower, upper, symbol, label)
ranges.append(rng)
# create the renderer and assign it to a layer
expression = 'nb_prises' # field name
renderer = QgsGraduatedSymbolRenderer(expression, ranges)
cables.setRenderer(renderer)
# Return the results
return {
'BUFFER_OUTPUT': buffer_result['OUTPUT'],
'CABLES_OUTPUT': cables_selection['OUTPUT']
}
def testQgsGraduatedSymbolRenderer_2(self):
"""Test QgsGraduatedSymbolRenderer: Adding /removing/editing classes """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
symbol.setColor(QColor(255, 0, 0))
# Add class without start and end ranges
renderer.addClass(symbol.clone())
renderer.addClass(symbol.clone())
renderer.updateRangeLabel(1, 'Second range')
renderer.updateRangeLowerValue(1, 10.0)
renderer.updateRangeUpperValue(1, 25.0)
renderer.updateRangeRenderState(1, False)
symbol.setColor(QColor(0, 0, 255))
renderer.updateRangeSymbol(1, symbol.clone())
# Add as a rangeobject
symbol.setColor(QColor(0, 255, 0))
range = QgsRendererRange(20.0, 25.5, symbol.clone(), 'Third range',
False)
renderer.addClassRange(range)
# Add class by lower and upper
renderer.addClassLowerUpper(25.5, 30.5)
# (Update label for sorting tests)
renderer.updateRangeLabel(3, 'Another range')
self.assertEqual(
dumpRangeLabels(renderer.ranges()),
'(0.0 - 0.0,Second range,Third range,Another range,)',
'Added ranges labels not correct')
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)',
'Added ranges lower/upper values not correct')
# Check that clone function works
renderer2 = renderer.clone()
self.assertEqual(dumpGraduatedRenderer(renderer),
dumpGraduatedRenderer(renderer2),
"clone function doesn't replicate renderer properly")
# Check save and reload from Dom works
doc = QDomDocument()
element = renderer.save(doc)
renderer2 = QgsGraduatedSymbolRenderer.create(element)
self.assertEqual(
dumpGraduatedRenderer(renderer), dumpGraduatedRenderer(renderer2),
"Save/create from DOM doesn't replicate renderer properly")
# Check sorting
renderer.sortByLabel()
self.assertEqual(
dumpRangeList(renderer.ranges(), labelsOnly=True),
'(0.0 - 0.0,Another range,Second range,Third range,)',
'sortByLabel not correct')
renderer.sortByValue()
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)',
'sortByValue not correct')
renderer.sortByValue(Qt.DescendingOrder)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(25.5000-30.5000,20.0000-25.5000,10.0000-25.0000,0.0000-0.0000,)',
'sortByValue descending not correct')
# Check deleting
renderer.deleteClass(2)
self.assertEqual(dumpRangeBreaks(renderer.ranges()),
'(25.5000-30.5000,20.0000-25.5000,0.0000-0.0000,)',
'deleteClass not correct')
renderer.deleteAllClasses()
self.assertEqual(len(renderer.ranges()), 0,
"deleteAllClasses didn't delete all")
def processAlgorithm(self, parameters, context, feedback):
project = QgsProject()
project.setFileName(
os.path.join(parameters[self.FOLDER], "all-outputs-qgis.qgs"))
project.setCrs(QgsCoordinateReferenceSystem('EPSG:27700'))
def getMaxValue(layer, fieldname):
maxfound = float("-inf")
for f in layer.getFeatures():
attr = f.attribute(fieldname)
assert attr >= 0
if attr > maxfound:
maxfound = attr
return maxfound
with open(
os.path.join(parameters[self.FOLDER],
"all-town-metadata.json")) as f:
metadata = json.load(f)
classmethods = {
'quantile': QgsClassificationQuantile,
'jenks': QgsClassificationJenks,
'equal': QgsClassificationEqualInterval
}
html = ""
output = []
views_sorted_by_mode = sorted(metadata["views"],
key=lambda v: v["mode"])
for view in views_sorted_by_mode:
keysymbol = u'🔑'
viewname = view["label"]
keysign = ""
if viewname.find(keysymbol) != -1:
viewname = viewname.replace(keysymbol, '', 1)
keysign = "*** "
viewname = keysign + view["mode"] + " " + viewname
html += f"""
<h2>{viewname}</h2>
{view["description"]}
<ul>
"""
for layer in view["layers"]:
layername = viewname + " - " + layer["scalar_field_units"]
layerpath = os.path.join(parameters[self.FOLDER],
layer["file"])
vlayer = QgsVectorLayer(layerpath, layername, "ogr")
if not vlayer.isValid():
feedback.pushInfo("Layer failed to load: " + layerpath)
else:
context.temporaryLayerStore().addMapLayer(vlayer)
html += f"""<li><b>file:</b> {layer["file"]}"""
if "symbol_field" in layer:
html += f"""<ul>
<li><b>symbol field:</b> {layer["symbol_field"]}
</ul>
"""
categories = []
scalar_fieldname = layer["scalar_field"]
maxvalue = getMaxValue(vlayer, scalar_fieldname)
feedback.pushInfo("Max value for %s is %f" %
(scalar_fieldname, maxvalue))
for formality in ["I", "F"]:
for severity, colour in [(3, 'red'), (2, 'yellow'),
(1, 'green')]:
colour = {
("I", "red"): "#FF0000",
("I", "yellow"): "#FFFF00",
("I", "green"): "#00FF00",
("F", "red"): "#FF9999",
("F", "yellow"): "#FFFF66",
("F", "green"): "#99FF99",
}[(formality, colour)]
symbol_code = "%s%d" % (formality, severity)
if formality == "F":
symbol = QgsMarkerSymbol.createSimple({
'color':
colour,
'size':
'3',
'outline_color':
'#888888'
})
else:
assert (formality == "I")
symbol = QgsMarkerSymbol.createSimple({
'color':
colour,
'size':
'3',
'outline_color':
'#000000',
'name':
'star'
})
objTransf = QgsSizeScaleTransformer(
QgsSizeScaleTransformer.Flannery,
0, #minvalue
maxvalue, #maxvalue
3, #minsize
10, #maxsize
0, #nullsize
1) #exponent
objProp = QgsProperty()
objProp.setField(scalar_fieldname)
objProp.setTransformer(objTransf)
symbol.setDataDefinedSize(objProp)
label = {
"F": "Formal",
"I": "Informal"
}[formality] + " " + {
3: "Major",
2: "Secondary",
1: "Tertiary"
}[severity]
cat = QgsRendererCategory(
symbol_code, symbol, label, True)
categories.append(cat)
renderer = QgsCategorizedSymbolRenderer(
"Crossings", categories)
renderer.setClassAttribute(layer["symbol_field"])
vlayer.setRenderer(renderer)
else:
html += f"""<ul>
<li><b>field:</b> {layer["scalar_field"]}
<li><b>units:</b> {layer["scalar_field_units"]}
<li><b>recommended classification:</b> {layer["classes"]}
</ul>
"""
default_style = QgsStyle().defaultStyle()
color_ramp = default_style.colorRamp('bt')
renderer = QgsGraduatedSymbolRenderer()
renderer.setClassAttribute(layer["scalar_field"])
classmethod = classmethods[layer["classes"]]()
renderer.setClassificationMethod(classmethod)
renderer.updateClasses(vlayer, 5)
renderer.updateColorRamp(color_ramp)
vlayer.setRenderer(renderer)
project.addMapLayer(vlayer)
feedback.pushInfo("Loaded " + layerpath)
html += "</ul>"
project.write()
town = views_sorted_by_mode[0]["town"]
with open(os.path.join(parameters[self.FOLDER], "metadata.html"),
"w") as htmlfile:
htmlfile.write(
f"<html><head><title>{town} metadata</title></head><body><h1>{town}</h1>{html}</body></html>"
)
return {self.OUTPUT: output}
