Merge pull request #4417 from nyalldawson/processing_writer

Refactor processing writer to use QgsFeatureSink
2025-04-14 00:07:35 -04:00 · 2017-04-27 10:14:33 +10:00 · 2017-04-27 10:14:33 +10:00 · ccb4ac98b4
commit ccb4ac98b4
parent d7181105b5 fd2c18ee16
123 changed files with 307 additions and 458 deletions
--- a/python/core/processing/qgsprocessingcontext.sip
+++ b/python/core/processing/qgsprocessingcontext.sip
@ -75,8 +75,12 @@ class QgsProcessingContext
 Sets the expression ``context``.
 %End

-
-
+    QgsProject &temporaryLayerStore();
+%Docstring
+ Returns a reference to the project used for storing temporary layers during
+ algorithm execution.
+ :rtype: QgsProject
+%End

    QgsFeatureRequest::InvalidGeometryCheck invalidGeometryCheck() const;
 %Docstring
--- a/python/plugins/processing/algs/qgis/AddTableField.py
+++ b/python/plugins/processing/algs/qgis/AddTableField.py
@ -97,8 +97,7 @@ class AddTableField(GeoAlgorithm):
        fields = layer.fields()
        fields.append(QgsField(fieldName, self.TYPES[fieldType], '',
                               fieldLength, fieldPrecision))
-        writer = output.getVectorWriter(fields, layer.wkbType(),
-                                        layer.crs())
+        writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
        outFeat = QgsFeature()
        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/AutoincrementalField.py
+++ b/python/plugins/processing/algs/qgis/AutoincrementalField.py
@ -67,8 +67,7 @@ class AutoincrementalField(GeoAlgorithm):
            dataobjects.getLayerFromString(self.getParameterValue(self.INPUT))
        fields = vlayer.fields()
        fields.append(QgsField('AUTO', QVariant.Int))
-        writer = output.getVectorWriter(fields, vlayer.wkbType(),
-                                        vlayer.crs())
+        writer = output.getVectorWriter(fields, vlayer.wkbType(), vlayer.crs(), context)
        outFeat = QgsFeature()
        features = QgsProcessingUtils.getFeatures(vlayer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(vlayer, context)
--- a/python/plugins/processing/algs/qgis/Boundary.py
+++ b/python/plugins/processing/algs/qgis/Boundary.py
@ -78,10 +78,7 @@ class Boundary(GeoAlgorithm):
            output_wkb = QgsWkbTypes.addM(output_wkb)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields(),
-                output_wkb,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), output_wkb, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/BoundingBox.py
+++ b/python/plugins/processing/algs/qgis/BoundingBox.py
@ -67,10 +67,7 @@ class BoundingBox(GeoAlgorithm):
            self.getParameterValue(self.INPUT_LAYER))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields().toList(),
-                QgsWkbTypes.Polygon,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/Centroids.py
+++ b/python/plugins/processing/algs/qgis/Centroids.py
@ -69,10 +69,7 @@ class Centroids(GeoAlgorithm):
            self.getParameterValue(self.INPUT_LAYER))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields(),
-                QgsWkbTypes.Point,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), QgsWkbTypes.Point, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/CheckValidity.py
+++ b/python/plugins/processing/algs/qgis/CheckValidity.py
@ -108,10 +108,7 @@ class CheckValidity(GeoAlgorithm):

        valid_output = self.getOutputFromName(self.VALID_OUTPUT)
        valid_fields = layer.fields()
-        valid_writer = valid_output.getVectorWriter(
-            valid_fields,
-            layer.wkbType(),
-            layer.crs())
+        valid_writer = valid_output.getVectorWriter(valid_fields, layer.wkbType(), layer.crs(), context)
        valid_count = 0

        invalid_output = self.getOutputFromName(self.INVALID_OUTPUT)
@ -119,10 +116,7 @@ class CheckValidity(GeoAlgorithm):
            QgsField(name='_errors',
                     type=QVariant.String,
                     len=255)]
-        invalid_writer = invalid_output.getVectorWriter(
-            invalid_fields,
-            layer.wkbType(),
-            layer.crs())
+        invalid_writer = invalid_output.getVectorWriter(invalid_fields, layer.wkbType(), layer.crs(), context)
        invalid_count = 0

        error_output = self.getOutputFromName(self.ERROR_OUTPUT)
@ -130,10 +124,7 @@ class CheckValidity(GeoAlgorithm):
            QgsField(name='message',
                     type=QVariant.String,
                     len=255)]
-        error_writer = error_output.getVectorWriter(
-            error_fields,
-            QgsWkbTypes.Point,
-            layer.crs())
+        error_writer = error_output.getVectorWriter(error_fields, QgsWkbTypes.Point, layer.crs(), context)
        error_count = 0

        features = QgsProcessingUtils.getFeatures(layer, context)
--- a/python/plugins/processing/algs/qgis/Clip.py
+++ b/python/plugins/processing/algs/qgis/Clip.py
@ -75,10 +75,9 @@ class Clip(GeoAlgorithm):
        mask_layer = dataobjects.getLayerFromString(
            self.getParameterValue(Clip.OVERLAY))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            source_layer.fields(),
-            QgsWkbTypes.multiType(source_layer.wkbType()),
-            source_layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(source_layer.fields(),
+                                                                     QgsWkbTypes.multiType(source_layer.wkbType()),
+                                                                     source_layer.crs(), context)

        # first build up a list of clip geometries
        clip_geoms = []
--- a/python/plugins/processing/algs/qgis/ConcaveHull.py
+++ b/python/plugins/processing/algs/qgis/ConcaveHull.py
@ -133,8 +133,8 @@ class ConcaveHull(GeoAlgorithm):
        feedback.setProgressText(self.tr('Saving data...'))
        feat = QgsFeature()
        dissolved_layer.getFeatures(QgsFeatureRequest().setFilterFid(0)).nextFeature(feat)
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon,
+                                                                     layer.crs(), context)
        geom = feat.geometry()
        if no_multigeom and geom.isMultipart():
            # Only singlepart geometries are allowed
--- a/python/plugins/processing/algs/qgis/ConvexHull.py
+++ b/python/plugins/processing/algs/qgis/ConvexHull.py
@ -103,8 +103,7 @@ class ConvexHull(GeoAlgorithm):
                  QgsField('perim', QVariant.Double, '', 20, 6)
                  ]

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.Polygon, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)

        outFeat = QgsFeature()
        inGeom = QgsGeometry()
