[processing] restore gdal2tiles algorithm

python/plugins/processing/algs/gdal/GdalAlgorithmProvider.py

@@ -41,6 +41,7 @@ from .ClipByMask import ClipByMask
 from .ColorRelief import ColorRelief
 from .contour import contour
 from .fillnodata import fillnodata
+from .gdal2tiles import gdal2tiles
 from .gdaltindex import gdaltindex
 from .GridAverage import GridAverage
 from .GridDataMetrics import GridDataMetrics
@@ -71,7 +72,6 @@ from .warp import warp
 # from .gdalcalc import gdalcalc
 # from .rasterize_over import rasterize_over
 # from .retile import retile
-# from .gdal2tiles import gdal2tiles
 
 from .ogr2ogrpointsonlines import Ogr2OgrPointsOnLines
 from .ogr2ogrtopostgis import Ogr2OgrToPostGis
@@ -144,6 +144,7 @@ class GdalAlgorithmProvider(QgsProcessingProvider):
             ColorRelief(),
             contour(),
             fillnodata(),
+            gdal2tiles(),
             gdaltindex(),
             GridAverage(),
             GridDataMetrics(),
@@ -173,7 +174,6 @@ class GdalAlgorithmProvider(QgsProcessingProvider):
             # gdalcalc(),
             # rasterize_over(),
             # retile(),
-            # gdal2tiles(),
             # ----- OGR tools -----
             Ogr2OgrPointsOnLines(),
             Ogr2OgrToPostGis(),

python/plugins/processing/algs/gdal/gdal2tiles.py

