def processAlgorithm(self, feedback):
layer = dataobjects.getLayerFromString(
self.getParameterValue(self.INPUT_LAYER))
geometry_type = self.getParameterValue(self.OUTPUT_GEOMETRY)
wkb_type = None
if geometry_type == 0:
wkb_type = QgsWkbTypes.Polygon
elif geometry_type == 1:
wkb_type = QgsWkbTypes.LineString
else:
wkb_type = QgsWkbTypes.Point
if self.getParameterValue(self.WITH_Z):
wkb_type = QgsWkbTypes.addZ(wkb_type)
if self.getParameterValue(self.WITH_M):
wkb_type = QgsWkbTypes.addM(wkb_type)
writer = self.getOutputFromName(
self.OUTPUT_LAYER).getVectorWriter(
layer.fields(),
wkb_type,
layer.crs())
expression = QgsExpression(self.getParameterValue(self.EXPRESSION))
if expression.hasParserError():
raise GeoAlgorithmExecutionException(expression.parserErrorString())
exp_context = QgsExpressionContext(QgsExpressionContextUtils.globalProjectLayerScopes(layer))
if not expression.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: {0}').format(expression.evalErrorString()))
features = vector.features(layer)
total = 100.0 / len(features)
for current, input_feature in enumerate(features):
output_feature = input_feature
exp_context.setFeature(input_feature)
value = expression.evaluate(exp_context)
if expression.hasEvalError():
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: {0}').format(expression.evalErrorString()))
if not value:
output_feature.setGeometry(QgsGeometry())
else:
if not isinstance(value, QgsGeometry):
raise GeoAlgorithmExecutionException(
self.tr('{} is not a geometry').format(value))
output_feature.setGeometry(value)
writer.addFeature(output_feature)
feedback.setProgress(int(current * total))
del writer
def initContext(self):
exp_context = self.builder.expressionContext()
exp_context.appendScopes(QgsExpressionContextUtils.globalProjectLayerScopes(self.layer))
exp_context.lastScope().setVariable("row_number", 1)
exp_context.setHighlightedVariables(["row_number"])
self.builder.setExpressionContext(exp_context)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
fields = layer.fields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, layer.wkbType(),
layer.crs())
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp.setGeomCalculator(da)
exp.setDistanceUnits(QgsProject.instance().distanceUnits())
exp.setAreaUnits(QgsProject.instance().areaUnits())
exp_context = QgsExpressionContext(QgsExpressionContextUtils.globalProjectLayerScopes(layer))
if not exp.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = vector.features(layer)
total = 100.0 / len(features)
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = exp.evaluate(exp_context)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature)
progress.setPercentage(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n%s' % error))
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
fields = layer.fields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs())
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp.setGeomCalculator(da)
exp.setDistanceUnits(QgsProject.instance().distanceUnits())
exp.setAreaUnits(QgsProject.instance().areaUnits())
exp_context = QgsExpressionContext(
QgsExpressionContextUtils.globalProjectLayerScopes(layer))
if not exp.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = vector.features(layer)
total = 100.0 / len(features)
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = exp.evaluate(exp_context)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature)
feedback.setProgress(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n%s' % error))
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.INPUT_LAYER), context)
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
fields = layer.fields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(),
context)
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs())
da.setEllipsoid(QgsProject.instance().ellipsoid())
exp.setGeomCalculator(da)
exp.setDistanceUnits(QgsProject.instance().distanceUnits())
exp.setAreaUnits(QgsProject.instance().areaUnits())
exp_context = QgsExpressionContext(
QgsExpressionContextUtils.globalProjectLayerScopes(layer))
if not exp.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: {0}').format(exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = QgsProcessingUtils.getFeatures(layer, context)
total = 100.0 / layer.featureCount() if layer.featureCount() else 0
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = exp.evaluate(exp_context)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n{0}').format(error))
def initContext(self):
exp_context = self.builder.expressionContext()
exp_context.appendScopes(QgsExpressionContextUtils.globalProjectLayerScopes(self.layer))
exp_context.lastScope().setVariable("row_number", 1)
exp_context.setHighlightedVariables(["row_number"])
self.builder.setExpressionContext(exp_context)
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
fields = layer.fields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs())
da.setEllipsoid(QgsProject.instance().ellipsoid())
exp.setGeomCalculator(da)
exp.setDistanceUnits(QgsProject.instance().distanceUnits())
exp.setAreaUnits(QgsProject.instance().areaUnits())
exp_context = QgsExpressionContext(QgsExpressionContextUtils.globalProjectLayerScopes(layer))
if not exp.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: {0}').format(exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = QgsProcessingUtils.getFeatures(layer, context)
total = 100.0 / layer.featureCount() if layer.featureCount() else 0
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = exp.evaluate(exp_context)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n{0}').format(error))
def feature_validator(feature, layer):
"""Validate a QGIS feature by checking QGIS fields constraints
The logic here is to:
- if geometry is not None check if geometry type matches the layer type
- loop through the fields and check for constraints:
- NOT NULL, skip the next check if this fails
- UNIQUE (only if not NULL)
- EXPRESSION (QgsExpression configured in the form), always evaluated,
even in case of NULLs
Note: only hard constraints are checked!
:param feature: QGIS feature
:type feature: QgsFeature
:param layer: QGIS layer
:type layer: QgsVectorLayer
:return: a dictionary of errors for each field + geometry
:rtype: dict
"""
errors = dict()
geometry = feature.geometry()
data_provider = layer.dataProvider()
def _has_default_value(field_index, field):
return (
# Provider level
data_provider.defaultValueClause(field_index)
or data_provider.defaultValue(field_index)
or field.defaultValueDefinition().isValid())
# Check geometry type
if not geometry.isNull() and geometry.wkbType() != layer.wkbType():
if not (geometry.wkbType() == QgsWkbTypes.Point25D
and layer.wkbType() == QgsWkbTypes.PointZ
or geometry.wkbType() == QgsWkbTypes.Polygon25D
and layer.wkbType() == QgsWkbTypes.PolygonZ
or geometry.wkbType() == QgsWkbTypes.LineString25D
and layer.wkbType() == QgsWkbTypes.LineStringZ
or geometry.wkbType() == QgsWkbTypes.MultiPoint25D
and layer.wkbType() == QgsWkbTypes.MultiPointZ
or geometry.wkbType() == QgsWkbTypes.MultiPolygon25D
and layer.wkbType() == QgsWkbTypes.MultiPolygonZ
or geometry.wkbType() == QgsWkbTypes.MultiLineString25D
and layer.wkbType() == QgsWkbTypes.MultiLineStringZ):
errors['geometry'] = _(
'Feature geometry type %s does not match layer type: %s') % (
QgsWkbTypes.displayString(geometry.wkbType()),
QgsWkbTypes.displayString(layer.wkbType()))
def _set_error(field_name, error):
if not field_name in errors:
errors[field_name] = []
errors[field_name].append(error)
# Check fields "hard" constraints
for field_index in range(layer.fields().count()):
field = layer.fields().field(field_index)
# check if fields is a join field:
if layer.fields().fieldOrigin(field_index) == QgsFields.OriginJoin:
continue
# Check not null first, if it fails skip other tests (unique and expression)
value = feature.attribute(field.name())
# If there is a default value we assume it's not NULL (we cannot really know at this point
# what will be the result of the default value clause evaluation, it might even be provider-side
if (value is None or value
== QVariant()) and not _has_default_value(field_index, field):
not_null = (field.constraints().constraintOrigin(
QgsFieldConstraints.ConstraintNotNull) !=
QgsFieldConstraints.ConstraintOriginNotSet
and field.constraints().constraintStrength(
QgsFieldConstraints.ConstraintNotNull)
== QgsFieldConstraints.ConstraintStrengthHard)
if not_null:
_set_error(field.name(), _('Field value must be NOT NULL'))
continue
value = feature.attribute(field_index)
# Skip if NULL, not sure if we want to continue in this case but it seems pointless
# to check for unique or type compatibility on NULLs
if value is not None and value != QVariant():
if not QVariant(value).convert(field.type()):
_set_error(
field.name(),
_('Field value \'%s\' cannot be converted to %s') %
(value, QVariant.typeToName(field.type())))
unique = (field.constraints().constraintOrigin(
QgsFieldConstraints.ConstraintUnique) !=
QgsFieldConstraints.ConstraintOriginNotSet
and field.constraints().constraintStrength(
QgsFieldConstraints.ConstraintUnique)
== QgsFieldConstraints.ConstraintStrengthHard)
if unique:
# Search for features, excluding self if it's an update
request = QgsFeatureRequest()
request.setNoAttributes()
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setLimit(2)
if field.isNumeric():
request.setFilterExpression(
'"%s" = %s' %
(field.name().replace('"', '\\"'), value))
elif field.type() == QVariant.String:
request.setFilterExpression(
'"%s" = \'%s\'' % (field.name().replace(
'"', '\\"'), value.replace("'", "\\'")))
elif field.type() == QVariant.Date:
request.setFilterExpression(
'to_date("%s") = \'%s\'' % (field.name().replace(
'"', '\\"'), value.toString(Qt.ISODate)))
elif field.type() == QVariant.DateTime:
request.setFilterExpression(
'to_datetime("{field_name}") = \'{date_time_string}\' OR to_datetime("{field_name}") = \'{date_time_string}.000\''
.format(field_name=field.name().replace('"', '\\"'),
date_time_string=value.toString(Qt.ISODate)))
elif field.type(
) == QVariant.Bool: # This does not make any sense, but still
request.setFilterExpression(
'"%s" = %s' % (field.name().replace(
'"', '\\"'), 'true' if value else 'false'))
else: # All the other formats: let's convert to string and hope for the best
request.setFilterExpression(
'"%s" = \'%s\'' %
(field.name().replace('"', '\\"'), value.toString()))
# Exclude same feature by id
found = [
f.id() for f in layer.getFeatures(request)
if f.id() != feature.id()
]
if len(found) > 0:
_set_error(field.name(), _('Field value must be UNIQUE'))
# Check for expressions, even in case of NULL because expressions may want to check for combined
# conditions on multiple fields
expression = (field.constraints().constraintOrigin(
QgsFieldConstraints.ConstraintExpression) !=
QgsFieldConstraints.ConstraintOriginNotSet
and field.constraints().constraintStrength(
QgsFieldConstraints.ConstraintExpression)
== QgsFieldConstraints.ConstraintStrengthHard)
if expression:
constraints = field.constraints()
expression = constraints.constraintExpression()
description = constraints.constraintDescription()
value = feature.attribute(field_index)
exp = QgsExpression(expression)
context = QgsExpressionContextUtils.createFeatureBasedContext(
feature, layer.fields())
context.appendScopes(
QgsExpressionContextUtils.globalProjectLayerScopes(layer))
if not bool(exp.evaluate(context)):
if not description:
description = _('Expression check violation')
_set_error(field.name(),
_("%s Expression: %s") % (description, expression))
return errors
def fetch_values_from_layer(self): # pylint: disable=too-many-locals, too-many-branches, too-many-statements
"""
(Re)fetches plot values from the source layer.
"""
# Note: we keep things nice and efficient and only iterate a single time over the layer!
if not self.context_generator:
context = QgsExpressionContext()
context.appendScopes(
QgsExpressionContextUtils.globalProjectLayerScopes(
self.source_layer))
else:
context = self.context_generator.createExpressionContext()
# add a new scope corresponding to the source layer -- this will potentially overwrite any other
# layer scopes which may be present in the context (e.g. from atlas layers), but we need to ensure
# that source layer fields and attributes are present in the context
context.appendScope(
self.source_layer.createExpressionContextScope())
self.settings.data_defined_properties.prepare(context)
self.fetch_layout_properties(context)
def add_source_field_or_expression(field_or_expression):
field_index = self.source_layer.fields().lookupField(
field_or_expression)
if field_index == -1:
expression = QgsExpression(field_or_expression)
if not expression.hasParserError():
expression.prepare(context)
return expression, expression.needsGeometry(
), expression.referencedColumns()
return None, False, {field_or_expression}
x_expression, x_needs_geom, x_attrs = add_source_field_or_expression(self.settings.properties['x_name']) if \
self.settings.properties[
'x_name'] else (None, False, set())
y_expression, y_needs_geom, y_attrs = add_source_field_or_expression(self.settings.properties['y_name']) if \
self.settings.properties[
'y_name'] else (None, False, set())
z_expression, z_needs_geom, z_attrs = add_source_field_or_expression(self.settings.properties['z_name']) if \
self.settings.properties[
'z_name'] else (None, False, set())
additional_info_expression, additional_needs_geom, additional_attrs = add_source_field_or_expression(
self.settings.layout['additional_info_expression']
) if self.settings.layout['additional_info_expression'] else (None,
False,
set())
attrs = set().union(
self.settings.data_defined_properties.referencedFields(), x_attrs,
y_attrs, z_attrs, additional_attrs)
request = QgsFeatureRequest()
if self.settings.data_defined_properties.property(
PlotSettings.PROPERTY_FILTER).isActive():
expression = self.settings.data_defined_properties.property(
PlotSettings.PROPERTY_FILTER).asExpression()
request.setFilterExpression(expression)
request.setExpressionContext(context)
request.setSubsetOfAttributes(attrs, self.source_layer.fields())
if not x_needs_geom and not y_needs_geom and not z_needs_geom and not additional_needs_geom and not self.settings.data_defined_properties.hasActiveProperties(
):
request.setFlags(QgsFeatureRequest.NoGeometry)
visible_geom_engine = None
if self.settings.properties.get(
'visible_features_only',
False) and self.visible_region is not None:
ct = QgsCoordinateTransform(
self.visible_region.crs(), self.source_layer.crs(),
QgsProject.instance().transformContext())
try:
rect = ct.transformBoundingBox(self.visible_region)
request.setFilterRect(rect)
except QgsCsException:
pass
elif self.settings.properties.get(
'visible_features_only',
False) and self.polygon_filter is not None:
ct = QgsCoordinateTransform(
self.polygon_filter.crs(), self.source_layer.crs(),
QgsProject.instance().transformContext())
try:
rect = ct.transformBoundingBox(
self.polygon_filter.geometry.boundingBox())
request.setFilterRect(rect)
g = self.polygon_filter.geometry
g.transform(ct)
visible_geom_engine = QgsGeometry.createGeometryEngine(
g.constGet())
visible_geom_engine.prepareGeometry()
except QgsCsException:
pass
if self.selected_features_only:
it = self.source_layer.getSelectedFeatures(request)
else:
it = self.source_layer.getFeatures(request)
# Some plot types don't draw individual glyphs for each feature, but aggregate them instead.
# In that case it doesn't make sense to evaluate expressions for settings like marker size or color for each
# feature. Instead, the evaluation should be executed only once for these settings.
aggregating = self.settings.plot_type in ['box', 'histogram']
executed = False
xx = []
yy = []
zz = []
additional_hover_text = []
marker_sizes = []
colors = []
stroke_colors = []
stroke_widths = []
for f in it:
if visible_geom_engine and not visible_geom_engine.intersects(
f.geometry().constGet()):
continue
self.settings.feature_ids.append(f.id())
context.setFeature(f)
x = None
if x_expression:
x = x_expression.evaluate(context)
if x == NULL or x is None:
continue
elif self.settings.properties['x_name']:
x = f[self.settings.properties['x_name']]
if x == NULL or x is None:
continue
y = None
if y_expression:
y = y_expression.evaluate(context)
if y == NULL or y is None:
continue
elif self.settings.properties['y_name']:
y = f[self.settings.properties['y_name']]
if y == NULL or y is None:
continue
z = None
if z_expression:
z = z_expression.evaluate(context)
if z == NULL or z is None:
continue
elif self.settings.properties['z_name']:
z = f[self.settings.properties['z_name']]
if z == NULL or z is None:
continue
if additional_info_expression:
additional_hover_text.append(
additional_info_expression.evaluate(context))
elif self.settings.layout['additional_info_expression']:
additional_hover_text.append(
f[self.settings.layout['additional_info_expression']])
if x is not None:
xx.append(x)
if y is not None:
yy.append(y)
if z is not None:
zz.append(z)
if self.settings.data_defined_properties.isActive(
PlotSettings.PROPERTY_MARKER_SIZE):
default_value = self.settings.properties['marker_size']
context.setOriginalValueVariable(default_value)
value, _ = self.settings.data_defined_properties.valueAsDouble(
PlotSettings.PROPERTY_MARKER_SIZE, context, default_value)
marker_sizes.append(value)
if self.settings.data_defined_properties.isActive(
PlotSettings.PROPERTY_STROKE_WIDTH):
default_value = self.settings.properties['marker_width']
context.setOriginalValueVariable(default_value)
value, _ = self.settings.data_defined_properties.valueAsDouble(
PlotSettings.PROPERTY_STROKE_WIDTH, context, default_value)
stroke_widths.append(value)
if self.settings.data_defined_properties.isActive(
PlotSettings.PROPERTY_COLOR) and (not aggregating
or not executed):
default_value = QColor(self.settings.properties['in_color'])
value, conversion_success = self.settings.data_defined_properties.valueAsColor(
PlotSettings.PROPERTY_COLOR, context, default_value)
if conversion_success:
# We were given a valid color specification, use that color
colors.append(value.name())
else:
try:
# Attempt to interpret the value as a list of color specifications
value_list = self.settings.data_defined_properties.value(
PlotSettings.PROPERTY_COLOR, context)
color_list = [
QgsSymbolLayerUtils.decodeColor(item).name()
for item in value_list
]
colors.extend(color_list)
except TypeError:
# Not a list of color specifications, use the default color instead
colors.append(default_value.name())
if self.settings.data_defined_properties.isActive(
PlotSettings.PROPERTY_STROKE_COLOR) and (not aggregating
or not executed):
default_value = QColor(self.settings.properties['out_color'])
value, conversion_success = self.settings.data_defined_properties.valueAsColor(
PlotSettings.PROPERTY_STROKE_COLOR, context, default_value)
if conversion_success:
# We were given a valid color specification, use that color
stroke_colors.append(value.name())
else:
try:
# Attempt to interpret the value as a list of color specifications
value_list = self.settings.data_defined_properties.value(
PlotSettings.PROPERTY_STROKE_COLOR, context)
color_list = [
QgsSymbolLayerUtils.decodeColor(item).name()
for item in value_list
]
stroke_colors.extend(color_list)
except TypeError:
# Not a list of color specifications, use the default color instead
stroke_colors.append(default_value.name())
executed = True
self.settings.additional_hover_text = additional_hover_text
self.settings.x = xx
self.settings.y = yy
self.settings.z = zz
if marker_sizes:
self.settings.data_defined_marker_sizes = marker_sizes
if colors:
self.settings.data_defined_colors = colors
if stroke_colors:
self.settings.data_defined_stroke_colors = stroke_colors
if stroke_widths:
self.settings.data_defined_stroke_widths = stroke_widths
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
# Get input vector layer
vlayer = self.parameterAsVectorLayer(parameters, self.INPUT_LAYER,
context)
self.layer = vlayer
symbol_level = parameters[self.SYMBOL_LEVEL]
self.symbol_level = symbol_level
color_field = parameters[self.COLOR_FIELD]
virtual_color_field = parameters[self.VIRTUAL_COLOR_FIELD]
label_field = parameters[self.LABEL_FIELD]
virtual_label_field = parameters[self.VIRTUAL_LABEL_FIELD]
# Send some information to the user
feedback.pushInfo('Layer is {}'.format(vlayer.name()))
# Compute symbol based expressions
color_expression = self.getColorExpressionFromSymbology()
label_expression = self.getLabelExpressionFromSymbology()
if not color_expression or not label_expression:
raise QgsProcessingException(
self.
tr('Color expression or label expression cannot be generated'))
# Modify features
# Start an undo block
if color_field and label_field:
# Compute the number of steps to display within the progress bar and
# get features from source
total = 100.0 / vlayer.featureCount() if vlayer.featureCount(
) else 0
# prepare expression
exp_context = QgsExpressionContext()
exp_context.appendScopes(
QgsExpressionContextUtils.globalProjectLayerScopes(vlayer))
# color_expression = "concat('hop ', pcolor)"
color_exp = QgsExpression(color_expression)
color_idx = vlayer.fields().indexFromName(color_field)
label_exp = QgsExpression(label_expression)
label_idx = vlayer.fields().indexFromName(label_field)
vlayer.beginEditCommand('Translating all features')
features = vlayer.getFeatures(QgsFeatureRequest().setFlags(
QgsFeatureRequest.NoGeometry))
# .setSubsetOfAttributes([color_idx, label_idx]) )
for current, feature in enumerate(features):
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
break
# Edit feature
exp_context.setFeature(feature)
# color
color_val = color_exp.evaluate(exp_context)
print(color_val)
vlayer.changeAttributeValue(feature.id(), color_idx, color_val)
# label
label_val = label_exp.evaluate(exp_context)
print(label_val)
vlayer.changeAttributeValue(feature.id(), label_idx, label_val)
# Update the progress bar
feedback.setProgress(int(current * total))
if virtual_color_field:
self.createOrUpdateLayerExpressionField(virtual_color_field,
color_expression)
if virtual_label_field:
self.createOrUpdateLayerExpressionField(virtual_label_field,
label_expression)
# End the undo block
vlayer.endEditCommand()
return {self.OUTPUT: 'ok'}
def reloadData(self):
self.beginResetModel()
self._document_list = []
if self._relation.isValid() is False or self._feature.isValid(
) is False:
self.endResetModel()
return
feature_list = []
layer = self._relation.referencingLayer()
request = self._relation.getRelatedFeaturesRequest(self._feature)
for feature in layer.getFeatures(request):
feature_list.append(feature)
if self._nmRelation.isValid():
filters = []
for joinTableFeature in feature_list:
referencedFeatureRequest = self._nmRelation.getReferencedFeatureRequest(
joinTableFeature)
filterExpression = referencedFeatureRequest.filterExpression()
filters.append("(" + filterExpression.expression() + ")")
nmRequest = QgsFeatureRequest()
nmRequest.setFilterExpression(" OR ".join(filters))
feature_list = []
layer = self._nmRelation.referencedLayer()
for documentFeature in layer.getFeatures(nmRequest):
feature_list.append(documentFeature)
for documentFeature in feature_list:
documents_path = str()
if self._documents_path:
exp = QgsExpression(self._documents_path)
context = QgsExpressionContext()
context.appendScopes(
QgsExpressionContextUtils.globalProjectLayerScopes(layer))
context.setFeature(documentFeature)
documents_path = exp.evaluate(context)
document_filename = str()
if self._document_filename:
exp = QgsExpression(self._document_filename)
context = QgsExpressionContext()
context.appendScopes(
QgsExpressionContextUtils.globalProjectLayerScopes(layer))
context.setFeature(documentFeature)
document_filename = exp.evaluate(context)
file_info = QFileInfo(QDir(str(documents_path)),
str(document_filename))
# ToolTip
toolTipList = []
toolTipList.append("<ul>")
for field in documentFeature.fields():
index = documentFeature.fields().indexFromName(field.name())
toolTipList.append("<li><strong>{0}</strong>: {1}</li>".format(
field.displayName(), documentFeature[index]))
toolTipList.append("</ul>")
self._document_list.append({
self.DocumentIdRole:
documentFeature.id(),
self.DocumentPathRole:
file_info.filePath(),
self.DocumentNameRole:
file_info.fileName(),
self.DocumentExistsRole:
file_info.exists(),
self.DocumentToolTipRole:
"".join(toolTipList),
self.DocumentIsImageRole:
PreviewImageProvider.isMimeTypeSupported(file_info.filePath())
})
self.endResetModel()
def processAlgorithm(self, parameters, context: QgsProcessingContext,
feedback: QgsProcessingFeedback):
"""Here is where the processing itself takes place."""
feedback.setProgress(0)
# init params
reach_layer = self.parameterAsVectorLayer(parameters, self.REACH_LAYER,
context)
wastewater_node_layer = self.parameterAsVectorLayer(
parameters, self.WASTEWATER_NODE_LAYER, context)
value_expression = self.parameterAsExpression(parameters,
self.VALUE_EXPRESSION,
context)
reach_pk_name = self.parameterAsFields(parameters, self.REACH_PK_NAME,
context)[0]
node_pk_name = self.parameterAsFields(parameters, self.NODE_PK_NAME,
context)[0]
node_from_fk_name = self.parameterAsFields(parameters,
self.NODE_FROM_FK_NAME,
context)[0]
node_to_fk_name = self.parameterAsFields(parameters,
self.NODE_TO_FK_NAME,
context)[0]
branch_behavior = self.parameterAsEnum(parameters,
self.BRANCH_BEHAVIOR, context)
create_loop_layer = self.parameterAsBool(parameters,
self.CREATE_LOOP_LAYER,
context)
if branch_behavior == 0:
aggregate_method = lambda values: min(values) if values else 0
elif branch_behavior == 1:
aggregate_method = lambda values: max(values) if values else 0
elif branch_behavior == 2:
aggregate_method = lambda values: statistics.mean(
values) if values else 0
else:
aggregate_method = lambda values: feedback.pushError(
'Aggregate method not implemented')
# create feature sink
fields = wastewater_node_layer.fields()
fields.append(QgsField('value', QVariant.Double))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Point,
reach_layer.sourceCrs())
loop_sink = None
loop_dest_id = None
if create_loop_layer:
(loop_sink,
loop_dest_id) = self.parameterAsSink(parameters, self.LOOP_OUTPUT,
context, fields,
QgsWkbTypes.Point,
reach_layer.sourceCrs())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
feature_count = reach_layer.featureCount()
reaches_by_from_node = dict()
reaches_by_id = dict()
expression = QgsExpression(value_expression)
context = QgsExpressionContext(
QgsExpressionContextUtils.globalProjectLayerScopes(reach_layer))
expression.prepare(context)
progress = 0
feedback.setProgressText(self.tr('Indexing reaches'))
for reach in reach_layer.getFeatures(QgsFeatureRequest()):
if reach[node_from_fk_name] == NULL:
continue
context.setFeature(reach)
value = expression.evaluate(context)
reach_obj = Reach(reach[node_from_fk_name], reach[node_to_fk_name],
value, reach.geometry())
reaches_by_from_node.setdefault(reach_obj.from_id,
[]).append(reach_obj)
reaches_by_id[reach[reach_pk_name]] = reach_obj
feedback.setProgress(progress / feature_count * 10)
progress += 1
loop_nodes = []
current_feature = 0
calculated_values = {}
feedback.setProgressText(self.tr('Analyzing network'))
for node in wastewater_node_layer.getFeatures():
from_node_id = node[node_pk_name]
processed_nodes = []
times = []
if from_node_id in reaches_by_from_node.keys():
for reach in reaches_by_from_node[from_node_id]:
times.append(
self.calculate_branch(reach, reaches_by_from_node,
reaches_by_id,
list(processed_nodes),
calculated_values,
aggregate_method, loop_nodes,
feedback))
if times:
time = aggregate_method(times)
else:
time = 0
current_feature += 1
calculated_values[node[node_pk_name]] = time
new_node = QgsFeature(node)
new_node.setFields(fields)
new_node.setAttributes(node.attributes() + [time])
sink.addFeature(new_node, QgsFeatureSink.FastInsert)
if create_loop_layer and from_node_id in loop_nodes:
loop_sink.addFeature(node, QgsFeatureSink.FastInsert)
feedback.setProgress(10 + current_feature / feature_count * 90)
result = {self.OUTPUT: dest_id}
if create_loop_layer:
result[self.LOOP_OUTPUT] = loop_dest_id
return result
def create_mesure_layer(self):
""" Create an temporary point layer in the Qgis canvas """
try:
QApplication.setOverrideCursor(
Qt.WaitCursor) ## Start the 'wait' cursor
if self.list_mesures:
vl = QgsVectorLayer("Linestring?crs=" + self.selected_epsg,
self.layer_name, "memory")
pr = vl.dataProvider()
# add fields
pr.addAttributes([
QgsField("station", QVariant.String),
QgsField("st_num", QVariant.Int),
QgsField("st_y", QVariant.Double, "double", 12, 4),
QgsField("st_x", QVariant.Double, "double", 12, 4),
QgsField("st_h", QVariant.Double, "double", 10, 4),
QgsField("st_hi", QVariant.Double),
QgsField("vise", QVariant.String),
QgsField("vise_y", QVariant.Double, "double", 12, 4),
QgsField("vise_x", QVariant.Double, "double", 12, 4),
QgsField("vise_h", QVariant.Double, "double", 10, 4),
QgsField("vise_hs", QVariant.Double),
QgsField("vise_category", QVariant.Int),
QgsField("dhz", QVariant.Double),
QgsField("dh", QVariant.Double)
])
vl.updateFields(
) # tell the vector layer to fetch changes from the provider
# add features
for item in self.list_mesures:
st_y = float(item[2])
st_x = float(item[3])
vise_y = float(item[7])
vise_x = float(item[8])
fet = QgsFeature()
fet.setGeometry(
QgsGeometry.fromPolyline(
[QgsPoint(st_y, st_x),
QgsPoint(vise_y, vise_x)]))
fet.setAttributes(list(item))
pr.addFeatures([fet])
# Calculate the "dhz" and "dh" columns
expression1 = QgsExpression(
"round((sqrt((st_y - vise_y)^2 + (st_x - vise_x)^2)), 3)")
expression2 = QgsExpression(
"round((vise_h + vise_hs - st_h - st_hi), 3)")
context = QgsExpressionContext()
context.appendScopes(
QgsExpressionContextUtils.globalProjectLayerScopes(vl))
vl.startEditing()
for f in vl.getFeatures():
context.setFeature(f)
f["dhz"] = expression1.evaluate(context)
f["dh"] = expression2.evaluate(context)
vl.updateFeature(f)
vl.commitChanges()
# add preconfigured qgis.qml style file
plugin_folder = os.path.dirname(os.path.dirname(__file__))
qml_file = Path(plugin_folder) / "qml" / self.qml_style_mesure
if qml_file.is_file(
): # Test if file exist, avoid error if he is missing
vl.loadNamedStyle(str(qml_file))
# update layer's extent when new features have been added
vl.updateExtents()
# zoom to the layer extent
canvas = iface.mapCanvas()
canvas.setExtent(vl.extent())
# Show in project
self.rmv_old_qgs_mesure_layer()
QgsProject.instance().addMapLayer(vl)
except:
print(
"Mesures -> Failed to create a new measurements Qgis layer (def create_mesure_layer)"
)
QApplication.restoreOverrideCursor() ## Stop the 'wait' cursor
finally:
QApplication.restoreOverrideCursor() ## Stop the 'wait' cursor
