Merge pull request #4417 from nyalldawson/processing_writer

Refactor processing writer to use QgsFeatureSink

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

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(),
+        writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
-                                        layer.crs())
         outFeat = QgsFeature()
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(),
+        writer = output.getVectorWriter(fields, vlayer.wkbType(), vlayer.crs(), context)
-                                        vlayer.crs())
         outFeat = QgsFeature()
         features = QgsProcessingUtils.getFeatures(vlayer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(vlayer, context)

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), output_wkb, layer.crs(), context)
-                layer.fields(),
-                output_wkb,
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)
-                layer.fields().toList(),
-                QgsWkbTypes.Polygon,
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), QgsWkbTypes.Point, layer.crs(), context)
-                layer.fields(),
-                QgsWkbTypes.Point,
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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_writer = valid_output.getVectorWriter(valid_fields, layer.wkbType(), layer.crs(), context)
-            valid_fields,
-            layer.wkbType(),
-            layer.crs())
         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_writer = invalid_output.getVectorWriter(invalid_fields, layer.wkbType(), layer.crs(), context)
-            invalid_fields,
-            layer.wkbType(),
-            layer.crs())
         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_writer = error_output.getVectorWriter(error_fields, QgsWkbTypes.Point, layer.crs(), context)
-            error_fields,
-            QgsWkbTypes.Point,
-            layer.crs())
         error_count = 0
 
         features = QgsProcessingUtils.getFeatures(layer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(source_layer.fields(),
-            source_layer.fields(),
                                                                      QgsWkbTypes.multiType(source_layer.wkbType()),
-            source_layer.crs())
+                                                                     source_layer.crs(), context)
 
         # first build up a list of clip geometries
         clip_geoms = []

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon,
-            layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs())
+                                                                     layer.crs(), context)
         geom = feat.geometry()
         if no_multigeom and geom.isMultipart():
             # Only singlepart geometries are allowed

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)
-            fields, QgsWkbTypes.Polygon, layer.crs())
 
         outFeat = QgsFeature()
         inGeom = QgsGeometry()

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)
-                                                                     QgsWkbTypes.Polygon, layer.crs())
 
         pts = []
         ptDict = {}

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
-                                                                     layer.wkbType(), layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

python/plugins/processing/algs/qgis/DeleteDuplicateGeometries.py

@@ -65,8 +65,7 @@ class DeleteDuplicateGeometries(GeoAlgorithm):
 
         fields = layer.fields()
 
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
-                                                                     layer.wkbType(), layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
 

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(),
-            layer.fields(),
+                                                                     context)
-            layer.wkbType(),
-            layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(),
+            self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
-                                         layer.wkbType(), layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(),
+            self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
-                                         layer.wkbType(), layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(),
+            Difference.OUTPUT).getVectorWriter(layerA.fields(), geomType, layerA.crs(), context)
-                                               geomType,
-                                               layerA.crs())
 
         outFeat = QgsFeature()
         index = vector.spatialindex(layerB)

python/plugins/processing/algs/qgis/Dissolve.py