--- a/python/plugins/processing/algs/qgis/Delaunay.py
+++ b/python/plugins/processing/algs/qgis/Delaunay.py
@ -77,8 +77,7 @@ class Delaunay(GeoAlgorithm):
                  QgsField('POINTB', QVariant.Double, '', 24, 15),
                  QgsField('POINTC', QVariant.Double, '', 24, 15)]

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
-                                                                     QgsWkbTypes.Polygon, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)

        pts = []
        ptDict = {}
--- a/python/plugins/processing/algs/qgis/DeleteColumn.py
+++ b/python/plugins/processing/algs/qgis/DeleteColumn.py
@ -83,8 +83,7 @@ class DeleteColumn(GeoAlgorithm):
        for index in field_indices:
            fields.remove(index)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
-                                                                     layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/DeleteDuplicateGeometries.py
+++ b/python/plugins/processing/algs/qgis/DeleteDuplicateGeometries.py
@ -65,8 +65,7 @@ class DeleteDuplicateGeometries(GeoAlgorithm):

        fields = layer.fields()

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
-                                                                     layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)

--- a/python/plugins/processing/algs/qgis/DeleteHoles.py
+++ b/python/plugins/processing/algs/qgis/DeleteHoles.py
@ -77,10 +77,8 @@ class DeleteHoles(GeoAlgorithm):
        if min_area == 0.0:
            min_area = -1.0

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields(),
-            layer.wkbType(),
-            layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(),
+                                                                     context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/DensifyGeometries.py
+++ b/python/plugins/processing/algs/qgis/DensifyGeometries.py
@ -85,8 +85,7 @@ class DensifyGeometries(GeoAlgorithm):
        isPolygon = layer.geometryType() == QgsWkbTypes.PolygonGeometry

        writer = self.getOutputFromName(
-            self.OUTPUT).getVectorWriter(layer.fields().toList(),
-                                         layer.wkbType(), layer.crs())
+            self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/DensifyGeometriesInterval.py
+++ b/python/plugins/processing/algs/qgis/DensifyGeometriesInterval.py
@ -79,8 +79,7 @@ class DensifyGeometriesInterval(GeoAlgorithm):
        isPolygon = layer.geometryType() == QgsWkbTypes.PolygonGeometry

        writer = self.getOutputFromName(
-            self.OUTPUT).getVectorWriter(layer.fields().toList(),
-                                         layer.wkbType(), layer.crs())
+            self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/Difference.py
+++ b/python/plugins/processing/algs/qgis/Difference.py
@ -77,9 +77,7 @@ class Difference(GeoAlgorithm):

        geomType = QgsWkbTypes.multiType(layerA.wkbType())
        writer = self.getOutputFromName(
-            Difference.OUTPUT).getVectorWriter(layerA.fields(),
-                                               geomType,
-                                               layerA.crs())
+            Difference.OUTPUT).getVectorWriter(layerA.fields(), geomType, layerA.crs(), context)

        outFeat = QgsFeature()
        index = vector.spatialindex(layerB)
--- a/python/plugins/processing/algs/qgis/Dissolve.py
+++ b/python/plugins/processing/algs/qgis/Dissolve.py
@ -82,10 +82,7 @@ class Dissolve(GeoAlgorithm):
            self.getParameterValue(Dissolve.INPUT))

        writer = self.getOutputFromName(
-            Dissolve.OUTPUT).getVectorWriter(
-                vlayerA.fields().toList(),
-                vlayerA.wkbType(),
-                vlayerA.crs())
+            Dissolve.OUTPUT).getVectorWriter(vlayerA.fields().toList(), vlayerA.wkbType(), vlayerA.crs(), context)

        outFeat = QgsFeature()
        features = QgsProcessingUtils.getFeatures(vlayerA, context)
--- a/python/plugins/processing/algs/qgis/DropGeometry.py
+++ b/python/plugins/processing/algs/qgis/DropGeometry.py
@ -70,10 +70,8 @@ class DropGeometry(GeoAlgorithm):
        layer = dataobjects.getLayerFromString(
            self.getParameterValue(self.INPUT_LAYER))
        writer = self.getOutputFromName(
-            self.OUTPUT_TABLE).getVectorWriter(
-                layer.fields(),
-                QgsWkbTypes.NoGeometry,
-                QgsCoordinateReferenceSystem())
+            self.OUTPUT_TABLE).getVectorWriter(layer.fields(), QgsWkbTypes.NoGeometry, QgsCoordinateReferenceSystem(),
+                                               context)

        request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry)
        features = QgsProcessingUtils.getFeatures(layer, context, request)
--- a/python/plugins/processing/algs/qgis/EliminateSelection.py
+++ b/python/plugins/processing/algs/qgis/EliminateSelection.py
@ -92,8 +92,7 @@ class EliminateSelection(GeoAlgorithm):
        featToEliminate = []
        selFeatIds = inLayer.selectedFeatureIds()
        output = self.getOutputFromName(self.OUTPUT)
-        writer = output.getVectorWriter(inLayer.fields(),
-                                        inLayer.wkbType(), inLayer.crs())
+        writer = output.getVectorWriter(inLayer.fields(), inLayer.wkbType(), inLayer.crs(), context)

        for aFeat in inLayer.getFeatures():
            if aFeat.id() in selFeatIds:
--- a/python/plugins/processing/algs/qgis/EquivalentNumField.py
+++ b/python/plugins/processing/algs/qgis/EquivalentNumField.py
@ -73,8 +73,7 @@ class EquivalentNumField(GeoAlgorithm):
        fieldindex = vlayer.fields().lookupField(fieldname)
        fields = vlayer.fields()
        fields.append(QgsField('NUM_FIELD', QVariant.Int))
-        writer = output.getVectorWriter(fields, vlayer.wkbType(),
-                                        vlayer.crs())
+        writer = output.getVectorWriter(fields, vlayer.wkbType(), vlayer.crs(), context)
        outFeat = QgsFeature()
        classes = {}

--- a/python/plugins/processing/algs/qgis/ExecuteSQL.py
+++ b/python/plugins/processing/algs/qgis/ExecuteSQL.py
@ -146,11 +146,9 @@ class ExecuteSQL(GeoAlgorithm):
        if not vLayer.isValid():
            raise GeoAlgorithmExecutionException(vLayer.dataProvider().error().message())

-        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
-            vLayer.fields().toList(),
-            # Create a point layer (without any points) if 'no geometry' is chosen
-            vLayer.wkbType() if geometry_type != 1 else 1,
-            vLayer.crs())
+        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(vLayer.fields().toList(),
+                                                                           vLayer.wkbType() if geometry_type != 1 else 1,
+                                                                           vLayer.crs(), context)

        features = QgsProcessingUtils.getFeatures(vLayer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(vLayer, context)
--- a/python/plugins/processing/algs/qgis/Explode.py
+++ b/python/plugins/processing/algs/qgis/Explode.py
@ -68,8 +68,7 @@ class Explode(GeoAlgorithm):
            self.getParameterValue(self.INPUT))
        output = self.getOutputFromName(self.OUTPUT)
        fields = vlayer.fields()
-        writer = output.getVectorWriter(fields, QgsWkbTypes.LineString,
-                                        vlayer.crs())
+        writer = output.getVectorWriter(fields, QgsWkbTypes.LineString, vlayer.crs(), context)
        outFeat = QgsFeature()
        features = QgsProcessingUtils.getFeatures(vlayer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(vlayer, context)
--- a/python/plugins/processing/algs/qgis/ExportGeometryInfo.py
+++ b/python/plugins/processing/algs/qgis/ExportGeometryInfo.py
@ -107,8 +107,8 @@ class ExportGeometryInfo(GeoAlgorithm):
                zName = vector.createUniqueFieldName('mvalue', fields)
                fields.append(QgsField(zName, QVariant.Double))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields.toList(), layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), layer.wkbType(), layer.crs(),
+                                                                     context)

        ellips = None
        crs = None
--- a/python/plugins/processing/algs/qgis/ExtendLines.py
+++ b/python/plugins/processing/algs/qgis/ExtendLines.py
@ -71,10 +71,7 @@ class ExtendLines(GeoAlgorithm):
            self.getParameterValue(self.INPUT_LAYER))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields(),
-                layer.wkbType(),
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        start_distance = self.getParameterValue(self.START_DISTANCE)
        end_distance = self.getParameterValue(self.END_DISTANCE)
--- a/python/plugins/processing/algs/qgis/ExtentFromLayer.py
+++ b/python/plugins/processing/algs/qgis/ExtentFromLayer.py
@ -89,8 +89,7 @@ class ExtentFromLayer(GeoAlgorithm):
            QgsField('WIDTH', QVariant.Double),
        ]

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
-                                                                     QgsWkbTypes.Polygon, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)

        if byFeature:
            self.featureExtent(layer, context, writer, feedback)
--- a/python/plugins/processing/algs/qgis/ExtractByAttribute.py
+++ b/python/plugins/processing/algs/qgis/ExtractByAttribute.py
@ -111,8 +111,7 @@ class ExtractByAttribute(GeoAlgorithm):
        value = self.getParameterValue(self.VALUE)

        fields = layer.fields()
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
-                                                                     layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)

        idx = layer.fields().lookupField(fieldName)
        fieldType = fields[idx].type()
--- a/python/plugins/processing/algs/qgis/ExtractByExpression.py
+++ b/python/plugins/processing/algs/qgis/ExtractByExpression.py
@ -70,7 +70,8 @@ class ExtractByExpression(GeoAlgorithm):
    def processAlgorithm(self, context, feedback):
        layer = dataobjects.getLayerFromString(self.getParameterValue(self.INPUT))
        expression_string = self.getParameterValue(self.EXPRESSION)
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(),
+                                                                     context)

        expression = QgsExpression(expression_string)
        if not expression.hasParserError():
--- a/python/plugins/processing/algs/qgis/ExtractByLocation.py
+++ b/python/plugins/processing/algs/qgis/ExtractByLocation.py
@ -97,8 +97,7 @@ class ExtractByLocation(GeoAlgorithm):
        index = vector.spatialindex(layer)

        output = self.getOutputFromName(self.OUTPUT)
-        writer = output.getVectorWriter(layer.fields(),
-                                        layer.wkbType(), layer.crs())
+        writer = output.getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        if 'disjoint' in predicates:
            disjoinSet = []
--- a/python/plugins/processing/algs/qgis/ExtractNodes.py
+++ b/python/plugins/processing/algs/qgis/ExtractNodes.py
@ -75,8 +75,7 @@ class ExtractNodes(GeoAlgorithm):
        fields.append(QgsField('distance', QVariant.Double))
        fields.append(QgsField('angle', QVariant.Double))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.Point, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/ExtractSpecificNodes.py
+++ b/python/plugins/processing/algs/qgis/ExtractSpecificNodes.py
@ -80,10 +80,7 @@ class ExtractSpecificNodes(GeoAlgorithm):
        fields.append(QgsField('angle', QVariant.Double))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                fields,
-                QgsWkbTypes.Point,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)

        node_indices_string = self.getParameterValue(self.NODES)
        indices = []
--- a/python/plugins/processing/algs/qgis/FieldPyculator.py
+++ b/python/plugins/processing/algs/qgis/FieldPyculator.py
@ -107,8 +107,7 @@ class FieldsPyculator(GeoAlgorithm):
        fields = layer.fields()
        fields.append(QgsField(fieldName, self.TYPES[fieldType], '',
                               fieldLength, fieldPrecision))
-        writer = output.getVectorWriter(fields, layer.wkbType(),
-                                        layer.crs())
+        writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
        outFeat = QgsFeature()
        new_ns = {}

--- a/python/plugins/processing/algs/qgis/FieldsCalculator.py
+++ b/python/plugins/processing/algs/qgis/FieldsCalculator.py
@ -113,8 +113,7 @@ class FieldsCalculator(GeoAlgorithm):
        if newField:
            fields.append(QgsField(fieldName, fieldType, '', width, precision))

-        writer = output.getVectorWriter(fields, layer.wkbType(),
-                                        layer.crs())
+        writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)

        exp = QgsExpression(formula)

--- a/python/plugins/processing/algs/qgis/FieldsMapper.py
+++ b/python/plugins/processing/algs/qgis/FieldsMapper.py
@ -144,9 +144,7 @@ class FieldsMapper(GeoAlgorithm):
                            str(expression.parserErrorString())))
            expressions.append(expression)

-        writer = output.getVectorWriter(fields,
-                                        layer.wkbType(),
-                                        layer.crs())
+        writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)

        # Create output vector layer with new attributes
        error_exp = None
--- a/python/plugins/processing/algs/qgis/FixGeometry.py
+++ b/python/plugins/processing/algs/qgis/FixGeometry.py
@ -73,10 +73,7 @@ class FixGeometry(GeoAlgorithm):
            self.getParameterValue(self.INPUT))

        writer = self.getOutputFromName(
-            self.OUTPUT).getVectorWriter(
-                layer.fields(),
-                QgsWkbTypes.multiType(layer.wkbType()),
-                layer.crs())
+            self.OUTPUT).getVectorWriter(layer.fields(), QgsWkbTypes.multiType(layer.wkbType()), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        if QgsProcessingUtils.featureCount(layer, context) == 0:
--- a/python/plugins/processing/algs/qgis/FixedDistanceBuffer.py
+++ b/python/plugins/processing/algs/qgis/FixedDistanceBuffer.py
@ -105,8 +105,7 @@ class FixedDistanceBuffer(GeoAlgorithm):
        miter_limit = self.getParameterValue(self.MITRE_LIMIT)

        writer = self.getOutputFromName(
-            self.OUTPUT).getVectorWriter(layer.fields().toList(),
-                                         QgsWkbTypes.Polygon, layer.crs())
+            self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)

        buff.buffering(feedback, context, writer, distance, None, False, layer, dissolve, segments, end_cap_style,
                       join_style, miter_limit)
