def getVectorWriter(self, fields, geomType, crs, context): """Returns a suitable writer to which features can be added as a result of the algorithm. Use this to transparently handle output values instead of creating your own method. Executing this method might modify the object, adding additional information to it, so the writer can be later accessed and processed within QGIS. It should be called just once, since a new call might result in previous data being replaced, thus rendering a previously obtained writer useless. @param fields a list of QgsField @param geomType a suitable geometry type, as it would be passed to a QgsVectorFileWriter constructor @param crs the crs of the layer to create @return writer instance of the vector writer class :param context: """ if self.encoding is None: settings = QgsSettings() self.encoding = settings.value('/Processing/encoding', 'System', str) w, w_dest = QgsProcessingUtils.createFeatureSink(self.value, context, fields, geomType, crs, {'fileEncoding': self.encoding}) self.value = w_dest return w
def executeIterating(alg, parameters, paramToIter, context, feedback): # Generate all single-feature layers parameter_definition = alg.parameterDefinition(paramToIter) if not parameter_definition: return False iter_source = QgsProcessingParameters.parameterAsSource( parameter_definition, parameters, context) sink_list = [] if iter_source.featureCount() == 0: return False total = 100.0 / iter_source.featureCount() for current, feat in enumerate(iter_source.getFeatures()): if feedback.isCanceled(): return False sink, sink_id = QgsProcessingUtils.createFeatureSink( 'memory:', context, iter_source.fields(), iter_source.wkbType(), iter_source.sourceCrs()) sink_list.append(sink_id) sink.addFeature(feat, QgsFeatureSink.FastInsert) del sink feedback.setProgress(int(current * total)) # store output values to use them later as basenames for all outputs outputs = {} for out in alg.destinationParameterDefinitions(): outputs[out.name()] = parameters[out.name()] # now run all the algorithms for i, f in enumerate(sink_list): if feedback.isCanceled(): return False parameters[paramToIter] = f for out in alg.destinationParameterDefinitions(): o = outputs[out.name()] parameters[ out.name()] = QgsProcessingUtils.generateIteratingDestination( o, i, context) feedback.setProgressText( QCoreApplication.translate('AlgorithmExecutor', 'Executing iteration {0}/{1}…').format( i, len(sink_list))) feedback.setProgress(i * 100 / len(sink_list)) ret, results = execute(alg, parameters, context, feedback) if not ret: return False handleAlgorithmResults(alg, context, feedback, False) return True
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) output_format = context.preferredVectorFormat() if not output_format in QgsVectorFileWriter.supportedFormatExtensions(): # fallback to gpkg if preferred format is not available output_format = 'gpkg' 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}.{2}'.format(baseName, str(i).strip(), output_format) 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 executeIterating(alg, parameters, paramToIter, context, feedback): # Generate all single-feature layers parameter_definition = alg.parameterDefinition(paramToIter) if not parameter_definition: return False iter_source = QgsProcessingParameters.parameterAsSource(parameter_definition, parameters, context) sink_list = [] if iter_source.featureCount() == 0: return False total = 100.0 / iter_source.featureCount() for current, feat in enumerate(iter_source.getFeatures()): if feedback.isCanceled(): return False sink, sink_id = QgsProcessingUtils.createFeatureSink('memory:', context, iter_source.fields(), iter_source.wkbType(), iter_source.sourceCrs()) sink_list.append(sink_id) sink.addFeature(feat, QgsFeatureSink.FastInsert) del sink feedback.setProgress(int(current * total)) # store output values to use them later as basenames for all outputs outputs = {} for out in alg.destinationParameterDefinitions(): if out.name() in parameters: outputs[out.name()] = parameters[out.name()] # now run all the algorithms for i, f in enumerate(sink_list): if feedback.isCanceled(): return False parameters[paramToIter] = f for out in alg.destinationParameterDefinitions(): if out.name() not in outputs: continue o = outputs[out.name()] parameters[out.name()] = QgsProcessingUtils.generateIteratingDestination(o, i, context) feedback.setProgressText(QCoreApplication.translate('AlgorithmExecutor', 'Executing iteration {0}/{1}…').format(i + 1, len(sink_list))) feedback.setProgress(i * 100 / len(sink_list)) ret, results = execute(alg, parameters, context, feedback) if not ret: return False handleAlgorithmResults(alg, context, feedback, False) return True
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, parameters, context, feedback): source = self.parameterAsSource(parameters, self.INPUT, context) 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): expr_context = self.createExpressionContext(parameters, context) self.group_by_expr.prepare(expr_context) # Group features in memory layers source = self.source count = self.source.featureCount() if count: progress_step = 50.0 / count current = 0 groups = {} keys = [] # We need deterministic order for the tests feature = QgsFeature() for feature in self.source.getFeatures(): expr_context.setFeature(feature) group_by_value = self.evaluateExpression(self.group_by_expr, expr_context) # Get an hashable key for the dict key = group_by_value if isinstance(key, list): key = tuple(key) group = groups.get(key, None) if group is None: sink, id = QgsProcessingUtils.createFeatureSink( 'memory:', context, source.fields(), source.wkbType(), source.sourceCrs()) layer = QgsProcessingUtils.mapLayerFromString(id, context) group = {'sink': sink, 'layer': layer, 'feature': feature} groups[key] = group keys.append(key) group['sink'].addFeature(feature, QgsFeatureSink.FastInsert) current += 1 feedback.setProgress(int(current * progress_step)) if feedback.isCanceled(): return (sink, dest_id) = self.parameterAsSink( parameters, self.OUTPUT, context, self.fields, QgsWkbTypes.multiType(source.wkbType()), source.sourceCrs()) # Calculate aggregates on memory layers if len(keys): progress_step = 50.0 / len(keys) for current, key in enumerate(keys): group = groups[key] expr_context = self.createExpressionContext(parameters, context) expr_context.appendScope( QgsExpressionContextUtils.layerScope(group['layer'])) expr_context.setFeature(group['feature']) geometry = self.evaluateExpression(self.geometry_expr, expr_context) if geometry is not None and not geometry.isEmpty(): geometry = QgsGeometry.unaryUnion( geometry.asGeometryCollection()) if geometry.isEmpty(): raise QgsProcessingException( 'Impossible to combine geometries for {} = {}'.format( self.group_by, group_by_value)) attrs = [] for fields_expr in self.fields_expr: attrs.append(self.evaluateExpression(fields_expr, expr_context)) # Write output feature outFeat = QgsFeature() if geometry is not None: outFeat.setGeometry(geometry) outFeat.setAttributes(attrs) sink.addFeature(outFeat, QgsFeatureSink.FastInsert) feedback.setProgress(50 + int(current * progress_step)) if feedback.isCanceled(): return return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback): expr_context = self.createExpressionContext(parameters, context, self.source) self.group_by_expr.prepare(expr_context) # Group features in memory layers source = self.source count = self.source.featureCount() if count: progress_step = 50.0 / count current = 0 groups = {} keys = [] # We need deterministic order for the tests feature = QgsFeature() for feature in self.source.getFeatures(): expr_context.setFeature(feature) group_by_value = self.evaluateExpression(self.group_by_expr, expr_context) # Get an hashable key for the dict key = group_by_value if isinstance(key, list): key = tuple(key) group = groups.get(key, None) if group is None: sink, id = QgsProcessingUtils.createFeatureSink( 'memory:', context, source.fields(), source.wkbType(), source.sourceCrs()) layer = QgsProcessingUtils.mapLayerFromString(id, context) group = { 'sink': sink, 'layer': layer, 'feature': feature } groups[key] = group keys.append(key) group['sink'].addFeature(feature, QgsFeatureSink.FastInsert) current += 1 feedback.setProgress(int(current * progress_step)) if feedback.isCanceled(): return (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, self.fields, QgsWkbTypes.multiType(source.wkbType()), source.sourceCrs()) if sink is None: raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT)) # Calculate aggregates on memory layers if len(keys): progress_step = 50.0 / len(keys) for current, key in enumerate(keys): group = groups[key] expr_context = self.createExpressionContext(parameters, context) expr_context.appendScope(QgsExpressionContextUtils.layerScope(group['layer'])) expr_context.setFeature(group['feature']) geometry = self.evaluateExpression(self.geometry_expr, expr_context) if geometry is not None and not geometry.isEmpty(): geometry = QgsGeometry.unaryUnion(geometry.asGeometryCollection()) if geometry.isEmpty(): raise QgsProcessingException( 'Impossible to combine geometries for {} = {}' .format(self.group_by, group_by_value)) attrs = [] for fields_expr in self.fields_expr: attrs.append(self.evaluateExpression(fields_expr, expr_context)) # Write output feature outFeat = QgsFeature() if geometry is not None: outFeat.setGeometry(geometry) outFeat.setAttributes(attrs) sink.addFeature(outFeat, QgsFeatureSink.FastInsert) feedback.setProgress(50 + int(current * progress_step)) if feedback.isCanceled(): return return {self.OUTPUT: dest_id}
##Centroids=name ##Geometry=group ##INPUT_LAYER=vector ##OUTPUT_LAYER=output vector from qgis.core import QgsWkbTypes, QgsProcessingUtils layer = QgsProcessingUtils.mapLayerFromString(INPUT_LAYER, context) fields = layer.fields() writer, writer_dest = QgsProcessingUtils.createFeatureSink( OUTPUT_LAYER, context, fields, QgsWkbTypes.Point, layer.crs(), {'fileEncoding': 'utf-8'}) features = QgsProcessingUtils.getFeatures(layer, context) count = QgsProcessingUtils.featureCount(layer, context) if count == 0: raise GeoAlgorithmExecutionException('Input layer contains no features.') total = 100.0 / count for count, f in enumerate(features): outputFeature = f if f.hasGeometry(): outputGeometry = f.geometry().centroid() outputFeature.setGeometry(outputGeometry) writer.addFeature(outputFeature) feedback.setProgress(int(count * total))
##Centroids=name ##Geometry=group ##INPUT_LAYER=vector ##OUTPUT_LAYER=output vector from qgis.core import QgsWkbTypes, QgsProcessingUtils layer = QgsProcessingUtils.mapLayerFromString(INPUT_LAYER, context) fields = layer.fields() writer, writer_dest = QgsProcessingUtils.createFeatureSink( OUTPUT_LAYER, 'utf-8', fields, QgsWkbTypes.Point, layer.crs(), context) features = QgsProcessingUtils.getFeatures(layer, context) count = QgsProcessingUtils.featureCount(layer, context) if count == 0: raise GeoAlgorithmExecutionException('Input layer contains no features.') total = 100.0 / count for count, f in enumerate(features): outputFeature = f if f.hasGeometry(): outputGeometry = f.geometry().centroid() outputFeature.setGeometry(outputGeometry) writer.addFeature(outputFeature) feedback.setProgress(int(count * total))
##Vector table tools=group ##input=vector ##class_field=field input ##value_field=field input ##N_unique_values=output vector from qgis.PyQt.QtCore import QVariant from qgis.core import QgsFeature, QgsField, QgsProcessingUtils layer = QgsProcessingUtils.mapLayerFromString(input, context) fields = layer.fields() fields.append(QgsField('UNIQ_COUNT', QVariant.Int)) writer, writer_dest = QgsProcessingUtils.createFeatureSink( N_unique_values, context, fields, layer.wkbType(), layer.crs()) class_field_index = layer.fields().lookupField(class_field) value_field_index = layer.fields().lookupField(value_field) outFeat = QgsFeature() classes = {} feats = QgsProcessingUtils.getFeatures(layer, context) nFeat = QgsProcessingUtils.featureCount(layer, context) for n, inFeat in enumerate(feats): feedback.setProgress(int(100 * n / nFeat)) attrs = inFeat.attributes() clazz = attrs[class_field_index] value = attrs[value_field_index] if clazz not in classes: classes[clazz] = [] if value not in classes[clazz]: classes[clazz].append(value)
##Centroids=name ##Geometry=group ##INPUT_LAYER=vector ##OUTPUT_LAYER=output vector from qgis.core import QgsWkbTypes, QgsProcessingUtils layer = QgsProcessingUtils.mapLayerFromString(INPUT_LAYER, context) fields = layer.fields() writer, writer_dest = QgsProcessingUtils.createFeatureSink(OUTPUT_LAYER, context, fields, QgsWkbTypes.Point, layer.crs(), {'fileEncoding': 'utf-8'}) features = QgsProcessingUtils.getFeatures(layer, context) count = QgsProcessingUtils.featureCount(layer, context) if count == 0: raise GeoAlgorithmExecutionException('Input layer contains no features.') total = 100.0 / count for count, f in enumerate(features): outputFeature = f if f.hasGeometry(): outputGeometry = f.geometry().centroid() outputFeature.setGeometry(outputGeometry) writer.addFeature(outputFeature) feedback.setProgress(int(count * total))
##Vector table tools=group ##input=vector ##class_field=field input ##value_field=field input ##N_unique_values=output vector from qgis.PyQt.QtCore import QVariant from qgis.core import QgsFeature, QgsField, QgsProcessingUtils layer = QgsProcessingUtils.mapLayerFromString(input, context) fields = layer.fields() fields.append(QgsField('UNIQ_COUNT', QVariant.Int)) writer, writer_dest = QgsProcessingUtils.createFeatureSink(N_unique_values, context, fields, layer.wkbType(), layer.crs()) class_field_index = layer.fields().lookupField(class_field) value_field_index = layer.fields().lookupField(value_field) outFeat = QgsFeature() classes = {} feats = QgsProcessingUtils.getFeatures(layer, context) nFeat = QgsProcessingUtils.featureCount(layer, context) for n, inFeat in enumerate(feats): feedback.setProgress(int(100 * n / nFeat)) attrs = inFeat.attributes() clazz = attrs[class_field_index] value = attrs[value_field_index] if clazz not in classes: classes[clazz] = [] if value not in classes[clazz]: classes[clazz].append(value)