@@ -82,10 +82,7 @@ class Dissolve(GeoAlgorithm):
             self.getParameterValue(Dissolve.INPUT))
 
         writer = self.getOutputFromName(
-            Dissolve.OUTPUT).getVectorWriter(
+            Dissolve.OUTPUT).getVectorWriter(vlayerA.fields().toList(), vlayerA.wkbType(), vlayerA.crs(), context)
-                vlayerA.fields().toList(),
-                vlayerA.wkbType(),
-                vlayerA.crs())
 
         outFeat = QgsFeature()
         features = QgsProcessingUtils.getFeatures(vlayerA, context)

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(
+            self.OUTPUT_TABLE).getVectorWriter(layer.fields(), QgsWkbTypes.NoGeometry, QgsCoordinateReferenceSystem(),
-                layer.fields(),
+                                               context)
-                QgsWkbTypes.NoGeometry,
-                QgsCoordinateReferenceSystem())
 
         request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry)
         features = QgsProcessingUtils.getFeatures(layer, context, request)

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(),
+        writer = output.getVectorWriter(inLayer.fields(), inLayer.wkbType(), inLayer.crs(), context)
-                                        inLayer.wkbType(), inLayer.crs())
 
         for aFeat in inLayer.getFeatures():
             if aFeat.id() in selFeatIds:

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(),
+        writer = output.getVectorWriter(fields, vlayer.wkbType(), vlayer.crs(), context)
-                                        vlayer.crs())
         outFeat = QgsFeature()
         classes = {}
 

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(
+        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(vLayer.fields().toList(),
-            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())
+                                                                           vLayer.crs(), context)
 
         features = QgsProcessingUtils.getFeatures(vLayer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(vLayer, context)

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,
+        writer = output.getVectorWriter(fields, QgsWkbTypes.LineString, vlayer.crs(), context)
-                                        vlayer.crs())
         outFeat = QgsFeature()
         features = QgsProcessingUtils.getFeatures(vlayer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(vlayer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), layer.wkbType(), layer.crs(),
-            fields.toList(), layer.wkbType(), layer.crs())
+                                                                     context)
 
         ellips = None
         crs = None

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)
-                layer.fields(),
-                layer.wkbType(),
-                layer.crs())
 
         start_distance = self.getParameterValue(self.START_DISTANCE)
         end_distance = self.getParameterValue(self.END_DISTANCE)

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)
-                                                                     QgsWkbTypes.Polygon, layer.crs())
 
         if byFeature:
             self.featureExtent(layer, context, writer, feedback)

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
-                                                                     layer.wkbType(), layer.crs())
 
         idx = layer.fields().lookupField(fieldName)
         fieldType = fields[idx].type()

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():

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(),
+        writer = output.getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)
-                                        layer.wkbType(), layer.crs())
 
         if 'disjoint' in predicates:
             disjoinSet = []

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
-            fields, QgsWkbTypes.Point, layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+            self.OUTPUT_LAYER).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
-                fields,
-                QgsWkbTypes.Point,
-                layer.crs())
 
         node_indices_string = self.getParameterValue(self.NODES)
         indices = []

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(),
+        writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
-                                        layer.crs())
         outFeat = QgsFeature()
         new_ns = {}
 

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(),
+        writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
-                                        layer.crs())
 
         exp = QgsExpression(formula)
 

python/plugins/processing/algs/qgis/FieldsMapper.py

@@ -144,9 +144,7 @@ class FieldsMapper(GeoAlgorithm):
                             str(expression.parserErrorString())))
             expressions.append(expression)
 
-        writer = output.getVectorWriter(fields,
+        writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
-                                        layer.wkbType(),
-                                        layer.crs())
 
         # Create output vector layer with new attributes
         error_exp = None

python/plugins/processing/algs/qgis/FixGeometry.py

@@ -73,10 +73,7 @@ class FixGeometry(GeoAlgorithm):
             self.getParameterValue(self.INPUT))
 
         writer = self.getOutputFromName(
-            self.OUTPUT).getVectorWriter(
+            self.OUTPUT).getVectorWriter(layer.fields(), QgsWkbTypes.multiType(layer.wkbType()), layer.crs(), context)
-                layer.fields(),
-                QgsWkbTypes.multiType(layer.wkbType()),
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         if QgsProcessingUtils.featureCount(layer, context) == 0:

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(),
+            self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)
-                                         QgsWkbTypes.Polygon, layer.crs())
 
         buff.buffering(feedback, context, writer, distance, None, False, layer, dissolve, segments, end_cap_style,
                        join_style, miter_limit)

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), wkb_type, layer.crs(), context)
-                layer.fields(),
-                wkb_type,
-                layer.crs())
 
         expression = QgsExpression(self.getParameterValue(self.EXPRESSION))
         if expression.hasParserError():

python/plugins/processing/algs/qgis/GeometryConvert.py

@@ -93,8 +93,7 @@ class GeometryConvert(GeoAlgorithm):
         else:
             newType = QgsWkbTypes.Point
 
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), newType, layer.crs(), context)
-            layer.fields(), newType, layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.LineString, crs, context)
-                                                                     QgsWkbTypes.LineString, crs)
 
         if hOverlay > 0:
             hSpace = [hSpacing - hOverlay, hOverlay]

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, crs, context)
-                                                                     QgsWkbTypes.Polygon, crs)
 
         if idx == 0:
             self._rectangleGrid(

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(),
-            layer.fields(), layer.wkbType(), layer.crs())
+                                                                     context)
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.LineString, layerPoints.crs(),
-            fields, QgsWkbTypes.LineString, layerPoints.crs())
+                                                                     context)
 
         index = vector.spatialindex(layerHubs)
 

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layerPoints.crs(),
-            fields, QgsWkbTypes.Point, layerPoints.crs())
+                                                                     context)
 
         index = vector.spatialindex(layerHubs)
 

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layerSpoke.fields(), QgsWkbTypes.LineString,
-            layerSpoke.fields(), QgsWkbTypes.LineString, layerSpoke.crs())
+                                                                     layerSpoke.crs(), context)
 
         spokes = QgsProcessingUtils.getFeatures(layerSpoke, context)
         hubs = QgsProcessingUtils.getFeatures(layerHub, context)

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, geomType, vlayerA.crs(), context)
-                                                                     geomType, vlayerA.crs())
         outFeat = QgsFeature()
         index = vector.spatialindex(vlayerB)
         selectionA = QgsProcessingUtils.getFeatures(vlayerA, context)

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(),
+        writer = output.getVectorWriter(outFields, layer.wkbType(), layer.crs(), context)
-                                        layer.crs())
 
         # Cache attributes of Layer 2
         cache = {}

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldListA, QgsWkbTypes.Point, layerA.crs(),
-                                                                     QgsWkbTypes.Point, layerA.crs())
+                                                                     context)
 
         spatialIndex = vector.spatialindex(layerB)
 

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon,
-            layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs()
+                                                                     layer.crs(), context)
-        )
 
         outFeat = QgsFeature()
         features = QgsProcessingUtils.getFeatures(layer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList, QgsWkbTypes.Point, layer.crs(), context)
-            fieldList, QgsWkbTypes.Point, layer.crs()
-        )
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), layers[0].wkbType(),
-            fields.toList(), layers[0].wkbType(),
+                                                                     layers[0].crs(), context)
-            layers[0].crs())
 
         featureCount = 0
         for layer in layers:

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
-                layer.fields().toList(),
-                layer.wkbType(),
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), geomType, layer.crs(),
-            layer.fields().toList(), geomType, layer.crs())
+                                                                     context)
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.LineString, layer.crs(), context)
-                layer.fields().toList(),
-                QgsWkbTypes.LineString,
-                layer.crs())
 
         distance = self.getParameterValue(self.DISTANCE)
         segments = int(self.getParameterValue(self.SEGMENTS))

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)
-                                                                     QgsWkbTypes.Polygon, layer.crs())
 
         if byFeature:
             self.featureOmbb(layer, context, writer, feedback)

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)
-                layer.fields(),
-                layer.wkbType(),
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Point, layer.crs(), context)
-                layer.fields().toList(),
-                QgsWkbTypes.Point,
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
-            fields, QgsWkbTypes.Point, layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(),
+        writer = output.getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)
-                                        layer.wkbType(), layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
 

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(
+        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.Point,
-            fields.toList(), QgsWkbTypes.Point, layer.crs())
+                                                                           layer.crs(), context)
 
         outFeature = QgsFeature()
         outFeature.setFields(fields)

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(
+        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.Point,
-            fields.toList(), QgsWkbTypes.Point, layer.crs())
+                                                                           layer.crs(), context)
 
         outFeature = QgsFeature()
         outFeature.setFields(fields)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), polyLayer.wkbType(),