--- a/python/plugins/processing/algs/qgis/GeometryByExpression.py
+++ b/python/plugins/processing/algs/qgis/GeometryByExpression.py
@ -103,10 +103,7 @@ class GeometryByExpression(GeoAlgorithm):
            wkb_type = QgsWkbTypes.addM(wkb_type)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields(),
-                wkb_type,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), wkb_type, layer.crs(), context)

        expression = QgsExpression(self.getParameterValue(self.EXPRESSION))
        if expression.hasParserError():
--- a/python/plugins/processing/algs/qgis/GeometryConvert.py
+++ b/python/plugins/processing/algs/qgis/GeometryConvert.py
@ -93,8 +93,7 @@ class GeometryConvert(GeoAlgorithm):
        else:
            newType = QgsWkbTypes.Point

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields(), newType, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), newType, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/GridLine.py
+++ b/python/plugins/processing/algs/qgis/GridLine.py
@ -126,8 +126,7 @@ class GridLine(GeoAlgorithm):
                  QgsField('coord', QVariant.Double, '', 24, 15)
                  ]

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
-                                                                     QgsWkbTypes.LineString, crs)
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.LineString, crs, context)

        if hOverlay > 0:
            hSpace = [hSpacing - hOverlay, hOverlay]
--- a/python/plugins/processing/algs/qgis/GridPolygon.py
+++ b/python/plugins/processing/algs/qgis/GridPolygon.py
@ -130,8 +130,7 @@ class GridPolygon(GeoAlgorithm):
                  QgsField('id', QVariant.Int, '', 10, 0)
                  ]

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
-                                                                     QgsWkbTypes.Polygon, crs)
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, crs, context)

        if idx == 0:
            self._rectangleGrid(
--- a/python/plugins/processing/algs/qgis/Gridify.py
+++ b/python/plugins/processing/algs/qgis/Gridify.py
@ -81,8 +81,8 @@ class Gridify(GeoAlgorithm):
            raise GeoAlgorithmExecutionException(
                self.tr('Invalid grid spacing: {0}/{1}').format(hSpacing, vSpacing))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields(), layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(),
+                                                                     context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/HubDistanceLines.py
+++ b/python/plugins/processing/algs/qgis/HubDistanceLines.py
@ -112,8 +112,8 @@ class HubDistanceLines(GeoAlgorithm):
        fields.append(QgsField('HubName', QVariant.String))
        fields.append(QgsField('HubDist', QVariant.Double))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.LineString, layerPoints.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.LineString, layerPoints.crs(),
+                                                                     context)

        index = vector.spatialindex(layerHubs)

--- a/python/plugins/processing/algs/qgis/HubDistancePoints.py
+++ b/python/plugins/processing/algs/qgis/HubDistancePoints.py
@ -112,8 +112,8 @@ class HubDistancePoints(GeoAlgorithm):
        fields.append(QgsField('HubName', QVariant.String))
        fields.append(QgsField('HubDist', QVariant.Double))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.Point, layerPoints.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layerPoints.crs(),
+                                                                     context)

        index = vector.spatialindex(layerHubs)

--- a/python/plugins/processing/algs/qgis/HubLines.py
+++ b/python/plugins/processing/algs/qgis/HubLines.py
@ -88,8 +88,8 @@ class HubLines(GeoAlgorithm):
            raise GeoAlgorithmExecutionException(
                self.tr('Same layer given for both hubs and spokes'))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layerSpoke.fields(), QgsWkbTypes.LineString, layerSpoke.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layerSpoke.fields(), QgsWkbTypes.LineString,
+                                                                     layerSpoke.crs(), context)

        spokes = QgsProcessingUtils.getFeatures(layerSpoke, context)
        hubs = QgsProcessingUtils.getFeatures(layerHub, context)
--- a/python/plugins/processing/algs/qgis/Intersection.py
+++ b/python/plugins/processing/algs/qgis/Intersection.py
@ -86,8 +86,7 @@ class Intersection(GeoAlgorithm):

        geomType = QgsWkbTypes.multiType(vlayerA.wkbType())
        fields = vector.combineVectorFields(vlayerA, vlayerB)
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
-                                                                     geomType, vlayerA.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, geomType, vlayerA.crs(), context)
        outFeat = QgsFeature()
        index = vector.spatialindex(vlayerB)
        selectionA = QgsProcessingUtils.getFeatures(vlayerA, context)
--- a/python/plugins/processing/algs/qgis/JoinAttributes.py
+++ b/python/plugins/processing/algs/qgis/JoinAttributes.py
@ -91,8 +91,7 @@ class JoinAttributes(GeoAlgorithm):
        joinField2Index = layer2.fields().lookupField(field2)

        outFields = vector.combineVectorFields(layer, layer2)
-        writer = output.getVectorWriter(outFields, layer.wkbType(),
-                                        layer.crs())
+        writer = output.getVectorWriter(outFields, layer.wkbType(), layer.crs(), context)

        # Cache attributes of Layer 2
        cache = {}
--- a/python/plugins/processing/algs/qgis/LinesIntersection.py
+++ b/python/plugins/processing/algs/qgis/LinesIntersection.py
@ -105,8 +105,8 @@ class LinesIntersection(GeoAlgorithm):
        fieldListB = vector.testForUniqueness(fieldListA, fieldListB)
        fieldListA.extend(fieldListB)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldListA,
-                                                                     QgsWkbTypes.Point, layerA.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldListA, QgsWkbTypes.Point, layerA.crs(),
+                                                                     context)

        spatialIndex = vector.spatialindex(layerB)

--- a/python/plugins/processing/algs/qgis/LinesToPolygons.py
+++ b/python/plugins/processing/algs/qgis/LinesToPolygons.py
@ -68,9 +68,8 @@ class LinesToPolygons(GeoAlgorithm):
    def processAlgorithm(self, context, feedback):
        layer = dataobjects.getLayerFromString(self.getParameterValue(self.INPUT))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs()
-        )
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon,
+                                                                     layer.crs(), context)

        outFeat = QgsFeature()
        features = QgsProcessingUtils.getFeatures(layer, context)
--- a/python/plugins/processing/algs/qgis/MeanCoords.py
+++ b/python/plugins/processing/algs/qgis/MeanCoords.py
@ -97,9 +97,7 @@ class MeanCoords(GeoAlgorithm):
                     QgsField('MEAN_Y', QVariant.Double, '', 24, 15),
                     QgsField('UID', QVariant.String, '', 255)]

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fieldList, QgsWkbTypes.Point, layer.crs()
-        )
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList, QgsWkbTypes.Point, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/Merge.py
+++ b/python/plugins/processing/algs/qgis/Merge.py
@ -94,9 +94,8 @@ class Merge(GeoAlgorithm):
                    fields.append(sfield)

        total = 100.0 / totalFeatureCount
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields.toList(), layers[0].wkbType(),
-            layers[0].crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), layers[0].wkbType(),
+                                                                     layers[0].crs(), context)

        featureCount = 0
        for layer in layers:
--- a/python/plugins/processing/algs/qgis/MergeLines.py
+++ b/python/plugins/processing/algs/qgis/MergeLines.py
@ -70,10 +70,7 @@ class MergeLines(GeoAlgorithm):
            self.getParameterValue(self.INPUT_LAYER))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields().toList(),
-                layer.wkbType(),
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/MultipartToSingleparts.py
+++ b/python/plugins/processing/algs/qgis/MultipartToSingleparts.py
@ -64,8 +64,8 @@ class MultipartToSingleparts(GeoAlgorithm):
        layer = dataobjects.getLayerFromString(self.getParameterValue(self.INPUT))
        geomType = QgsWkbTypes.singleType(layer.wkbType())

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields().toList(), geomType, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), geomType, layer.crs(),
+                                                                     context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/OffsetLine.py
+++ b/python/plugins/processing/algs/qgis/OffsetLine.py
@ -88,10 +88,7 @@ class OffsetLine(GeoAlgorithm):
            self.getParameterValue(self.INPUT_LAYER))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields().toList(),
-                QgsWkbTypes.LineString,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.LineString, layer.crs(), context)

        distance = self.getParameterValue(self.DISTANCE)
        segments = int(self.getParameterValue(self.SEGMENTS))
--- a/python/plugins/processing/algs/qgis/OrientedMinimumBoundingBox.py
+++ b/python/plugins/processing/algs/qgis/OrientedMinimumBoundingBox.py
@ -90,8 +90,7 @@ class OrientedMinimumBoundingBox(GeoAlgorithm):
        fields.append(QgsField('width', QVariant.Double))
        fields.append(QgsField('height', QVariant.Double))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
-                                                                     QgsWkbTypes.Polygon, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)

        if byFeature:
            self.featureOmbb(layer, context, writer, feedback)
--- a/python/plugins/processing/algs/qgis/Orthogonalize.py
+++ b/python/plugins/processing/algs/qgis/Orthogonalize.py
@ -82,10 +82,7 @@ class Orthogonalize(GeoAlgorithm):
        max_iterations = self.getParameterValue(self.MAX_ITERATIONS)
        angle_tolerance = self.getParameterValue(self.ANGLE_TOLERANCE)
        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields(),
-                layer.wkbType(),
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/PointOnSurface.py
+++ b/python/plugins/processing/algs/qgis/PointOnSurface.py
@ -67,10 +67,7 @@ class PointOnSurface(GeoAlgorithm):
            self.getParameterValue(self.INPUT_LAYER))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields().toList(),
-                QgsWkbTypes.Point,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Point, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/PointsAlongGeometry.py
+++ b/python/plugins/processing/algs/qgis/PointsAlongGeometry.py
@ -87,8 +87,7 @@ class PointsAlongGeometry(GeoAlgorithm):
        fields.append(QgsField('distance', QVariant.Double))
        fields.append(QgsField('angle', QVariant.Double))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.Point, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/PointsDisplacement.py
+++ b/python/plugins/processing/algs/qgis/PointsDisplacement.py
@ -80,8 +80,7 @@ class PointsDisplacement(GeoAlgorithm):

        layer = dataobjects.getLayerFromString(self.getParameterValue(self.INPUT_LAYER))

-        writer = output.getVectorWriter(layer.fields(),
-                                        layer.wkbType(), layer.crs())
+        writer = output.getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)

--- a/python/plugins/processing/algs/qgis/PointsFromLines.py
+++ b/python/plugins/processing/algs/qgis/PointsFromLines.py
@ -87,8 +87,8 @@ class PointsFromLines(GeoAlgorithm):
        fields.append(QgsField('line_id', QVariant.Int, '', 10, 0))
        fields.append(QgsField('point_id', QVariant.Int, '', 10, 0))

-        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
-            fields.toList(), QgsWkbTypes.Point, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.Point,
+                                                                           layer.crs(), context)

        outFeature = QgsFeature()
        outFeature.setFields(fields)
--- a/python/plugins/processing/algs/qgis/PointsFromPolygons.py
+++ b/python/plugins/processing/algs/qgis/PointsFromPolygons.py
@ -87,8 +87,8 @@ class PointsFromPolygons(GeoAlgorithm):
        fields.append(QgsField('poly_id', QVariant.Int, '', 10, 0))
        fields.append(QgsField('point_id', QVariant.Int, '', 10, 0))

-        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
-            fields.toList(), QgsWkbTypes.Point, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.Point,
+                                                                           layer.crs(), context)

        outFeature = QgsFeature()
        outFeature.setFields(fields)
--- a/python/plugins/processing/algs/qgis/PointsInPolygon.py
+++ b/python/plugins/processing/algs/qgis/PointsInPolygon.py
@ -80,8 +80,8 @@ class PointsInPolygon(GeoAlgorithm):
        (idxCount, fieldList) = vector.findOrCreateField(polyLayer,
                                                         polyLayer.fields(), fieldName)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields.toList(), polyLayer.wkbType(), polyLayer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), polyLayer.wkbType(),
+                                                                     polyLayer.crs(), context)

        spatialIndex = vector.spatialindex(pointLayer)

--- a/python/plugins/processing/algs/qgis/PointsInPolygonUnique.py
+++ b/python/plugins/processing/algs/qgis/PointsInPolygonUnique.py
@ -87,8 +87,8 @@ class PointsInPolygonUnique(GeoAlgorithm):
        (idxCount, fieldList) = vector.findOrCreateField(polyLayer,
                                                         polyLayer.fields(), fieldName)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields.toList(), polyLayer.wkbType(), polyLayer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), polyLayer.wkbType(),
