Unify processing "polygon from layer extent" algorithms

Now that the extra features of the "polygon from vector layer extent"
algorithm are covered by the new "Minimum bounding geometry" algorithm,
we can replace the previous two "polygon from vector extent" and
"polygon from raster extent" algorithms by a single "polygon
from layer extent" algorithm.

python/plugins/processing/algs/help/qgis.yaml

@@ -402,12 +402,7 @@ qgis:polygoncentroids: >
   NOTE: This algorithm is deprecated and the generic "centroids" algorithm (which works for line and multi geometry layers) should be used instead.
 
 qgis:polygonfromlayerextent: >
-  This algorithm takes a vector layer and generates a new one with the minimum bounding box (rectangle with N-S orientation) that covers all the input features.
-
-  As an alternative, the output layer can contain not just a single bounding box, but one for each input feature, representing the bounding box of each of them.
-
-qgis:polygonfromrasterextent: >
-  This algorithm takes a raster layer and generates a vector layer containing a feature with the minimum bounding box that covers the raster layer's extent.
+  This algorithm takes a map layer and generates a new vector layer with the minimum bounding box (rectangle with N-S orientation) that covers the input layer.
 
 qgis:polygonize:  >
   This algorithm takes a lines layer and creates a polygon layer, with polygons generated from the lines in the input layer.

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

@@ -32,14 +32,12 @@ from qgis.PyQt.QtCore import QVariant
 
 from qgis.core import (QgsField,
                        QgsFeatureSink,
-                       QgsPointXY,
                        QgsGeometry,
                        QgsFeature,
                        QgsWkbTypes,
                        QgsProcessing,
-                       QgsProcessingParameterFeatureSource,
+                       QgsProcessingParameterMapLayer,
                        QgsProcessingParameterFeatureSink,
-                       QgsProcessingParameterBoolean,
                        QgsFields)
 
 from processing.algs.qgis.QgisAlgorithm import QgisAlgorithm
@@ -61,27 +59,23 @@ class ExtentFromLayer(QgisAlgorithm):
         return self.tr('extent,envelope,bounds,bounding,boundary,layer').split(',')
 
     def group(self):
-        return self.tr('Vector general')
+        return self.tr('Layer tools')
 
     def __init__(self):
         super().__init__()
 
     def initAlgorithm(self, config=None):
-        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Input layer')))
-        self.addParameter(QgsProcessingParameterBoolean(self.BY_FEATURE,
-                                                        self.tr('Calculate extent for each feature separately'), False))
-
+        self.addParameter(QgsProcessingParameterMapLayer(self.INPUT, self.tr('Input layer')))
         self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Extent'), type=QgsProcessing.TypeVectorPolygon))
 
     def name(self):
         return 'polygonfromlayerextent'
 
     def displayName(self):
-        return self.tr('Polygon from vector extent')
+        return self.tr('Polygon from layer extent')
 
     def processAlgorithm(self, parameters, context, feedback):
-        source = self.parameterAsSource(parameters, self.INPUT, context)
-        byFeature = self.parameterAsBool(parameters, self.BY_FEATURE, context)
+        layer = self.parameterAsLayer(parameters, self.INPUT, context)
 
         fields = QgsFields()
         fields.append(QgsField('MINX', QVariant.Double))
@@ -96,17 +90,15 @@ class ExtentFromLayer(QgisAlgorithm):
         fields.append(QgsField('WIDTH', QVariant.Double))
 
         (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
-                                               fields, QgsWkbTypes.Polygon, source.sourceCrs())
+                                               fields, QgsWkbTypes.Polygon, layer.crs())
 
-        if byFeature:
-            self.featureExtent(source, context, sink, feedback)
-        else:
-            self.layerExtent(source, sink, feedback)
+        try:
+            # may not be possible
+            layer.updateExtents()
+        except:
+            pass
 
-        return {self.OUTPUT: dest_id}
-
-    def layerExtent(self, source, sink, feedback):
-        rect = source.sourceExtent()
+        rect = layer.extent()
         geometry = QgsGeometry.fromRect(rect)
         minx = rect.xMinimum()
         miny = rect.yMinimum()
@@ -136,43 +128,4 @@ class ExtentFromLayer(QgisAlgorithm):
         feat.setAttributes(attrs)
         sink.addFeature(feat, QgsFeatureSink.FastInsert)
 
-    def featureExtent(self, source, context, sink, feedback):
-        features = source.getFeatures()
-        total = 100.0 / source.featureCount() if source.featureCount() else 0
-        feat = QgsFeature()
-        for current, f in enumerate(features):
-            if feedback.isCanceled():
-                break
-
-            rect = f.geometry().boundingBox()
-            minx = rect.xMinimum()
-            miny = rect.yMinimum()
-            maxx = rect.xMaximum()
-            maxy = rect.yMaximum()
-            height = rect.height()
-            width = rect.width()
-            cntx = minx + width / 2.0
-            cnty = miny + height / 2.0
-            area = width * height
-            perim = 2 * width + 2 * height
-            rect = [QgsPointXY(minx, miny), QgsPointXY(minx, maxy), QgsPointXY(maxx,
-                                                                               maxy), QgsPointXY(maxx, miny), QgsPointXY(minx, miny)]
-
-            geometry = QgsGeometry().fromPolygon([rect])
-            feat.setGeometry(geometry)
-            attrs = [
-                minx,
-                miny,
-                maxx,
-                maxy,
-                cntx,
-                cnty,
-                area,
-                perim,
-                height,
-                width,
-            ]
-            feat.setAttributes(attrs)
-
-            sink.addFeature(feat, QgsFeatureSink.FastInsert)
-            feedback.setProgress(int(current * total))
+        return {self.OUTPUT: dest_id}

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