-            fields.toList(), polyLayer.wkbType(), polyLayer.crs())
+                                                                     polyLayer.crs(), context)
 
         spatialIndex = vector.spatialindex(pointLayer)
 

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), polyLayer.wkbType(),
-            fields.toList(), polyLayer.wkbType(), polyLayer.crs())
+                                                                     polyLayer.crs(), context)
 
         spatialIndex = vector.spatialindex(pointLayer)
 

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), polyLayer.wkbType(),
-            fields.toList(), polyLayer.wkbType(), polyLayer.crs())
+                                                                     polyLayer.crs(), context)
 
         spatialIndex = vector.spatialindex(pointLayer)
 

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)

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(
+        writer = self.getOutputFromName(self.OUTPUT_LINES).getVectorWriter(fields, QgsWkbTypes.LineString, layer.crs(),
-            fields, QgsWkbTypes.LineString, layer.crs())
+                                                                           context)
 
         points = dict()
         features = QgsProcessingUtils.getFeatures(layer, context)

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(
+            self.OUTPUT_LAYER).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
-                fields,
-                QgsWkbTypes.Point,
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), QgsWkbTypes.Point, layer.crs(), context)
-                layer.fields(),
-                QgsWkbTypes.Point,
-                layer.crs())
 
         outFeat = QgsFeature()
 

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()

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.LineString,
-            layer.fields().toList(), QgsWkbTypes.LineString, layer.crs())
+                                                                     layer.crs(), context)
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
-            layer.fields().toList(), layer.wkbType(), layer.crs())
+                                                                     layer.crs(), context)
 
         total = 100.0 / featureCount
         for i, feat in enumerate(features):

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
-            layer.fields().toList(), layer.wkbType(), layer.crs())
+                                                                     layer.crs(), context)
 
         selran = []
         total = 100.0 / (featureCount * len(unique))

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
-            fields, QgsWkbTypes.Point, layer.crs())
 
         nPoints = 0
         nIterations = 0

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, crs, context)
-            fields, QgsWkbTypes.Point, crs)
 
         nPoints = 0
         nIterations = 0

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
-            fields, QgsWkbTypes.Point, layer.crs())
 
         nPoints = 0
         nIterations = 0

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
-            fields, QgsWkbTypes.Point, layer.crs())
 
         da = QgsDistanceArea()
 

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
-            fields, QgsWkbTypes.Point, layer.crs())
 
         da = QgsDistanceArea()
 

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)
-                layer.fields().toList(),
-                QgsWkbTypes.Polygon,
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
 

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)
-                layer.fields().toList(),
-                QgsWkbTypes.Polygon,
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
 

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, crs, context)
-            fields, QgsWkbTypes.Point, crs)
 
         if randomize:
             seed()

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)
-                layer.fields(),
-                layer.wkbType(),
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
-            layer.fields().toList(), layer.wkbType(), targetCrs)
+                                                                     targetCrs, context)
 
         layerCrs = layer.crs()
         crsTransform = QgsCoordinateTransform(layerCrs, targetCrs)

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
-                layer.fields().toList(),
-                layer.wkbType(),
-                layer.crs())
 
         outFeat = QgsFeature()
 

python/plugins/processing/algs/qgis/SaveSelectedFeatures.py

@@ -65,8 +65,7 @@ class SaveSelectedFeatures(GeoAlgorithm):
 
         vectorLayer = dataobjects.getLayerFromString(inputFilename)
 
-        writer = output.getVectorWriter(vectorLayer.fields(),
+        writer = output.getVectorWriter(vectorLayer.fields(), vectorLayer.wkbType(), vectorLayer.crs(), context)
-                                        vectorLayer.wkbType(), vectorLayer.crs())
 
         features = vectorLayer.selectedFeaturesIterator()
         total = 100.0 / int(vectorLayer.selectedFeatureCount())

python/plugins/processing/algs/qgis/ServiceAreaFromLayer.py

@@ -176,16 +176,10 @@ class ServiceAreaFromLayer(GeoAlgorithm):
         feat.setFields(fields)
 
         writerPoints = self.getOutputFromName(
-            self.OUTPUT_POINTS).getVectorWriter(
+            self.OUTPUT_POINTS).getVectorWriter(fields, QgsWkbTypes.MultiPoint, layer.crs(), context)
-                fields,
-                QgsWkbTypes.MultiPoint,
-                layer.crs())
 
         writerPolygons = self.getOutputFromName(
-            self.OUTPUT_POLYGON).getVectorWriter(
+            self.OUTPUT_POLYGON).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)
-                fields,
-                QgsWkbTypes.Polygon,
-                layer.crs())
 
         directionField = -1
         if directionFieldName is not None:

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(
+            self.OUTPUT_POINTS).getVectorWriter(fields, QgsWkbTypes.MultiPoint, layer.crs(), context)
-                fields,
-                QgsWkbTypes.MultiPoint,
-                layer.crs())
 
         feat.setGeometry(geomUpper)
         feat['type'] = 'upper'
