def processAlgorithm(self, parameters, context, feedback):
layer = self.parameterAsVectorLayer(parameters, self.INPUT, context)
fieldName = self.parameterAsString(parameters, self.FIELD, context)
operator = self.OPERATORS[self.parameterAsEnum(parameters, self.OPERATOR, context)]
value = self.parameterAsString(parameters, self.VALUE, context)
fields = layer.fields()
idx = layer.fields().lookupField(fieldName)
if idx < 0:
raise QgsProcessingException(self.tr("Field '{}' was not found in layer").format(fieldName))
fieldType = fields[idx].type()
if fieldType != QVariant.String and operator in self.STRING_OPERATORS:
op = ''.join(['"%s", ' % o for o in self.STRING_OPERATORS])
raise QgsProcessingException(
self.tr('Operators {0} can be used only with string fields.').format(op))
field_ref = QgsExpression.quotedColumnRef(fieldName)
quoted_val = QgsExpression.quotedValue(value)
if operator == 'is null':
expression_string = '{} IS NULL'.format(field_ref)
elif operator == 'is not null':
expression_string = '{} IS NOT NULL'.format(field_ref)
elif operator == 'begins with':
expression_string = "{} LIKE '{}%'".format(field_ref, value)
elif operator == 'contains':
expression_string = "{} LIKE '%{}%'".format(field_ref, value)
elif operator == 'does not contain':
expression_string = "{} NOT LIKE '%{}%'".format(field_ref, value)
else:
expression_string = '{} {} {}'.format(field_ref, operator, quoted_val)
method = self.parameterAsEnum(parameters, self.METHOD, context)
if method == 0:
behavior = QgsVectorLayer.SetSelection
elif method == 1:
behavior = QgsVectorLayer.AddToSelection
elif method == 2:
behavior = QgsVectorLayer.RemoveFromSelection
elif method == 3:
behavior = QgsVectorLayer.IntersectSelection
expression = QgsExpression(expression_string)
if expression.hasParserError():
raise QgsProcessingException(expression.parserErrorString())
layer.selectByExpression(expression_string, behavior)
return {self.OUTPUT: parameters[self.INPUT]}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
fieldName = self.parameterAsString(parameters, self.FIELD, context)
directory = self.parameterAsString(parameters, self.OUTPUT, context)
mkdir(directory)
fieldIndex = source.fields().lookupField(fieldName)
uniqueValues = source.uniqueValues(fieldIndex)
baseName = os.path.join(directory, '{0}'.format(fieldName))
fields = source.fields()
crs = source.sourceCrs()
geomType = source.wkbType()
total = 100.0 / len(uniqueValues) if uniqueValues else 1
output_layers = []
for current, i in enumerate(uniqueValues):
if feedback.isCanceled():
break
fName = u'{0}_{1}.shp'.format(baseName, str(i).strip())
feedback.pushInfo(self.tr('Creating layer: {}').format(fName))
sink, dest = QgsProcessingUtils.createFeatureSink(
fName, context, fields, geomType, crs)
filter = '{} = {}'.format(QgsExpression.quotedColumnRef(fieldName),
QgsExpression.quotedValue(i))
req = QgsFeatureRequest().setFilterExpression(filter)
count = 0
for f in source.getFeatures(req):
if feedback.isCanceled():
break
sink.addFeature(f, QgsFeatureSink.FastInsert)
count += 1
feedback.pushInfo(
self.tr('Added {} features to layer').format(count))
output_layers.append(fName)
del sink
feedback.setProgress(int(current * total))
return {self.OUTPUT: directory, self.OUTPUT_LAYERS: output_layers}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
field_split = self.parameterAsString(parameters, self.SPLIT, context)
if field_split:
field_split_index = source.fields().lookupField(field_split)
field_event = self.parameterAsString(parameters, self.EVENT_ID,
context)
if field_event:
field_event_index = source.fields().lookupField(field_event)
output_file = self.parameterAsFileOutput(parameters,
self.OUTPUT_HTML_FILE,
context)
self.path = output_file
spatialIndex = QgsSpatialIndex(source, feedback)
uniqueValues = source.uniqueValues(field_split)
total = 100.0 / len(uniqueValues) if uniqueValues else 1
distArea = QgsDistanceArea()
distArea.setSourceCrs(source.sourceCrs(), context.transformContext())
distArea.setEllipsoid(context.project().ellipsoid())
for current, i in enumerate(uniqueValues):
if feedback.isCanceled():
break
filter = '{} = {}'.format(
QgsExpression.quotedColumnRef(field_split),
QgsExpression.quotedValue(i))
req = QgsFeatureRequest().setFilterExpression(
filter).setSubsetOfAttributes([field_event])
features = source.getFeatures(req)
for current, inFeat in enumerate(features):
if feedback.isCanceled():
break
inGeom = inFeat.geometry()
inID = str(inFeat[field_event])
featList = index.nearestNeighbor(inGeom.asPoint(), 1)
self.output = {self.OUTPUT_HTML_FILE: output_file}
return self.output
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.INPUT), context)
fieldName = self.getParameterValue(self.FIELD)
operator = self.OPERATORS[self.getParameterValue(self.OPERATOR)]
value = self.getParameterValue(self.VALUE)
fields = layer.fields()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, layer.wkbType(), layer.crs(), context)
idx = layer.fields().lookupField(fieldName)
fieldType = fields[idx].type()
if fieldType != QVariant.String and operator in self.STRING_OPERATORS:
op = ''.join(['"%s", ' % o for o in self.STRING_OPERATORS])
raise GeoAlgorithmExecutionException(
self.tr('Operators {0} can be used only with string fields.').
format(op))
field_ref = QgsExpression.quotedColumnRef(fieldName)
quoted_val = QgsExpression.quotedValue(value)
if operator == 'is null':
expr = '{} IS NULL'.format(field_ref)
elif operator == 'is not null':
expr = '{} IS NOT NULL'.format(field_ref)
elif operator == 'begins with':
expr = """%s LIKE '%s%%'""" % (field_ref, value)
elif operator == 'contains':
expr = """%s LIKE '%%%s%%'""" % (field_ref, value)
elif operator == 'does not contain':
expr = """%s NOT LIKE '%%%s%%'""" % (field_ref, value)
else:
expr = '{} {} {}'.format(field_ref, operator, quoted_val)
expression = QgsExpression(expr)
if not expression.hasParserError():
req = QgsFeatureRequest(expression)
else:
raise GeoAlgorithmExecutionException(
expression.parserErrorString())
for f in layer.getFeatures(req):
writer.addFeature(f)
del writer
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
fieldName = self.parameterAsString(parameters, self.FIELD, context)
directory = self.parameterAsString(parameters, self.OUTPUT, context)
mkdir(directory)
fieldIndex = source.fields().lookupField(fieldName)
uniqueValues = source.uniqueValues(fieldIndex)
baseName = os.path.join(directory, '{0}'.format(fieldName))
fields = source.fields()
crs = source.sourceCrs()
geomType = source.wkbType()
total = 100.0 / len(uniqueValues) if uniqueValues else 1
output_layers = []
for current, i in enumerate(uniqueValues):
if feedback.isCanceled():
break
fName = '{0}_{1}.gpkg'.format(baseName, str(i).strip())
feedback.pushInfo(self.tr('Creating layer: {}').format(fName))
sink, dest = QgsProcessingUtils.createFeatureSink(fName, context, fields, geomType, crs)
filter = '{} = {}'.format(QgsExpression.quotedColumnRef(fieldName), QgsExpression.quotedValue(i))
req = QgsFeatureRequest().setFilterExpression(filter)
count = 0
for f in source.getFeatures(req):
if feedback.isCanceled():
break
sink.addFeature(f, QgsFeatureSink.FastInsert)
count += 1
feedback.pushInfo(self.tr('Added {} features to layer').format(count))
output_layers.append(fName)
del sink
feedback.setProgress(int(current * total))
return {self.OUTPUT: directory, self.OUTPUT_LAYERS: output_layers}
def processAlgorithm(self, feedback):
layer = dataobjects.getLayerFromString(self.getParameterValue(self.INPUT))
fieldName = self.getParameterValue(self.FIELD)
operator = self.OPERATORS[self.getParameterValue(self.OPERATOR)]
value = self.getParameterValue(self.VALUE)
fields = layer.fields()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
layer.wkbType(), layer.crs())
idx = layer.fields().lookupField(fieldName)
fieldType = fields[idx].type()
if fieldType != QVariant.String and operator in self.STRING_OPERATORS:
op = ''.join(['"%s", ' % o for o in self.STRING_OPERATORS])
raise GeoAlgorithmExecutionException(
self.tr('Operators {0} can be used only with string fields.').format(op))
field_ref = QgsExpression.quotedColumnRef(fieldName)
quoted_val = QgsExpression.quotedValue(value)
if operator == 'is null':
expr = '{} IS NULL'.format(field_ref)
elif operator == 'is not null':
expr = '{} IS NOT NULL'.format(field_ref)
elif operator == 'begins with':
expr = """%s LIKE '%s%%'""" % (field_ref, value)
elif operator == 'contains':
expr = """%s LIKE '%%%s%%'""" % (field_ref, value)
elif operator == 'does not contain':
expr = """%s NOT LIKE '%%%s%%'""" % (field_ref, value)
else:
expr = '{} {} {}'.format(field_ref, operator, quoted_val)
expression = QgsExpression(expr)
if not expression.hasParserError():
req = QgsFeatureRequest(expression)
else:
raise GeoAlgorithmExecutionException(expression.parserErrorString())
for f in layer.getFeatures(req):
writer.addFeature(f)
del writer
def processAlgorithm(self, parameters, context, feedback):
layer = self.parameterAsVectorLayer(parameters, self.INPUT, context)
fieldName = self.parameterAsString(parameters, self.FIELD, context)
operator = self.OPERATORS[self.parameterAsEnum(parameters,
self.OPERATOR, context)]
value = self.parameterAsString(parameters, self.VALUE, context)
fields = layer.fields()
idx = layer.fields().lookupField(fieldName)
fieldType = fields[idx].type()
if fieldType != QVariant.String and operator in self.STRING_OPERATORS:
op = ''.join(['"%s", ' % o for o in self.STRING_OPERATORS])
raise GeoAlgorithmExecutionException(
self.tr('Operators {0} can be used only with string fields.').
format(op))
field_ref = QgsExpression.quotedColumnRef(fieldName)
quoted_val = QgsExpression.quotedValue(value)
if operator == 'is null':
expression_string = '{} IS NULL'.format(field_ref)
elif operator == 'is not null':
expression_string = '{} IS NOT NULL'.format(field_ref)
elif operator == 'begins with':
expression_string = """%s LIKE '%s%%'""" % (field_ref, value)
elif operator == 'contains':
expression_string = """%s LIKE '%%%s%%'""" % (field_ref, value)
elif operator == 'does not contain':
expression_string = """%s NOT LIKE '%%%s%%'""" % (field_ref, value)
else:
expression_string = '{} {} {}'.format(field_ref, operator,
quoted_val)
expression = QgsExpression(expression_string)
if expression.hasParserError():
raise GeoAlgorithmExecutionException(
expression.parserErrorString())
layer.selectByExpression(expression_string)
return {self.OUTPUT: parameters[self.INPUT]}
def processAlgorithm(self, parameters, context, feedback):
layer = self.parameterAsVectorLayer(parameters, self.INPUT, context)
fieldName = self.parameterAsString(parameters, self.FIELD, context)
operator = self.OPERATORS[self.parameterAsEnum(parameters, self.OPERATOR, context)]
value = self.parameterAsString(parameters, self.VALUE, context)
fields = layer.fields()
idx = layer.fields().lookupField(fieldName)
fieldType = fields[idx].type()
if fieldType != QVariant.String and operator in self.STRING_OPERATORS:
op = ''.join(['"%s", ' % o for o in self.STRING_OPERATORS])
raise QgsProcessingException(
self.tr('Operators {0} can be used only with string fields.').format(op))
field_ref = QgsExpression.quotedColumnRef(fieldName)
quoted_val = QgsExpression.quotedValue(value)
if operator == 'is null':
expression_string = '{} IS NULL'.format(field_ref)
elif operator == 'is not null':
expression_string = '{} IS NOT NULL'.format(field_ref)
elif operator == 'begins with':
expression_string = """%s LIKE '%s%%'""" % (field_ref, value)
elif operator == 'contains':
expression_string = """%s LIKE '%%%s%%'""" % (field_ref, value)
elif operator == 'does not contain':
expression_string = """%s NOT LIKE '%%%s%%'""" % (field_ref, value)
else:
expression_string = '{} {} {}'.format(field_ref, operator, quoted_val)
expression = QgsExpression(expression_string)
if expression.hasParserError():
raise QgsProcessingException(expression.parserErrorString())
layer.selectByExpression(expression_string)
return {self.OUTPUT: parameters[self.INPUT]}
def processAlgorithm(self, feedback):
fileName = self.getParameterValue(self.INPUT)
layer = dataobjects.getLayerFromString(fileName)
fieldName = self.getParameterValue(self.FIELD)
operator = self.OPERATORS[self.getParameterValue(self.OPERATOR)]
value = self.getParameterValue(self.VALUE)
fields = layer.fields()
idx = layer.fields().lookupField(fieldName)
fieldType = fields[idx].type()
if fieldType != QVariant.String and operator in self.STRING_OPERATORS:
op = ''.join(['"%s", ' % o for o in self.STRING_OPERATORS])
raise GeoAlgorithmExecutionException(
self.tr('Operators {0} can be used only with string fields.').format(op))
field_ref = QgsExpression.quotedColumnRef(fieldName)
quoted_val = QgsExpression.quotedValue(value)
if operator == 'is null':
expression_string = '{} IS NULL'.format(field_ref)
elif operator == 'is not null':
expression_string = '{} IS NOT NULL'.format(field_ref)
elif operator == 'begins with':
expression_string = """%s LIKE '%s%%'""" % (field_ref, value)
elif operator == 'contains':
expression_string = """%s LIKE '%%%s%%'""" % (field_ref, value)
elif operator == 'does not contain':
expression_string = """%s NOT LIKE '%%%s%%'""" % (field_ref, value)
else:
expression_string = '{} {} {}'.format(field_ref, operator, quoted_val)
expression = QgsExpression(expression_string)
if expression.hasParserError():
raise GeoAlgorithmExecutionException(expression.parserErrorString())
layer.selectByExpression(expression_string)
self.setOutputValue(self.OUTPUT, fileName)
def _categorizedStyle(layer):
renderer = layer.renderer()
labeling = layer.labeling()
classAttribute = renderer.classAttribute()
fields = layer.fields()
fieldNames = [f.name() for f in fields]
if classAttribute in fieldNames:
classAttribute = '"{}"'.format(classAttribute)
elseValues = []
styles = []
styleMap = {}
categories = renderer.categories()
for i, c in enumerate(categories):
styleId = 'category{}'.format(i)
symbolLayer = c.symbol().symbolLayer(0)
ok, style = _symbolLayerToStyle(symbolLayer, labeling)
if not ok:
return None, style
styleDefinition = ' <Style id="{}">\n{}\n </Style>'.format(
styleId, style)
styles.append(styleDefinition)
if c.value() is not None:
v = QgsExpression.quotedValue(c.value())
elseValues.append(v)
styleMap[styleId] = '{} = {}'.format(classAttribute, v)
else:
styleMap[styleId] = '{} NOT IN ({})'.format(
classAttribute, ','.join(elseValues))
return styleMap, '\n'.join(styles)
def processFeatures(self, reaches, reach_layer, wastewater_node_layer, distance_threshold):
ids = list()
to_ids = list()
# Gather ids of connected networkelements
# to_ids are also gathered separately, because they can be either
# reaches or nodes
for reach in reaches:
if reach['rp_from_fk_wastewater_networkelement']:
ids.append(reach['rp_from_fk_wastewater_networkelement'])
if reach['rp_to_fk_wastewater_networkelement']:
ids.append(reach['rp_to_fk_wastewater_networkelement'])
to_ids.append(reach['rp_to_fk_wastewater_networkelement'])
# Get all nodes on which to snap
quoted_ids = [QgsExpression.quotedValue(objid) for objid in ids]
node_request = QgsFeatureRequest()
filter_expression = '"obj_id" IN ({ids})'.format(
ids=','.join(quoted_ids))
node_request.setFilterExpression(filter_expression)
node_request.setSubsetOfAttributes([])
nodes = dict()
for node in wastewater_node_layer.getFeatures(node_request):
nodes[node['obj_id']] = node
# Get all reaches on which to snap
quoted_to_ids = [QgsExpression.quotedValue(objid) for objid in to_ids]
reach_request = QgsFeatureRequest()
filter_expression = '"obj_id" IN ({ids})'.format(
ids=','.join(quoted_to_ids))
reach_request.setFilterExpression(filter_expression)
reach_request.setSubsetOfAttributes([])
target_reaches = dict()
for target_reach in reach_layer.getFeatures(reach_request):
target_reaches[target_reach['obj_id']] = target_reach
for reach in reaches:
reach_geometry = QgsGeometry(reach.geometry())
from_id = reach['rp_from_fk_wastewater_networkelement']
if from_id in list(nodes.keys()):
if distance_threshold == 0 or reach_geometry.sqrDistToVertexAt(nodes[from_id].geometry().asPoint(), 0) < distance_threshold:
reach_geometry.moveVertex(
nodes[from_id].geometry().constGet(), 0)
to_id = reach['rp_to_fk_wastewater_networkelement']
if to_id in list(nodes.keys()):
last_vertex = reach_geometry.constGet().nCoordinates() - 1
if distance_threshold == 0 or reach_geometry.sqrDistToVertexAt(nodes[to_id].geometry().asPoint(), last_vertex) < distance_threshold:
reach_geometry.moveVertex(
nodes[to_id].geometry().constGet(), last_vertex)
if to_id in list(target_reaches.keys()):
last_vertex = reach_geometry.constGet().nCoordinates() - 1
target_reach = target_reaches[to_id]
distance, point, min_distance_point, after_vertex = target_reach.geometry(
).closestSegmentWithContext(QgsPointXY(reach_geometry.vertexAt(last_vertex)))
if distance_threshold == 0 or distance < distance_threshold:
reach_geometry.moveVertex(
point.x(), point.y(), last_vertex)
reach.setGeometry(reach_geometry)
reach_layer.updateFeature(reach)
def onAttributeChanged(self, attributeName, value):
idx = self.layer.fields().indexOf(attributeName)
self.layer.blockSignals(True)
self.layer.setDefaultValueDefinition(
idx, QgsDefaultValue(QgsExpression.quotedValue(value)))
self.layer.blockSignals(False)
