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)