@@ -16,7 +16,6 @@
 *                                                                         *
 ***************************************************************************
 """
-from builtins import str
 
 __author__ = 'Médéric Ribreux'
 __date__ = 'January 2016'
@@ -26,17 +25,19 @@ __copyright__ = '(C) 2016, Médéric Ribreux'
 
 __revision__ = '$Format:%H$'
 
-from qgis.core import QgsProcessingParameterDefinition
 
+from qgis.core import (QgsProcessingParameterDefinition,
+                       QgsProcessingParameterRasterLayer,
+                       QgsProcessingParameterCrs,
+                       QgsProcessingParameterEnum,
+                       QgsProcessingParameterString,
+                       QgsProcessingParameterNumber,
+                       QgsProcessingParameterBoolean,
+                       QgsProcessingOutputFolder,
+                       QgsProcessingParameterFolderDestination)
 from processing.algs.gdal.GdalAlgorithm import GdalAlgorithm
-from processing.core.parameters import ParameterRaster
-from processing.core.parameters import ParameterString
-from processing.core.parameters import ParameterSelection
-from processing.core.parameters import ParameterCrs
-from processing.core.parameters import ParameterBoolean
-from processing.core.outputs import OutputDirectory
-from processing.tools.system import isWindows
 from processing.algs.gdal.GdalUtils import GdalUtils
+from processing.tools.system import isWindows
 
 
 class gdal2tiles(GdalAlgorithm):
@@ -45,81 +46,103 @@ class gdal2tiles(GdalAlgorithm):
     PROFILE = 'PROFILE'
     RESAMPLING = 'RESAMPLING'
     ZOOM = 'ZOOM'
-    S_SRS = 'S_SRS'
+    SOURCE_CRS = 'SOURCE_CRS'
-    OUTPUTDIR = 'OUTPUTDIR'
-    RESUME = 'RESUME'
     NODATA = 'NODATA'
-    FORCEKML = 'FORCEKML'
+    KML = 'KML'
-    NOKML = 'NOKML'
+    NO_KML = 'NO_KML'
     URL = 'URL'
-    WEBVIEWER = 'WEBVIEWER'
+    VIEWER = 'VIEWER'
     TITLE = 'TITLE'
     COPYRIGHT = 'COPYRIGHT'
-    GOOGLEKEY = 'GOOGLEKEY'
+    GOOGLE_KEY = 'GOOGLE_KEY'
-    BINGKEY = 'BINGKEY'
+    BING_KEY = 'BING_KEY'
-
+    RESUME = 'RESUME'
-    PROFILES = ['mercator', 'geodetic', 'raster']
+    OUTPUT = 'OUTPUT'
-    RESAMPLINGS = ['average', 'near', 'bilinear', 'cubic', 'cubicspline', 'lanczos', 'antialias']
-    WEBVIEWERS = ['all', 'google', 'openlayers', 'leaflet', 'none']
 
     def __init__(self):
         super().__init__()
 
     def initAlgorithm(self, config=None):
-        # Required parameters
+        self.profiles = ((self.tr('Mercator'), 'mercator'),
-        self.addParameter(ParameterRaster(self.INPUT, self.tr('Input layer')))
+                         (self.tr('Geodetic'), 'geodetic'),
+                         (self.tr('Raster'), 'raster'))
 
-        # Advanced parameters
+        self.methods = ((self.tr('Average'), 'average'),
-        params = []
+                        (self.tr('Nearest neighbour'), 'near'),
-        params.append(ParameterSelection(self.PROFILE,
+                        (self.tr('Bilinear'), 'bilinear'),
+                        (self.tr('Cubic'), 'cubic'),
+                        (self.tr('Cubic spline'), 'cubicspline'),
+                        (self.tr('Lanczos windowed sinc'), 'lanczos'),
+                        (self.tr('Antialias'), 'antialias'))
+
+        self.viewers = ((self.tr('All'), 'all'),
+                        (self.tr('GoogleMaps'), 'google'),
+                        (self.tr('OpenLayers'), 'openlayers'),
+                        (self.tr('Leaflet'), 'leaflet'),
+                        (self.tr('None'), 'none'))
+
+        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
+        self.addParameter(QgsProcessingParameterEnum(self.PROFILE,
                                                      self.tr('Tile cutting profile'),
-                                         self.PROFILES, 0, False, optional=True))
+                                                     options=[i[0] for i in self.profiles],
-        params.append(ParameterSelection(self.RESAMPLING,
+                                                     allowMultiple=False,
-                                         self.tr('Resampling method'),
+                                                     defaultValue=0))
-                                         self.RESAMPLINGS, 0, False, optional=True))
+        self.addParameter(QgsProcessingParameterString(self.ZOOM,
-        params.append(ParameterCrs(self.S_SRS,
-                                   self.tr('The spatial reference system used for the source input data'),
-                                   None, True))
-        params.append(ParameterString(self.ZOOM,
                                                        self.tr('Zoom levels to render'),
-                                      None, False, True))
+                                                       defaultValue='',
-        params.append(ParameterBoolean(self.RESUME,
+                                                       optional=True))
-                                       self.tr('Resume mode, generate only missing files'),
+        self.addParameter(QgsProcessingParameterEnum(self.VIEWER,
-                                       False, True))
-        params.append(ParameterString(self.NODATA,
-                                      self.tr('NODATA transparency value to assign to the input data'),
-                                      None, False, True))
-        params.append(ParameterBoolean(self.FORCEKML,
-                                       self.tr('Generate KML for Google Earth - default for "geodetic" profile and "raster" in EPSG:4326'),
-                                       False, True))
-        params.append(ParameterBoolean(self.NOKML,
-                                       self.tr('Avoid automatic generation of KML files for EPSG:4326'),
-                                       False, True))
-        params.append(ParameterString(self.URL,
-                                      self.tr('URL address where the generated tiles are going to be published'),
-                                      None, False, True))
-        params.append(ParameterSelection(self.WEBVIEWER,
                                                      self.tr('Web viewer to generate'),
-                                         self.WEBVIEWERS, 0, False, optional=True))
+                                                     options=[i[0] for i in self.viewers],
-        params.append(ParameterString(self.TITLE,
+                                                     allowMultiple=False,
+                                                     defaultValue=0))
+        self.addParameter(QgsProcessingParameterString(self.TITLE,
                                                        self.tr('Title of the map'),
-                                      None, False, True))
+                                                       optional=True))
-        params.append(ParameterString(self.COPYRIGHT,
+        self.addParameter(QgsProcessingParameterString(self.COPYRIGHT,
-                                      self.tr('Copyright for the map'),
+                                                       self.tr('Copyright of the map'),
-                                      None, False, True))
+                                                       optional=True))
-        params.append(ParameterString(self.GOOGLEKEY,
-                                      self.tr('Google Maps API key from http://code.google.com/apis/maps/signup.html'),
-                                      None, False, True))
-        params.append(ParameterString(self.BINGKEY,
-                                      self.tr('Bing Maps API key from https://www.bingmapsportal.com/'),
-                                      None, False, True))
 
+        params = []
+        params.append(QgsProcessingParameterEnum(self.RESAMPLING,
+                                                 self.tr('Resampling method'),
+                                                 options=[i[0] for i in self.methods],
+                                                 allowMultiple=False,
+                                                 defaultValue=0))
+        params.append(QgsProcessingParameterCrs(self.SOURCE_CRS,
+                                                self.tr('The spatial reference system used for the source input data'),
+                                                optional=True))
+        params.append(QgsProcessingParameterNumber(self.NODATA,
+                                                   self.tr('Transparency value to assign to the input data'),
+                                                   type=QgsProcessingParameterNumber.Double,
+                                                   defaultValue=0,
+                                                   optional=True))
+        params.append(QgsProcessingParameterString(self.URL,
+                                                   self.tr('URL address where the generated tiles are going to be published'),
+                                                   optional=True))
+        params.append(QgsProcessingParameterString(self.GOOGLE_KEY,
+                                                   self.tr('Google Maps API key (http://code.google.com/apis/maps/signup.html)'),
+                                                   optional=True))
+        params.append(QgsProcessingParameterString(self.BING_KEY,
+                                                   self.tr('Bing Maps API key (https://www.bingmapsportal.com/)'),
+                                                   optional=True))
+        params.append(QgsProcessingParameterBoolean(self.RESUME,
+                                                    self.tr('Generate only missing files'),
+                                                    defaultValue=False))
+        params.append(QgsProcessingParameterBoolean(self.KML,
+                                                    self.tr('Generate KML for Google Earth'),
+                                                    defaultValue=False))
+        params.append(QgsProcessingParameterBoolean(self.NO_KML,
+                                                    self.tr('Avoid automatic generation of KML files for EPSG:4326'),
+                                                    defaultValue=False))
         for param in params:
             param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
             self.addParameter(param)
 
-        self.addOutput(OutputDirectory(self.OUTPUTDIR,
+        self.addParameter(QgsProcessingParameterFolderDestination(self.OUTPUT,
-                                       self.tr('The directory where the tile result is created')))
+                                                                  self.tr('Output directory')))
+
+        self.addOutput(QgsProcessingOutputFolder(self.OUTPUT, self.tr('Output directory')))
 
     def name(self):
         return 'gdal2tiles'
@@ -131,58 +154,69 @@ class gdal2tiles(GdalAlgorithm):
         return self.tr('Raster miscellaneous')
 
     def getConsoleCommands(self, parameters, context, feedback):
-
         arguments = []
 
-        if self.getParameterValue(self.PROFILE):
         arguments.append('-p')
-            arguments.append(self.PROFILES[self.getParameterValue(self.PROFILE)])
+        arguments.append(self.profiles[self.parameterAsEnum(parameters, self.PROFILE, context)][1])
 
-        if self.getParameterValue(self.RESAMPLING):
+        zoom = self.parameterAsString(parameters, self.ZOOM, context)
-            arguments.append('-r')
+        if zoom:
-            arguments.append(self.RESAMPLINGS[self.getParameterValue(self.RESAMPLING)])
-
-        ssrs = str(self.getParameterValue(self.S_SRS))
-        if len(ssrs) > 0:
-            arguments.append('-s')
-            arguments.append(ssrs)
-
-        if self.getParameterValue(self.ZOOM):
             arguments.append('-z')
-            arguments.append(str(self.getParameterValue(self.ZOOM)))
+            arguments.append(str(zoom))
 
-        if self.getParameterValue(self.RESUME):
+        arguments.append('-w')
+        arguments.append(self.viewers[self.parameterAsEnum(parameters, self.VIEWER, context)][1])
+
+        title = self.parameterAsString(parameters, self.TITLE, context)
+        if title:
+            arguments.append('-t')
+            arguments.append(title)
+
+        copying = self.parameterAsString(parameters, self.COPYRIGHT, context)
+        if copying:
+            arguments.append('-c')
+            arguments.append(copying)
+
+        arguments.append('-r')
+        arguments.append(self.methods[self.parameterAsEnum(parameters, self.RESAMPLING, context)][1])
+
+        crs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
+        if crs.isValid():
+            arguments.append('-s')
+            arguments.append(crs.authid())
+
+        nodata = self.parameterAsDouble(parameters, self.NODATA, context)
+        if nodata:
+            arguments.append('-a')
+            arguments.append(str(nodata))
+
+        url = self.parameterAsString(parameters, self.URL, context)
+        if url:
+            arguments.append('-u')
+            arguments.append(url)
+
+        key = self.parameterAsString(parameters, self.GOOGLE_KEY, context)
+        if key:
+            arguments.append('-g')
+            arguments.append(key)
+
+        key = self.parameterAsString(parameters, self.BING_KEY, context)
+        if key:
+            arguments.append('-b')
+            arguments.append(key)
+
+        if self.parameterAsBool(parameters, self.RESUME, context):
             arguments.append('-e')
 
-        if self.getParameterValue(self.NODATA):
+        if self.parameterAsBool(parameters, self.KML, context):
-            arguments.append('-a')
-            arguments.append(str(self.getParameterValue(self.NODATA)))
-
-        # KML arguments
-        if self.getParameterValue(self.FORCEKML):
             arguments.append('-k')
 
-        if self.getParameterValue(self.NOKML):
+        if self.parameterAsBool(parameters, self.NO_KML, context):
             arguments.append('-n')
 
-        if self.getParameterValue(self.URL):
+        inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
-            arguments.append('-u')
+        arguments.append(inLayer.source())
-            arguments.append(str(self.getParameterValue(self.URL)))
+        arguments.append(self.parameterAsString(parameters, self.OUTPUT, context))
-
-        # Web viewer arguments
-        if self.getParameterValue(self.WEBVIEWER):
-            arguments.append('-w')
-            arguments.append(self.WEBVIEWERS[self.getParameterValue(self.WEBVIEWER)])
-
-        parameters = {self.TITLE: '-t', self.COPYRIGHT: '-c',
-                      self.GOOGLEKEY: '-g', self.BINGKEY: '-b'}
-        for arg, parameter in list(parameters.items()):
-            if self.getParameterValue(arg):
-                arguments.append(parameter)
-                arguments.append(self.getParameterValue(arg))
-
-        arguments.append(self.getParameterValue(self.INPUT))
-        arguments.append(self.getOutputValue(self.OUTPUTDIR))
 
         commands = []
         if isWindows():