+                                                                     polyLayer.crs(), context)

        spatialIndex = vector.spatialindex(pointLayer)

--- a/python/plugins/processing/algs/qgis/PointsInPolygonWeighted.py
+++ b/python/plugins/processing/algs/qgis/PointsInPolygonWeighted.py
@ -93,8 +93,8 @@ class PointsInPolygonWeighted(GeoAlgorithm):
        (idxCount, fieldList) = vector.findOrCreateField(polyLayer,
                                                         polyLayer.fields(), fieldName)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields.toList(), polyLayer.wkbType(), polyLayer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), polyLayer.wkbType(),
+                                                                     polyLayer.crs(), context)

        spatialIndex = vector.spatialindex(pointLayer)

--- a/python/plugins/processing/algs/qgis/PointsLayerFromTable.py
+++ b/python/plugins/processing/algs/qgis/PointsLayerFromTable.py
@ -107,7 +107,7 @@ class PointsLayerFromTable(GeoAlgorithm):
        target_crs = QgsCoordinateReferenceSystem()
        target_crs.createFromUserInput(crsId)

-        writer = output.getVectorWriter(fields, wkb_type, target_crs)
+        writer = output.getVectorWriter(fields, wkb_type, target_crs, context)

        features = QgsProcessingUtils.getFeatures(vlayer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(vlayer, context)
--- a/python/plugins/processing/algs/qgis/PointsToPaths.py
+++ b/python/plugins/processing/algs/qgis/PointsToPaths.py
@ -101,8 +101,8 @@ class PointsToPaths(GeoAlgorithm):
        fields.append(QgsField('group', QVariant.String, '', 254, 0))
        fields.append(QgsField('begin', QVariant.String, '', 254, 0))
        fields.append(QgsField('end', QVariant.String, '', 254, 0))
-        writer = self.getOutputFromName(self.OUTPUT_LINES).getVectorWriter(
-            fields, QgsWkbTypes.LineString, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT_LINES).getVectorWriter(fields, QgsWkbTypes.LineString, layer.crs(),
+                                                                           context)

        points = dict()
        features = QgsProcessingUtils.getFeatures(layer, context)
--- a/python/plugins/processing/algs/qgis/PoleOfInaccessibility.py
+++ b/python/plugins/processing/algs/qgis/PoleOfInaccessibility.py
@ -79,10 +79,7 @@ class PoleOfInaccessibility(GeoAlgorithm):
        fields.append(QgsField('dist_pole', QVariant.Double))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                fields,
-                QgsWkbTypes.Point,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/PolygonCentroids.py
+++ b/python/plugins/processing/algs/qgis/PolygonCentroids.py
@ -76,10 +76,7 @@ class PolygonCentroids(GeoAlgorithm):
            self.getParameterValue(self.INPUT_LAYER))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields(),
-                QgsWkbTypes.Point,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), QgsWkbTypes.Point, layer.crs(), context)

        outFeat = QgsFeature()

--- a/python/plugins/processing/algs/qgis/Polygonize.py
+++ b/python/plugins/processing/algs/qgis/Polygonize.py
@ -110,7 +110,7 @@ class Polygonize(GeoAlgorithm):
        feedback.setProgress(50)

        feedback.pushInfo('Saving polygons...')
-        writer = output.getVectorWriter(fields, QgsWkbTypes.Polygon, vlayer.crs())
+        writer = output.getVectorWriter(fields, QgsWkbTypes.Polygon, vlayer.crs(), context)
        total = 50.0 / polygons.geometry().numGeometries()
        for i in range(polygons.geometry().numGeometries()):
            outFeat = QgsFeature()
--- a/python/plugins/processing/algs/qgis/PolygonsToLines.py
+++ b/python/plugins/processing/algs/qgis/PolygonsToLines.py
@ -68,8 +68,8 @@ class PolygonsToLines(GeoAlgorithm):
    def processAlgorithm(self, context, feedback):
        layer = dataobjects.getLayerFromString(self.getParameterValue(self.INPUT))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields().toList(), QgsWkbTypes.LineString, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.LineString,
+                                                                     layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/RandomExtract.py
+++ b/python/plugins/processing/algs/qgis/RandomExtract.py
@ -97,8 +97,8 @@ class RandomExtract(GeoAlgorithm):

        selran = random.sample(list(range(featureCount)), value)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields().toList(), layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
+                                                                     layer.crs(), context)

        total = 100.0 / featureCount
        for i, feat in enumerate(features):
--- a/python/plugins/processing/algs/qgis/RandomExtractWithinSubsets.py
+++ b/python/plugins/processing/algs/qgis/RandomExtractWithinSubsets.py
@ -104,8 +104,8 @@ class RandomExtractWithinSubsets(GeoAlgorithm):
                            "correct value and try again."))
            value = value / 100.0

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields().toList(), layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
+                                                                     layer.crs(), context)

        selran = []
        total = 100.0 / (featureCount * len(unique))
--- a/python/plugins/processing/algs/qgis/RandomPointsAlongLines.py
+++ b/python/plugins/processing/algs/qgis/RandomPointsAlongLines.py
@ -88,8 +88,7 @@ class RandomPointsAlongLines(GeoAlgorithm):

        fields = QgsFields()
        fields.append(QgsField('id', QVariant.Int, '', 10, 0))
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.Point, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)

        nPoints = 0
        nIterations = 0
--- a/python/plugins/processing/algs/qgis/RandomPointsExtent.py
+++ b/python/plugins/processing/algs/qgis/RandomPointsExtent.py
@ -97,8 +97,7 @@ class RandomPointsExtent(GeoAlgorithm):

        fields = QgsFields()
        fields.append(QgsField('id', QVariant.Int, '', 10, 0))
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.Point, crs)
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, crs, context)

        nPoints = 0
        nIterations = 0
--- a/python/plugins/processing/algs/qgis/RandomPointsLayer.py
+++ b/python/plugins/processing/algs/qgis/RandomPointsLayer.py
@ -83,8 +83,7 @@ class RandomPointsLayer(GeoAlgorithm):

        fields = QgsFields()
        fields.append(QgsField('id', QVariant.Int, '', 10, 0))
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.Point, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)

        nPoints = 0
        nIterations = 0
--- a/python/plugins/processing/algs/qgis/RandomPointsPolygonsFixed.py
+++ b/python/plugins/processing/algs/qgis/RandomPointsPolygonsFixed.py
@ -89,8 +89,7 @@ class RandomPointsPolygonsFixed(GeoAlgorithm):

        fields = QgsFields()
        fields.append(QgsField('id', QVariant.Int, '', 10, 0))
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.Point, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)

        da = QgsDistanceArea()