@@ -1,127 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-***************************************************************************
-    ExtentFromRasterLayer.py
-    ---------------------
-    Date                 : August 2017
-    Copyright            : (C) 2017 by Nyall Dawson
-    Email                : nyall dot dawson at gmail dot com
-***************************************************************************
-*                                                                         *
-*   This program is free software; you can redistribute it and/or modify  *
-*   it under the terms of the GNU General Public License as published by  *
-*   the Free Software Foundation; either version 2 of the License, or     *
-*   (at your option) any later version.                                   *
-*                                                                         *
-***************************************************************************
-"""
-
-__author__ = 'Nyall Dawson'
-__date__ = 'August 2017'
-__copyright__ = '(C) 2017, Nyall Dawson'
-
-# This will get replaced with a git SHA1 when you do a git archive
-
-__revision__ = '$Format:%H$'
-
-import os
-
-from qgis.PyQt.QtGui import QIcon
-from qgis.PyQt.QtCore import QVariant
-
-from qgis.core import (QgsField,
-                       QgsFeatureSink,
-                       QgsPointXY,
-                       QgsGeometry,
-                       QgsFeature,
-                       QgsWkbTypes,
-                       QgsProcessing,
-                       QgsProcessingParameterRasterLayer,
-                       QgsProcessingParameterFeatureSink,
-                       QgsFields)
-
-from processing.algs.qgis.QgisAlgorithm import QgisAlgorithm
-
-pluginPath = os.path.split(os.path.split(os.path.dirname(__file__))[0])[0]
-
-
-class ExtentFromRasterLayer(QgisAlgorithm):
-
-    INPUT = 'INPUT'
-    OUTPUT = 'OUTPUT'
-
-    def icon(self):
-        return QIcon(os.path.join(pluginPath, 'images', 'ftools', 'layer_extent.png'))
-
-    def tags(self):
-        return self.tr('extent,envelope,bounds,bounding,boundary,layer').split(',')
-
-    def group(self):
-        return self.tr('Raster tools')
-
-    def __init__(self):
-        super().__init__()
-
-    def initAlgorithm(self, config=None):
-        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
-        self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Extent'), type=QgsProcessing.TypeVectorPolygon))
-
-    def name(self):
-        return 'polygonfromrasterextent'
-
-    def displayName(self):
-        return self.tr('Polygon from raster extent')
-
-    def processAlgorithm(self, parameters, context, feedback):
-        raster = self.parameterAsRasterLayer(parameters, self.INPUT, context)
-
-        fields = QgsFields()
-        fields.append(QgsField('MINX', QVariant.Double))
-        fields.append(QgsField('MINY', QVariant.Double))
-        fields.append(QgsField('MAXX', QVariant.Double))
-        fields.append(QgsField('MAXY', QVariant.Double))
-        fields.append(QgsField('CNTX', QVariant.Double))
-        fields.append(QgsField('CNTY', QVariant.Double))
-        fields.append(QgsField('AREA', QVariant.Double))
-        fields.append(QgsField('PERIM', QVariant.Double))
-        fields.append(QgsField('HEIGHT', QVariant.Double))
-        fields.append(QgsField('WIDTH', QVariant.Double))
-
-        (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
-                                               fields, QgsWkbTypes.Polygon, raster.crs())
-
-        self.layerExtent(raster, sink, feedback)
-
-        return {self.OUTPUT: dest_id}
-
-    def layerExtent(self, raster, sink, feedback):
-        rect = raster.extent()
-        geometry = QgsGeometry.fromRect(rect)
-        minx = rect.xMinimum()
-        miny = rect.yMinimum()
-        maxx = rect.xMaximum()
-        maxy = rect.yMaximum()
-        height = rect.height()
-        width = rect.width()
-        cntx = minx + width / 2.0
-        cnty = miny + height / 2.0
-        area = width * height
-        perim = 2 * width + 2 * height
-
-        feat = QgsFeature()
-        feat.setGeometry(geometry)
-        attrs = [
-            minx,
-            miny,
-            maxx,
-            maxy,
-            cntx,
-            cnty,
-            area,
-            perim,
-            height,
-            width,
-        ]
-        feat.setAttributes(attrs)
-        sink.addFeature(feat, QgsFeatureSink.FastInsert)

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

@@ -68,7 +68,6 @@ from .Explode import Explode
 from .ExportGeometryInfo import ExportGeometryInfo
 from .ExtendLines import ExtendLines
 from .ExtentFromLayer import ExtentFromLayer
-from .ExtentFromRasterLayer import ExtentFromRasterLayer
 from .ExtractNodes import ExtractNodes
 from .ExtractSpecificNodes import ExtractSpecificNodes
 from .FieldPyculator import FieldsPyculator
@@ -219,7 +218,6 @@ class QGISAlgorithmProvider(QgsProcessingProvider):
                 ExportGeometryInfo(),
                 ExtendLines(),
                 ExtentFromLayer(),
-                ExtentFromRasterLayer(),
                 ExtractNodes(),
                 ExtractSpecificNodes(),
                 FieldsCalculator(),

python/plugins/processing/tests/testdata/qgis_algorithm_tests.yaml

@@ -3205,7 +3205,7 @@ tests:
         name: expected/execute_sql.gml
         type: vector
 
-  - algorithm: qgis:polygonfromrasterextent
+  - algorithm: qgis:polygonfromlayerextent
     name: Polygon from raster extent
     params:
       INPUT: