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
"""
if min_v is not None and max_v is not None:
distinct_values = list(np.arange(min_v, max_v, steps))
else:
distinct = self.db.get_distinct(tbl_name, field, schema)
if len(distinct) == 1:
return
distinct_values = []
distinct_count = []
for value, count in distinct:
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
colors = self._create_colors(len(distinct_values))
# TODO: fix for str values!
if len(distinct_values) > 19:
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 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 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 equal_count(self, layer, data_values_list, field, steps=10,
min_value=None, max_value=None):
"""
Parameters
----------
layer
data_values_list
field
steps
min_value
max_value
Returns
-------
"""
if min_value is not None:
values = []
for value in data_values_list:
if value >= min_value:
values.append(value)
data_values_list = values
if max_value is not None:
values = []
for value in data_values_list:
if value <= max_value:
values.append(value)
data_values_list = values
count_0 = data_values_list.count(0)
if count_0 > 1:
def remove_values_from_list(the_list, val):
return [value for value in the_list if value != val]
data_values_list = remove_values_from_list(data_values_list, 0)
data_values_list.insert(0, 0)
n, bins, patches = plt.hist(data_values_list,
hist_edges_equal(data_values_list, steps))
colors = self._create_colors(steps)
range_list = []
for i in range(steps):
red, green, blue = colors[i]
range_list.append(
self._make_symbology(layer, bins[i],
bins[i + 1],
str(bins[i]) + ' - ' + str(
bins[i + 1]),
QColor(int(red * 255),
int(green * 255),
int(blue * 255), 128)))
renderer = QgsGraduatedSymbolRenderer(field, range_list)
renderer.setMode(QgsGraduatedSymbolRenderer.Custom)
layer.setRenderer(renderer)
return layer
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 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 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 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])
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')