--- a/python/plugins/processing/algs/qgis/RandomPointsPolygonsVariable.py
+++ b/python/plugins/processing/algs/qgis/RandomPointsPolygonsVariable.py
@ -90,8 +90,7 @@ class RandomPointsPolygonsVariable(GeoAlgorithm):

        fields = QgsFields()
        fields.append(QgsField('id', QVariant.Int, '', 10, 0))
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.Point, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)

        da = QgsDistanceArea()

--- a/python/plugins/processing/algs/qgis/RectanglesOvalsDiamondsFixed.py
+++ b/python/plugins/processing/algs/qgis/RectanglesOvalsDiamondsFixed.py
@ -102,10 +102,7 @@ class RectanglesOvalsDiamondsFixed(GeoAlgorithm):
        segments = self.getParameterValue(self.SEGMENTS)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields().toList(),
-                QgsWkbTypes.Polygon,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)

--- a/python/plugins/processing/algs/qgis/RectanglesOvalsDiamondsVariable.py
+++ b/python/plugins/processing/algs/qgis/RectanglesOvalsDiamondsVariable.py
@ -111,10 +111,7 @@ class RectanglesOvalsDiamondsVariable(GeoAlgorithm):
        segments = self.getParameterValue(self.SEGMENTS)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields().toList(),
-                QgsWkbTypes.Polygon,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)

--- a/python/plugins/processing/algs/qgis/RegularPoints.py
+++ b/python/plugins/processing/algs/qgis/RegularPoints.py
@ -101,8 +101,7 @@ class RegularPoints(GeoAlgorithm):
        fields = QgsFields()
        fields.append(QgsField('id', QVariant.Int, '', 10, 0))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, QgsWkbTypes.Point, crs)
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, crs, context)

        if randomize:
            seed()
--- a/python/plugins/processing/algs/qgis/RemoveNullGeometry.py
+++ b/python/plugins/processing/algs/qgis/RemoveNullGeometry.py
@ -65,10 +65,7 @@ class RemoveNullGeometry(GeoAlgorithm):
        layer = dataobjects.getLayerFromString(
            self.getParameterValue(self.INPUT_LAYER))
        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields(),
-                layer.wkbType(),
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/ReprojectLayer.py
+++ b/python/plugins/processing/algs/qgis/ReprojectLayer.py
@ -73,8 +73,8 @@ class ReprojectLayer(GeoAlgorithm):
        targetCrs = QgsCoordinateReferenceSystem()
        targetCrs.createFromUserInput(crsId)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields().toList(), layer.wkbType(), targetCrs)
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
+                                                                     targetCrs, context)

        layerCrs = layer.crs()
        crsTransform = QgsCoordinateTransform(layerCrs, targetCrs)
--- a/python/plugins/processing/algs/qgis/ReverseLineDirection.py
+++ b/python/plugins/processing/algs/qgis/ReverseLineDirection.py
@ -66,10 +66,7 @@ class ReverseLineDirection(GeoAlgorithm):
            self.getParameterValue(self.INPUT_LAYER))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields().toList(),
-                layer.wkbType(),
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)

        outFeat = QgsFeature()

--- a/python/plugins/processing/algs/qgis/SaveSelectedFeatures.py
+++ b/python/plugins/processing/algs/qgis/SaveSelectedFeatures.py
@ -65,8 +65,7 @@ class SaveSelectedFeatures(GeoAlgorithm):

        vectorLayer = dataobjects.getLayerFromString(inputFilename)

-        writer = output.getVectorWriter(vectorLayer.fields(),
-                                        vectorLayer.wkbType(), vectorLayer.crs())
+        writer = output.getVectorWriter(vectorLayer.fields(), vectorLayer.wkbType(), vectorLayer.crs(), context)

        features = vectorLayer.selectedFeaturesIterator()
        total = 100.0 / int(vectorLayer.selectedFeatureCount())
--- a/python/plugins/processing/algs/qgis/ServiceAreaFromLayer.py
+++ b/python/plugins/processing/algs/qgis/ServiceAreaFromLayer.py
@ -176,16 +176,10 @@ class ServiceAreaFromLayer(GeoAlgorithm):
        feat.setFields(fields)

        writerPoints = self.getOutputFromName(
-            self.OUTPUT_POINTS).getVectorWriter(
-                fields,
-                QgsWkbTypes.MultiPoint,
-                layer.crs())
+            self.OUTPUT_POINTS).getVectorWriter(fields, QgsWkbTypes.MultiPoint, layer.crs(), context)

        writerPolygons = self.getOutputFromName(
-            self.OUTPUT_POLYGON).getVectorWriter(
-                fields,
-                QgsWkbTypes.Polygon,
-                layer.crs())
+            self.OUTPUT_POLYGON).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)

        directionField = -1
        if directionFieldName is not None:
--- a/python/plugins/processing/algs/qgis/ServiceAreaFromPoint.py
+++ b/python/plugins/processing/algs/qgis/ServiceAreaFromPoint.py
@ -231,10 +231,7 @@ class ServiceAreaFromPoint(GeoAlgorithm):
        geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)

        writer = self.getOutputFromName(
-            self.OUTPUT_POINTS).getVectorWriter(
-                fields,
-                QgsWkbTypes.MultiPoint,
-                layer.crs())
+            self.OUTPUT_POINTS).getVectorWriter(fields, QgsWkbTypes.MultiPoint, layer.crs(), context)

        feat.setGeometry(geomUpper)
        feat['type'] = 'upper'
@ -254,10 +251,7 @@ class ServiceAreaFromPoint(GeoAlgorithm):
        geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)

        writer = self.getOutputFromName(
-            self.OUTPUT_POLYGON).getVectorWriter(
-                fields,
-                QgsWkbTypes.Polygon,
-                layer.crs())
+            self.OUTPUT_POLYGON).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)

        geom = geomUpper.convexHull()
        feat.setGeometry(geom)
--- a/python/plugins/processing/algs/qgis/ShortestPathLayerToPoint.py
+++ b/python/plugins/processing/algs/qgis/ShortestPathLayerToPoint.py
@ -182,10 +182,7 @@ class ShortestPathLayerToPoint(GeoAlgorithm):
        feat.setFields(fields)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                fields.toList(),
-                QgsWkbTypes.LineString,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.LineString, layer.crs(), context)

        tmp = endPoint.split(',')
        endPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
--- a/python/plugins/processing/algs/qgis/ShortestPathPointToLayer.py
+++ b/python/plugins/processing/algs/qgis/ShortestPathPointToLayer.py
@ -175,10 +175,7 @@ class ShortestPathPointToLayer(GeoAlgorithm):
        feat.setFields(fields)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                fields.toList(),