@@ -254,10 +251,7 @@ class ServiceAreaFromPoint(GeoAlgorithm):
         geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
 
         writer = self.getOutputFromName(
-            self.OUTPUT_POLYGON).getVectorWriter(
+            self.OUTPUT_POLYGON).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)
-                fields,
-                QgsWkbTypes.Polygon,
-                layer.crs())
 
         geom = geomUpper.convexHull()
         feat.setGeometry(geom)

python/plugins/processing/algs/qgis/ShortestPathLayerToPoint.py

@@ -182,10 +182,7 @@ class ShortestPathLayerToPoint(GeoAlgorithm):
         feat.setFields(fields)
 
         writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
+            self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.LineString, layer.crs(), context)
-                fields.toList(),
-                QgsWkbTypes.LineString,
-                layer.crs())
 
         tmp = endPoint.split(',')
         endPoint = QgsPoint(float(tmp[0]), float(tmp[1]))

python/plugins/processing/algs/qgis/ShortestPathPointToLayer.py

@@ -175,10 +175,7 @@ class ShortestPathPointToLayer(GeoAlgorithm):
         feat.setFields(fields)
 
         writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(
+            self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.LineString, layer.crs(), context)
-                fields.toList(),
-                QgsWkbTypes.LineString,
-                layer.crs())
 
         tmp = startPoint.split(',')
         startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))

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(
+            self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.LineString, layer.crs(), context)
-                fields.toList(),
-                QgsWkbTypes.LineString,
-                layer.crs())
 
         tmp = startPoint.split(',')
         startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))

python/plugins/processing/algs/qgis/SimplifyGeometries.py

@@ -86,8 +86,8 @@ class SimplifyGeometries(GeoAlgorithm):
         pointsBefore = 0
         pointsAfter = 0
 
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
-            layer.fields().toList(), layer.wkbType(), layer.crs())
+                                                                     layer.crs(), context)
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), geomType, layer.crs(),
-            layer.fields().toList(), geomType, layer.crs())
+                                                                     context)
 
         outFeat = QgsFeature()
         inGeom = QgsGeometry()

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)
-                layer.fields().toList(),
-                QgsWkbTypes.Polygon,
-                layer.crs())
 
         distance = self.getParameterValue(self.DISTANCE)
         segments = int(self.getParameterValue(self.SEGMENTS))

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(
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
-                layer.fields().toList(),
-                layer.wkbType(),
-                layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
         total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(),
-            layer.fields(), layer.wkbType(), layer.crs())
+                                                                     context)
 
         features = QgsProcessingUtils.getFeatures(layer, context)
 

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, target.wkbType(), target.crs(), context)
-            fields, target.wkbType(), target.crs())
 
         outFeat = QgsFeature()
         inFeatB = QgsFeature()

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList, QgsWkbTypes.LineString, layerA.crs(),
-                                                                     QgsWkbTypes.LineString, layerA.crs())
+                                                                     context)
 
         spatialIndex = vector.spatialindex(layerB)
 

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList, QgsWkbTypes.multiType(layerA.wkbType()),
-                                                                     QgsWkbTypes.multiType(layerA.wkbType()), layerA.crs())
+                                                                     layerA.crs(), context)
 
         spatialIndex = QgsSpatialIndex()
         splitGeoms = {}

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList.toList(), polyLayer.wkbType(),
-            fieldList.toList(), polyLayer.wkbType(), polyLayer.crs())
+                                                                     polyLayer.crs(), context)
 
         spatialIndex = vector.spatialindex(lineLayer)
 

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(
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, geomType, layerA.crs(), context)
-            fields, geomType, layerA.crs())
 
         featB = QgsFeature()
         outFeat = QgsFeature()

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,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
-                                                                     layer.wkbType(), layer.crs())
 
         features = QgsProcessingUtils.getFeatures(layer, context)
 

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(
+            self.OUTPUT_LAYER).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
-            fields,
-            layer.wkbType(),
-            layer.crs())
 
         features = {f.id(): f for f in QgsProcessingUtils.getFeatures(layer, context)}