def get_feature_value(self, model=None):
self.layer.startEditing()
feature = None
request = QgsFeatureRequest()
if model is None:
model = self.host.model()
request.setFilterFid(model.id)
feature_itr = self.layer.getFeatures(request)
for feat in feature_itr:
feature = feat
break
exp = QgsExpression(self.column.expression)
if exp.hasParserError():
raise Exception(exp.parserErrorString())
exp.prepare(self.layer.pendingFields())
if feature is not None:
value = exp.evaluate(feature)
return value
else:
return None
def layer_value(feature, layer, defaultconfig):
layername = defaultconfig['layer']
expression = defaultconfig['expression']
field = defaultconfig['field']
searchlayer = QgsMapLayerRegistry.instance().mapLayersByName(layername)[0]
if feature.geometry():
rect = feature.geometry().boundingBox()
if layer.geometryType() == QGis.Point:
point = feature.geometry().asPoint()
rect = QgsRectangle(point.x(), point.y(), point.x() + 10, point.y() + 10)
else:
rect.scale(20)
rect = canvas.mapRenderer().mapToLayerCoordinates(layer, rect)
rq = QgsFeatureRequest().setFilterRect(rect)\
.setFlags(QgsFeatureRequest.ExactIntersect)
features = searchlayer.getFeatures(rq)
else:
features = searchlayer.getFeatures()
exp = QgsExpression(expression)
exp.prepare(searchlayer.pendingFields())
for f in features:
if exp.evaluate(f):
return f[field]
raise DefaultError('No features found')
def add_flooded_field(self, shapefile_path):
"""Create the layer from the local shp adding the flooded field.
.. versionadded:: 3.3
Use this method to add a calculated field to a shapefile. The shapefile
should have a field called 'count' containing the number of flood
reports for the field. The field values will be set to 0 if the count
field is < 1, otherwise it will be set to 1.
:param shapefile_path: Path to the shapefile that will have the flooded
field added.
:type shapefile_path: basestring
:return: A vector layer with the flooded field added.
:rtype: QgsVectorLayer
"""
layer = QgsVectorLayer(
shapefile_path, self.tr('Jakarta Floods'), 'ogr')
# Add a calculated field indicating if a poly is flooded or not
# from PyQt4.QtCore import QVariant
layer.startEditing()
field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([field])
layer.commitChanges()
layer.startEditing()
idx = layer.fieldNameIndex('flooded')
expression = QgsExpression('state > 0')
expression.prepare(layer.pendingFields())
for feature in layer.getFeatures():
feature[idx] = expression.evaluate(feature)
layer.updateFeature(feature)
layer.commitChanges()
return layer
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
layer = self.parameterAsVectorLayer(parameters, self.INPUT, context)
field_name = self.parameterAsString(parameters, self.FIELD_NAME, context)
field_type = self.TYPES[self.parameterAsEnum(parameters, self.FIELD_TYPE, context)]
width = self.parameterAsInt(parameters, self.FIELD_LENGTH, context)
precision = self.parameterAsInt(parameters, self.FIELD_PRECISION, context)
new_field = self.parameterAsBool(parameters, self.NEW_FIELD, context)
formula = self.parameterAsString(parameters, self.FORMULA, context)
expression = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(source.sourceCrs(), context.transformContext())
da.setEllipsoid(context.project().ellipsoid())
expression.setGeomCalculator(da)
expression.setDistanceUnits(context.project().distanceUnits())
expression.setAreaUnits(context.project().areaUnits())
fields = source.fields()
field_index = fields.lookupField(field_name)
if new_field or field_index < 0:
fields.append(QgsField(field_name, field_type, '', width, precision))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, source.wkbType(), source.sourceCrs())
exp_context = self.createExpressionContext(parameters, context)
if layer is not None:
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
expression.prepare(exp_context)
features = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(features):
if feedback.isCanceled():
break
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = expression.evaluate(exp_context)
if expression.hasEvalError():
feedback.reportError(expression.evalErrorString())
else:
attrs = f.attributes()
if new_field or field_index < 0:
attrs.append(value)
else:
attrs[field_index] = value
f.setAttributes(attrs)
sink.addFeature(f, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def where(layer, exp):
exp = QgsExpression(exp)
if exp.hasParserError():
raise Exception(exp.parserErrorString())
exp.prepare(layer.pendingFields())
for feature in layer.getFeatures():
value = exp.evaluate(feature)
if exp.hasEvalError():
raise ValueError(exp.evalErrorString())
if bool(value):
yield feature
def layer_value(feature, layer, defaultconfig):
if not canvas:
roam.utils.warning("No canvas set for using layer_values default function")
return None
layers = []
# layer name can also be a list of layers to search
layername = defaultconfig['layer']
if isinstance(layername, basestring):
layers.append(layername)
else:
layers = layername
expression = defaultconfig['expression']
field = defaultconfig['field']
for searchlayer in layers:
try:
searchlayer = QgsMapLayerRegistry.instance().mapLayersByName(searchlayer)[0]
except IndexError:
RoamEvents.raisemessage("Missing layer",
"Unable to find layer used in widget expression {}".format(searchlayer),
level=1)
roam.utils.warning("Unable to find expression layer {}".format(searchlayer))
return
if feature.geometry():
rect = feature.geometry().boundingBox()
if layer.geometryType() == QGis.Point:
point = feature.geometry().asPoint()
rect = QgsRectangle(point.x(), point.y(), point.x() + 10, point.y() + 10)
rect.scale(20)
rect = canvas.mapRenderer().mapToLayerCoordinates(layer, rect)
rq = QgsFeatureRequest().setFilterRect(rect)\
.setFlags(QgsFeatureRequest.ExactIntersect)
features = searchlayer.getFeatures(rq)
else:
features = searchlayer.getFeatures()
exp = QgsExpression(expression)
exp.prepare(searchlayer.pendingFields())
if exp.hasParserError():
error = exp.parserErrorString()
roam.utils.warning(error)
for f in features:
value = exp.evaluate(f)
if exp.hasEvalError():
error = exp.evalErrorString()
roam.utils.warning(error)
if value:
return f[field]
raise DefaultError('No features found')
def __call__(self, features):
func = self.filterfunc
if not hasattr(self.filterfunc, '__call__'):
exp = QgsExpression(self.filterfunc)
fields = self.layer.pendingFields()
exp.prepare(fields)
func = exp.evaluate
# Return a generator of features that match the given where check.
for f in features:
if func(f):
yield f
def sum_fields(layer, output_field_key, input_fields):
"""Sum the value of input_fields and put it as output_field.
:param layer: The vector layer.
:type layer: QgsVectorLayer
:param output_field_key: The output field definition key.
:type output_field_key: basestring
:param input_fields: List of input fields' name.
:type input_fields: list
"""
field_definition = definition(output_field_key)
output_field_name = field_definition['field_name']
# If the fields only has one element
if len(input_fields) == 1:
# Name is different, copy it
if input_fields[0] != output_field_name:
to_rename = {input_fields[0]: output_field_name}
# We copy only, it will be deleted later.
# We can't rename the field, we need to copy it as the same
# field might be used many times in the FMT tool.
copy_fields(layer, to_rename)
else:
# Name is same, do nothing
return
else:
# Creating expression
# Put field name in a double quote. See #4248
input_fields = ['"%s"' % f for f in input_fields]
string_expression = ' + '.join(input_fields)
sum_expression = QgsExpression(string_expression)
context = QgsExpressionContext()
context.setFields(layer.fields())
sum_expression.prepare(context)
# Get the output field index
output_idx = layer.fields().lookupField(output_field_name)
# Output index is not found
layer.startEditing()
if output_idx == -1:
output_field = create_field_from_definition(field_definition)
layer.addAttribute(output_field)
output_idx = layer.fields().lookupField(output_field_name)
# Iterate to all features
for feature in layer.getFeatures():
context.setFeature(feature)
result = sum_expression.evaluate(context)
feature[output_idx] = result
layer.updateFeature(feature)
layer.commitChanges()
def processAlgorithm(self, progress):
fileName = self.getParameterValue(self.INPUT)
layer = dataobjects.getObjectFromUri(fileName)
fieldName = self.getParameterValue(self.FIELD)
operator = self.OPERATORS[self.getParameterValue(self.OPERATOR)]
value = self.getParameterValue(self.VALUE)
fields = layer.pendingFields()
idx = layer.fieldNameIndex(fieldName)
fieldType = fields[idx].type()
if fieldType != QVariant.String and operator in self.OPERATORS[-2:]:
op = ''.join(['"%s", ' % o for o in self.OPERATORS[-2:]])
raise GeoAlgorithmExecutionException(
self.tr('Operators %s can be used only with string fields.' % op))
if fieldType in [QVariant.Int, QVariant.Double]:
progress.setInfo(self.tr('Numeric field'))
expr = '"%s" %s %s' % (fieldName, operator, value)
progress.setInfo(expr)
elif fieldType == QVariant.String:
progress.setInfo(self.tr('String field'))
if operator not in self.OPERATORS[-2:]:
expr = """"%s" %s '%s'""" % (fieldName, operator, value)
elif operator == 'begins with':
expr = """"%s" LIKE '%s%%'""" % (fieldName, value)
elif operator == 'contains':
expr = """"%s" LIKE '%%%s%%'""" % (fieldName, value)
progress.setInfo(expr)
elif fieldType in [QVariant.Date, QVariant.DateTime]:
progress.setInfo(self.tr('Date field'))
expr = """"%s" %s '%s'""" % (fieldName, operator, value)
progress.setInfo(expr)
else:
raise GeoAlgorithmExecutionException(
self.tr('Unsupported field type "%s"' % fields[idx].typeName()))
expression = QgsExpression(expr)
expression.prepare(fields)
features = vector.features(layer)
selected = []
count = len(features)
total = 100.0 / float(count)
for count, f in enumerate(features):
if expression.evaluate(f, fields):
selected.append(f.id())
progress.setPercentage(int(count * total))
layer.setSelectedFeatures(selected)
self.setOutputValue(self.OUTPUT, fileName)
def sum_fields(layer, output_field_key, input_fields):
"""Sum the value of input_fields and put it as output_field.
:param layer: The vector layer.
:type layer: QgsVectorLayer
:param output_field_key: The output field definition key.
:type output_field_key: basestring
:param input_fields: List of input fields' name.
:type input_fields: list
"""
field_definition = definition(output_field_key)
output_field_name = field_definition['field_name']
# If the fields only has one element
if len(input_fields) == 1:
# Name is different, copy it
if input_fields[0] != output_field_name:
copy_fields(layer, {
input_fields[0]: output_field_name})
# Name is same, do nothing
else:
return
else:
# Creating expression
# Put field name in a double quote. See #4248
input_fields = ['"%s"' % f for f in input_fields]
string_expression = ' + '.join(input_fields)
sum_expression = QgsExpression(string_expression)
context = QgsExpressionContext()
context.setFields(layer.pendingFields())
sum_expression.prepare(context)
# Get the output field index
output_idx = layer.fieldNameIndex(output_field_name)
# Output index is not found
if output_idx == -1:
output_field = create_field_from_definition(field_definition)
layer.startEditing()
layer.addAttribute(output_field)
layer.commitChanges()
output_idx = layer.fieldNameIndex(output_field_name)
layer.startEditing()
# Iterate to all features
for feature in layer.getFeatures():
context.setFeature(feature)
result = sum_expression.evaluate(context)
feature[output_idx] = result
layer.updateFeature(feature)
layer.commitChanges()
def add_flooded_field(self, shapefile_path):
"""Create the layer from the local shp adding the flooded field.
.. versionadded:: 3.3
Use this method to add a calculated field to a shapefile. The shapefile
should have a field called 'count' containing the number of flood
reports for the field. The field values will be set to 0 if the count
field is < 1, otherwise it will be set to 1.
:param shapefile_path: Path to the shapefile that will have the flooded
field added.
:type shapefile_path: basestring
:return: A vector layer with the flooded field added.
:rtype: QgsVectorLayer
"""
layer = QgsVectorLayer(
shapefile_path, self.tr('Jakarta Floods'), 'ogr')
# Add a calculated field indicating if a poly is flooded or not
# from qgis.PyQt.QtCore import QVariant
layer.startEditing()
# Add field with integer from 0 to 4 which represents the flood
# class. Its the same as 'state' field except that is being treated
# as a string.
# This is used for cartography
flood_class_field = QgsField('floodclass', QVariant.Int)
layer.addAttribute(flood_class_field)
layer.commitChanges()
layer.startEditing()
flood_class_idx = layer.fields().lookupField('floodclass')
flood_class_expression = QgsExpression('to_int(state)')
context = QgsExpressionContext()
context.setFields(layer.fields())
flood_class_expression.prepare(context)
# Add field with boolean flag to say if the area is flooded
# This is used by the impact function
flooded_field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([flooded_field])
layer.commitChanges()
layer.startEditing()
flooded_idx = layer.fields().lookupField('flooded')
flood_flag_expression = QgsExpression('state > 0')
flood_flag_expression.prepare(context)
for feature in layer.getFeatures():
context.setFeature(feature)
feature[flood_class_idx] = flood_class_expression.evaluate(context)
feature[flooded_idx] = flood_flag_expression.evaluate(context)
layer.updateFeature(feature)
layer.commitChanges()
return layer
def _buildfromlayer(self, widget, layerconfig):
layername = layerconfig['layer']
keyfield = layerconfig['key']
valuefield = layerconfig['value']
filterexp = layerconfig.get('filter', None)
try:
layer = QgsMapLayerRegistry.instance().mapLayersByName(layername)[0]
except IndexError:
roam.utils.warning("Can't find layer {} in project".format(layername))
return
keyfieldindex = layer.fieldNameIndex(keyfield)
valuefieldindex = layer.fieldNameIndex(valuefield)
if keyfieldindex == -1 or valuefieldindex == -1:
roam.utils.warning("Can't find key or value column")
return
if not filterexp and valuefieldindex == keyfieldindex:
values = layer.uniqueValues(keyfieldindex)
for value in values:
widget.addItem(value, value)
return
attributes = {keyfieldindex, valuefieldindex}
flags = QgsFeatureRequest.NoGeometry
expression = None
if filterexp:
expression = QgsExpression(filterexp)
expression.prepare(layer.pendingFields())
if expression.hasParserError():
roam.utils.warning("Expression has parser error: {}".format(expression.parserErrorString()))
return
if expression.needsGeometry():
flags = QgsFeatureRequest.NoFlags
for field in expression.referencedColumns():
index = layer.fieldNameIndex(field)
attributes.add(index)
values = set()
request = QgsFeatureRequest().setFlags(flags).setSubsetOfAttributes(list(attributes))
for feature in layer.getFeatures(request):
if expression and not expression.evaluate(feature):
continue
widget.addItem(feature[keyfieldindex], feature[valuefield])
if self.allownulls:
widget.insertItem(0, '(no selection)', None)
def calculate( self, layer, fieldName, expression ):
if ( layer.featureCount() == 0 ):
self.msg.show( "[Info] * No existing features on layer " + layer.name() + " to calculate expression.", 'info', True )
return
expression = QgsExpression( expression )
if expression.hasParserError():
self.msg.show( QApplication.translate( "AutoFields-FieldCalculator", "[Error] (Parsing) " ) + \
expression.parserErrorString(), 'critical' )
return
context = QgsExpressionContext()
context.appendScope( QgsExpressionContextUtils.globalScope() )
context.appendScope( QgsExpressionContextUtils.projectScope() )
context.appendScope( QgsExpressionContextUtils.layerScope( layer ) )
context.setFields( layer.fields() )
if expression.needsGeometry():
if self.iface:
# This block was borrowed from QGIS/python/plugins/processing/algs/qgis/FieldsCalculator.py
da = QgsDistanceArea()
da.setSourceCrs( layer.crs().srsid() )
da.setEllipsoidalMode( self.iface.mapCanvas().mapSettings().hasCrsTransformEnabled() )
da.setEllipsoid( QgsProject.instance().readEntry( 'Measure', '/Ellipsoid', GEO_NONE )[0] )
expression.setGeomCalculator( da )
if QGis.QGIS_VERSION_INT >= 21400: # Methods added in QGIS 2.14
expression.setDistanceUnits( QgsProject.instance().distanceUnits() )
expression.setAreaUnits( QgsProject.instance().areaUnits() )
expression.prepare( context )
fieldIndex = layer.fieldNameIndex( fieldName )
if fieldIndex == -1:
return
field = layer.fields()[fieldIndex]
dictResults = {}
for feature in layer.getFeatures():
context.setFeature( feature )
result = expression.evaluate( context )
if expression.hasEvalError():
self.msg.show( QApplication.translate( "AutoFields-FieldCalculator", "[Error] (Evaluating) " ) + \
expression.evalErrorString(), 'critical' )
return
dictResults[feature.id()] = { fieldIndex: field.convertCompatible( result ) }
layer.dataProvider().changeAttributeValues( dictResults )
self.msg.show( "[Info] * An expression was calculated on existing features of layer " + layer.name() + ", field " + fieldName + ".", 'info', True )
def _features_select(self):
"""
Generator function that returns features based on user-defined
expression.
"""
exp = QgsExpression(self.expressionText())
if exp.hasParserError():
raise Exception(exp.parserErrorString())
exp.prepare(self._ref_layer.pendingFields())
for f in self._ref_layer.getFeatures():
value = exp.evaluate(f)
if bool(value):
yield f
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
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()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
if not expression.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % 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: %s' % 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)
progress.setPercentage(int(current * total))
del writer
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
expression_string = self.parameterAsExpression(parameters, self.EXPRESSION, context)
(matching_sink, matching_sink_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
source.fields(), source.wkbType(), source.sourceCrs())
(nonmatching_sink, non_matching_sink_id) = self.parameterAsSink(parameters, self.FAIL_OUTPUT, context,
source.fields(), source.wkbType(), source.sourceCrs())
expression = QgsExpression(expression_string)
if expression.hasParserError():
raise GeoAlgorithmExecutionException(expression.parserErrorString())
expression_context = self.createExpressionContext(parameters, context)
if not nonmatching_sink:
# not saving failing features - so only fetch good features
req = QgsFeatureRequest().setFilterExpression(expression_string)
req.setExpressionContext(expression_context)
for f in source.getFeatures(req):
if feedback.isCanceled():
break
matching_sink.addFeature(f)
else:
# saving non-matching features, so we need EVERYTHING
expression_context.setFields(source.fields())
expression.prepare(expression_context)
total = 100.0 / source.featureCount()
for current, f in enumerate(source.getFeatures()):
if feedback.isCanceled():
break
expression_context.setFeature(f)
if expression.evaluate(expression_context):
matching_sink.addFeature(f)
else:
nonmatching_sink.addFeature(f)
feedback.setProgress(int(current * total))
results = {self.OUTPUT: matching_sink_id}
if nonmatching_sink:
results[self.FAIL_OUTPUT] = non_matching_sink_id
return results
def __call__(self, features):
"""
Each feature is evaluated against filterfunc and if true will
be returned from this function.
Features are returned using a generator to avoid memory issues.
"""
func = self.filterfunc
if not hasattr(self.filterfunc, '__call__'):
exp = QgsExpression(self.filterfunc)
fields = self.layer.pendingFields()
exp.prepare(fields)
func = exp.evaluate
# Return a generator of features that match the given where check.
for f in features:
if func(f):
yield f
def _layer_tooltip(self, layer, feat):
try:
df = layer.displayField()
if df:
return str(feat.attribute(df))
else:
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope(QgsProject.instance()))
context.appendScope(QgsExpressionContextUtils.layerScope(layer))
context.appendScope(QgsExpressionContextUtils.mapSettingsScope( self.canvas.mapSettings() ) )
context.setFeature( feat )
x = QgsExpression(layer.displayExpression())
x.prepare(context)
return x.evaluate(context).replace('\n', "<br/>")
except:
return ""
def setAxisDataFromLayer(self, axis, **kwargs):
'''
Get data in plot.ly format from layer
'''
layer = self.plot_layer
data = None
if 'expression' in kwargs:
exp = QgsExpression(kwargs['expression'])
if not exp.hasParserError():
exp.prepare(layer.pendingFields())
data = [ exp.evaluate(feat) for feat in layer.getFeatures() ]
else:
return False
if 'fieldName' in kwargs:
data = [feat[kwargs['fieldName']] for feat in layer.getFeatures() ]
self.plot_data[axis] = data
class PyFeatureSource(QgsAbstractFeatureSource):
def __init__(self, provider):
super(PyFeatureSource, self).__init__()
self._provider = provider
self._features = provider._features
self._expression_context = QgsExpressionContext()
self._expression_context.appendScope(QgsExpressionContextUtils.globalScope())
self._expression_context.appendScope(QgsExpressionContextUtils.projectScope(QgsProject.instance()))
self._expression_context.setFields(self._provider.fields())
if self._provider.subsetString():
self._subset_expression = QgsExpression(self._provider.subsetString())
self._subset_expression.prepare(self._expression_context)
else:
self._subset_expression = None
def getFeatures(self, request):
return QgsFeatureIterator(PyFeatureIterator(self, request))
def layer_value(feature, layer, defaultconfig):
layername = defaultconfig['layer']
expression = defaultconfig['expression']
field = defaultconfig['field']
searchlayer = QgsMapLayerRegistry.instance().mapLayersByName(layername)[0]
rect = feature.geometry().boundingBox()
rect.scale(10)
rect = canvas.mapRenderer().mapToLayerCoordinates(layer, rect)
rq = QgsFeatureRequest().setFilterRect(rect)
features = searchlayer.getFeatures(rq)
exp = QgsExpression(expression)
exp.prepare(searchlayer.pendingFields())
for f in features:
if exp.evaluate(f):
return f[field]
raise DefaultError('No features found')
def testExpression(self, row):
self._errors[row] = None
field = self._mapping[row]
exp_context = self.contextGenerator().createExpressionContext()
expression = QgsExpression(field['expression'])
expression.prepare(exp_context)
if expression.hasParserError():
self._errors[row] = expression.parserErrorString()
return
# test evaluation on the first feature
if self._layer is None:
return
for feature in self._layer.getFeatures():
exp_context.setFeature(feature)
exp_context.lastScope().setVariable("row_number", 1)
expression.evaluate(exp_context)
if expression.hasEvalError():
self._errors[row] = expression.evalErrorString()
break
def layer_value(feature, layer, defaultconfig):
if not canvas:
roam.utils.warning("No canvas set for using layer_values default function")
return None
layers = []
# layer name can also be a list of layers to search
layername = defaultconfig['layer']
if isinstance(layername, basestring):
layers.append(layername)
else:
layers = layername
expression = defaultconfig['expression']
field = defaultconfig['field']
for searchlayer in layers:
searchlayer = QgsMapLayerRegistry.instance().mapLayersByName(searchlayer)[0]
if feature.geometry():
rect = feature.geometry().boundingBox()
if layer.geometryType() == QGis.Point:
point = feature.geometry().asPoint()
rect = QgsRectangle(point.x(), point.y(), point.x() + 10, point.y() + 10)
else:
rect.scale(20)
rect = canvas.mapRenderer().mapToLayerCoordinates(layer, rect)
rq = QgsFeatureRequest().setFilterRect(rect)\
.setFlags(QgsFeatureRequest.ExactIntersect)
features = searchlayer.getFeatures(rq)
else:
features = searchlayer.getFeatures()
exp = QgsExpression(expression)
exp.prepare(searchlayer.pendingFields())
for f in features:
if exp.evaluate(f):
return f[field]
raise DefaultError('No features found')
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)
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(), context)
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 = QgsProcessingUtils.getFeatures(layer, context)
total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
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 selectionChanged(self):
self.cleanBrowserFields()
self.rubber.reset()
nItems = self.layer.selectedFeatureCount()
if nItems < 2:
self.close()
self.layer.emit(SIGNAL("browserNoItem()"))
return
self.browseFrame.setEnabled(True)
subset = self.layer.selectedFeaturesIds()
if self.settings.value("saveSelectionInProject"):
self.layer.setCustomProperty("itemBrowserSelection", repr(subset))
f = QgsFeature()
title = QgsExpression(self.layer.displayExpression())
title.prepare(self.layer.pendingFields())
iterator = self.layer.getFeatures(QgsFeatureRequest().setFilterFids(subset))
while iterator.nextFeature(f):
result = title.evaluate(f)
if title.hasEvalError():
self.listCombo.addItem("%u" % f.id(), f.id())
else:
self.listCombo.addItem("%s" % result, f.id())
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)
if output.value == '':
ext = output.getDefaultFileExtension(self)
output.value = system.getTempFilenameInTempFolder(output.name +
'.' + ext)
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()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
if not exp.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
# add layer to registry to fix https://issues.qgis.org/issues/17300
# it is necessary only for aggregate expressions that verify that layer
# is registered
removeRegistryAfterEvaluation = False
if not QgsMapLayerRegistry.instance().mapLayer(layer.id()):
removeRegistryAfterEvaluation = True
QgsMapLayerRegistry.instance().addMapLayer(layer,
addToLegend=False)
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = vector.features(layer)
total = 100.0 / len(features) if len(features) > 0 else 1
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
# remove from registry if added for expression requirement
# see above comment about fix #17300
if removeRegistryAfterEvaluation:
QgsMapLayerRegistry.instance().removeMapLayer(layer)
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n%s' % error))
def print_layout(project,
layout_name,
feature_filter: str = None,
scales=None,
scale=None,
**kwargs):
"""Generate a PDF for an atlas or a report.
:param project: The QGIS project.
:type project: QgsProject
:param layout_name: Name of the layout of the atlas or report.
:type layout_name: basestring
:param feature_filter: QGIS Expression to use to select the feature.
It can return many features, a multiple pages PDF will be returned.
This is required to print atlas, not report
:type feature_filter: basestring
:param scale: A scale to force in the atlas context. Default to None.
:type scale: int
:param scales: A list of predefined list of scales to force in the atlas context.
Default to None.
:type scales: list
:return: Path to the PDF.
:rtype: basestring
"""
canvas = QgsMapCanvas()
bridge = QgsLayerTreeMapCanvasBridge(project.layerTreeRoot(), canvas)
bridge.setCanvasLayers()
manager = project.layoutManager()
master_layout = manager.layoutByName(layout_name)
settings = QgsLayoutExporter.PdfExportSettings()
atlas = None
atlas_layout = None
report_layout = None
logger = Logger()
if not master_layout:
raise AtlasPrintException('Layout `{}` not found'.format(layout_name))
if master_layout.layoutType() == QgsMasterLayoutInterface.PrintLayout:
for _print_layout in manager.printLayouts():
if _print_layout.name() == layout_name:
atlas_layout = _print_layout
break
atlas = atlas_layout.atlas()
if not atlas.enabled():
raise AtlasPrintException('The layout is not enabled for an atlas')
layer = atlas.coverageLayer()
if feature_filter is None:
raise AtlasPrintException(
'EXP_FILTER is mandatory to print an atlas layout')
feature_filter = optimize_expression(layer, feature_filter)
expression = QgsExpression(feature_filter)
if expression.hasParserError():
raise AtlasPrintException(
'Expression is invalid, parser error: {}'.format(
expression.parserErrorString()))
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope(project))
context.appendScope(
QgsExpressionContextUtils.layoutScope(atlas_layout))
context.appendScope(QgsExpressionContextUtils.atlasScope(atlas))
context.appendScope(QgsExpressionContextUtils.layerScope(layer))
expression.prepare(context)
if expression.hasEvalError():
raise AtlasPrintException(
'Expression is invalid, eval error: {}'.format(
expression.evalErrorString()))
atlas.setFilterFeatures(True)
atlas.setFilterExpression(feature_filter)
if scale:
atlas_layout.referenceMap().setAtlasScalingMode(
QgsLayoutItemMap.Fixed)
atlas_layout.referenceMap().setScale(scale)
if scales:
atlas_layout.referenceMap().setAtlasScalingMode(
QgsLayoutItemMap.Predefined)
if Qgis.QGIS_VERSION_INT >= 30900:
settings.predefinedMapScales = scales
else:
atlas_layout.reportContext().setPredefinedScales(scales)
if not scales and atlas_layout.referenceMap().atlasScalingMode(
) == QgsLayoutItemMap.Predefined:
if Qgis.QGIS_VERSION_INT >= 30900:
use_project = project.useProjectScales()
map_scales = project.mapScales()
else:
map_scales = project_scales(project)
use_project = len(map_scales) == 0
if not use_project or len(map_scales) == 0:
logger.info(
'Map scales not found in project, fetching predefined map scales in global config'
)
map_scales = global_scales()
if Qgis.QGIS_VERSION_INT >= 30900:
settings.predefinedMapScales = map_scales
else:
atlas_layout.reportContext().setPredefinedScales(map_scales)
elif master_layout.layoutType() == QgsMasterLayoutInterface.Report:
report_layout = master_layout
else:
raise AtlasPrintException('The layout is not supported by the plugin')
for key, value in kwargs.items():
found = False
if atlas_layout:
item = atlas_layout.itemById(key.lower())
if isinstance(item, QgsLayoutItemLabel):
item.setText(value)
found = True
logger.info(
'Additional parameters: {} found in layout {}, value {}'.format(
key, found, value))
export_path = os.path.join(
tempfile.gettempdir(), '{}_{}.pdf'.format(clean_string(layout_name),
uuid4()))
result, error = QgsLayoutExporter.exportToPdf(atlas or report_layout,
export_path, settings)
if result != QgsLayoutExporter.Success:
raise Exception('Export not generated in QGIS exporter {} : {}'.format(
export_path, error))
if not os.path.isfile(export_path):
raise Exception(
'Export OK from QGIS, but file not found on the file system : {}'.
format(export_path))
return export_path
class GeometryByExpression(QgisFeatureBasedAlgorithm):
OUTPUT_GEOMETRY = 'OUTPUT_GEOMETRY'
WITH_Z = 'WITH_Z'
WITH_M = 'WITH_M'
EXPRESSION = 'EXPRESSION'
def group(self):
return self.tr('Vector geometry')
def groupId(self):
return 'vectorgeometry'
def __init__(self):
super().__init__()
self.geometry_types = [self.tr('Polygon'), 'Line', 'Point']
def initParameters(self, config=None):
self.addParameter(
QgsProcessingParameterEnum(self.OUTPUT_GEOMETRY,
self.tr('Output geometry type'),
options=self.geometry_types,
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(
self.WITH_Z,
self.tr('Output geometry has z dimension'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.WITH_M,
self.tr('Output geometry has m values'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterExpression(self.EXPRESSION,
self.tr("Geometry expression"),
defaultValue='$geometry',
parentLayerParameterName='INPUT'))
def name(self):
return 'geometrybyexpression'
def displayName(self):
return self.tr('Geometry by expression')
def outputName(self):
return self.tr('Modified geometry')
def prepareAlgorithm(self, parameters, context, feedback):
self.geometry_type = self.parameterAsEnum(parameters,
self.OUTPUT_GEOMETRY,
context)
self.wkb_type = None
if self.geometry_type == 0:
self.wkb_type = QgsWkbTypes.Polygon
elif self.geometry_type == 1:
self.wkb_type = QgsWkbTypes.LineString
else:
self.wkb_type = QgsWkbTypes.Point
if self.parameterAsBool(parameters, self.WITH_Z, context):
self.wkb_type = QgsWkbTypes.addZ(self.wkb_type)
if self.parameterAsBool(parameters, self.WITH_M, context):
self.wkb_type = QgsWkbTypes.addM(self.wkb_type)
self.expression = QgsExpression(
self.parameterAsString(parameters, self.EXPRESSION, context))
if self.expression.hasParserError():
feedback.reportError(self.expression.parserErrorString())
return False
self.expression_context = self.createExpressionContext(
parameters, context)
self.expression.prepare(self.expression_context)
return True
def outputWkbType(self, input_wkb_type):
return self.wkb_type
def inputLayerTypes(self):
return [QgsProcessing.TypeVector]
def sourceFlags(self):
return QgsProcessingFeatureSource.FlagSkipGeometryValidityChecks
def processFeature(self, feature, context, feedback):
self.expression_context.setFeature(feature)
value = self.expression.evaluate(self.expression_context)
if self.expression.hasEvalError():
raise QgsProcessingException(
self.tr('Evaluation error: {0}').format(
self.expression.evalErrorString()))
if not value:
feature.setGeometry(QgsGeometry())
else:
if not isinstance(value, QgsGeometry):
raise QgsProcessingException(
self.tr('{} is not a geometry').format(value))
feature.setGeometry(value)
return [feature]
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 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(context.project().ellipsoid())
exp.setGeomCalculator(da)
exp.setDistanceUnits(context.project().distanceUnits())
exp.setAreaUnits(context.project().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 processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
strategy = self.parameterAsEnum(parameters, self.STRATEGY, context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context)
expression = QgsExpression(self.parameterAsString(parameters, self.EXPRESSION, context))
if expression.hasParserError():
raise QgsProcessingException(expression.parserErrorString())
expressionContext = self.createExpressionContext(parameters, context, source)
expression.prepare(expressionContext)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Point, source.sourceCrs(), QgsFeatureSink.RegeneratePrimaryKey)
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
da = QgsDistanceArea()
da.setSourceCrs(source.sourceCrs(), context.transformContext())
da.setEllipsoid(context.project().ellipsoid())
total = 100.0 / source.featureCount() if source.featureCount() else 0
current_progress = 0
for current, f in enumerate(source.getFeatures()):
if feedback.isCanceled():
break
if not f.hasGeometry():
continue
current_progress = total * current
feedback.setProgress(current_progress)
expressionContext.setFeature(f)
value = expression.evaluate(expressionContext)
if expression.hasEvalError():
feedback.pushInfo(
self.tr('Evaluation error for feature ID {}: {}').format(f.id(), expression.evalErrorString()))
continue
fGeom = f.geometry()
engine = QgsGeometry.createGeometryEngine(fGeom.constGet())
engine.prepareGeometry()
bbox = fGeom.boundingBox()
if strategy == 0:
pointCount = int(value)
else:
pointCount = int(round(value * da.measureArea(fGeom)))
if pointCount == 0:
feedback.pushInfo("Skip feature {} as number of points for it is 0.".format(f.id()))
continue
index = QgsSpatialIndex()
points = dict()
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
feature_total = total / pointCount if pointCount else 1
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
if engine.contains(geom.constGet()) and \
vector.checkMinDistance(p, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.addFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(current_progress + int(nPoints * feature_total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(self.tr('Could not generate requested number of random '
'points. Maximum number of attempts exceeded.'))
feedback.setProgress(100)
return {self.OUTPUT: dest_id}
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))
joinObject.joinLayerId = csvfile.id()
joinObject.joinFieldName = csvField
joinObject.targetFieldName = shpField
joinObject.memoryCache = True
shp.addJoin(joinObject)
shp.startEditing()
#step 1
myField = QgsField( 'Hill%', QVariant.Double)
shp.addAttribute( myField )
idx = shp.fieldNameIndex( 'Hill%' )
#step 2
e = QgsExpression( 'if("csv_pres_clinton" + "csv_pres_trump">0,("csv_pres_clinton"-"csv_pres_trump")/("csv_pres_clinton"+"csv_pres_trump"),0)' )
e.prepare( shp.pendingFields() )
for f in shp.getFeatures():
f[idx] = e.evaluate( f )
shp.updateFeature( f )
shp.commitChanges()
shp.startEditing()
#step 1
myField = QgsField( 'X', QVariant.Double)
myField2 = QgsField( 'Y', QVariant.Double)
shp.addAttribute( myField )
shp.addAttribute( myField2 )
idx = shp.fieldNameIndex( 'X' )
idx2 = shp.fieldNameIndex( 'Y' )
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
expressionContext = self.createExpressionContext(
parameters, context, source)
x_expression = self.parameterAsString(parameters, self.XEXPRESSION,
context)
x_expression = QgsExpression(x_expression)
if x_expression.hasParserError():
x_expression.prepare(expressionContext)
raise QgsProcessingException(x_expression.parserErrorString())
y_expression = self.parameterAsString(parameters, self.YEXPRESSION,
context)
y_expression = QgsExpression(y_expression)
if y_expression.hasParserError():
y_expression.prepare(expressionContext)
raise QgsProcessingException(y_expression.parserErrorString())
size = self.parameterAsDouble(parameters, self.SIZE, context)
size_property = None
if QgsProcessingParameters.isDynamic(parameters, "SIZE"):
size_property = parameters["SIZE"]
color = self.parameterAsColor(parameters, self.COLOR, context)
color_property = None
if QgsProcessingParameters.isDynamic(parameters, "COLOR"):
color_property = parameters["COLOR"]
facet_row = self.parameterAsString(parameters, self.FACET_ROW, context)
facet_row_expression = QgsExpression(facet_row)
if facet_row and facet_row_expression.hasParserError():
facet_row_expression.prepare(expressionContext)
raise QgsProcessingException(
facet_row_expression.parserErrorString())
facet_col = self.parameterAsString(parameters, self.FACET_COL, context)
facet_col_expression = QgsExpression(facet_col)
if facet_col and facet_col_expression.hasParserError():
facet_col_expression.prepare(expressionContext)
raise QgsProcessingException(
facet_col_expression.parserErrorString())
offline = self.parameterAsBool(parameters, self.OFFLINE, context)
if offline is not True:
offline = 'cdn'
output_html = self.parameterAsFileOutput(parameters,
self.OUTPUT_HTML_FILE,
context)
output_json = self.parameterAsFileOutput(parameters,
self.OUTPUT_JSON_FILE,
context)
colnames = ['x', 'y', 'customdata']
data = []
request = QgsFeatureRequest()
request.setFlags(QgsFeatureRequest.NoGeometry)
for current, f in enumerate(source.getFeatures(request)):
tl = []
expressionContext.setFeature(f)
x_val = x_expression.evaluate(expressionContext)
y_val = y_expression.evaluate(expressionContext)
ids = f.id()
tl.append(x_val)
tl.append(y_val)
tl.append(ids)
if facet_row:
facet_row_val = facet_row_expression.evaluate(
expressionContext)
tl.append(facet_row_val)
if facet_col:
facet_col_val = facet_col_expression.evaluate(
expressionContext)
tl.append(facet_col_val)
if size_property:
the_size, _ = size_property.valueAsDouble(
expressionContext, size)
tl.append(the_size)
if color_property:
the_color, _ = color_property.value(expressionContext, color)
tl.append(the_color)
data.append(tl)
if facet_row:
colnames.append('facet_row')
if facet_col:
colnames.append('facet_col')
if size_property:
colnames.append('size')
if color_property:
colnames.append('color')
df = pd.DataFrame(data=data, columns=colnames)
feedback.pushDebugInfo(f'{df}')
fig = px.scatter(df,
x='x',
y='y',
size='size' if size_property else None,
color='color' if color_property else None,
facet_row="facet_row" if facet_row else None,
facet_col="facet_col" if facet_col else None)
if size_property is None:
fig.update_traces(marker_size=size)
if color_property is None:
fig.update_traces(marker_color=color.name())
fig.update_layout(showlegend=True)
results = {}
fig.write_html(output_html, include_plotlyjs=offline)
results[self.OUTPUT_HTML_FILE] = output_html
if output_json:
fig.write_json(output_json, pretty=True)
results[self.OUTPUT_JSON_FILE] = output_json
return results
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
strategy = self.parameterAsEnum(parameters, self.STRATEGY, context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE,
context)
expression = QgsExpression(
self.parameterAsString(parameters, self.EXPRESSION, context))
if expression.hasParserError():
raise QgsProcessingException(expression.parserErrorString())
expressionContext = self.createExpressionContext(
parameters, context, source)
expression.prepare(expressionContext)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Point,
source.sourceCrs())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
da = QgsDistanceArea()
da.setSourceCrs(source.sourceCrs(), context.transformContext())
da.setEllipsoid(context.project().ellipsoid())
total = 100.0 / source.featureCount() if source.featureCount() else 0
current_progress = 0
for current, f in enumerate(source.getFeatures()):
if feedback.isCanceled():
break
if not f.hasGeometry():
continue
current_progress = total * current
feedback.setProgress(current_progress)
expressionContext.setFeature(f)
value = expression.evaluate(expressionContext)
if expression.hasEvalError():
feedback.pushInfo(
self.tr('Evaluation error for feature ID {}: {}').format(
f.id(), expression.evalErrorString()))
continue
fGeom = f.geometry()
engine = QgsGeometry.createGeometryEngine(fGeom.constGet())
engine.prepareGeometry()
bbox = fGeom.boundingBox()
if strategy == 0:
pointCount = int(value)
else:
pointCount = int(round(value * da.measureArea(fGeom)))
if pointCount == 0:
feedback.pushInfo(
"Skip feature {} as number of points for it is 0.".format(
f.id()))
continue
index = QgsSpatialIndex()
points = dict()
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
feature_total = total / pointCount if pointCount else 1
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
if engine.contains(geom.constGet()) and \
vector.checkMinDistance(p, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.addFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(current_progress +
int(nPoints * feature_total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(
self.tr('Could not generate requested number of random '
'points. Maximum number of attempts exceeded.'))
feedback.setProgress(100)
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
path = self.parameterAsFile(parameters, self.INPUT, context)
t_file = self.parameterAsVectorLayer(
parameters,
self.FILE_TABLE,
context
)
t_troncon = self.parameterAsVectorLayer(
parameters,
self.SEGMENT_TABLE,
context
)
t_obs = self.parameterAsVectorLayer(
parameters,
self.OBSERVATIONS_TABLE,
context
)
t_regard = self.parameterAsVectorLayer(
parameters,
self.MANHOLES_TABLE,
context
)
paths = path.split(';')
if len(paths) != 1:
raise QgsProcessingException(
tr('* ERREUR: 1 fichier a la fois {}.').format(path)
)
if not os.path.exists(path):
raise QgsProcessingException(
tr('* ERREUR: {} n\'existe pas.').format(path)
)
# add date fields to itv file table
# relation_aggregate(
# 'itv_tronco_id_file_itv_file20_id',
# 'max',
# "abf"
# )
if 'date_debut' not in t_file.dataProvider().fields().names():
with edit(t_file):
res = t_file.dataProvider().addAttributes([
QgsField("date_debut", QVariant.String),
QgsField("date_fin", QVariant.String)
])
if res:
t_file.updateFields()
feat_file = None
with open(path, 'rb') as f:
basename = os.path.basename(path)
md = hashlib.md5()
md.update(f.read())
hashcontent = md.hexdigest()
feat_file = QgsVectorLayerUtils.createFeature(t_file)
feat_file.setAttribute('basename', basename)
feat_file.setAttribute('hashcontent', hashcontent)
if not feat_file:
raise QgsProcessingException(
tr(
'* ERREUR: le fichier {} n\'a pas été lu '
'correctement.'
).format(path)
)
exp_context = QgsExpressionContext()
exp_context.appendScope(
QgsExpressionContextUtils.globalScope()
)
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project())
)
exp_context.appendScope(
QgsExpressionContextUtils.layerScope(t_file)
)
exp_str = QgsExpression.createFieldEqualityExpression(
'basename', feat_file['basename']
) + ' AND ' + QgsExpression.createFieldEqualityExpression(
'hashcontent', feat_file['hashcontent']
)
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr('* ERROR: Expression {} has eval error: {}').format(
exp.expression(), exp.evalErrorString()
)
)
request = QgsFeatureRequest(exp, exp_context)
request.setLimit(1)
for _t in t_file.getFeatures(request):
raise QgsProcessingException(
tr('* ERREUR: le fichier {} a deja ete lu').format(
path
)
)
exp_str = QgsExpression.createFieldEqualityExpression(
'hashcontent', feat_file['hashcontent']
)
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr('* ERROR: Expression {} has eval error: {}').format(
(exp.expression(), exp.evalErrorString())
)
)
request = QgsFeatureRequest(exp, exp_context)
request.setLimit(1)
for _t in t_file.getFeatures(request):
raise QgsProcessingException(
tr(
'* ERREUR: le fichier {} semble deja avoir ete lu'
).format(path)
)
exp_context = QgsExpressionContext()
exp_context.appendScope(
QgsExpressionContextUtils.globalScope()
)
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project())
)
exp_context.appendScope(
QgsExpressionContextUtils.layerScope(t_troncon)
)
exp_str = 'maximum("id")'
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr(
'* ERROR: Expression {} has eval error: {}'
).format(exp.expression(), exp.evalErrorString())
)
last_t_id = exp.evaluate(exp_context)
if not last_t_id:
last_t_id = 0
exp_context = QgsExpressionContext()
exp_context.appendScope(
QgsExpressionContextUtils.globalScope()
)
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project())
)
exp_context.appendScope(
QgsExpressionContextUtils.layerScope(t_regard)
)
exp_str = 'maximum("id")'
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr(
'* ERROR: Expression {} has eval error: {}'
).format(exp.expression(), exp.evalErrorString())
)
last_r_id = exp.evaluate(exp_context)
if not last_r_id:
last_r_id = 0
# lecture des entetes
ENCODING = 'ISO-8859-1'
LANG = 'fr'
DELIMITER = ','
DECIMAL = '.'
QUOTECHAR = '"'
VERSION = ''
with open(path, 'rb') as f:
for line in f:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
try:
line = line.decode()
except UnicodeDecodeError:
raise QgsProcessingException(
'Error while reading {}'.format(path)
)
# remove break line
line = line.replace('\n', '').replace('\r', '')
if line.startswith('#'):
if line.startswith('#A'):
if line.startswith('#A1'):
ENCODING = line[4:]
if ENCODING.find(':') != -1:
ENCODING = ENCODING[:ENCODING.find(':')]
elif line.startswith('#A2'):
LANG = line[4:]
elif line.startswith('#A3'):
DELIMITER = line[4:]
elif line.startswith('#A4'):
DECIMAL = line[4:]
elif line.startswith('#A5'):
QUOTECHAR = line[4:]
else:
break
# Dialect CSV pour la lecture des tableaux de valeurs du
# fichier d'ITV
class itvDialect(csv.Dialect):
strict = True
skipinitialspace = True
quoting = csv.QUOTE_MINIMAL
delimiter = DELIMITER
quotechar = QUOTECHAR
lineterminator = '\r\n'
# Liste des troncons, observations et regards
troncons = []
regards = []
observations = []
# Lectures des donnees
with open(path, 'rb') as f:
# Identifiant de départ
t_id = last_t_id
r_id = last_r_id
# Entête
header = []
# Nom du tableau
array = ''
# Observations de troncons ?
obs_for_troncon = False
# initialisation du Dialect CSV pour ITV
dia = itvDialect()
# Lecture ligne à ligne du fichier
for line in f:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
# Decoding line en utilisant l'encoding du fichier
line = line.decode(ENCODING)
# remove break line
line = line.replace('\n', '').replace('\r', '')
# Ligne commençant par un # est une ligne d'entête
if line.startswith('#'):
# Entête de troncon ou regard
if line.startswith('#B'):
l_b = io.StringIO(line[5:])
for l_r in csv.reader(l_b, dia):
header = l_r
break
array = line[1:4]
continue
# Entête d'observation
elif line.startswith('#C'):
if header[0].startswith('A'):
obs_for_troncon = True
else:
obs_for_troncon = False
l_b = io.StringIO(line[3:])
for l_r in csv.reader(l_b, dia):
header = l_r
break
array = line[1:2]
continue
# Fin d'observation
elif line.startswith('#Z'):
header = []
array = ''
obs_for_troncon = False
continue
# La ligne contient des donnees
else:
if not header: # an error in the file structure
continue
l_b = io.StringIO(line)
for l_r in csv.reader(l_b, dia):
data = l_r
row = list(
zip(
[h.lower() for h in header],
[t for t in data]
)
)
# observation
if array == 'C':
if obs_for_troncon:
observations.append(
row + [('id_troncon', t_id)]
)
# Premiere ligne de description d'un troncon ou regard
elif array == 'B01':
if header[0].startswith('A'):
t_id += 1
troncons.append([('id', t_id)] + row)
elif header[0].startswith('C'):
r_id += 1
regards.append([('id', r_id)] + row)
# Ligne complémentaire de description
else:
if header[0].startswith('A'):
troncons[-1] += row
elif header[0].startswith('C'):
regards[-1] += row
# Recuperation des references de noeuds et dates
itv_dates = []
regard_node_refs = []
regard_ref_id = {}
max_r_id = last_r_id
for reg in regards:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
d_rg = dict(reg)
if d_rg['caa'] and d_rg['caa'] not in regard_node_refs:
regard_node_refs.append(d_rg['caa'])
regard_ref_id[d_rg['caa']] = d_rg['id']
if d_rg['id'] and d_rg['id'] > max_r_id:
max_r_id = d_rg['id']
if 'cbf' in d_rg and d_rg['cbf'] not in itv_dates:
itv_dates.append(d_rg['cbf'])
node_refs = []
for tro in troncons:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
d_tr = dict(tro)
# The nodes ref are stored in AAB, AAD, AAF and AAT
if 'aab' in d_tr and \
d_tr['aab'] and \
d_tr['aab'] not in regard_node_refs and \
d_tr['aab'] not in node_refs:
node_refs.append(d_tr['aab'])
if 'aad' in d_tr and \
d_tr['aad'] and \
d_tr['aad'] not in regard_node_refs and \
d_tr['aad'] not in node_refs:
node_refs.append(d_tr['aad'])
if 'aaf' in d_tr and \
d_tr['aaf'] and \
d_tr['aaf'] not in regard_node_refs and \
d_tr['aaf'] not in node_refs:
node_refs.append(d_tr['aaf'])
if 'aat' in d_tr and \
d_tr['aat'] and \
d_tr['aat'] not in regard_node_refs and \
d_tr['aat'] not in node_refs:
node_refs.append(d_tr['aat'])
if 'abf' in d_tr and d_tr['abf'] not in itv_dates:
itv_dates.append(d_tr['abf'])
# Ajout des regards manquant
for n_ref in node_refs:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
max_r_id += 1
regards.append([('id', max_r_id), ('caa', n_ref)])
regard_ref_id[n_ref] = max_r_id
# Ajout des identifiants de regards aux tronçons
regard_refs = regard_ref_id.keys()
for tro in troncons:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
d_tr = dict(tro)
# If AAD is not defined then it is equal to AAB
if 'aad' not in d:
d['aad'] = d['aab']
if d_tr['aad'] and \
d_tr['aad'] in regard_refs:
tro += [('id_regard1', regard_ref_id[d_tr['aad']])]
if d_tr['aaf'] and \
d_tr['aaf'] in regard_refs:
tro += [('id_regard2', regard_ref_id[d_tr['aaf']])]
if 'aat' in d_tr.keys() and \
d_tr['aat'] and \
d_tr['aat'] in regard_refs:
tro += [('id_regard3', regard_ref_id[d_tr['aat']])]
# Verification des champs
fields = provider_fields(t_troncon.fields())
for tro in troncons:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
for key, val in tro:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
if fields.indexOf(key) == -1:
raise QgsProcessingException(
tr(
'* ERREUR dans le fichier : '
'le champs de tronçon "{}" est inconnue'
).format(key)
)
field = fields.field(key)
if isinstance(val, str) and field.isNumeric():
if val:
try:
float(val.replace(DECIMAL, '.'))
except BaseException:
raise QgsProcessingException(
tr(
'* ERREUR dans le fichier : '
'le champs de tronçon "{}" est '
'numérique mais pas la valeur "{}"'
).format(key, val)
)
fields = provider_fields(t_obs.fields())
for obs in observations:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
for key, val in obs:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
if fields.indexOf(key) == -1:
raise QgsProcessingException(
tr(
'* ERREUR dans le fichier : '
'le champs d\'observation "{}" est '
'inconnue'
).format(key)
)
field = fields.field(key)
if isinstance(val, str) and field.isNumeric():
if val:
try:
float(val.replace(DECIMAL, '.'))
except BaseException:
raise QgsProcessingException(
tr(
'* ERREUR dans le fichier : '
'le champs d\'observation "{}" est '
'numérique mais pas la valeur "{}"'
).format(key, val)
)
fields = provider_fields(t_regard.fields())
for reg in regards:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
for key, val in reg:
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
if fields.indexOf(key) == -1:
raise QgsProcessingException(
tr(
'* ERREUR dans le fichier : '
'le champs de regard "{}" est inconnue'
).format(key)
)
field = fields.field(key)
if isinstance(val, str) and field.isNumeric():
if val:
try:
float(val.replace(DECIMAL, '.'))
except BaseException:
raise QgsProcessingException(
tr(
'* ERREUR dans le fichier : '
'le champs de regard "{}" est '
'numérique mais pas la valeur "{}"'
).format(key, val)
)
# Finalisation objet fichier
feat_file.setAttribute('encoding', ENCODING)
feat_file.setAttribute('lang', LANG)
if VERSION:
feat_file.setAttribute('version', VERSION)
if itv_dates:
feat_file.setAttribute('date_debut', min(itv_dates))
feat_file.setAttribute('date_fin', max(itv_dates))
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.SUCCESS: 0}
# Ajout de l'objet fichier
t_file.startEditing()
(res, outFeats) = t_file.dataProvider().addFeatures([feat_file])
if not res or not outFeats:
raise QgsProcessingException(
tr(
'* ERREUR: lors de l\'enregistrement du fichier {}'
).format(', '.join(t_file.dataProvider().errors()))
)
if not t_file.commitChanges():
raise QgsProcessingException(
tr('* ERROR: Commit {}.').format(t_file.commitErrors())
)
# Mise a jour de l'identifiant de l'objet fichier
feat_file.setAttribute('id', outFeats[0]['id'])
# Creation des objets troncons
features = []
fields = provider_fields(t_troncon.fields())
for tro in troncons:
feat_t = QgsVectorLayerUtils.createFeature(t_troncon)
feat_t.setAttribute('id_file', feat_file['id'])
for key, val in tro:
field = fields.field(key)
if isinstance(val, str) and field.isNumeric():
if val:
feat_t.setAttribute(
key, float(val.replace(DECIMAL, '.'))
)
else:
feat_t.setAttribute(key, val)
features.append(feat_t)
# Ajout des objets troncons
if features:
t_troncon.startEditing()
(res, outFeats) = t_troncon.dataProvider().addFeatures(features)
if not res or not outFeats:
raise QgsProcessingException(
tr(
'* ERREUR: lors de l\'enregistrement '
'des troncon {}'
).format(
', '.join(t_troncon.dataProvider().errors())
)
)
if not t_troncon.commitChanges():
raise QgsProcessingException(
tr('* ERROR: Commit {}.').format(
t_troncon.commitErrors()
)
)
# Creation des objets observations
features = []
fields = provider_fields(t_obs.fields())
for obs in observations:
feat_o = QgsVectorLayerUtils.createFeature(t_obs)
feat_o.setAttribute('id_file', feat_file['id'])
for key, val in obs:
field = fields.field(key)
if isinstance(val, str) and field.isNumeric():
if val:
feat_o.setAttribute(
key, float(val.replace(DECIMAL, '.'))
)
else:
feat_o.setAttribute(key, val)
features.append(feat_o)
# Ajout des objets observations
if features:
t_obs.startEditing()
(res, outFeats) = t_obs.dataProvider().addFeatures(features)
if not res or not outFeats:
raise QgsProcessingException(
tr(
'* ERREUR: lors de l\'enregistrement '
'des observations {}'
).format(
', '.join(t_obs.dataProvider().errors())
)
)
if not t_obs.commitChanges():
raise QgsProcessingException(
tr('* ERROR: Commit {}.').format(
t_obs.commitErrors()
)
)
# Creation des objets regards
features = []
fields = provider_fields(t_regard.fields())
for reg in regards:
feat_r = QgsVectorLayerUtils.createFeature(t_regard)
feat_r.setAttribute('id_file', feat_file['id'])
for key, val in reg:
field = fields.field(key)
if isinstance(val, str) and field.isNumeric():
if val:
feat_r.setAttribute(
key, float(val.replace(DECIMAL, '.'))
)
else:
feat_r.setAttribute(key, val)
features.append(feat_r)
# Ajout des objets regards
if features:
t_regard.startEditing()
(res, outFeats) = t_regard.dataProvider().addFeatures(
features
)
if not res or not outFeats:
raise QgsProcessingException(
tr(
'* ERREUR: lors de l\'enregistrement '
'des regards {}'
).format(
', '.join(t_regard.dataProvider().errors())
)
)
if not t_regard.commitChanges():
raise QgsProcessingException(
tr('* ERROR: Commit %s.').format(
t_regard.commitErrors()
)
)
# Returns empty dict if no outputs
return {self.SUCCESS: 1}
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)
if output.value == '':
ext = output.getDefaultFileExtension(self)
output.value = system.getTempFilenameInTempFolder(output.name +
'.' + ext)
provider = layer.dataProvider()
fields = layer.pendingFields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, provider.geometryType(),
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)
if not exp.prepare(layer.pendingFields()):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
current = 0
features = vector.features(layer)
total = 100.0 / len(features)
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp.setCurrentRowNumber(rownum)
value = exp.evaluate(f)
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 occured while evaluating the calculation '
'string:\n%s' % error))
def start_progress(self):
import datetime
start = datetime.datetime.now()
# Check OS and dep
if sys.platform == 'darwin':
gdal_os_dep = '/Library/Frameworks/GDAL.framework/Versions/Current/Programs/'
else:
gdal_os_dep = ''
if self.dlg.canvasButton.isChecked():
# Map Canvas
extentCanvasCRS = self.iface.mapCanvas()
srs = extentCanvasCRS.mapSettings().destinationCrs()
crs = str(srs.authid())
# old_crs = osr.SpatialReference()
# old_crs.ImportFromEPSG(int(crs[5:]))
can_crs = QgsCoordinateReferenceSystem(int(crs[5:]))
# can_wkt = extentCanvasCRS.mapRenderer().destinationCrs().toWkt()
# can_crs = osr.SpatialReference()
# can_crs.ImportFromWkt(can_wkt)
# Raster Layer
dem_layer = self.layerComboManagerDEM.currentLayer()
dem_prov = dem_layer.dataProvider()
dem_path = str(dem_prov.dataSourceUri())
dem_raster = gdal.Open(dem_path)
projdsm = osr.SpatialReference(wkt=dem_raster.GetProjection())
projdsm.AutoIdentifyEPSG()
projdsmepsg = int(projdsm.GetAttrValue('AUTHORITY', 1))
dem_crs = QgsCoordinateReferenceSystem(projdsmepsg)
# dem_wkt = dem_raster.GetProjection()
# dem_crs = osr.SpatialReference()
# dem_crs.ImportFromWkt(dem_wkt)
if can_crs != dem_crs:
extentCanvas = self.iface.mapCanvas().extent()
extentDEM = dem_layer.extent()
transformExt = QgsCoordinateTransform(can_crs, dem_crs)
# transformExt = osr.CoordinateTransformation(can_crs, dem_crs)
canminx = extentCanvas.xMinimum()
canmaxx = extentCanvas.xMaximum()
canminy = extentCanvas.yMinimum()
canmaxy = extentCanvas.yMaximum()
canxymin = transformExt.TransformPoint(canminx, canminy)
canxymax = transformExt.TransformPoint(canmaxx, canmaxy)
extDiffminx = canxymin[0] - extentDEM.xMinimum(
) # If smaller than zero = warning
extDiffminy = canxymin[1] - extentDEM.yMinimum(
) # If smaller than zero = warning
extDiffmaxx = canxymax[0] - extentDEM.xMaximum(
) # If larger than zero = warning
extDiffmaxy = canxymax[0] - extentDEM.yMaximum(
) # If larger than zero = warning
if extDiffminx < 0 or extDiffminy < 0 or extDiffmaxx > 0 or extDiffmaxy > 0:
QMessageBox.warning(
None,
"Warning! Extent of map canvas is larger than raster extent.",
"Change to an extent equal to or smaller than the raster extent."
)
return
# Extent
self.yMax = self.dlg.lineEditNorth.text()
self.yMin = self.dlg.lineEditSouth.text()
self.xMin = self.dlg.lineEditWest.text()
self.xMax = self.dlg.lineEditEast.text()
if not self.DSMoutputfile:
QMessageBox.critical(None, "Error", "Specify a raster output file")
return
if self.dlg.checkBoxPolygon.isChecked() and not self.OSMoutputfile:
QMessageBox.critical(None, "Error",
"Specify an output file for OSM data")
return
# Acquiring geodata and attributes
dem_layer = self.layerComboManagerDEM.currentLayer()
if dem_layer is None:
QMessageBox.critical(None, "Error",
"No valid raster layer is selected")
return
else:
provider = dem_layer.dataProvider()
filepath_dem = str(provider.dataSourceUri())
demRaster = gdal.Open(filepath_dem)
dem_layer_crs = osr.SpatialReference()
dem_layer_crs.ImportFromWkt(demRaster.GetProjection())
self.dem_layer_unit = dem_layer_crs.GetAttrValue("UNIT")
posUnits = [
'metre', 'US survey foot', 'meter', 'm', 'ft', 'feet', 'foot',
'ftUS', 'International foot'
] # Possible units
if not self.dem_layer_unit in posUnits:
QMessageBox.critical(
None, "Error",
"Raster projection is not in metre or foot. Please reproject.")
return
polygon_layer = self.layerComboManagerPolygon.currentLayer()
osm_layer = self.dlg.checkBoxOSM.isChecked()
if polygon_layer is None and osm_layer is False:
QMessageBox.critical(None, "Error",
"No valid building height layer is selected")
return
elif polygon_layer:
vlayer = QgsVectorLayer(polygon_layer.source(), "buildings", "ogr")
fileInfo = QFileInfo(polygon_layer.source())
polygon_ln = fileInfo.baseName()
polygon_field = self.layerComboManagerPolygonField.currentField()
idx = vlayer.fieldNameIndex(polygon_field)
flname = vlayer.attributeDisplayName(idx)
if idx == -1:
QMessageBox.critical(
None, "Error",
"An attribute with unique fields must be selected")
return
### main code ###
self.dlg.progressBar.setRange(0, 5)
self.dlg.progressBar.setValue(1)
if self.dlg.checkBoxOSM.isChecked():
# TODO replace osr.CoordinateTransformation with QgsCoordinateTransform
dem_original = gdal.Open(filepath_dem)
dem_wkt = dem_original.GetProjection()
ras_crs = osr.SpatialReference()
ras_crs.ImportFromWkt(dem_wkt)
rasEPSG = ras_crs.GetAttrValue("PROJCS|AUTHORITY", 1)
if self.dlg.layerButton.isChecked():
old_crs = ras_crs
elif self.dlg.canvasButton.isChecked():
canvasCRS = self.iface.mapCanvas()
outputWkt = canvasCRS.mapRenderer().destinationCrs().toWkt()
old_crs = osr.SpatialReference()
old_crs.ImportFromWkt(outputWkt)
wgs84_wkt = """
GEOGCS["WGS 84",
DATUM["WGS_1984",
SPHEROID["WGS 84",6378137,298.257223563,
AUTHORITY["EPSG","7030"]],
AUTHORITY["EPSG","6326"]],
PRIMEM["Greenwich",0,
AUTHORITY["EPSG","8901"]],
UNIT["degree",0.01745329251994328,
AUTHORITY["EPSG","9122"]],
AUTHORITY["EPSG","4326"]]"""
new_crs = osr.SpatialReference()
new_crs.ImportFromWkt(wgs84_wkt)
transform = osr.CoordinateTransformation(old_crs, new_crs)
minx = float(self.xMin)
miny = float(self.yMin)
maxx = float(self.xMax)
maxy = float(self.yMax)
lonlatmin = transform.TransformPoint(minx, miny)
lonlatmax = transform.TransformPoint(maxx, maxy)
if ras_crs != old_crs:
rasTrans = osr.CoordinateTransformation(old_crs, ras_crs)
raslonlatmin = rasTrans.TransformPoint(float(self.xMin),
float(self.yMin))
raslonlatmax = rasTrans.TransformPoint(float(self.xMax),
float(self.yMax))
#else:
#raslonlatmin = [float(self.xMin), float(self.yMin)]
#raslonlatmax = [float(self.xMax), float(self.yMax)]
self.xMin = raslonlatmin[0]
self.yMin = raslonlatmin[1]
self.xMax = raslonlatmax[0]
self.yMax = raslonlatmax[1]
# Make data queries to overpass-api
urlStr = 'http://overpass-api.de/api/map?bbox=' + str(
lonlatmin[0]) + ',' + str(lonlatmin[1]) + ',' + str(
lonlatmax[0]) + ',' + str(lonlatmax[1])
osmXml = urllib.urlopen(urlStr).read()
#print urlStr
# Make OSM building file
osmPath = self.plugin_dir + '/temp/OSM_building.osm'
osmFile = open(osmPath, 'w')
osmFile.write(osmXml)
if os.fstat(osmFile.fileno()).st_size < 1:
urlStr = 'http://api.openstreetmap.org/api/0.6/map?bbox=' + str(
lonlatmin[0]) + ',' + str(lonlatmin[1]) + ',' + str(
lonlatmax[0]) + ',' + str(lonlatmax[1])
osmXml = urllib.urlopen(urlStr).read()
osmFile.write(osmXml)
#print 'Open Street Map'
if os.fstat(osmFile.fileno()).st_size < 1:
QMessageBox.critical(None, "Error",
"No OSM data available")
return
osmFile.close()
outputshp = self.plugin_dir + '/temp/'
osmToShape = gdal_os_dep + 'ogr2ogr --config OSM_CONFIG_FILE "' + self.plugin_dir + '/osmconf.ini" -skipfailures -t_srs EPSG:' + str(
rasEPSG
) + ' -overwrite -nlt POLYGON -f "ESRI Shapefile" "' + outputshp + '" "' + osmPath + '"'
if sys.platform == 'win32':
si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
subprocess.call(osmToShape, startupinfo=si)
else:
os.system(osmToShape)
driver = ogr.GetDriverByName('ESRI Shapefile')
driver.DeleteDataSource(outputshp + 'lines.shp')
driver.DeleteDataSource(outputshp + 'multilinestrings.shp')
driver.DeleteDataSource(outputshp + 'other_relations.shp')
driver.DeleteDataSource(outputshp + 'points.shp')
osmPolygonPath = outputshp + 'multipolygons.shp'
vlayer = QgsVectorLayer(osmPolygonPath, 'multipolygons', 'ogr')
polygon_layer = vlayer
fileInfo = QFileInfo(polygon_layer.source())
polygon_ln = fileInfo.baseName()
def renameField(srcLayer, oldFieldName, newFieldName):
ds = gdal.OpenEx(srcLayer.source(),
gdal.OF_VECTOR | gdal.OF_UPDATE)
ds.ExecuteSQL('ALTER TABLE {} RENAME COLUMN {} TO {}'.format(
srcLayer.name(), oldFieldName, newFieldName))
srcLayer.reload()
vlayer.startEditing()
renameField(vlayer, 'building_l', 'bld_levels')
renameField(vlayer, 'building_h', 'bld_hght')
renameField(vlayer, 'building_c', 'bld_colour')
renameField(vlayer, 'building_m', 'bld_materi')
renameField(vlayer, 'building_u', 'bld_use')
vlayer.commitChanges()
vlayer.startEditing()
vlayer.dataProvider().addAttributes(
[QgsField('bld_height', QVariant.Double, 'double', 3, 2)])
vlayer.updateFields()
bld_lvl = vlayer.fieldNameIndex('bld_levels')
hght = vlayer.fieldNameIndex('height')
bld_hght = vlayer.fieldNameIndex('bld_hght')
bld_height = vlayer.fieldNameIndex('bld_height')
bldLvlHght = float(self.dlg.doubleSpinBoxBldLvl.value())
illegal_chars = string.ascii_letters + "!#$%&'*+^_`|~:" + " "
counterNone = 0
counter = 0
#counterWeird = 0
for feature in vlayer.getFeatures():
if feature[hght]:
try:
#feature[bld_height] = float(re.sub("[^0-9]", ".", str(feature[hght])))
feature[bld_height] = float(
str(feature[hght]).translate(None, illegal_chars))
except:
counterNone += 1
elif feature[bld_hght]:
try:
#feature[bld_height] = float(re.sub("[^0-9]", ".", str(feature[bld_hght])))
feature[bld_height] = float(
str(feature[bld_hght]).translate(
None, illegal_chars))
except:
counterNone += 1
elif feature[bld_lvl]:
try:
#feature[bld_height] = float(re.sub("[^0-9]", "", str(feature[bld_lvl])))*bldLvlHght
feature[bld_height] = float(
str(feature[bld_lvl]).translate(
None, illegal_chars)) * bldLvlHght
except:
counterNone += 1
else:
counterNone += 1
vlayer.updateFeature(feature)
counter += 1
vlayer.commitChanges()
flname = vlayer.attributeDisplayName(bld_height)
counterDiff = counter - counterNone
# Zonal statistics
vlayer.startEditing()
zoneStat = QgsZonalStatistics(vlayer, filepath_dem, "stat_", 1,
QgsZonalStatistics.Mean)
zoneStat.calculateStatistics(None)
vlayer.dataProvider().addAttributes(
[QgsField('height_asl', QVariant.Double)])
vlayer.updateFields()
e = QgsExpression('stat_mean + ' + flname)
e.prepare(vlayer.pendingFields())
idx = vlayer.fieldNameIndex('height_asl')
for f in vlayer.getFeatures():
f[idx] = e.evaluate(f)
vlayer.updateFeature(f)
vlayer.commitChanges()
vlayer.startEditing()
idx2 = vlayer.fieldNameIndex('stat_mean')
vlayer.dataProvider().deleteAttributes([idx2])
vlayer.updateFields()
vlayer.commitChanges()
self.dlg.progressBar.setValue(2)
# Convert polygon layer to raster
# Define pixel_size and NoData value of new raster
pixel_size = self.dlg.spinBox.value() # half picture size
# Create the destination data source
gdalrasterize = gdal_os_dep + 'gdal_rasterize -a ' + 'height_asl' + ' -te ' + str(self.xMin) + ' ' + str(self.yMin) + ' ' + str(self.xMax) + ' ' + str(self.yMax) +\
' -tr ' + str(pixel_size) + ' ' + str(pixel_size) + ' -l "' + str(polygon_ln) + '" "' \
+ str(polygon_layer.source()) + '" "' + self.plugin_dir + '/temp/clipdsm.tif"'
# gdalclipdem = gdal_os_dep + 'gdalwarp -dstnodata -9999 -q -overwrite -te ' + str(self.xMin) + ' ' + str(self.yMin) + ' ' + str(self.xMax) + ' ' + str(self.yMax) +\
# ' -tr ' + str(pixel_size) + ' ' + str(pixel_size) + \
# ' -of GTiff ' + '"' + filepath_dem + '" "' + self.plugin_dir + '/temp/clipdem.tif"'
# Rasterize
if sys.platform == 'win32':
si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
subprocess.call(gdalrasterize, startupinfo=si)
# subprocess.call(gdalclipdem, startupinfo=si)
gdal.Warp(self.plugin_dir + '/temp/clipdem.tif',
filepath_dem,
xRes=pixel_size,
yRes=pixel_size)
else:
os.system(gdalrasterize)
# os.system(gdalclipdem)
gdal.Warp(self.plugin_dir + '/temp/clipdem.tif',
filepath_dem,
xRes=pixel_size,
yRes=pixel_size)
# Remove gdalwarp with gdal.Translate
# bigraster = gdal.Open(filepath_dem)
# bbox = (self.xMin, self.yMax, self.xMax, self.yMin)
# gdal.Translate(self.plugin_dir + '/data/clipdem.tif', bigraster, projWin=bbox)
self.dlg.progressBar.setValue(3)
# Adding DSM to DEM
# Read DEM
dem_raster = gdal.Open(self.plugin_dir + '/temp/clipdem.tif')
dem_array = np.array(dem_raster.ReadAsArray().astype(np.float))
dsm_raster = gdal.Open(self.plugin_dir + '/temp/clipdsm.tif')
dsm_array = np.array(dsm_raster.ReadAsArray().astype(np.float))
indx = dsm_array.shape
for ix in range(0, int(indx[0])):
for iy in range(0, int(indx[1])):
if int(dsm_array[ix, iy]) == 0:
dsm_array[ix, iy] = dem_array[ix, iy]
if self.dlg.checkBoxPolygon.isChecked():
vlayer.startEditing()
idxHght = vlayer.fieldNameIndex('height_asl')
idxBld = vlayer.fieldNameIndex('building')
features = vlayer.getFeatures()
#for f in vlayer.getFeatures():
for f in features:
geom = f.geometry()
posUnitsMetre = ['metre', 'meter', 'm'] # Possible metre units
posUnitsFt = [
'US survey foot', 'ft', 'feet', 'foot', 'ftUS',
'International foot'
] # Possible foot units
if self.dem_layer_unit in posUnitsMetre:
sqUnit = 1
elif self.dem_layer_unit in posUnitsFt:
sqUnit = 10.76
if int(geom.area()) > 50000 * sqUnit:
vlayer.deleteFeature(f.id())
#if not f[idxHght]:
#vlayer.deleteFeature(f.id())
#elif not f[idxBld]:
#vlayer.deleteFeature(f.id())
vlayer.updateFields()
vlayer.commitChanges()
QgsVectorFileWriter.writeAsVectorFormat(vlayer,
str(self.OSMoutputfile),
"UTF-8", None,
"ESRI Shapefile")
else:
vlayer.startEditing()
idx3 = vlayer.fieldNameIndex('height_asl')
vlayer.dataProvider().deleteAttributes([idx3])
vlayer.updateFields()
vlayer.commitChanges()
self.dlg.progressBar.setValue(4)
# Save raster
def saveraster(
gdal_data, filename, raster
): # gdal_data = raster extent, filename = output filename, raster = numpy array (raster to be saved)
rows = gdal_data.RasterYSize
cols = gdal_data.RasterXSize
outDs = gdal.GetDriverByName("GTiff").Create(
filename, cols, rows, int(1), gdal.GDT_Float32)
outBand = outDs.GetRasterBand(1)
# write the data
outBand.WriteArray(raster, 0, 0)
# flush data to disk, set the NoData value and calculate stats
outBand.FlushCache()
outBand.SetNoDataValue(-9999)
# georeference the image and set the projection
outDs.SetGeoTransform(gdal_data.GetGeoTransform())
outDs.SetProjection(gdal_data.GetProjection())
saveraster(dsm_raster, self.DSMoutputfile, dsm_array)
# Load result into canvas
rlayer = self.iface.addRasterLayer(self.DSMoutputfile)
# Trigger a repaint
if hasattr(rlayer, "setCacheImage"):
rlayer.setCacheImage(None)
rlayer.triggerRepaint()
self.dlg.progressBar.setValue(5)
#runTime = datetime.datetime.now() - start
if self.dlg.checkBoxOSM.isChecked():
QMessageBox.information(
self.dlg, 'DSM Generator', 'Operation successful! ' +
str(counterDiff) + ' building polygons out of ' +
str(counter) + ' contained height values.')
#self.iface.messageBar().pushMessage("DSM Generator. Operation successful! " + str(counterDiff) + " buildings out of " + str(counter) + " contained height values.", level=QgsMessageBar.INFO, duration=5)
else:
#self.iface.messageBar().pushMessage("DSM Generator. Operation successful!", level=QgsMessageBar.INFO, duration=5)
QMessageBox.information(self.dlg, 'DSM Generator',
'Operation successful!')
self.resetPlugin()
def processAlgorithm(self, progress):
layer = self.getParameterValue(self.INPUT_LAYER)
mapping = self.getParameterValue(self.FIELDS_MAPPING)
output = self.getOutputFromName(self.OUTPUT_LAYER)
layer = dataobjects.getObjectFromUri(layer)
fields = []
expressions = []
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
for field_def in mapping:
fields.append(
QgsField(name=field_def['name'],
type=field_def['type'],
len=field_def['length'],
prec=field_def['precision']))
expression = QgsExpression(field_def['expression'])
expression.setGeomCalculator(da)
expression.setDistanceUnits(QgsProject.instance().distanceUnits())
expression.setAreaUnits(QgsProject.instance().areaUnits())
if expression.hasParserError():
raise GeoAlgorithmExecutionException(
self.tr(u'Parser error in expression "{}": {}').format(
str(field_def['expression']),
str(expression.parserErrorString())))
expression.prepare(exp_context)
if expression.hasEvalError():
raise GeoAlgorithmExecutionException(
self.tr(u'Evaluation error in expression "{}": {}').format(
str(field_def['expression']),
str(expression.evalErrorString())))
expressions.append(expression)
writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs())
# Create output vector layer with new attributes
error = ''
calculationSuccess = True
inFeat = QgsFeature()
outFeat = QgsFeature()
features = vector.features(layer)
total = 100.0 / len(features)
for current, inFeat in enumerate(features):
rownum = current + 1
geometry = inFeat.geometry()
outFeat.setGeometry(geometry)
attrs = []
for i in range(0, len(mapping)):
field_def = mapping[i]
expression = expressions[i]
exp_context.setFeature(inFeat)
exp_context.lastScope().setVariable("row_number", rownum)
value = expression.evaluate(exp_context)
if expression.hasEvalError():
calculationSuccess = False
error = expression.evalErrorString()
break
attrs.append(value)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation'
' string:\n') + error)
def _buildfromlayer(self, widget, layerconfig):
layername = layerconfig['layer']
keyfield = layerconfig['key']
valuefield = layerconfig['value']
filterexp = layerconfig.get('filter', None)
try:
layer = QgsMapLayerRegistry.instance().mapLayersByName(
layername)[0]
except IndexError:
roam.utils.warning(
"Can't find layer {} in project".format(layername))
return
keyfieldindex = layer.fieldNameIndex(keyfield)
valuefieldindex = layer.fieldNameIndex(valuefield)
if keyfieldindex == -1 or valuefieldindex == -1:
roam.utils.warning("Can't find key or value column")
return
if self.allownulls:
item = QStandardItem('(no selection)')
item.setData(None, Qt.UserRole)
self.listmodel.appendRow(item)
attributes = {keyfieldindex, valuefieldindex}
iconfieldindex = layer.fieldNameIndex('icon')
if iconfieldindex > -1:
attributes.add(iconfieldindex)
if not filterexp and valuefieldindex == keyfieldindex and iconfieldindex == -1:
values = layer.uniqueValues(keyfieldindex)
for value in values:
value = nullconvert(value)
item = QStandardItem(value)
item.setData(value, Qt.UserRole)
self.listmodel.appendRow(item)
return
flags = QgsFeatureRequest.NoGeometry
expression = None
if filterexp:
expression = QgsExpression(filterexp)
expression.prepare(layer.pendingFields())
if expression.hasParserError():
roam.utils.warning("Expression has parser error: {}".format(
expression.parserErrorString()))
return
if expression.needsGeometry():
flags = QgsFeatureRequest.NoFlags
for field in expression.referencedColumns():
index = layer.fieldNameIndex(field)
attributes.add(index)
request = QgsFeatureRequest().setFlags(flags).setSubsetOfAttributes(
list(attributes))
for feature in layer.getFeatures(request):
if expression and not expression.evaluate(feature):
continue
keyvalue = nullconvert(feature[keyfieldindex])
valuvalue = nullconvert(feature[valuefield])
try:
path = feature[iconfieldindex]
icon = QIcon(path)
except KeyError:
icon = QIcon()
item = QStandardItem(unicode(keyvalue))
item.setData(unicode(valuvalue), Qt.UserRole)
item.setIcon(icon)
self.listmodel.appendRow(item)
def virtualFields(self, params: Dict[str,
str], response: QgsServerResponse,
project: QgsProject) -> None:
""" Get virtual fields for features
In parameters:
LAYER=wms-layer-name
VIRTUALS={"key1": "first expression", "key2": "second expression"}
// optionals
FILTER=An expression to filter layer
FIELDS=list of requested field separated by comma
WITH_GEOMETRY=False
"""
layername = params.get('LAYER', '')
if not layername:
raise ExpressionServiceError(
"Bad request error",
"Invalid 'VirtualFields' REQUEST: LAYER parameter is mandatory",
400)
# get layer
layer = findVectorLayer(layername, project)
# layer not found
if not layer:
raise ExpressionServiceError(
"Bad request error",
"Invalid LAYER parameter for 'VirtualFields': {} provided".
format(layername), 400)
# get virtuals
virtuals = params.get('VIRTUALS', '')
if not virtuals:
raise ExpressionServiceError(
"Bad request error",
"Invalid 'VirtualFields' REQUEST: VIRTUALS parameter is mandatory",
400)
# try to load virtuals dict
vir_json = None
try:
vir_json = json.loads(virtuals)
except Exception:
QgsMessageLog.logMessage(
"JSON loads virtuals '{}' exception:\n{}".format(
virtuals, traceback.format_exc()), "lizmap", Qgis.Critical)
raise ExpressionServiceError(
"Bad request error",
"Invalid 'VirtualFields' REQUEST: VIRTUALS '{}' are not well formed"
.format(virtuals), 400)
if not isinstance(vir_json, dict):
raise ExpressionServiceError(
"Bad request error",
"Invalid 'VirtualFields' REQUEST: VIRTUALS '{}' are not well formed"
.format(virtuals), 400)
# create expression context
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(project))
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
# create distance area context
da = QgsDistanceArea()
da.setSourceCrs(layer.crs(), project.transformContext())
da.setEllipsoid(project.ellipsoid())
# parse virtuals
exp_map = {}
exp_parser_errors = []
for k, e in vir_json.items():
exp = QgsExpression(e)
exp.setGeomCalculator(da)
exp.setDistanceUnits(project.distanceUnits())
exp.setAreaUnits(project.areaUnits())
if exp.hasParserError():
exp_parser_errors.append('Error "{}": {}'.format(
e, exp.parserErrorString()))
continue
if not exp.isValid():
exp_parser_errors.append('Expression not valid "{}"'.format(e))
continue
exp.prepare(exp_context)
exp_map[k] = exp
# expression parser errors found
if exp_parser_errors:
raise ExpressionServiceError(
"Bad request error",
"Invalid VIRTUALS for 'VirtualFields':\n{}".format(
'\n'.join(exp_parser_errors)), 400)
req = QgsFeatureRequest()
# get filter
req_filter = params.get('FILTER', '')
if req_filter:
req_exp = QgsExpression(req_filter)
req_exp.setGeomCalculator(da)
req_exp.setDistanceUnits(project.distanceUnits())
req_exp.setAreaUnits(project.areaUnits())
if req_exp.hasParserError():
raise ExpressionServiceError(
"Bad request error",
"Invalid FILTER for 'VirtualFields' Error \"{}\": {}".
format(req_filter, req_exp.parserErrorString()), 400)
if not req_exp.isValid():
raise ExpressionServiceError(
"Bad request error",
"Invalid FILTER for 'VirtualFields' Expression not valid \"{}\""
.format(req_filter), 400)
req_exp.prepare(exp_context)
req = QgsFeatureRequest(req_exp, exp_context)
# With geometry
withGeom = params.get('WITH_GEOMETRY',
'').lower() in ['true', '1', 't']
if not withGeom:
req.setFlags(QgsFeatureRequest.NoGeometry)
# Fields
pkAttributes = layer.primaryKeyAttributes()
attributeList = [i for i in pkAttributes]
fields = layer.fields()
r_fields = [
f.strip() for f in params.get('FIELDS', '').split(',') if f
]
for f in r_fields:
attributeList.append(fields.indexOf(f))
# response
response.setStatusCode(200)
response.setHeader("Content-Type", "application/json")
response.write('{ "type": "FeatureCollection","features":[')
response.flush()
jsonExporter = QgsJsonExporter(layer)
if attributeList:
jsonExporter.setAttributes(attributeList)
separator = ''
for feat in layer.getFeatures(req):
fid = layername + '.' + getServerFid(feat, pkAttributes)
extra = {}
# Update context
exp_context.setFeature(feat)
exp_context.setFields(feat.fields())
# Evaluate expressions for virtual fields
errors = {}
for k, exp in exp_map.items():
value = exp.evaluate(exp_context)
if exp.hasEvalError():
extra[k] = None
errors[k] = exp.evalErrorString()
else:
extra[k] = json.loads(QgsJsonUtils.encodeValue(value))
errors[k] = exp.expression()
response.write(separator +
jsonExporter.exportFeature(feat, extra, fid))
response.flush()
separator = ',\n'
response.write(']}')
return
def processAlgorithm(self, progress):
layer = self.getParameterValue(self.INPUT_LAYER)
mapping = self.getParameterValue(self.FIELDS_MAPPING)
output = self.getOutputFromName(self.OUTPUT_LAYER)
layer = dataobjects.getObjectFromUri(layer)
provider = layer.dataProvider()
fields = []
expressions = []
for field_def in mapping:
fields.append(QgsField(name=field_def['name'],
type=field_def['type'],
len=field_def['length'],
prec=field_def['precision']))
expression = QgsExpression(field_def['expression'])
if expression.hasParserError():
raise GeoAlgorithmExecutionException(
self.tr(u'Parser error in expression "{}": {}')
.format(unicode(field_def['expression']),
unicode(expression.parserErrorString())))
expression.prepare(provider.fields())
if expression.hasEvalError():
raise GeoAlgorithmExecutionException(
self.tr(u'Evaluation error in expression "{}": {}')
.format(unicode(field_def['expression']),
unicode(expression.evalErrorString())))
expressions.append(expression)
writer = output.getVectorWriter(fields,
provider.geometryType(),
layer.crs())
# Create output vector layer with new attributes
error = ''
calculationSuccess = True
inFeat = QgsFeature()
outFeat = QgsFeature()
features = vector.features(layer)
count = len(features)
for current, inFeat in enumerate(features):
rownum = current + 1
outFeat.setGeometry(inFeat.geometry())
attrs = []
for i in xrange(0, len(mapping)):
field_def = mapping[i]
expression = expressions[i]
expression.setCurrentRowNumber(rownum)
value = expression.evaluate(inFeat)
if expression.hasEvalError():
calculationSuccess = False
error = expression.evalErrorString()
break
attrs.append(value)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
current += 1
progress.setPercentage(100 * current / float(count))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation'
' string:\n') + error)
def getFeatureWithFormScope(self, params: Dict[str, str],
response: QgsServerResponse,
project: QgsProject) -> None:
""" Get filtered features with a form scope
In parameters:
LAYER=wms-layer-name
FILTER=An expression to filter layer
FORM_FEATURE={"type": "Feature", "geometry": {}, "properties": {}}
// optionals
FIELDS=list of requested field separated by comma
WITH_GEOMETRY=False
"""
layername = params.get('LAYER', '')
if not layername:
raise ExpressionServiceError(
"Bad request error",
"Invalid 'GetFeatureWithFormScope' REQUEST: LAYER parameter is mandatory",
400)
# get layer
layer = findVectorLayer(layername, project)
# layer not found
if not layer:
raise ExpressionServiceError(
"Bad request error",
"Invalid LAYER parameter for 'VirtualField': {} provided".
format(layername), 400)
# get filter
exp_filter = params.get('FILTER', '')
if not exp_filter:
raise ExpressionServiceError(
"Bad request error",
"Invalid 'GetFeatureWithFormScope' REQUEST: FILTER parameter is mandatory",
400)
# get form feature
form_feature = params.get('FORM_FEATURE', '')
if not form_feature:
raise ExpressionServiceError(
"Bad request error",
"Invalid 'GetFeatureWithFormScope' REQUEST: FORM_FEATURE parameter is mandatory",
400)
# Check features
geojson = {}
try:
geojson = json.loads(form_feature)
except Exception:
QgsMessageLog.logMessage(
"JSON loads form feature '{}' exception:\n{}".format(
form_feature, traceback.format_exc()), "lizmap",
Qgis.Critical)
raise ExpressionServiceError(
"Bad request error",
"Invalid 'GetFeatureWithFormScope' REQUEST: FORM_FEATURE '{}' are not well formed"
.format(form_feature), 400)
if not geojson or not isinstance(geojson, dict):
raise ExpressionServiceError(
"Bad request error",
"Invalid 'GetFeatureWithFormScope' REQUEST: FORM_FEATURE '{}' are not well formed"
.format(form_feature), 400)
if ('type' not in geojson) or geojson['type'] != 'Feature':
raise ExpressionServiceError(
"Bad request error",
"Invalid 'GetFeatureWithFormScope' REQUEST: FORM_FEATURE '{}' are not well formed: type not defined or not Feature."
.format(form_feature), 400)
# try to load form feature
# read fields
form_feature_fields = QgsJsonUtils.stringToFields(
form_feature, QTextCodec.codecForName("UTF-8"))
# read features
form_feature_list = QgsJsonUtils.stringToFeatureList(
form_feature, form_feature_fields,
QTextCodec.codecForName("UTF-8"))
# features not well formed
if not form_feature_list:
raise ExpressionServiceError(
"Bad request error",
"Invalid FORM_FEATURE for 'GetFeatureWithFormScope': not GeoJSON feature provided\n{}"
.format(form_feature), 400)
if len(form_feature_list) != 1:
raise ExpressionServiceError(
"Bad request error",
"Invalid FORM_FEATURE for 'GetFeatureWithFormScope': not GeoJSON feature provided\n{}"
.format(form_feature), 400)
# Get the form feature
form_feat = form_feature_list[0]
# create expression context
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(project))
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
exp_context.appendScope(QgsExpressionContextUtils.formScope(form_feat))
# create distance area context
da = QgsDistanceArea()
da.setSourceCrs(layer.crs(), project.transformContext())
da.setEllipsoid(project.ellipsoid())
# Get filter expression
exp_f = QgsExpression(exp_filter)
exp_f.setGeomCalculator(da)
exp_f.setDistanceUnits(project.distanceUnits())
exp_f.setAreaUnits(project.areaUnits())
if exp_f.hasParserError():
raise ExpressionServiceError(
"Bad request error",
"Invalid FILTER for 'GetFeatureWithFormScope': Error \"{}\": {}"
.format(exp_filter, exp_f.parserErrorString()), 400)
if not exp_f.isValid():
raise ExpressionServiceError(
"Bad request error",
"Invalid FILTER for 'GetFeatureWithFormScope': Expression not valid \"{}\""
.format(exp_filter), 400)
exp_f.prepare(exp_context)
req = QgsFeatureRequest(exp_f, exp_context)
# With geometry
withGeom = params.get('WITH_GEOMETRY',
'').lower() in ['true', '1', 't']
if not withGeom:
req.setFlags(QgsFeatureRequest.NoGeometry)
# Fields
pkAttributes = layer.primaryKeyAttributes()
attributeList = [i for i in pkAttributes]
fields = layer.fields()
r_fields = [
f.strip() for f in params.get('FIELDS', '').split(',') if f
]
for f in r_fields:
attributeList.append(fields.indexOf(f))
# response
response.setStatusCode(200)
response.setHeader("Content-Type", "application/json")
response.write('{ "type": "FeatureCollection","features":[')
response.flush()
jsonExporter = QgsJsonExporter(layer)
if attributeList:
jsonExporter.setAttributes(attributeList)
separator = ''
for feat in layer.getFeatures(req):
fid = layername + '.' + getServerFid(feat, pkAttributes)
response.write(separator +
jsonExporter.exportFeature(feat, {}, fid))
response.flush()
separator = ',\n'
response.write(']}')
return
def save_hazard_data(self):
hazard_geojson = PetaJakartaAPI.get_aggregate_report(
self.duration, self.level)
if not hazard_geojson:
raise PetaJakartaAPIError("Can't access PetaJakarta REST API")
with open(self.hazard_path, 'w+') as f:
f.write(hazard_geojson)
# Save the layer as shp
file_info = QFileInfo(self.hazard_path)
hazard_layer = QgsVectorLayer(self.hazard_path, file_info.baseName(),
'ogr', False)
target_name = 'flood_data.shp'
self.hazard_path = os.path.join(self.report_path, target_name)
QgsVectorFileWriter.writeAsVectorFormat(hazard_layer, self.hazard_path,
'CP1250', None,
'ESRI Shapefile')
file_info = QFileInfo(self.hazard_path)
hazard_layer = QgsVectorLayer(self.hazard_path, file_info.baseName(),
'ogr')
hazard_layer.startEditing()
field = QgsField('flooded', QVariant.Int)
hazard_layer.dataProvider().addAttributes([field])
hazard_layer.commitChanges()
idx = hazard_layer.fieldNameIndex('flooded')
expression = QgsExpression('count > 0')
expression.prepare(hazard_layer.pendingFields())
hazard_layer.startEditing()
for feature in hazard_layer.getFeatures():
feature[idx] = expression.evaluate(feature)
hazard_layer.updateFeature(feature)
hazard_layer.commitChanges()
# writing keywords
keyword_io = KeywordIO()
keywords = {
'field': 'flooded',
'hazard': 'flood',
'hazard_category': 'single_event',
'keyword_version': '3.3',
'layer_geometry': 'polygon',
'layer_mode': 'classified',
'layer_purpose': 'hazard',
'title': 'Flood',
'value_map': '{"wet": [1], "dry": [0]}',
'vector_hazard_classification': 'flood_vector_hazard_classes'
}
keyword_io.write_keywords(hazard_layer, keywords)
# archiving hazard layer
with ZipFile(self.hazard_zip_path, 'w') as zf:
for root, dirs, files in os.walk(self.report_path):
for f in files:
_, ext = os.path.splitext(f)
if 'flood_data' in f:
filename = os.path.join(root, f)
zf.write(filename, arcname=f)
def evaluate(self, params: Dict[str, str], response: QgsServerResponse,
project: QgsProject) -> None:
""" Evaluate expressions against layer or features
In parameters:
LAYER=wms-layer-name
EXPRESSION=An expression to evaluate
or
EXPRESSIONS=["first expression", "second expression"]
or
EXPRESSIONS={"key1": "first expression", "key2": "second expression"}
// optionals
FEATURE={"type": "Feature", "geometry": {}, "properties": {}}
or
FEATURES=[{"type": "Feature", "geometry": {}, "properties": {}}, {"type": "Feature", "geometry": {}, "properties": {}}]
FORM_SCOPE=boolean to add formScope based on provided features
"""
layername = params.get('LAYER', '')
if not layername:
raise ExpressionServiceError(
"Bad request error",
"Invalid 'Evaluate' REQUEST: LAYER parameter is mandatory",
400)
# get layer
layer = findVectorLayer(layername, project)
# layer not found
if not layer:
raise ExpressionServiceError(
"Bad request error",
"Invalid LAYER parameter for 'Evaluate': {} provided".format(
layername), 400)
# get expressions
expressions = params.get('EXPRESSIONS', '')
if not expressions:
expression = params.get('EXPRESSION', '')
if not expression:
raise ExpressionServiceError(
"Bad request error",
"Invalid 'Evaluate' REQUEST: EXPRESSION or EXPRESSIONS parameter is mandatory",
400)
expressions = '["{}"]'.format(expression)
# try to load expressions list or dict
exp_json = None
try:
exp_json = json.loads(expressions)
except Exception:
QgsMessageLog.logMessage(
"JSON loads expressions '{}' exception:\n{}".format(
expressions, traceback.format_exc()), "lizmap",
Qgis.Critical)
raise ExpressionServiceError(
"Bad request error",
"Invalid 'Evaluate' REQUEST: EXPRESSIONS '{}' are not well formed"
.format(expressions), 400)
# create expression context
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(project))
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
# create distance area context
da = QgsDistanceArea()
da.setSourceCrs(layer.crs(), project.transformContext())
da.setEllipsoid(project.ellipsoid())
# parse expressions
exp_map = {}
exp_parser_errors = []
exp_items = []
if isinstance(exp_json, list):
exp_items = enumerate(exp_json)
elif isinstance(exp_json, dict):
exp_items = exp_json.items()
for k, e in exp_items:
exp = QgsExpression(e)
exp.setGeomCalculator(da)
exp.setDistanceUnits(project.distanceUnits())
exp.setAreaUnits(project.areaUnits())
if exp.hasParserError():
exp_parser_errors.append('Error "{}": {}'.format(
e, exp.parserErrorString()))
continue
if not exp.isValid():
exp_parser_errors.append('Expression not valid "{}"'.format(e))
continue
exp.prepare(exp_context)
exp_map[k] = exp
# expression parser errors found
if exp_parser_errors:
raise ExpressionServiceError(
"Bad request error",
"Invalid EXPRESSIONS for 'Evaluate':\n{}".format(
'\n'.join(exp_parser_errors)), 400)
# get features
features = params.get('FEATURES', '')
if not features:
feature = params.get('FEATURE', '')
if feature:
features = '[' + feature + ']'
# create the body
body = {
'status': 'success',
'results': [],
'errors': [],
'features': 0
}
# without features just evaluate expression with layer context
if not features:
result = {}
error = {}
for k, exp in exp_map.items():
value = exp.evaluate(exp_context)
if exp.hasEvalError():
result[k] = None
error[k] = exp.evalErrorString()
else:
result[k] = json.loads(QgsJsonUtils.encodeValue(value))
body['results'].append(result)
body['errors'].append(error)
write_json_response(body, response)
return
# Check features
geojson = []
try:
geojson = json.loads(features)
except Exception:
QgsMessageLog.logMessage(
"JSON loads features '{}' exception:\n{}".format(
features, traceback.format_exc()), "lizmap", Qgis.Critical)
raise ExpressionServiceError(
"Bad request error",
"Invalid 'Evaluate' REQUEST: FEATURES '{}' are not well formed"
.format(features), 400)
if not geojson or not isinstance(geojson, list) or len(geojson) == 0:
raise ExpressionServiceError(
"Bad request error",
"Invalid 'Evaluate' REQUEST: FEATURES '{}' are not well formed"
.format(features), 400)
if ('type' not in geojson[0]) or geojson[0]['type'] != 'Feature':
raise ExpressionServiceError(
"Bad request error",
"Invalid 'Evaluate' REQUEST: FEATURES '{}' are not well formed: type not defined or not Feature."
.format(features), 400)
# try to load features
# read fields
feature_fields = QgsJsonUtils.stringToFields(
'{ "type": "FeatureCollection","features":' + features + '}',
QTextCodec.codecForName("UTF-8"))
# read features
feature_list = QgsJsonUtils.stringToFeatureList(
'{ "type": "FeatureCollection","features":' + features + '}',
feature_fields, QTextCodec.codecForName("UTF-8"))
# features not well formed
if not feature_list:
raise ExpressionServiceError(
"Bad request error",
"Invalid FEATURES for 'Evaluate': not GeoJSON features array provided\n{}"
.format(features), 400)
# Extend layer fields with this provided in GeoJSON Features
feat_fields = QgsFields(layer.fields())
feat_fields.extend(feature_fields)
# form scope
addFormScope = params.get('FORM_SCOPE',
'').lower() in ['true', '1', 't']
# loop through provided features to evaluate expressions
for f in feature_list:
# clone the features with all attributes
# those defined in layer + fields from GeoJSON Features
feat = QgsFeature(feat_fields)
feat.setGeometry(f.geometry())
for field in f.fields():
fname = field.name()
if feat_fields.indexOf(fname) != -1:
feat.setAttribute(fname, f[fname])
# Add form scope to expression context
if addFormScope:
exp_context.appendScope(
QgsExpressionContextUtils.formScope(feat))
exp_context.setFeature(feat)
exp_context.setFields(feat.fields())
# Evaluate expressions with the new feature
result = {}
error = {}
for k, exp in exp_map.items():
if addFormScope: # need to prepare the expression because the context as been updated with a new scope
exp.prepare(exp_context)
value = exp.evaluate(exp_context)
if exp.hasEvalError():
result[k] = None
error[k] = exp.evalErrorString()
else:
result[k] = json.loads(QgsJsonUtils.encodeValue(value))
error[k] = exp.expression()
body['results'].append(result)
body['errors'].append(error)
write_json_response(body, response)
return
def processAlgorithm(self, progress):
layer = self.getParameterValue(self.INPUT_LAYER)
mapping = self.getParameterValue(self.FIELDS_MAPPING)
output = self.getOutputFromName(self.OUTPUT_LAYER)
layer = dataobjects.getObjectFromUri(layer)
fields = []
expressions = []
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp_context = layer.createExpressionContext()
for field_def in mapping:
fields.append(QgsField(name=field_def['name'],
type=field_def['type'],
len=field_def['length'],
prec=field_def['precision']))
expression = QgsExpression(field_def['expression'])
expression.setGeomCalculator(da)
expression.setDistanceUnits(QgsProject.instance().distanceUnits())
expression.setAreaUnits(QgsProject.instance().areaUnits())
expression.prepare(exp_context)
if expression.hasParserError():
raise GeoAlgorithmExecutionException(
self.tr(u'Parser error in expression "{}": {}')
.format(unicode(expression.expression()),
unicode(expression.parserErrorString())))
expressions.append(expression)
writer = output.getVectorWriter(fields,
layer.wkbType(),
layer.crs())
# Create output vector layer with new attributes
error_exp = None
inFeat = QgsFeature()
outFeat = QgsFeature()
features = vector.features(layer)
total = 100.0 / len(features)
for current, inFeat in enumerate(features):
rownum = current + 1
geometry = inFeat.geometry()
outFeat.setGeometry(geometry)
attrs = []
for i in range(0, len(mapping)):
field_def = mapping[i]
expression = expressions[i]
exp_context.setFeature(inFeat)
exp_context.lastScope().setVariable("row_number", rownum)
value = expression.evaluate(exp_context)
if expression.hasEvalError():
error_exp = expression
break
attrs.append(value)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
del writer
if error_exp is not None:
raise GeoAlgorithmExecutionException(
self.tr(u'Evaluation error in expression "{}": {}')
.format(unicode(error_exp.expression()),
unicode(error_exp.parserErrorString())))
def layer_value(feature, layer, defaultconfig):
if not canvas:
roam.utils.warning(
"No canvas set for using layer_values default function")
return None
layers = []
# layer name can also be a list of layers to search
layername = defaultconfig['layer']
if isinstance(layername, basestring):
layers.append(layername)
else:
layers = layername
expression = defaultconfig['expression']
field = defaultconfig['field']
for searchlayer in layers:
try:
searchlayer = QgsMapLayerRegistry.instance().mapLayersByName(
searchlayer)[0]
except IndexError:
RoamEvents.raisemessage(
"Missing layer",
"Unable to find layer used in widget expression {}".format(
searchlayer),
level=1)
roam.utils.warning(
"Unable to find expression layer {}".format(searchlayer))
return
if feature.geometry():
rect = feature.geometry().boundingBox()
if layer.geometryType() == QGis.Point:
point = feature.geometry().asPoint()
rect = QgsRectangle(point.x(), point.y(),
point.x() + 10,
point.y() + 10)
rect.scale(20)
rect = canvas.mapRenderer().mapToLayerCoordinates(layer, rect)
rq = QgsFeatureRequest().setFilterRect(rect)\
.setFlags(QgsFeatureRequest.ExactIntersect)
features = searchlayer.getFeatures(rq)
else:
features = searchlayer.getFeatures()
exp = QgsExpression(expression)
exp.prepare(searchlayer.pendingFields())
if exp.hasParserError():
error = exp.parserErrorString()
roam.utils.warning(error)
for f in features:
value = exp.evaluate(f)
if exp.hasEvalError():
error = exp.evalErrorString()
roam.utils.warning(error)
if value:
return f[field]
raise DefaultError('No features found')
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()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(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, progress):
layer = self.getParameterValue(self.INPUT_LAYER)
mapping = self.getParameterValue(self.FIELDS_MAPPING)
output = self.getOutputFromName(self.OUTPUT_LAYER)
layer = dataobjects.getObjectFromUri(layer)
provider = layer.dataProvider()
fields = []
expressions = []
for field_def in mapping:
fields.append(QgsField(name=field_def['name'],
type=field_def['type'],
len=field_def['length'],
prec=field_def['precision']))
expression = QgsExpression(field_def['expression'])
if expression.hasParserError():
raise GeoAlgorithmExecutionException(
self.tr(u'Parser error in expression "{}": {}')
.format(unicode(field_def['expression']),
unicode(expression.parserErrorString())))
expression.prepare(provider.fields())
if expression.hasEvalError():
raise GeoAlgorithmExecutionException(
self.tr(u'Evaluation error in expression "{}": {}')
.format(unicode(field_def['expression']),
unicode(expression.evalErrorString())))
expressions.append(expression)
writer = output.getVectorWriter(fields,
provider.geometryType(),
layer.crs())
# Create output vector layer with new attributes
error = ''
calculationSuccess = True
inFeat = QgsFeature()
outFeat = QgsFeature()
features = vector.features(layer)
count = len(features)
for current, inFeat in enumerate(features):
rownum = current + 1
outFeat.setGeometry(inFeat.geometry())
attrs = []
for i in xrange(0, len(mapping)):
field_def = mapping[i]
expression = expressions[i]
expression.setCurrentRowNumber(rownum)
value = expression.evaluate(inFeat)
if expression.hasEvalError():
calculationSuccess = False
error = expression.evalErrorString()
break
attrs.append(value)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
current += 1
progress.setPercentage(100 * current / float(count))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation'
' string:\n') + error)
class GeometryByExpression(QgisFeatureBasedAlgorithm):
OUTPUT_GEOMETRY = 'OUTPUT_GEOMETRY'
WITH_Z = 'WITH_Z'
WITH_M = 'WITH_M'
EXPRESSION = 'EXPRESSION'
def group(self):
return self.tr('Vector geometry')
def groupId(self):
return 'vectorgeometry'
def __init__(self):
super().__init__()
self.geometry_types = [self.tr('Polygon'),
'Line',
'Point']
def initParameters(self, config=None):
self.addParameter(QgsProcessingParameterEnum(
self.OUTPUT_GEOMETRY,
self.tr('Output geometry type'),
options=self.geometry_types, defaultValue=0))
self.addParameter(QgsProcessingParameterBoolean(self.WITH_Z,
self.tr('Output geometry has z dimension'), defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.WITH_M,
self.tr('Output geometry has m values'), defaultValue=False))
self.addParameter(QgsProcessingParameterExpression(self.EXPRESSION,
self.tr("Geometry expression"), defaultValue='$geometry', parentLayerParameterName='INPUT'))
def name(self):
return 'geometrybyexpression'
def displayName(self):
return self.tr('Geometry by expression')
def outputName(self):
return self.tr('Modified geometry')
def prepareAlgorithm(self, parameters, context, feedback):
self.geometry_type = self.parameterAsEnum(parameters, self.OUTPUT_GEOMETRY, context)
self.wkb_type = None
if self.geometry_type == 0:
self.wkb_type = QgsWkbTypes.Polygon
elif self.geometry_type == 1:
self.wkb_type = QgsWkbTypes.LineString
else:
self.wkb_type = QgsWkbTypes.Point
if self.parameterAsBool(parameters, self.WITH_Z, context):
self.wkb_type = QgsWkbTypes.addZ(self.wkb_type)
if self.parameterAsBool(parameters, self.WITH_M, context):
self.wkb_type = QgsWkbTypes.addM(self.wkb_type)
self.expression = QgsExpression(self.parameterAsString(parameters, self.EXPRESSION, context))
if self.expression.hasParserError():
feedback.reportError(self.expression.parserErrorString())
return False
self.expression_context = self.createExpressionContext(parameters, context)
self.expression.prepare(self.expression_context)
return True
def outputWkbType(self, input_wkb_type):
return self.wkb_type
def sourceFlags(self):
return QgsProcessingFeatureSource.FlagSkipGeometryValidityChecks
def processFeature(self, feature, context, feedback):
self.expression_context.setFeature(feature)
value = self.expression.evaluate(self.expression_context)
if self.expression.hasEvalError():
raise QgsProcessingException(
self.tr('Evaluation error: {0}').format(self.expression.evalErrorString()))
if not value:
feature.setGeometry(QgsGeometry())
else:
if not isinstance(value, QgsGeometry):
raise QgsProcessingException(
self.tr('{} is not a geometry').format(value))
feature.setGeometry(value)
return [feature]
def processAlgorithm(self, feedback):
layer = self.getParameterValue(self.INPUT_LAYER)
mapping = self.getParameterValue(self.FIELDS_MAPPING)
output = self.getOutputFromName(self.OUTPUT_LAYER)
layer = dataobjects.getObjectFromUri(layer)
fields = []
expressions = []
da = QgsDistanceArea()
da.setSourceCrs(layer.crs())
da.setEllipsoidalMode(True)
da.setEllipsoid(QgsProject.instance().ellipsoid())
exp_context = layer.createExpressionContext()
for field_def in mapping:
fields.append(
QgsField(name=field_def['name'],
type=field_def['type'],
len=field_def['length'],
prec=field_def['precision']))
expression = QgsExpression(field_def['expression'])
expression.setGeomCalculator(da)
expression.setDistanceUnits(QgsProject.instance().distanceUnits())
expression.setAreaUnits(QgsProject.instance().areaUnits())
expression.prepare(exp_context)
if expression.hasParserError():
raise GeoAlgorithmExecutionException(
self.tr(u'Parser error in expression "{}": {}').format(
str(expression.expression()),
str(expression.parserErrorString())))
expressions.append(expression)
writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs())
# Create output vector layer with new attributes
error_exp = None
inFeat = QgsFeature()
outFeat = QgsFeature()
features = vector.features(layer)
total = 100.0 / len(features)
for current, inFeat in enumerate(features):
rownum = current + 1
geometry = inFeat.geometry()
outFeat.setGeometry(geometry)
attrs = []
for i in range(0, len(mapping)):
field_def = mapping[i]
expression = expressions[i]
exp_context.setFeature(inFeat)
exp_context.lastScope().setVariable("row_number", rownum)
value = expression.evaluate(exp_context)
if expression.hasEvalError():
error_exp = expression
break
attrs.append(value)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
feedback.setProgress(int(current * total))
del writer
if error_exp is not None:
raise GeoAlgorithmExecutionException(
self.tr(u'Evaluation error in expression "{}": {}').format(
str(error_exp.expression()),
str(error_exp.parserErrorString())))
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
layer = self.parameterAsVectorLayer(parameters, self.INPUT, context)
field_name = self.parameterAsString(parameters, self.FIELD_NAME,
context)
field_type = self.TYPES[self.parameterAsEnum(parameters,
self.FIELD_TYPE, context)]
width = self.parameterAsInt(parameters, self.FIELD_LENGTH, context)
precision = self.parameterAsInt(parameters, self.FIELD_PRECISION,
context)
new_field = self.parameterAsBool(parameters, self.NEW_FIELD, context)
formula = self.parameterAsString(parameters, self.FORMULA, context)
expression = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(source.sourceCrs(), context.transformContext())
da.setEllipsoid(context.project().ellipsoid())
expression.setGeomCalculator(da)
expression.setDistanceUnits(context.project().distanceUnits())
expression.setAreaUnits(context.project().areaUnits())
fields = source.fields()
field_index = fields.lookupField(field_name)
if new_field or field_index < 0:
fields.append(
QgsField(field_name, field_type, '', width, precision))
(sink, dest_id) = self.parameterAsSink(parameters,
self.OUTPUT, context, fields,
source.wkbType(),
source.sourceCrs())
exp_context = self.createExpressionContext(parameters, context)
if layer is not None:
exp_context.appendScope(
QgsExpressionContextUtils.layerScope(layer))
if not expression.prepare(exp_context):
raise QgsProcessingException(
self.tr('Evaluation error: {0}').format(
expression.parserErrorString()))
features = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(features):
if feedback.isCanceled():
break
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = expression.evaluate(exp_context)
if expression.hasEvalError():
feedback.reportError(expression.evalErrorString())
else:
attrs = f.attributes()
if new_field or field_index < 0:
attrs.append(value)
else:
attrs[field_index] = value
f.setAttributes(attrs)
sink.addFeature(f, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
t_troncon = self.parameterAsSource(parameters, self.SEGMENTS_TABLE,
context)
g_troncon = self.parameterAsSource(parameters, self.GEOM_SEGMENTS,
context)
t_obs = self.parameterAsSource(parameters, self.OBSERVATION_TABLE,
context)
g_obs = self.parameterAsVectorLayer(parameters, self.GEOM_OBSERVATION,
context)
# Get troncon ids and file ids
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project()))
exp_context.appendScope(t_troncon.createExpressionContextScope())
exp_str = '"id_geom_troncon" IS NOT NULL'
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr('* ERROR: Expression %s has eval error: %s').format(
exp.expression(), exp.evalErrorString()))
request = QgsFeatureRequest(exp, exp_context)
request.setSubsetOfAttributes(
['id', 'aab', 'aad', 'aaf', 'abq', 'id_file', 'id_geom_troncon'],
t_troncon.fields())
has_geo_troncon = False
troncons = {}
file_ids = []
for tro in t_troncon.getFeatures(request):
troncons[tro['id']] = tro
file_ids.append(tro['id_file'])
has_geo_troncon = True
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.OBSERVATIONS_CREATED: None}
if not has_geo_troncon:
raise QgsProcessingException(tr('* ERROR: No troncon geometries'))
# Get observation ids
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project()))
exp_context.appendScope(t_obs.createExpressionContextScope())
exp_str = ('"id_troncon" IN ({}) AND '
'"id_file" IN ({})').format(
','.join([str(i) for i in troncons.keys()]),
','.join([str(i) for i in file_ids]))
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr('* ERROR: Expression {} has eval error: {}').format(
exp.expression(), exp.evalErrorString()))
obs_ids = []
request = QgsFeatureRequest(exp, exp_context)
for obs in t_obs.getFeatures(request):
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.OBSERVATIONS_CREATED: None}
troncon = troncons[obs['id_troncon']]
# verifying ITV file
if troncon['id_file'] != obs['id_file']:
continue
obs_ids.append(obs['id'])
if not obs_ids:
raise QgsProcessingException(
tr('* ERROR: No observations to geolocalize found'))
# Check observations already geolocalised on troncon
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project()))
exp_context.appendScope(QgsExpressionContextUtils.layerScope(g_obs))
exp_str = '"id" IN ({})'.format(','.join([str(i) for i in obs_ids]))
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr('* ERROR: Expression {} has eval error: {}').format(
exp.expression(), exp.evalErrorString()))
request = QgsFeatureRequest(exp, exp_context)
geo_observations = []
for obs in g_obs.getFeatures(request):
geo_observations.append(obs['id'])
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.OBSERVATIONS_CREATED: None}
# build observation geometry based on table
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project()))
exp_context.appendScope(t_obs.createExpressionContextScope())
exp_str = ('"id_troncon" IN ({}) AND '
'"id_file" IN ({})').format(
','.join([str(i) for i in troncons.keys()]),
','.join([str(i) for i in file_ids]))
if geo_observations:
exp_str += ' AND id NOT IN ({})'.format(','.join(
[str(i) for i in geo_observations]))
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr('* ERROR: Expression {} has eval error: {}').format(
exp.expression(), exp.evalErrorString()))
request = QgsFeatureRequest(exp, exp_context)
features = []
fields = provider_fields(g_obs.fields())
for obs in t_obs.getFeatures(request):
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.OBSERVATIONS_CREATED: None}
troncon = troncons[obs['id_troncon']]
# verifying ITV file
if troncon['id_file'] != obs['id_file']:
continue
geo_req = QgsFeatureRequest()
geo_req.setFilterFid(troncon['id_geom_troncon'])
for g_tro in g_troncon.getFeatures(geo_req):
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.OBSERVATIONS_CREATED: None}
geom = g_tro.geometry()
pt = None
if troncon['aab'] == troncon['aad']:
pt = geom.interpolate(geom.length() * obs['i'] /
troncon['abq'])
else:
pt = geom.interpolate(geom.length() *
(1 - obs['i'] / troncon['abq']))
fet = QgsFeature(fields)
fet.setGeometry(pt)
fet.setAttribute('id', obs['id'])
features.append(fet)
# Ajout des objets observations
if features:
g_obs.startEditing()
(res, outFeats) = g_obs.dataProvider().addFeatures(features)
if not res or not outFeats:
raise QgsProcessingException(
tr('* ERREUR: lors de l\'enregistrement '
'des regards {}').format(', '.join(
g_obs.dataProvider().errors())))
if not g_obs.commitChanges():
raise QgsProcessingException(
tr('* ERROR: Commit {}.').format(g_obs.commitErrors()))
# Returns empty dict if no outputs
return {self.OBSERVATIONS_CREATED: len(features)}