-                QgsWkbTypes.LineString,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.LineString, layer.crs(), context)

        tmp = startPoint.split(',')
        startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
--- a/python/plugins/processing/algs/qgis/ShortestPathPointToPoint.py
+++ b/python/plugins/processing/algs/qgis/ShortestPathPointToPoint.py
@ -174,10 +174,7 @@ class ShortestPathPointToPoint(GeoAlgorithm):
        fields.append(QgsField('cost', QVariant.Double, '', 20, 7))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                fields.toList(),
-                QgsWkbTypes.LineString,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.LineString, layer.crs(), context)

        tmp = startPoint.split(',')
        startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
--- a/python/plugins/processing/algs/qgis/SimplifyGeometries.py
+++ b/python/plugins/processing/algs/qgis/SimplifyGeometries.py
@ -86,8 +86,8 @@ class SimplifyGeometries(GeoAlgorithm):
        pointsBefore = 0
        pointsAfter = 0

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields().toList(), layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
+                                                                     layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/SinglePartsToMultiparts.py
+++ b/python/plugins/processing/algs/qgis/SinglePartsToMultiparts.py
@ -72,8 +72,8 @@ class SinglePartsToMultiparts(GeoAlgorithm):

        geomType = QgsWkbTypes.multiType(layer.wkbType())

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields().toList(), geomType, layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), geomType, layer.crs(),
+                                                                     context)

        outFeat = QgsFeature()
        inGeom = QgsGeometry()
--- a/python/plugins/processing/algs/qgis/SingleSidedBuffer.py
+++ b/python/plugins/processing/algs/qgis/SingleSidedBuffer.py
@ -98,10 +98,7 @@ class SingleSidedBuffer(GeoAlgorithm):
            self.getParameterValue(self.INPUT_LAYER))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields().toList(),
-                QgsWkbTypes.Polygon,
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)

        distance = self.getParameterValue(self.DISTANCE)
        segments = int(self.getParameterValue(self.SEGMENTS))
--- a/python/plugins/processing/algs/qgis/Smooth.py
+++ b/python/plugins/processing/algs/qgis/Smooth.py
@ -76,10 +76,7 @@ class Smooth(GeoAlgorithm):
        max_angle = self.getParameterValue(self.MAX_ANGLE)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-                layer.fields().toList(),
-                layer.wkbType(),
-                layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/SnapGeometries.py
+++ b/python/plugins/processing/algs/qgis/SnapGeometries.py
@ -82,8 +82,8 @@ class SnapGeometriesToLayer(GeoAlgorithm):
        tolerance = self.getParameterValue(self.TOLERANCE)
        mode = self.getParameterValue(self.BEHAVIOR)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            layer.fields(), layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(),
+                                                                     context)

        features = QgsProcessingUtils.getFeatures(layer, context)

--- a/python/plugins/processing/algs/qgis/SpatialJoin.py
+++ b/python/plugins/processing/algs/qgis/SpatialJoin.py
@ -150,8 +150,7 @@ class SpatialJoin(GeoAlgorithm):
        for f in list(targetFields.values()):
            fields.append(f)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, target.wkbType(), target.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, target.wkbType(), target.crs(), context)

        outFeat = QgsFeature()
        inFeatB = QgsFeature()
--- a/python/plugins/processing/algs/qgis/SplitLinesWithLines.py
+++ b/python/plugins/processing/algs/qgis/SplitLinesWithLines.py
@ -82,8 +82,8 @@ class SplitLinesWithLines(GeoAlgorithm):
        sameLayer = self.getParameterValue(self.INPUT_A) == self.getParameterValue(self.INPUT_B)
        fieldList = layerA.fields()

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList,
-                                                                     QgsWkbTypes.LineString, layerA.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList, QgsWkbTypes.LineString, layerA.crs(),
+                                                                     context)

        spatialIndex = vector.spatialindex(layerB)

--- a/python/plugins/processing/algs/qgis/SplitWithLines.py
+++ b/python/plugins/processing/algs/qgis/SplitWithLines.py
@ -78,8 +78,8 @@ class SplitWithLines(GeoAlgorithm):
        sameLayer = self.getParameterValue(self.INPUT_A) == self.getParameterValue(self.INPUT_B)
        fieldList = layerA.fields()

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList,
-                                                                     QgsWkbTypes.multiType(layerA.wkbType()), layerA.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList, QgsWkbTypes.multiType(layerA.wkbType()),
+                                                                     layerA.crs(), context)

        spatialIndex = QgsSpatialIndex()
        splitGeoms = {}
--- a/python/plugins/processing/algs/qgis/SumLines.py
+++ b/python/plugins/processing/algs/qgis/SumLines.py
@ -83,8 +83,8 @@ class SumLines(GeoAlgorithm):
        (idxCount, fieldList) = vector.findOrCreateField(polyLayer, fieldList,
                                                         countFieldName)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fieldList.toList(), polyLayer.wkbType(), polyLayer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList.toList(), polyLayer.wkbType(),
+                                                                     polyLayer.crs(), context)

        spatialIndex = vector.spatialindex(lineLayer)

--- a/python/plugins/processing/algs/qgis/SymmetricalDifference.py
+++ b/python/plugins/processing/algs/qgis/SymmetricalDifference.py
@ -78,8 +78,7 @@ class SymmetricalDifference(GeoAlgorithm):

        geomType = QgsWkbTypes.multiType(layerA.wkbType())
        fields = vector.combineVectorFields(layerA, layerB)
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
-            fields, geomType, layerA.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, geomType, layerA.crs(), context)

        featB = QgsFeature()
        outFeat = QgsFeature()
--- a/python/plugins/processing/algs/qgis/TextToFloat.py
+++ b/python/plugins/processing/algs/qgis/TextToFloat.py
@ -72,8 +72,7 @@ class TextToFloat(GeoAlgorithm):
        fields = layer.fields()
        fields[idx] = QgsField(fieldName, QVariant.Double, '', 24, 15)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
-                                                                     layer.wkbType(), layer.crs())
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)

--- a/python/plugins/processing/algs/qgis/TopoColors.py
+++ b/python/plugins/processing/algs/qgis/TopoColors.py
@ -104,10 +104,7 @@ class TopoColor(GeoAlgorithm):
        fields.append(QgsField('color_id', QVariant.Int))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
-            fields,
-            layer.wkbType(),
-            layer.crs())
+            self.OUTPUT_LAYER).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)

        features = {f.id(): f for f in QgsProcessingUtils.getFeatures(layer, context)}

--- a/Show More
+++ b/Show More