def initAlgorithm(self, config=None):
     db_param = QgsProcessingParameterString(
         self.DATABASE,
         self.tr('Database (connection name)'))
     db_param.setMetadata({
         'widget_wrapper': {
             'class': 'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'}})
     self.addParameter(db_param)
     self.addParameter(QgsProcessingParameterString(
         self.SQL,
         self.tr('SQL query'),
         multiLine=True))
     self.addParameter(QgsProcessingParameterString(
         self.ID_FIELD,
         self.tr('Unique ID field name'),
         defaultValue='id'))
     self.addParameter(QgsProcessingParameterString(
         self.GEOMETRY_FIELD,
         self.tr('Geometry field name'),
         defaultValue='geom',
         optional=True))
     self.addOutput(QgsProcessingOutputVectorLayer(
         self.OUTPUT,
         self.tr("Output layer"),
         QgsProcessing.TypeVectorAnyGeometry))
Example #2
0
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT,
                self.tr('Input Point Layer'),
                [QgsProcessing.TypeVectorPoint]
            )
        )

        self.addParameter(
            QgsProcessingParameterRasterLayer(
                self.RASTERCOPY,
                self.tr('Raster Layer to sample'),
            )
        )

        columnPrefix = QgsProcessingParameterString(
            self.COLUMN_PREFIX,
            self.tr('Output column prefix'), 'rvalue'
        )
        columnPrefix.setFlags(columnPrefix.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(columnPrefix)

        self.addParameter(
            QgsProcessingParameterFeatureSink(
                self.OUTPUT,
                self.tr('Sampled Points')
            )
        )
Example #3
0
File: Buffer.py Project: aaime/QGIS
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterString(self.GEOMETRY,
                                                       self.tr('Geometry column name'),
                                                       defaultValue='geometry'))
        self.addParameter(QgsProcessingParameterDistance(self.DISTANCE,
                                                         self.tr('Buffer distance'),
                                                         parentParameterName=self.INPUT,
                                                         minValue=0.0,
                                                         defaultValue=10.0))
        self.addParameter(QgsProcessingParameterField(self.FIELD,
                                                      self.tr('Dissolve by attribute'),
                                                      None,
                                                      self.INPUT,
                                                      QgsProcessingParameterField.Any,
                                                      optional=True))
        self.addParameter(QgsProcessingParameterBoolean(self.DISSOLVE,
                                                        self.tr('Dissolve all results'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.EXPLODE_COLLECTIONS,
                                                        self.tr('Produce one feature for each geometry in any kind of geometry collection in the source file'),
                                                        defaultValue=False))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterVectorDestination(self.OUTPUT,
                                                                  self.tr('Buffer'),
                                                                  QgsProcessing.TypeVectorPolygon))
Example #4
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterNumber(self.OUTSIZE,
                                                       self.tr('Set the size of the output file (In pixels or %)'),
                                                       minValue=1, defaultValue=100))
        self.addParameter(QgsProcessingParameterBoolean(self.OUTSIZE_PERC,
                                                        self.tr('Output size is a percentage of input size'), defaultValue=True))
        self.addParameter(QgsProcessingParameterString(self.NO_DATA,
                                                       self.tr("Nodata value, leave blank to take the nodata value from input"),
                                                       defaultValue='', optional=True))
        self.addParameter(QgsProcessingParameterEnum(self.EXPAND,
                                                     self.tr('Expand'), options=['none', 'gray', 'rgb', 'rgba'], defaultValue=0))
        self.addParameter(QgsProcessingParameterCrs(self.SRS,
                                                    self.tr('Output projection for output file [leave blank to use input projection]'), defaultValue=None, optional=True))
        self.addParameter(QgsProcessingParameterExtent(self.PROJWIN,
                                                       self.tr('Subset based on georeferenced coordinates'), optional=True))
        self.addParameter(QgsProcessingParameterBoolean(self.SDS,
                                                        self.tr('Copy all subdatasets of this file to individual output files'),
                                                        defaultValue=False))

        create_options_param = QgsProcessingParameterString(self.OPTIONS,
                                                            self.tr('Additional creation options'),
                                                            optional=True)
        create_options_param.setMetadata({'widget_wrapper': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'})
        self.addParameter(create_options_param)
        self.addParameter(QgsProcessingParameterEnum(self.RTYPE,
                                                     self.tr('Output raster type'),
                                                     options=self.TYPE, defaultValue=5))

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Converted')))
Example #5
0
    def initAlgorithm(self, config=None):
        self.dialects = ((self.tr('None'), ''),
                         (self.tr('OGR SQL'), 'ogrsql'),
                         (self.tr('SQLite'), 'sqlite'))

        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterString(self.SQL,
                                                       self.tr('SQL expression'),
                                                       defaultValue=''))
        self.addParameter(QgsProcessingParameterEnum(self.DIALECT,
                                                     self.tr('SQL dialect'),
                                                     options=[i[0] for i in self.dialects],
                                                     allowMultiple=False,
                                                     defaultValue=0))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterVectorDestination(self.OUTPUT,
                                                                  self.tr('SQL result')))
Example #6
0
    def initAlgorithm(self, config=None):

        class ParameterVrtDestination(QgsProcessingParameterRasterDestination):

            def __init__(self, name, description):
                super().__init__(name, description)

            def clone(self):
                copy = ParameterVrtDestination(self.name(), self.description())
                return copy

            def type(self):
                return 'vrt_destination'

            def defaultFileExtension(self):
                return 'vrt'

        self.addParameter(QgsProcessingParameterMultipleLayers(self.INPUT,
                                                               self.tr('Input layers'),
                                                               QgsProcessing.TypeRaster))
        self.addParameter(QgsProcessingParameterEnum(self.RESOLUTION,
                                                     self.tr('Resolution'),
                                                     options=self.RESOLUTION_OPTIONS,
                                                     defaultValue=0))
        self.addParameter(QgsProcessingParameterBoolean(self.SEPARATE,
                                                        self.tr('Place each input file into a separate band'),
                                                        defaultValue=True))
        self.addParameter(QgsProcessingParameterBoolean(self.PROJ_DIFFERENCE,
                                                        self.tr('Allow projection difference'),
                                                        defaultValue=False))

        add_alpha_param = QgsProcessingParameterBoolean(self.ADD_ALPHA,
                                                        self.tr('Add alpha mask band to VRT when source raster has none'),
                                                        defaultValue=False)
        add_alpha_param.setFlags(add_alpha_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(add_alpha_param)

        assign_crs = QgsProcessingParameterCrs(self.ASSIGN_CRS,
                                               self.tr('Override projection for the output file'),
                                               defaultValue=None, optional=True)
        assign_crs.setFlags(assign_crs.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(assign_crs)

        resampling = QgsProcessingParameterEnum(self.RESAMPLING,
                                                self.tr('Resampling algorithm'),
                                                options=self.RESAMPLING_OPTIONS,
                                                defaultValue=0)
        resampling.setFlags(resampling.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(resampling)

        src_nodata_param = QgsProcessingParameterString(self.SRC_NODATA,
                                                        self.tr('Nodata value(s) for input bands (space separated)'),
                                                        defaultValue=None,
                                                        optional=True)
        src_nodata_param.setFlags(src_nodata_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(src_nodata_param)

        self.addParameter(ParameterVrtDestination(self.OUTPUT, QCoreApplication.translate("ParameterVrtDestination", 'Virtual')))
Example #7
0
 def initAlgorithm(self, config=None):
     db_param = QgsProcessingParameterString(
         self.DATABASE,
         self.tr('Database (connection name)'))
     db_param.setMetadata({
         'widget_wrapper': {
             'class': 'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'}})
     self.addParameter(db_param)
     self.addParameter(QgsProcessingParameterString(self.SQL, self.tr('SQL query'), multiLine=True))
Example #8
0
    def initAlgorithm(self, config=None):
        """Here we define the inputs and output of the algorithm, along
        with some other properties.
        """
        # The parameters
        self.addParameter(
            QgsProcessingParameterExtent(self.EXTENT, description=self.tr(
                'Minimum extent to render')))

        self.addParameter(
            QgsProcessingParameterNumber(
                self.TILE_SIZE,
                self.tr('Tile size'),
                defaultValue=1024, minValue=64))

        self.addParameter(QgsProcessingParameterNumber(
            self.MAP_UNITS_PER_PIXEL,
            self.tr(
                'Map units per '
                'pixel'),
            defaultValue=100,
            minValue=0,
            type=QgsProcessingParameterNumber.Double
        ))

        self.addParameter(
            QgsProcessingParameterBoolean(
                self.MAKE_BACKGROUND_TRANSPARENT,
                self.tr('Make background transparent'),
                defaultValue=False))

        map_theme_param = QgsProcessingParameterString(
            self.MAP_THEME,
            description=self.tr(
                'Map theme to render'),
            defaultValue=None, optional=True)

        map_theme_param.setMetadata(
            {'widget_wrapper': {
                'class':
                    'processing.gui.wrappers_map_theme.MapThemeWrapper'}})
        self.addParameter(map_theme_param)

        self.addParameter(
            QgsProcessingParameterMapLayer(
                self.LAYER,
                description=self.tr(
                    'Single layer to render'),
                optional=True))

        # We add a raster layer as output
        self.addParameter(QgsProcessingParameterRasterDestination(
            self.OUTPUT,
            self.tr(
                'Output layer')))
Example #9
0
    def __init__(self):
        super().__init__()

        db_param = QgsProcessingParameterString(
            self.DATABASE,
            self.tr('Database (connection name)'))
        db_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'}})
        self.addParameter(db_param)
        self.addParameter(QgsProcessingParameterString(self.SQL, self.tr('SQL query')))
Example #10
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
                                                            self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterBand(self.BAND,
                                                     self.tr('Band number'),
                                                     1,
                                                     parentLayerParameterName=self.INPUT))
        self.addParameter(QgsProcessingParameterNumber(self.INTERVAL,
                                                       self.tr('Interval between contour lines'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=10.0))
        self.addParameter(QgsProcessingParameterString(self.FIELD_NAME,
                                                       self.tr('Attribute name (if not set, no elevation attribute is attached)'),
                                                       defaultValue='ELEV',
                                                       optional=True))

        create_3d_param = QgsProcessingParameterBoolean(self.CREATE_3D,
                                                        self.tr('Produce 3D vector'),
                                                        defaultValue=False)
        create_3d_param.setFlags(create_3d_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(create_3d_param)

        ignore_nodata_param = QgsProcessingParameterBoolean(self.IGNORE_NODATA,
                                                            self.tr('Treat all raster values as valid'),
                                                            defaultValue=False)
        ignore_nodata_param.setFlags(ignore_nodata_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(ignore_nodata_param)

        nodata_param = QgsProcessingParameterNumber(self.NODATA,
                                                    self.tr('Input pixel value to treat as "nodata"'),
                                                    type=QgsProcessingParameterNumber.Double,
                                                    defaultValue=None,
                                                    optional=True)
        nodata_param.setFlags(nodata_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(nodata_param)

        offset_param = QgsProcessingParameterNumber(self.OFFSET,
                                                    self.tr('Offset from zero relative to which to interpret intervals'),
                                                    type=QgsProcessingParameterNumber.Double,
                                                    defaultValue=0.0,
                                                    optional=True)
        nodata_param.setFlags(offset_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(offset_param)

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterVectorDestination(
            self.OUTPUT, self.tr('Contours'), QgsProcessing.TypeVectorLine))
Example #11
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Input layer')))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterVectorDestination(self.OUTPUT,
                                                                  self.tr('Converted')))
Example #12
0
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterString(
                self.QUERY, tr('Query'), optional=False, multiLine=True))

        self.addParameter(
            QgsProcessingParameterExtent(
                self.EXTENT, tr('Extent, if "{{bbox}}" in the query'), optional=True))

        server = get_setting('defaultOAPI', OVERPASS_SERVERS[0]) + 'interpreter'
        parameter = QgsProcessingParameterString(
            self.SERVER, tr('Overpass server'), optional=False, defaultValue=server)
        parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(parameter)

        parameter = QgsProcessingParameterString(
            self.AREA,
            tr('Area (if you want to override {{geocodeArea}} in the query'),
            optional=True)
        parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(parameter)

        self.addOutput(
            QgsProcessingOutputString(
                self.OUTPUT_URL, tr('Query as encoded URL')))

        self.addOutput(
            QgsProcessingOutputString(
                self.OUTPUT_OQL_QUERY, tr('Raw query as OQL')))
Example #13
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Layer to import'),
                                                              types=[QgsProcessing.TypeVector]))

        db_param = QgsProcessingParameterString(
            self.DATABASE,
            self.tr('Database (connection name)'))
        db_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'}})
        self.addParameter(db_param)

        schema_param = QgsProcessingParameterString(
            self.SCHEMA,
            self.tr('Schema (schema name)'), 'public', False, True)
        schema_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
                'connection_param': self.DATABASE}})
        self.addParameter(schema_param)

        table_param = QgsProcessingParameterString(
            self.TABLENAME,
            self.tr('Table to import to (leave blank to use layer name)'), '', False, True)
        table_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.gui.wrappers_postgis.TableWidgetWrapper',
                'schema_param': self.SCHEMA}})
        self.addParameter(table_param)

        self.addParameter(QgsProcessingParameterField(self.PRIMARY_KEY,
                                                      self.tr('Primary key field'), None, self.INPUT,
                                                      QgsProcessingParameterField.Any, False, True))
        self.addParameter(QgsProcessingParameterString(self.GEOMETRY_COLUMN,
                                                       self.tr('Geometry column'), 'geom'))
        self.addParameter(QgsProcessingParameterString(self.ENCODING,
                                                       self.tr('Encoding'), 'UTF-8',
                                                       False, True))
        self.addParameter(QgsProcessingParameterBoolean(self.OVERWRITE,
                                                        self.tr('Overwrite'), True))
        self.addParameter(QgsProcessingParameterBoolean(self.CREATEINDEX,
                                                        self.tr('Create spatial index'), True))
        self.addParameter(QgsProcessingParameterBoolean(self.LOWERCASE_NAMES,
                                                        self.tr('Convert field names to lowercase'), True))
        self.addParameter(QgsProcessingParameterBoolean(self.DROP_STRING_LENGTH,
                                                        self.tr('Drop length constraints on character fields'), False))
        self.addParameter(QgsProcessingParameterBoolean(self.FORCE_SINGLEPART,
                                                        self.tr('Create single-part geometries instead of multi-part'),
                                                        False))
Example #14
0
    def initAlgorithm(self, config=None):
        self.formats = ((self.tr('Auto'), 'AUTO'),
                        (self.tr('Well-known text (WKT)'), 'WKT'),
                        (self.tr('EPSG'), 'EPSG'),
                        (self.tr('Proj.4'), 'PROJ'))

        self.addParameter(QgsProcessingParameterMultipleLayers(self.LAYERS,
                                                               self.tr('Input files'),
                                                               QgsProcessing.TypeRaster))
        self.addParameter(QgsProcessingParameterString(self.PATH_FIELD_NAME,
                                                       self.tr('Field name to hold the file path to the indexed rasters'),
                                                       defaultValue='location'))
        self.addParameter(QgsProcessingParameterBoolean(self.ABSOLUTE_PATH,
                                                        self.tr('Store absolute path to the indexed rasters'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.PROJ_DIFFERENCE,
                                                        self.tr('Skip files with different projection reference'),
                                                        defaultValue=False))

        target_crs_param = QgsProcessingParameterCrs(self.TARGET_CRS,
                                                     self.tr('Transform geometries to the given CRS'),
                                                     optional=True)
        target_crs_param.setFlags(target_crs_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(target_crs_param)

        crs_field_param = QgsProcessingParameterString(self.CRS_FIELD_NAME,
                                                       self.tr('The name of the field to store the SRS of each tile'),
                                                       optional=True)
        crs_field_param.setFlags(crs_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(crs_field_param)

        crs_format_param = QgsProcessingParameterEnum(self.CRS_FORMAT,
                                                      self.tr('The format in which the CRS of each tile must be written'),
                                                      options=[i[0] for i in self.formats],
                                                      allowMultiple=False,
                                                      defaultValue=0)
        crs_format_param.setFlags(crs_format_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(crs_format_param)

        self.addParameter(QgsProcessingParameterVectorDestination(self.OUTPUT,
                                                                  self.tr('Tile index'),
                                                                  QgsProcessing.TypeVectorPolygon))
Example #15
0
    def initAlgorithm(self, config=None):
        self.bufferSides = [self.tr('Right'), self.tr('Left')]

        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Input layer'),
                                                              [QgsProcessing.TypeVectorLine]))
        self.addParameter(QgsProcessingParameterString(self.GEOMETRY,
                                                       self.tr('Geometry column name'),
                                                       defaultValue='geometry'))
        self.addParameter(QgsProcessingParameterNumber(self.DISTANCE,
                                                       self.tr('Buffer distance'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       defaultValue=10))
        self.addParameter(QgsProcessingParameterEnum(self.BUFFER_SIDE,
                                                     self.tr('Buffer side'),
                                                     options=self.bufferSides,
                                                     allowMultiple=False,
                                                     defaultValue=0))
        self.addParameter(QgsProcessingParameterField(self.FIELD,
                                                      self.tr('Dissolve by attribute'),
                                                      None,
                                                      self.INPUT,
                                                      QgsProcessingParameterField.Any,
                                                      optional=True))
        self.addParameter(QgsProcessingParameterBoolean(self.DISSOLVE,
                                                        self.tr('Dissolve all results'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.EXPLODE_COLLECTIONS,
                                                        self.tr('Produce one feature for each geometry in any kind of geometry collection in the source file'),
                                                        defaultValue=False))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterVectorDestination(self.OUTPUT,
                                                                  self.tr('One-sided buffer'),
                                                                  QgsProcessing.TypeVectorPolygon))
Example #16
0
    def initAlgorithm(self, config=None):
        self.methods = ((self.tr('Nearest Neighbour'), 'nearest'),
                        (self.tr('Bilinear'), 'bilinear'),
                        (self.tr('Cubic'), 'cubic'),
                        (self.tr('Cubic Spline'), 'cubicspline'),
                        (self.tr('Lanczos Windowed Sinc'), 'lanczos'),
                        (self.tr('Average'), 'average'))

        self.addParameter(QgsProcessingParameterRasterLayer(self.SPECTRAL,
                                                            self.tr('Spectral dataset')))
        self.addParameter(QgsProcessingParameterRasterLayer(self.PANCHROMATIC,
                                                            self.tr('Panchromatic dataset')))

        resampling_param = QgsProcessingParameterEnum(self.RESAMPLING,
                                                      self.tr('Resampling algorithm'),
                                                      options=[i[0] for i in self.methods],
                                                      defaultValue=2)
        resampling_param.setFlags(resampling_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(resampling_param)

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Output')))
Example #17
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterBand(self.BAND,
                                                     self.tr('Band number'),
                                                     1,
                                                     parentLayerParameterName=self.INPUT))
        self.addParameter(QgsProcessingParameterBoolean(self.TRIG_ANGLE,
                                                        self.tr('Return trigonometric angle instead of azimuth'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.ZERO_FLAT,
                                                        self.tr('Return 0 for flat instead of -9999'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.COMPUTE_EDGES,
                                                        self.tr('Compute edges'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.ZEVENBERGEN,
                                                        self.tr("Use Zevenbergen&Thorne formula instead of the Horn's one"),
                                                        defaultValue=False))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Aspect')))
Example #18
0
File: warp.py Project: GeoCat/QGIS
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer'), optional=False))
        self.addParameter(QgsProcessingParameterCrs(self.SOURCE_SRS,
                                                    self.tr('Source SRS'),
                                                    optional=True))
        self.addParameter(QgsProcessingParameterCrs(self.DEST_SRS,
                                                    self.tr('Destination SRS'),
                                                    'EPSG:4326'))
        self.addParameter(QgsProcessingParameterString(self.NO_DATA,
                                                       self.tr("Nodata value, leave blank to take the nodata value from input"), optional=True))
        self.addParameter(QgsProcessingParameterNumber(self.TR,
                                                       self.tr('Output file resolution in target georeferenced units (leave 0 for no change)'),
                                                       minValue=0.0, defaultValue=0.0))
        self.addParameter(QgsProcessingParameterEnum(self.METHOD,
                                                     self.tr('Resampling method'),
                                                     self.METHOD_OPTIONS))
        self.addParameter(QgsProcessingParameterBoolean(self.USE_RASTER_EXTENT,
                                                        self.tr('Set georeferenced extents of output file'),
                                                        False
                                                        ))
        self.addParameter(QgsProcessingParameterExtent(self.RASTER_EXTENT,
                                                       self.tr('Raster extent'),
                                                       optional=True))
        self.addParameter(QgsProcessingParameterCrs(self.EXTENT_CRS,
                                                    self.tr('CRS of the raster extent, leave blank for using Destination SRS'),
                                                    optional=True))
        co = QgsProcessingParameterString(self.OPTIONS,
                                          self.tr('Additional creation options'),
                                          optional=True)
        co.setMetadata({'widget_wrapper': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'})
        self.addParameter(co)
        self.addParameter(QgsProcessingParameterBoolean(self.MULTITHREADING,
                                                        self.tr('Use multithreaded warping implementation'),
                                                        False
                                                        ))
        self.addParameter(QgsProcessingParameterEnum(self.RTYPE,
                                                     self.tr('Output raster type'),
                                                     self.TYPE, defaultValue=5))

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Reprojected')))
Example #19
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterCrs(self.TARGET_CRS,
                                                    self.tr('Override the projection for the output file'),
                                                    defaultValue=None,
                                                    optional=True))
        self.addParameter(QgsProcessingParameterNumber(self.NODATA,
                                                       self.tr('Assign a specified nodata value to output bands'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       defaultValue=None,
                                                       optional=True))
        self.addParameter(QgsProcessingParameterBoolean(self.COPY_SUBDATASETS,
                                                        self.tr('Copy all subdatasets of this file to individual output files'),
                                                        defaultValue=False))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
                                                    self.tr('Output data type'),
                                                    self.TYPES,
                                                    allowMultiple=False,
                                                    defaultValue=0)
        dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Converted')))
Example #20
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterMultipleLayers(self.INPUT,
                                                               self.tr('Input layers'),
                                                               QgsProcessing.TypeRaster))
        self.addParameter(QgsProcessingParameterBoolean(self.PCT,
                                                        self.tr('Grab pseudocolor table from first layer'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.SEPARATE,
                                                        self.tr('Place each input file into a separate band'),
                                                        defaultValue=False))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation parameters'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterEnum(self.DATA_TYPE,
                                                     self.tr('Output data type'),
                                                     self.TYPES,
                                                     allowMultiple=False,
                                                     defaultValue=5))

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Merged')))
Example #21
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterBand(self.BANDS,
                                                     self.tr('Selected band(s)'),
                                                     None,
                                                     self.INPUT,
                                                     allowMultiple=True))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
                                                    self.tr('Output data type'),
                                                    self.TYPES,
                                                    allowMultiple=False,
                                                    defaultValue=0)
        dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Converted')))
Example #22
0
    def initAlgorithm(self, config=None):
        self.modes = ((self.tr('Use strict color matching'), '-exact_color_entry'),
                      (self.tr('Use closest RGBA quadruplet'), '-nearest_color_entry'),
                      (self.tr('Use smoothly blended colors'), ''))

        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
                                                            self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterBand(self.BAND,
                                                     self.tr('Band number'),
                                                     1,
                                                     parentLayerParameterName=self.INPUT))
        self.addParameter(QgsProcessingParameterBoolean(self.COMPUTE_EDGES,
                                                        self.tr('Compute edges'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterFile(self.COLOR_TABLE,
                                                     self.tr('Color configuration file')))
        self.addParameter(QgsProcessingParameterEnum(self.MATCH_MODE,
                                                     self.tr('Matching mode'),
                                                     options=[i[0] for i in self.modes],
                                                     defaultValue=2))
        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)

        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Color relief')))
Example #23
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Point layer'),
                                                              [QgsProcessing.TypeVectorPoint]))

        z_field_param = QgsProcessingParameterField(self.Z_FIELD,
                                                    self.tr('Z value from field'),
                                                    None,
                                                    self.INPUT,
                                                    QgsProcessingParameterField.Numeric,
                                                    optional=True)
        z_field_param.setFlags(z_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(z_field_param)

        self.addParameter(QgsProcessingParameterNumber(self.RADIUS_1,
                                                       self.tr('The first radius of search ellipse'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=0.0))
        self.addParameter(QgsProcessingParameterNumber(self.RADIUS_2,
                                                       self.tr('The second radius of search ellipse'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=0.0))
        self.addParameter(QgsProcessingParameterNumber(self.ANGLE,
                                                       self.tr('Angle of search ellipse rotation in degrees (counter clockwise)'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       maxValue=360.0,
                                                       defaultValue=0.0))
        self.addParameter(QgsProcessingParameterNumber(self.MIN_POINTS,
                                                       self.tr('Minimum number of data points to use'),
                                                       type=QgsProcessingParameterNumber.Integer,
                                                       minValue=0,
                                                       defaultValue=0))
        self.addParameter(QgsProcessingParameterNumber(self.NODATA,
                                                       self.tr('NODATA marker to fill empty points'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       defaultValue=0.0))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation parameters'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
                                                    self.tr('Output data type'),
                                                    self.TYPES,
                                                    allowMultiple=False,
                                                    defaultValue=5)
        dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Interpolated (moving average)')))
Example #24
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
                                                            self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterExtent(self.EXTENT,
                                                       self.tr('Clipping extent')))
        self.addParameter(QgsProcessingParameterNumber(self.NODATA,
                                                       self.tr('Assign a specified nodata value to output bands'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       defaultValue=None,
                                                       optional=True))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
                                                    self.tr('Output data type'),
                                                    self.TYPES,
                                                    allowMultiple=False,
                                                    defaultValue=0)
        dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Clipped (extent)')))
Example #25
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterBand(self.BAND,
                                                     self.tr('Band number'),
                                                     parentLayerParameterName=self.INPUT))
        self.addParameter(QgsProcessingParameterNumber(self.SCALE,
                                                       self.tr('Ratio of vertical units to horizontal'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=1.0))
        self.addParameter(QgsProcessingParameterBoolean(self.AS_PERCENT,
                                                        self.tr('Slope expressed as percent instead of degrees'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.COMPUTE_EDGES,
                                                        self.tr('Compute edges'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.ZEVENBERGEN,
                                                        self.tr("Use Zevenbergen&Thorne formula instead of the Horn's one"),
                                                        defaultValue=False))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation parameters'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Slope')))
Example #26
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Input layer'),
                                                              [QgsProcessing.TypeVectorLine]))
        self.addParameter(QgsProcessingParameterString(self.GEOMETRY,
                                                       self.tr('Geometry column name'),
                                                       defaultValue='geometry'))
        self.addParameter(QgsProcessingParameterDistance(self.DISTANCE,
                                                         self.tr('Offset distance (left-sided: positive, right-sided: negative)'),
                                                         parentParameterName=self.INPUT,
                                                         defaultValue=10))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterVectorDestination(self.OUTPUT,
                                                                  self.tr('Offset curve'),
                                                                  QgsProcessing.TypeVectorLine))
Example #27
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
                                                            self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterFeatureSource(self.MASK,
                                                              self.tr('Mask layer'),
                                                              [QgsProcessing.TypeVectorPolygon]))
        self.addParameter(QgsProcessingParameterNumber(self.NODATA,
                                                       self.tr('Assign a specified nodata value to output bands'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       defaultValue=None,
                                                       optional=True))
        self.addParameter(QgsProcessingParameterBoolean(self.ALPHA_BAND,
                                                        self.tr('Create an output alpha band'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.CROP_TO_CUTLINE,
                                                        self.tr('Match the extent of the clipped raster to the extent of the mask layer'),
                                                        defaultValue=True))
        self.addParameter(QgsProcessingParameterBoolean(self.KEEP_RESOLUTION,
                                                        self.tr('Keep resolution of output raster'),
                                                        defaultValue=False))

        target_extent_param = QgsProcessingParameterExtent(self.TARGET_EXTENT,
                                                           self.tr('Georeferenced extents of output file to be created'),
                                                           optional=True)
        target_extent_param.setFlags(target_extent_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(target_extent_param)

        target_extent_crs_param = QgsProcessingParameterCrs(self.TARGET_EXTENT_CRS,
                                                            self.tr('CRS of the target raster extent'),
                                                            optional=True)
        target_extent_crs_param.setFlags(target_extent_crs_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(target_extent_crs_param)

        multithreading_param = QgsProcessingParameterBoolean(self.MULTITHREADING,
                                                             self.tr('Use multithreaded warping implementation'),
                                                             defaultValue=False)
        multithreading_param.setFlags(multithreading_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(multithreading_param)

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
                                                    self.tr('Output data type'),
                                                    self.TYPES,
                                                    allowMultiple=False,
                                                    defaultValue=0)
        dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Clipped (mask)')))
Example #28
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Input layer'),
                                                              [QgsProcessing.TypeVectorLine]))
        self.addParameter(QgsProcessingParameterString(self.GEOMETRY,
                                                       self.tr('Geometry column name'),
                                                       defaultValue='geometry'))
        self.addParameter(QgsProcessingParameterNumber(self.DISTANCE,
                                                       self.tr('Distance from line start represented as fraction of line length'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0,
                                                       maxValue=1,
                                                       defaultValue=0.5))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterVectorDestination(self.OUTPUT,
                                                                  self.tr('Points along lines'),
                                                                  QgsProcessing.TypeVectorPoint))
Example #29
0
    def initAlgorithm(self, config=None):
        self.distanceUnits = ((self.tr('Georeferenced coordinates'), 'GEO'),
                              (self.tr('Pixel coordinates'), 'PIXEL'))

        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
                                                            self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterBand(self.BAND,
                                                     self.tr('Band number'),
                                                     1,
                                                     parentLayerParameterName=self.INPUT))
        self.addParameter(QgsProcessingParameterString(self.VALUES,
                                                       self.tr('A list of pixel values in the source image to be considered target pixels'),
                                                       optional=True))
        self.addParameter(QgsProcessingParameterEnum(self.UNITS,
                                                     self.tr('Distance units'),
                                                     options=[i[0] for i in self.distanceUnits],
                                                     allowMultiple=False,
                                                     defaultValue=1))
        self.addParameter(QgsProcessingParameterNumber(self.MAX_DISTANCE,
                                                       self.tr('The maximum distance to be generated'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=0.0,
                                                       optional=True))
        self.addParameter(QgsProcessingParameterNumber(self.REPLACE,
                                                       self.tr('Value to be applied to all pixels that are within the -maxdist of target pixels'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       defaultValue=0.0,
                                                       optional=True))
        self.addParameter(QgsProcessingParameterNumber(self.NODATA,
                                                       self.tr('Nodata value to use for the destination proximity raster'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       defaultValue=0.0,
                                                       optional=True))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterEnum(self.DATA_TYPE,
                                                     self.tr('Output data type'),
                                                     self.TYPES,
                                                     allowMultiple=False,
                                                     defaultValue=5))

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Proximity map')))
Example #30
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterBand(self.BAND,
                                                     self.tr('Band number'),
                                                     1,
                                                     parentLayerParameterName=self.INPUT))
        self.addParameter(QgsProcessingParameterNumber(self.Z_FACTOR,
                                                       self.tr('Z factor (vertical exaggeration)'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=1.0))
        self.addParameter(QgsProcessingParameterNumber(self.SCALE,
                                                       self.tr('Scale (ratio of vertical units to horizontal)'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=1.0))
        self.addParameter(QgsProcessingParameterNumber(self.AZIMUTH,
                                                       self.tr('Azimuth of the light'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       maxValue=360,
                                                       defaultValue=315.0))
        self.addParameter(QgsProcessingParameterNumber(self.ALTITUDE,
                                                       self.tr('Altitude of the light'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=45.0))
        self.addParameter(QgsProcessingParameterBoolean(self.COMPUTE_EDGES,
                                                        self.tr('Compute edges'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.ZEVENBERGEN,
                                                        self.tr("Use Zevenbergen&Thorne formula instead of the Horn's one"),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.COMBINED,
                                                        self.tr("Combined shading"),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.MULTIDIRECTIONAL,
                                                        self.tr("Multidirectional shading"),
                                                        defaultValue=False))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Hillshade')))
Example #31
0
    def initAlgorithm(self, config=None):
        self.methods = ((self.tr('Nearest neighbour'), 'near'),
                        (self.tr('Bilinear'), 'bilinear'),
                        (self.tr('Cubic'), 'cubic'),
                        (self.tr('Cubic spline'), 'cubicspline'),
                        (self.tr('Lanczos windowed sinc'), 'lanczos'),)

        self.addParameter(QgsProcessingParameterMultipleLayers(self.INPUT,
                                                               self.tr('Input files'),
                                                               QgsProcessing.TypeRaster))
        self.addParameter(QgsProcessingParameterNumber(self.TILE_SIZE_X,
                                                       self.tr('Tile width'),
                                                       type=QgsProcessingParameterNumber.Integer,
                                                       minValue=0,
                                                       defaultValue=256))
        self.addParameter(QgsProcessingParameterNumber(self.TILE_SIZE_Y,
                                                       self.tr('Tile height'),
                                                       type=QgsProcessingParameterNumber.Integer,
                                                       minValue=0,
                                                       defaultValue=256))
        self.addParameter(QgsProcessingParameterNumber(self.OVERLAP,
                                                       self.tr('Overlap in pixels between consecutive tiles'),
                                                       type=QgsProcessingParameterNumber.Integer,
                                                       minValue=0,
                                                       defaultValue=0))
        self.addParameter(QgsProcessingParameterNumber(self.LEVELS,
                                                       self.tr('Number of pyramids levels to build'),
                                                       type=QgsProcessingParameterNumber.Integer,
                                                       minValue=0,
                                                       defaultValue=1))

        params = []
        params.append(QgsProcessingParameterCrs(self.SOURCE_CRS,
                                                self.tr('Source coordinate reference system'),
                                                optional=True))
        params.append(QgsProcessingParameterEnum(self.RESAMPLING,
                                                 self.tr('Resampling method'),
                                                 options=[i[0] for i in self.methods],
                                                 allowMultiple=False,
                                                 defaultValue=0))
        params.append(QgsProcessingParameterString(self.DELIMITER,
                                                   self.tr('Column delimiter used in the CSV file'),
                                                   defaultValue=';',
                                                   optional=True))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        params.append(options_param)

        params.append(QgsProcessingParameterEnum(self.DATA_TYPE,
                                                 self.tr('Output data type'),
                                                 self.TYPES,
                                                 allowMultiple=False,
                                                 defaultValue=5))

        params.append(QgsProcessingParameterBoolean(self.ONLY_PYRAMIDS,
                                                    self.tr('Build only the pyramids'),
                                                    defaultValue=False))
        params.append(QgsProcessingParameterBoolean(self.DIR_FOR_ROW,
                                                    self.tr('Use separate directory for each tiles row'),
                                                    defaultValue=False))

        for param in params:
            param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
            self.addParameter(param)

        self.addParameter(QgsProcessingParameterFolderDestination(self.OUTPUT,
                                                                  self.tr('Output directory')))

        output_csv_param = QgsProcessingParameterFileDestination(self.OUTPUT_CSV,
                                                                 self.tr('CSV file containing the tile(s) georeferencing information'),
                                                                 'CSV files (*.csv)',
                                                                 optional=True)
        output_csv_param.setCreateByDefault(False)
        self.addParameter(output_csv_param)
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT,
                self.tr('Layer to import'),
                types=[QgsProcessing.TypeVector]))

        db_param = QgsProcessingParameterProviderConnection(
            self.DATABASE, self.tr('Database (connection name)'), 'postgres')
        self.addParameter(db_param)

        schema_param = QgsProcessingParameterDatabaseSchema(
            self.SCHEMA,
            self.tr('Schema (schema name)'),
            connectionParameterName=self.DATABASE,
            defaultValue='public',
            optional=True)
        self.addParameter(schema_param)

        table_param = QgsProcessingParameterDatabaseTable(
            self.TABLENAME,
            self.tr('Table to import to (leave blank to use layer name)'),
            defaultValue=None,
            connectionParameterName=self.DATABASE,
            schemaParameterName=self.SCHEMA,
            optional=True,
            allowNewTableNames=True)
        self.addParameter(table_param)

        self.addParameter(
            QgsProcessingParameterField(self.PRIMARY_KEY,
                                        self.tr('Primary key field'), None,
                                        self.INPUT,
                                        QgsProcessingParameterField.Any, False,
                                        True))
        self.addParameter(
            QgsProcessingParameterString(self.GEOMETRY_COLUMN,
                                         self.tr('Geometry column'), 'geom'))
        self.addParameter(
            QgsProcessingParameterString(self.ENCODING, self.tr('Encoding'),
                                         'UTF-8', False, True))
        self.addParameter(
            QgsProcessingParameterBoolean(self.OVERWRITE, self.tr('Overwrite'),
                                          True))
        self.addParameter(
            QgsProcessingParameterBoolean(self.CREATEINDEX,
                                          self.tr('Create spatial index'),
                                          True))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.LOWERCASE_NAMES,
                self.tr('Convert field names to lowercase'), True))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.DROP_STRING_LENGTH,
                self.tr('Drop length constraints on character fields'), False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.FORCE_SINGLEPART,
                self.tr('Create single-part geometries instead of multi-part'),
                False))
Example #33
0
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT,
                                              self.tr('Input layer')))
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.MASK, self.tr('Mask layer'),
                [QgsProcessing.TypeVectorPolygon]))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.NODATA,
                self.tr('Assign a specified nodata value to output bands'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=0.0,
                optional=True))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.ALPHA_BAND,
                self.tr('Create and output alpha band'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.CROP_TO_CUTLINE,
                self.
                tr('Crop the extent of the target dataset to the extent of the cutline'
                   ),
                defaultValue=True))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.KEEP_RESOLUTION,
                self.tr('Keep resolution of output raster'),
                defaultValue=False))

        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation parameters'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(
            self.DATA_TYPE,
            self.tr('Output data type'),
            self.TYPES,
            allowMultiple=False,
            defaultValue=5)
        dataType_param.setFlags(
            dataType_param.flags()
            | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Clipped (mask)')))
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT,
                                              self.tr('Input layer')))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND,
                                       self.tr('Band number'),
                                       1,
                                       parentLayerParameterName=self.INPUT))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.DISTANCE,
                self.
                tr('Maximum distance (in pixels) to search out for values to interpolate'
                   ),
                type=QgsProcessingParameterNumber.Integer,
                minValue=0,
                defaultValue=10))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.ITERATIONS,
                self.
                tr('Number of smoothing iterations to run after the interpolation'
                   ),
                type=QgsProcessingParameterNumber.Integer,
                minValue=0,
                defaultValue=0))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.NO_MASK,
                self.tr(
                    'Do not use the default validity mask for the input band'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.MASK_LAYER,
                                              self.tr('Validity mask'),
                                              optional=True))

        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation options'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        extra_param = QgsProcessingParameterString(
            self.EXTRA,
            self.tr('Additional command-line parameters'),
            defaultValue=None,
            optional=True)
        extra_param.setFlags(extra_param.flags()
                             | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(extra_param)

        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Filled')))
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT,
                                              self.tr('Input layer')))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.NEAR,
                self.tr('How far from black (white)'),
                type=QgsProcessingParameterNumber.Integer,
                minValue=0,
                defaultValue=15))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.WHITE,
                self.tr(
                    'Search for nearly white pixels instead of nearly black'),
                defaultValue=False))

        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation options'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        extra_param = QgsProcessingParameterString(
            self.EXTRA,
            self.tr('Additional command-line parameters'),
            defaultValue=None,
            optional=True)
        extra_param.setFlags(extra_param.flags()
                             | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(extra_param)

        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Nearblack')))
Example #36
0
    def initAlgorithm(self, config=None):
        self.predicates = (('intersects', self.tr('intersects')),
                           ('contains', self.tr('contains')),
                           ('isEqual', self.tr('equals')),
                           ('touches',
                            self.tr('touches')), ('overlaps',
                                                  self.tr('overlaps')),
                           ('within', self.tr('within')), ('crosses',
                                                           self.tr('crosses')))

        self.reversed_predicates = {
            'intersects': 'intersects',
            'contains': 'within',
            'isEqual': 'isEqual',
            'touches': 'touches',
            'overlaps': 'overlaps',
            'within': 'contains',
            'crosses': 'crosses'
        }

        self.methods = [
            self.
            tr('Create separate feature for each located feature (one-to-many)'
               ),
            self.
            tr('Take attributes of the first located feature only (one-to-one)'
               )
        ]

        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT, self.tr('Input layer'),
                [QgsProcessing.TypeVectorAnyGeometry]))
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.JOIN, self.tr('Join layer'),
                [QgsProcessing.TypeVectorAnyGeometry]))

        predicate = QgsProcessingParameterEnum(
            self.PREDICATE,
            self.tr('Geometric predicate'),
            options=[p[1] for p in self.predicates],
            allowMultiple=True,
            defaultValue=[0])
        predicate.setMetadata(
            {'widget_wrapper': {
                'useCheckBoxes': True,
                'columns': 2
            }})
        self.addParameter(predicate)
        self.addParameter(
            QgsProcessingParameterField(
                self.JOIN_FIELDS,
                self.tr('Fields to add (leave empty to use all fields)'),
                parentLayerParameterName=self.JOIN,
                allowMultiple=True,
                optional=True))
        self.addParameter(
            QgsProcessingParameterEnum(self.METHOD, self.tr('Join type'),
                                       self.methods))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.DISCARD_NONMATCHING,
                self.tr('Discard records which could not be joined'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterString(self.PREFIX,
                                         self.tr('Joined field prefix'),
                                         optional=True))
        self.addParameter(
            QgsProcessingParameterFeatureSink(
                self.OUTPUT,
                self.tr('Joined layer'),
                QgsProcessing.TypeVectorAnyGeometry,
                defaultValue=None,
                optional=True,
                createByDefault=True))

        non_matching = QgsProcessingParameterFeatureSink(
            self.NON_MATCHING,
            self.tr('Unjoinable features from first layer'),
            QgsProcessing.TypeVectorAnyGeometry,
            defaultValue=None,
            optional=True,
            createByDefault=False)
        # TODO GUI doesn't support advanced outputs yet
        # non_matching.setFlags(non_matching.flags() | QgsProcessingParameterDefinition.FlagAdvanced )
        self.addParameter(non_matching)

        self.addOutput(
            QgsProcessingOutputNumber(
                self.JOINED_COUNT,
                self.tr("Number of joined features from input table")))
Example #37
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Point layer'),
                                                              [QgsProcessing.TypeVectorPoint]))

        z_field_param = QgsProcessingParameterField(self.Z_FIELD,
                                                    self.tr('Z value from field'),
                                                    None,
                                                    self.INPUT,
                                                    QgsProcessingParameterField.Numeric,
                                                    optional=True)
        z_field_param.setFlags(z_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(z_field_param)

        self.addParameter(QgsProcessingParameterNumber(self.POWER,
                                                       self.tr('Weighting power'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       maxValue=100.0,
                                                       defaultValue=2.0))
        self.addParameter(QgsProcessingParameterNumber(self.SMOOTHING,
                                                       self.tr('Smoothing'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=0.0))
        self.addParameter(QgsProcessingParameterNumber(self.RADIUS,
                                                       self.tr('The radius of the search circle'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=1.0))
        self.addParameter(QgsProcessingParameterNumber(self.MAX_POINTS,
                                                       self.tr('Maximum number of data points to use'),
                                                       type=QgsProcessingParameterNumber.Integer,
                                                       minValue=0,
                                                       defaultValue=12))
        self.addParameter(QgsProcessingParameterNumber(self.MIN_POINTS,
                                                       self.tr('Minimum number of data points to use'),
                                                       type=QgsProcessingParameterNumber.Integer,
                                                       minValue=0,
                                                       defaultValue=0))
        self.addParameter(QgsProcessingParameterNumber(self.NODATA,
                                                       self.tr('NODATA marker to fill empty points'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       defaultValue=0.0))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation options'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
                                                    self.tr('Output data type'),
                                                    self.TYPES,
                                                    allowMultiple=False,
                                                    defaultValue=5)
        dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Interpolated (IDW with NN search)')))
    def initAlgorithm(self, config=None):
        """
        Here we define the inputs and output of the algorithm, along
        with some other properties.
        """

        # We add the input vector features source. It can have any kind of
        # geometry.
        #self.addParameter(
        #    QgsProcessingParameterFeatureSource(
        #        self.INPUT,
        #        self.tr('Input'),
        #        [QgsProcessing.TypeVectorAnyGeometry]
        #    )
        #)
        
        #self.addParameter(
        #    QgsProcessingParameterString(
        #        self.IN_DATE_MIN,
        #        self.tr('Date minimale'))
        #    )
            
        #self.addParameter(
        #    QgsProcessingParameterString(
        #        self.IN_DATE_MAX,
        #        self.tr('Date maximale'))
        #    )
        
        datDeb = QgsProcessingParameterString(self.IN_DATE_MIN, 'Date minimale')
        datDeb.setMetadata({
            'widget_wrapper': {
                'class': DateWidget}})

        self.addParameter(datDeb)
        
        datFin = QgsProcessingParameterString(self.IN_DATE_MAX, 'Date maximale')
        datFin.setMetadata({
            'widget_wrapper': {
                'class': DateWidget}})

        self.addParameter(datFin)
        
        self.addParameter(
            QgsProcessingParameterExtent(
                self.IN_EXTENT,
                'Emprise du projet', 
                defaultValue=None))
        
        self.addParameter(
            QgsProcessingParameterEnum(
                self.IN_LEVEL,
                tr('Niveau de traitement'),
                options=[tr('LEVEL2A'), tr('LEVEL3A')],
                defaultValue=0,
                optional=False)
        )

        self.addParameter(
            QgsProcessingParameterFolderDestination(
                self.OUTPUT,
                self.tr('Images S2')
            )
        )
        
        # We add a feature sink in which to store our processed features (this
        # usually takes the form of a newly created vector layer when the
        # algorithm is run in QGIS).
        
        #self.addParameter(
        #    QgsProcessingParameterFeatureSink(
        #        self.OUTPUT,
        #        self.tr('Output layer')
        #    )
        #)
        
        params = []
        params.append(QgsProcessingParameterString(self.IN_ID,
                                                   self.tr('Utilisateur'),
                                                   optional=False))
        params.append(QgsProcessingParameterString(self.IN_PW,
                                                   self.tr('Mot de passe'),
                                                   optional=False))
                                                   
                                                   
        params.append(QgsProcessingParameterBoolean(self.IN_SAVE_PW,
                                                    description="garder en mémoire",
                                                    optional=True,
                                                    defaultValue=False))
                                                   
        for p in params:
            p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
            self.addParameter(p)
Example #39
0
    def initAlgorithm(self, config=None):

        db_param = QgsProcessingParameterString(
            self.DATABASE, self.tr('Database (connection name)'))
        db_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
            }
        })
        self.addParameter(db_param)
        self.addParameter(
            QgsProcessingParameterFeatureSource(self.INPUT,
                                                self.tr('Input layer')))
        self.addParameter(
            QgsProcessingParameterString(self.SHAPE_ENCODING,
                                         self.tr('Shape encoding'),
                                         "",
                                         optional=True))
        self.addParameter(
            QgsProcessingParameterEnum(self.GTYPE,
                                       self.tr('Output geometry type'),
                                       options=self.GEOMTYPE,
                                       defaultValue=0))
        self.addParameter(
            QgsProcessingParameterCrs(self.A_SRS,
                                      self.tr('Assign an output CRS'),
                                      defaultValue='',
                                      optional=False))
        self.addParameter(
            QgsProcessingParameterCrs(
                self.T_SRS,
                self.tr('Reproject to this CRS on output '),
                defaultValue='',
                optional=True))
        self.addParameter(
            QgsProcessingParameterCrs(self.S_SRS,
                                      self.tr('Override source CRS'),
                                      defaultValue='',
                                      optional=True))

        schema_param = QgsProcessingParameterString(
            self.SCHEMA, self.tr('Schema (schema name)'), 'public', False,
            True)
        schema_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
                'connection_param': self.DATABASE
            }
        })
        self.addParameter(schema_param)

        table_param = QgsProcessingParameterString(
            self.TABLE,
            self.tr('Table to import to (leave blank to use layer name)'), '',
            False, True)
        table_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.gui.wrappers_postgis.TableWidgetWrapper',
                'schema_param': self.SCHEMA
            }
        })
        self.addParameter(table_param)

        self.addParameter(
            QgsProcessingParameterString(self.PK,
                                         self.tr('Primary key (new field)'),
                                         defaultValue='id',
                                         optional=True))
        self.addParameter(
            QgsProcessingParameterField(
                self.PRIMARY_KEY,
                self.
                tr('Primary key (existing field, used if the above option is left empty)'
                   ),
                parentLayerParameterName=self.INPUT,
                optional=True))
        self.addParameter(
            QgsProcessingParameterString(self.GEOCOLUMN,
                                         self.tr('Geometry column name'),
                                         defaultValue='geom',
                                         optional=True))
        self.addParameter(
            QgsProcessingParameterEnum(self.DIM,
                                       self.tr('Vector dimensions'),
                                       options=self.DIMLIST,
                                       defaultValue=0))
        self.addParameter(
            QgsProcessingParameterString(
                self.SIMPLIFY,
                self.tr('Distance tolerance for simplification'),
                defaultValue='',
                optional=True))
        self.addParameter(
            QgsProcessingParameterString(
                self.SEGMENTIZE,
                self.tr('Maximum distance between 2 nodes (densification)'),
                defaultValue='',
                optional=True))
        self.addParameter(
            QgsProcessingParameterExtent(
                self.SPAT,
                self.tr(
                    'Select features by extent (defined in input layer CRS)'),
                optional=True))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.CLIP,
                self.tr(
                    'Clip the input layer using the above (rectangle) extent'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterString(
                self.WHERE,
                self.
                tr('Select features using a SQL "WHERE" statement (Ex: column=\'value\')'
                   ),
                defaultValue='',
                optional=True))
        self.addParameter(
            QgsProcessingParameterString(
                self.GT,
                self.tr('Group N features per transaction (Default: 20000)'),
                defaultValue='',
                optional=True))
        self.addParameter(
            QgsProcessingParameterBoolean(self.OVERWRITE,
                                          self.tr('Overwrite existing table'),
                                          defaultValue=True))
        self.addParameter(
            QgsProcessingParameterBoolean(self.APPEND,
                                          self.tr('Append to existing table'),
                                          defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.ADDFIELDS,
                self.tr('Append and add new fields to existing table'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.LAUNDER,
                self.tr('Do not launder columns/table names'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.INDEX,
                self.tr('Do not create spatial index'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.SKIPFAILURES,
                self.tr(
                    'Continue after a failure, skipping the failed feature'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(self.PROMOTETOMULTI,
                                          self.tr('Promote to Multipart'),
                                          defaultValue=True))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.PRECISION,
                self.tr('Keep width and precision of input attributes'),
                defaultValue=True))
        self.addParameter(
            QgsProcessingParameterString(
                self.OPTIONS,
                self.tr('Additional creation options'),
                defaultValue='',
                optional=True))
Example #40
0
    def initAlgorithm(self, config=None):
        self.distanceUnits = ((self.tr('Georeferenced coordinates'), 'GEO'),
                              (self.tr('Pixel coordinates'), 'PIXEL'))

        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT,
                                              self.tr('Input layer')))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND,
                                       self.tr('Band number'),
                                       parentLayerParameterName=self.INPUT))
        self.addParameter(
            QgsProcessingParameterString(
                self.VALUES,
                self.
                tr('A list of pixel values in the source image to be considered target pixels'
                   ),
                optional=True))
        self.addParameter(
            QgsProcessingParameterEnum(
                self.UNITS,
                self.tr('Distance units'),
                options=[i[0] for i in self.distanceUnits],
                allowMultiple=False,
                defaultValue=1))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.MAX_DISTANCE,
                self.tr('The maximum distance to be generated'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=0.0,
                optional=True))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.REPLACE,
                self.
                tr('Value to be applied to all pixels that are within the -maxdist of target pixels'
                   ),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=0.0,
                optional=True))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.NODATA,
                self.
                tr('Nodata value to use for the destination proximity raster'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=0.0,
                optional=True))

        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation parameters'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        self.addParameter(
            QgsProcessingParameterEnum(self.DATA_TYPE,
                                       self.tr('Output data type'),
                                       self.TYPES,
                                       allowMultiple=False,
                                       defaultValue=5))

        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Proximity map')))
Example #41
0
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT, self.tr('Point layer'),
                [QgsProcessing.TypeVectorPoint]))

        z_field_param = QgsProcessingParameterField(
            self.Z_FIELD,
            self.tr('Z value from field'),
            None,
            self.INPUT,
            QgsProcessingParameterField.Numeric,
            optional=True)
        z_field_param.setFlags(z_field_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(z_field_param)

        self.addParameter(
            QgsProcessingParameterNumber(
                self.RADIUS_1,
                self.tr('The first radius of search ellipse'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=0.0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.RADIUS_2,
                self.tr('The second radius of search ellipse'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=0.0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.ANGLE,
                self.
                tr('Angle of search ellipse rotation in degrees (counter clockwise)'
                   ),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                maxValue=360.0,
                defaultValue=0.0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.NODATA,
                self.tr('NODATA marker to fill empty points'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=0.0))

        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation parameters'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(
            self.DATA_TYPE,
            self.tr('Output data type'),
            self.TYPES,
            allowMultiple=False,
            defaultValue=5)
        dataType_param.setFlags(
            dataType_param.flags()
            | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        self.addParameter(
            QgsProcessingParameterRasterDestination(
                self.OUTPUT, self.tr('Interpolated (Nearest neighbor)')))
Example #42
0
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT_A,
                                              self.tr('Input layer A'),
                                              optional=False))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_A,
                                       self.tr('Number of raster band for A'),
                                       parentLayerParameterName=self.INPUT_A))
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT_B,
                                              self.tr('Input layer B'),
                                              optional=True))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_B,
                                       self.tr('Number of raster band for B'),
                                       parentLayerParameterName=self.INPUT_B,
                                       optional=True))
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT_C,
                                              self.tr('Input layer C'),
                                              optional=True))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_C,
                                       self.tr('Number of raster band for C'),
                                       parentLayerParameterName=self.INPUT_C,
                                       optional=True))
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT_D,
                                              self.tr('Input layer D'),
                                              optional=True))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_D,
                                       self.tr('Number of raster band for D'),
                                       parentLayerParameterName=self.INPUT_D,
                                       optional=True))
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT_E,
                                              self.tr('Input layer E'),
                                              optional=True))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_E,
                                       self.tr('Number of raster band for E'),
                                       parentLayerParameterName=self.INPUT_E,
                                       optional=True))
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT_F,
                                              self.tr('Input layer F'),
                                              optional=True))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_F,
                                       self.tr('Number of raster band for F'),
                                       parentLayerParameterName=self.INPUT_F,
                                       optional=True))
        self.addParameter(
            QgsProcessingParameterString(
                self.FORMULA,
                self.
                tr('Calculation in gdalnumeric syntax using +-/* or any numpy array functions (i.e. logical_and())'
                   ),
                'A*2',
                optional=False))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.NO_DATA,
                self.tr('Set output nodata value'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=None,
                optional=True))
        self.addParameter(
            QgsProcessingParameterEnum(self.RTYPE,
                                       self.tr('Output raster type'),
                                       options=self.TYPE,
                                       defaultValue=5))

        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation options'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Calculated')))
    def initAlgorithm(self, config=None):
        self.DIRECTIONS = OrderedDict([
            (self.tr('Forward direction'), QgsVectorLayerDirector.DirectionForward),
            (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward),
            (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)])

        self.STRATEGIES = [self.tr('Shortest'),
                           self.tr('Fastest')
                           ]

        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Vector layer representing network'),
                                                              [QgsProcessing.TypeVectorLine]))
        self.addParameter(QgsProcessingParameterPoint(self.START_POINT,
                                                      self.tr('Start point')))
        self.addParameter(QgsProcessingParameterPoint(self.END_POINT,
                                                      self.tr('End point')))
        self.addParameter(QgsProcessingParameterEnum(self.STRATEGY,
                                                     self.tr('Path type to calculate'),
                                                     self.STRATEGIES,
                                                     defaultValue=0))

        params = []
        params.append(QgsProcessingParameterField(self.DIRECTION_FIELD,
                                                  self.tr('Direction field'),
                                                  None,
                                                  self.INPUT,
                                                  optional=True))
        params.append(QgsProcessingParameterString(self.VALUE_FORWARD,
                                                   self.tr('Value for forward direction'),
                                                   optional=True))
        params.append(QgsProcessingParameterString(self.VALUE_BACKWARD,
                                                   self.tr('Value for backward direction'),
                                                   optional=True))
        params.append(QgsProcessingParameterString(self.VALUE_BOTH,
                                                   self.tr('Value for both directions'),
                                                   optional=True))
        params.append(QgsProcessingParameterEnum(self.DEFAULT_DIRECTION,
                                                 self.tr('Default direction'),
                                                 list(self.DIRECTIONS.keys()),
                                                 defaultValue=2))
        params.append(QgsProcessingParameterField(self.SPEED_FIELD,
                                                  self.tr('Speed field'),
                                                  None,
                                                  self.INPUT,
                                                  optional=True))
        params.append(QgsProcessingParameterNumber(self.DEFAULT_SPEED,
                                                   self.tr('Default speed (km/h)'),
                                                   QgsProcessingParameterNumber.Double,
                                                   5.0, False, 0, 99999999.99))
        params.append(QgsProcessingParameterNumber(self.TOLERANCE,
                                                   self.tr('Topology tolerance'),
                                                   QgsProcessingParameterNumber.Double,
                                                   0.0, False, 0, 99999999.99))

        for p in params:
            p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
            self.addParameter(p)

        self.addOutput(QgsProcessingOutputNumber(self.TRAVEL_COST,
                                                 self.tr('Travel cost')))
        self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
                                                            self.tr('Shortest path'),
                                                            QgsProcessing.TypeVectorLine))
Example #44
0
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT,
                                              self.tr('Input layer')))
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.MASK, self.tr('Mask layer'),
                [QgsProcessing.TypeVectorPolygon]))
        self.addParameter(
            QgsProcessingParameterCrs(self.SOURCE_CRS,
                                      self.tr('Source CRS'),
                                      optional=True))
        self.addParameter(
            QgsProcessingParameterCrs(self.TARGET_CRS,
                                      self.tr('Target CRS'),
                                      optional=True))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.NODATA,
                self.tr('Assign a specified nodata value to output bands'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=None,
                optional=True))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.ALPHA_BAND,
                self.tr('Create an output alpha band'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.CROP_TO_CUTLINE,
                self.
                tr('Match the extent of the clipped raster to the extent of the mask layer'
                   ),
                defaultValue=True))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.KEEP_RESOLUTION,
                self.tr('Keep resolution of input raster'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.SET_RESOLUTION,
                self.tr('Set output file resolution'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.X_RESOLUTION,
                self.tr('X Resolution to output bands'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=None,
                optional=True))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.Y_RESOLUTION,
                self.tr('Y Resolution to output bands'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=None,
                optional=True))
        multithreading_param = QgsProcessingParameterBoolean(
            self.MULTITHREADING,
            self.tr('Use multithreaded warping implementation'),
            defaultValue=False)
        multithreading_param.setFlags(
            multithreading_param.flags()
            | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(multithreading_param)
        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation options'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(
            self.DATA_TYPE,
            self.tr('Output data type'),
            self.TYPES,
            allowMultiple=False,
            defaultValue=0)
        dataType_param.setFlags(
            dataType_param.flags()
            | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Clipped (mask)')))
 def okPressed(self):
     description = str(self.nameTextBox.text())
     if description.strip() == '':
         QMessageBox.warning(self, self.tr('Unable to define parameter'),
                             self.tr('Invalid parameter name'))
         return
     if self.param is None:
         validChars = \
             'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
         safeName = ''.join(c for c in description if c in validChars)
         name = safeName.lower()
         i = 2
         while self.alg.parameterDefinition(name):
             name = safeName.lower() + str(i)
             i += 1
     else:
         name = self.param.name()
     if (self.paramType
             == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN
             or isinstance(self.param, QgsProcessingParameterBoolean)):
         self.param = QgsProcessingParameterBoolean(name, description,
                                                    self.state.isChecked())
     elif (self.paramType
           == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD
           or isinstance(self.param, QgsProcessingParameterField)):
         if self.parentCombo.currentIndex() < 0:
             QMessageBox.warning(
                 self, self.tr('Unable to define parameter'),
                 self.tr('Wrong or missing parameter values'))
             return
         parent = self.parentCombo.currentData()
         datatype = self.datatypeCombo.currentData()
         self.param = QgsProcessingParameterField(
             name, description, None, parent, datatype,
             self.multipleCheck.isChecked())
     elif (self.paramType
           == ModelerParameterDefinitionDialog.PARAMETER_RASTER
           or isinstance(self.param, QgsProcessingParameterRasterLayer)):
         self.param = QgsProcessingParameterRasterLayer(name, description)
     elif (self.paramType
           == ModelerParameterDefinitionDialog.PARAMETER_TABLE
           or isinstance(self.param, QgsProcessingParameterVectorLayer)):
         self.param = QgsProcessingParameterVectorLayer(name, description)
     elif (self.paramType
           == ModelerParameterDefinitionDialog.PARAMETER_VECTOR
           or isinstance(self.param, QgsProcessingParameterFeatureSource)):
         self.param = QgsProcessingParameterFeatureSource(
             name, description, [self.shapetypeCombo.currentIndex() - 1])
     elif (self.paramType
           == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
           or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
         self.param = QgsProcessingParameterMultipleLayers(
             name, description,
             self.datatypeCombo.currentIndex() - 1)
     elif (self.paramType
           == ModelerParameterDefinitionDialog.PARAMETER_NUMBER
           or isinstance(self.param, QgsProcessingParameterNumber)):
         try:
             self.param = QgsProcessingParameterNumber(
                 name, description, QgsProcessingParameterNumber.Double,
                 self.defaultTextBox.text())
             vmin = self.minTextBox.text().strip()
             if not vmin == '':
                 self.param.setMinimum(float(vmin))
             vmax = self.maxTextBox.text().strip()
             if not vmax == '':
                 self.param.setMaximum(float(vmax))
         except:
             QMessageBox.warning(
                 self, self.tr('Unable to define parameter'),
                 self.tr('Wrong or missing parameter values'))
             return
     elif (self.paramType
           == ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION
           or isinstance(self.param, QgsProcessingParameterExpression)):
         parent = self.parentCombo.currentData()
         self.param = QgsProcessingParameterExpression(
             name, description, str(self.defaultEdit.expression()), parent)
     elif (self.paramType
           == ModelerParameterDefinitionDialog.PARAMETER_STRING
           or isinstance(self.param, QgsProcessingParameterString)):
         self.param = QgsProcessingParameterString(
             name, description, str(self.defaultTextBox.text()))
     elif (self.paramType
           == ModelerParameterDefinitionDialog.PARAMETER_EXTENT
           or isinstance(self.param, QgsProcessingParameterExtent)):
         self.param = QgsProcessingParameterExtent(name, description)
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE
           or isinstance(self.param, QgsProcessingParameterFile)):
         isFolder = self.fileFolderCombo.currentIndex() == 1
         self.param = QgsProcessingParameterFile(
             name, description, QgsProcessingParameterFile.Folder
             if isFolder else QgsProcessingParameterFile.File)
     elif (self.paramType
           == ModelerParameterDefinitionDialog.PARAMETER_POINT
           or isinstance(self.param, QgsProcessingParameterPoint)):
         self.param = QgsProcessingParameterPoint(
             name, description, str(self.defaultTextBox.text()))
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS
           or isinstance(self.param, QgsProcessingParameterCrs)):
         self.param = QgsProcessingParameterCrs(
             name, description,
             self.selector.crs().authid())
     if not self.requiredCheck.isChecked():
         self.param.setFlags(
             self.param.flags()
             | QgsProcessingParameterDefinition.FlagOptional)
     self.close()
    def initAlgorithm(self, config=None):
        self.predicates = (('intersects', self.tr('intersects')),
                           ('contains', self.tr('contains')),
                           ('equals', self.tr('equals')), ('touches',
                                                           self.tr('touches')),
                           ('overlaps', self.tr('overlaps')),
                           ('within', self.tr('within')), ('crosses',
                                                           self.tr('crosses')))

        self.reversed_predicates = {
            'intersects': 'intersects',
            'contains': 'within',
            'isEqual': 'isEqual',
            'touches': 'touches',
            'overlaps': 'overlaps',
            'within': 'contains',
            'crosses': 'crosses'
        }

        self.methods = [
            self.
            tr('Create separate feature for each located feature (one-to-many)'
               ),
            self.
            tr('Take attributes of the first located feature only (one-to-one)'
               )
        ]

        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT, self.tr('Input layer'),
                [QgsProcessing.TypeVectorAnyGeometry]))
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.JOIN, self.tr('Join layer'),
                [QgsProcessing.TypeVectorAnyGeometry]))

        predicate = QgsProcessingParameterEnum(
            self.PREDICATE,
            self.tr('Geometric predicate'),
            options=[p[1] for p in self.predicates],
            allowMultiple=True,
            defaultValue=[0])
        predicate.setMetadata({
            'widget_wrapper': {
                'class': 'processing.gui.wrappers.EnumWidgetWrapper',
                'useCheckBoxes': True,
                'columns': 2
            }
        })
        self.addParameter(predicate)
        self.addParameter(
            QgsProcessingParameterField(
                self.JOIN_FIELDS,
                self.tr('Fields to add (leave empty to use all fields)'),
                parentLayerParameterName=self.JOIN,
                allowMultiple=True,
                optional=True))
        self.addParameter(
            QgsProcessingParameterEnum(self.METHOD, self.tr('Join type'),
                                       self.methods))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.DISCARD_NONMATCHING,
                self.tr('Discard records which could not be joined'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterString(self.PREFIX,
                                         self.tr('Joined field prefix'),
                                         optional=True))
        self.addParameter(
            QgsProcessingParameterFeatureSink(self.OUTPUT,
                                              self.tr('Joined layer')))
Example #47
0
    def initAlgorithm(self, config=None):
        self.metrics = ((self.tr('Minimum'), 'minimum'), (self.tr('Maximum'),
                                                          'maximum'),
                        (self.tr('Range'), 'range'), (self.tr('Count'),
                                                      'count'),
                        (self.tr('Average distance'), 'average_distance'),
                        (self.tr('Average distance between points'),
                         'average_distance_pts'))

        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT, self.tr('Point layer'),
                [QgsProcessing.TypeVectorPoint]))

        z_field_param = QgsProcessingParameterField(
            self.Z_FIELD,
            self.tr('Z value from field'),
            None,
            self.INPUT,
            QgsProcessingParameterField.Numeric,
            optional=True)
        z_field_param.setFlags(z_field_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(z_field_param)

        self.addParameter(
            QgsProcessingParameterEnum(self.METRIC,
                                       self.tr('Data metric to use'),
                                       options=[i[0] for i in self.metrics],
                                       allowMultiple=False,
                                       defaultValue=0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.RADIUS_1,
                self.tr('The first radius of search ellipse'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=0.0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.RADIUS_2,
                self.tr('The second radius of search ellipse'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=0.0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.ANGLE,
                self.
                tr('Angle of search ellipse rotation in degrees (counter clockwise)'
                   ),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                maxValue=360.0,
                defaultValue=0.0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.MIN_POINTS,
                self.tr('Minimum number of data points to use'),
                type=QgsProcessingParameterNumber.Integer,
                minValue=0,
                defaultValue=0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.NODATA,
                self.tr('NODATA marker to fill empty points'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=0.0))

        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation options'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(
            self.DATA_TYPE,
            self.tr('Output data type'),
            self.TYPES,
            allowMultiple=False,
            defaultValue=5)
        dataType_param.setFlags(
            dataType_param.flags()
            | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        self.addParameter(
            QgsProcessingParameterRasterDestination(
                self.OUTPUT, self.tr('Interpolated (data metrics)')))
Example #48
0
 def initAlgorithm(self, config=None):
     self.addParameter(
         QgsProcessingParameterFeatureSource(self.INPUT,
                                             self.tr('Input layer')))
     self.addParameter(
         QgsProcessingParameterString(self.SHAPE_ENCODING,
                                      self.tr('Shape encoding'),
                                      "",
                                      optional=True))
     self.addParameter(
         QgsProcessingParameterEnum(self.GTYPE,
                                    self.tr('Output geometry type'),
                                    options=self.GEOMTYPE,
                                    defaultValue=0))
     self.addParameter(
         QgsProcessingParameterCrs(self.A_SRS,
                                   self.tr('Assign an output CRS'),
                                   defaultValue='',
                                   optional=True))
     self.addParameter(
         QgsProcessingParameterCrs(
             self.T_SRS,
             self.tr('Reproject to this CRS on output '),
             defaultValue='',
             optional=True))
     self.addParameter(
         QgsProcessingParameterCrs(self.S_SRS,
                                   self.tr('Override source CRS'),
                                   defaultValue='',
                                   optional=True))
     self.addParameter(
         QgsProcessingParameterString(self.HOST,
                                      self.tr('Host'),
                                      defaultValue='localhost',
                                      optional=True))
     self.addParameter(
         QgsProcessingParameterString(self.PORT,
                                      self.tr('Port'),
                                      defaultValue='5432',
                                      optional=True))
     self.addParameter(
         QgsProcessingParameterString(self.USER,
                                      self.tr('Username'),
                                      defaultValue='',
                                      optional=True))
     self.addParameter(
         QgsProcessingParameterString(self.DBNAME,
                                      self.tr('Database name'),
                                      defaultValue='',
                                      optional=True))
     self.addParameter(
         QgsProcessingParameterString(self.PASSWORD,
                                      self.tr('Password'),
                                      defaultValue='',
                                      optional=True))
     self.addParameter(
         QgsProcessingParameterString(self.SCHEMA,
                                      self.tr('Schema name'),
                                      defaultValue='public',
                                      optional=True))
     self.addParameter(
         QgsProcessingParameterString(
             self.TABLE,
             self.tr('Table name, leave blank to use input name'),
             defaultValue='',
             optional=True))
     self.addParameter(
         QgsProcessingParameterString(self.PK,
                                      self.tr('Primary key (new field)'),
                                      defaultValue='id',
                                      optional=True))
     self.addParameter(
         QgsProcessingParameterField(
             self.PRIMARY_KEY,
             self.
             tr('Primary key (existing field, used if the above option is left empty)'
                ),
             parentLayerParameterName=self.INPUT,
             optional=True))
     self.addParameter(
         QgsProcessingParameterString(self.GEOCOLUMN,
                                      self.tr('Geometry column name'),
                                      defaultValue='geom',
                                      optional=True))
     self.addParameter(
         QgsProcessingParameterEnum(self.DIM,
                                    self.tr('Vector dimensions'),
                                    options=self.DIMLIST,
                                    defaultValue=0))
     self.addParameter(
         QgsProcessingParameterString(
             self.SIMPLIFY,
             self.tr('Distance tolerance for simplification'),
             defaultValue='',
             optional=True))
     self.addParameter(
         QgsProcessingParameterString(
             self.SEGMENTIZE,
             self.tr('Maximum distance between 2 nodes (densification)'),
             defaultValue='',
             optional=True))
     self.addParameter(
         QgsProcessingParameterExtent(
             self.SPAT,
             self.tr(
                 'Select features by extent (defined in input layer CRS)'),
             optional=True))
     self.addParameter(
         QgsProcessingParameterBoolean(
             self.CLIP,
             self.tr(
                 'Clip the input layer using the above (rectangle) extent'),
             defaultValue=False))
     self.addParameter(
         QgsProcessingParameterField(
             self.FIELDS,
             self.tr('Fields to include (leave empty to use all fields)'),
             parentLayerParameterName=self.INPUT,
             allowMultiple=True,
             optional=True))
     self.addParameter(
         QgsProcessingParameterString(
             self.WHERE,
             self.
             tr('Select features using a SQL "WHERE" statement (Ex: column=\'value\')'
                ),
             defaultValue='',
             optional=True))
     self.addParameter(
         QgsProcessingParameterString(
             self.GT,
             self.tr('Group N features per transaction (Default: 20000)'),
             defaultValue='',
             optional=True))
     self.addParameter(
         QgsProcessingParameterBoolean(self.OVERWRITE,
                                       self.tr('Overwrite existing table'),
                                       defaultValue=True))
     self.addParameter(
         QgsProcessingParameterBoolean(self.APPEND,
                                       self.tr('Append to existing table'),
                                       defaultValue=False))
     self.addParameter(
         QgsProcessingParameterBoolean(
             self.ADDFIELDS,
             self.tr('Append and add new fields to existing table'),
             defaultValue=False))
     self.addParameter(
         QgsProcessingParameterBoolean(
             self.LAUNDER,
             self.tr('Do not launder columns/table names'),
             defaultValue=False))
     self.addParameter(
         QgsProcessingParameterBoolean(
             self.INDEX,
             self.tr('Do not create spatial index'),
             defaultValue=False))
     self.addParameter(
         QgsProcessingParameterBoolean(
             self.SKIPFAILURES,
             self.tr(
                 'Continue after a failure, skipping the failed feature'),
             defaultValue=False))
     self.addParameter(
         QgsProcessingParameterBoolean(self.PROMOTETOMULTI,
                                       self.tr('Promote to Multipart'),
                                       defaultValue=True))
     self.addParameter(
         QgsProcessingParameterBoolean(
             self.PRECISION,
             self.tr('Keep width and precision of input attributes'),
             defaultValue=True))
     self.addParameter(
         QgsProcessingParameterString(
             self.OPTIONS,
             self.tr('Additional creation options'),
             defaultValue='',
             optional=True))
Example #49
0
File: warp.py Project: Geoany/QGIS
    def initAlgorithm(self, config=None):
        self.methods = ((self.tr('Nearest neighbour'), 'near'),
                        (self.tr('Bilinear'), 'bilinear'),
                        (self.tr('Cubic'), 'cubic'),
                        (self.tr('Cubic spline'), 'cubicspline'),
                        (self.tr('Lanczos windowed sinc'), 'lanczos'),
                        (self.tr('Average'), 'average'),
                        (self.tr('Mode'), 'mode'),
                        (self.tr('Maximum'), 'max'),
                        (self.tr('Minimum'), 'min'),
                        (self.tr('Median'), 'med'),
                        (self.tr('First quartile'), 'q1'),
                        (self.tr('Third quartile'), 'q3'))

        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterCrs(self.SOURCE_CRS,
                                                    self.tr('Source CRS'),
                                                    optional=True))
        self.addParameter(QgsProcessingParameterCrs(self.TARGET_CRS,
                                                    self.tr('Target CRS'),
                                                    'EPSG:4326'))
        self.addParameter(QgsProcessingParameterNumber(self.NODATA,
                                                       self.tr('Nodata value for output bands'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       defaultValue=0.0))
        self.addParameter(QgsProcessingParameterNumber(self.TARGET_RESOLUTION,
                                                       self.tr('Output file resolution in target georeferenced units'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0,
                                                       defaultValue=None))

        options_param = QgsProcessingParameterString(self.OPTIONS,
                                                     self.tr('Additional creation parameters'),
                                                     defaultValue='',
                                                     optional=True)
        options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
        self.addParameter(options_param)

        self.addParameter(QgsProcessingParameterEnum(self.RESAMPLING,
                                                     self.tr('Resampling method to use'),
                                                     options=[i[0] for i in self.methods],
                                                     defaultValue=0))

        dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
                                                    self.tr('Output data type'),
                                                    self.TYPES,
                                                    allowMultiple=False,
                                                    defaultValue=5)
        dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        target_extent_param = QgsProcessingParameterExtent(self.TARGET_EXTENT,
                                                           self.tr('Georeferenced extents of output file to be created'),
                                                           optional=True)
        target_extent_param.setFlags(target_extent_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(target_extent_param)

        target_extent_crs_param = QgsProcessingParameterCrs(self.TARGET_EXTENT_CRS,
                                                            self.tr('CRS of the target raster extent'),
                                                            optional=True)
        target_extent_crs_param.setFlags(target_extent_crs_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(target_extent_crs_param)

        multithreading_param = QgsProcessingParameterBoolean(self.MULTITHREADING,
                                                             self.tr('Use multithreaded warping implementation'),
                                                             defaultValue=False)
        multithreading_param.setFlags(multithreading_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(multithreading_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Reprojected')))
    def initAlgorithm(self, config=None):
        # LizSync config file from ini
        ls = lizsyncConfig()

        # INPUTS

        # Central database connection name
        connection_name_central = ls.variable('postgresql:central/name')
        label = tr('PostgreSQL connection to the central database')
        if Qgis.QGIS_VERSION_INT >= 31400:
            param = QgsProcessingParameterProviderConnection(
                self.CONNECTION_NAME_CENTRAL,
                label,
                "postgres",
                defaultValue=connection_name_central,
                optional=False,
            )
        else:
            param = QgsProcessingParameterString(
                self.CONNECTION_NAME_CENTRAL,
                label,
                defaultValue=connection_name_central,
                optional=False)
            param.setMetadata({
                'widget_wrapper': {
                    'class':
                    'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
                }
            })
        tooltip = tr('The PostgreSQL connection to the central database.')
        if Qgis.QGIS_VERSION_INT >= 31600:
            param.setHelp(tooltip)
        else:
            param.tooltip_3liz = tooltip
        self.addParameter(param)

        # Clone database connection parameters
        connection_name_clone = ls.variable('postgresql:clone/name')
        label = tr('PostgreSQL connection to the clone database')
        if Qgis.QGIS_VERSION_INT >= 31400:
            param = QgsProcessingParameterProviderConnection(
                self.CONNECTION_NAME_CLONE,
                label,
                "postgres",
                defaultValue=connection_name_clone,
                optional=False,
            )
        else:
            param = QgsProcessingParameterString(
                self.CONNECTION_NAME_CLONE,
                label,
                defaultValue=connection_name_clone,
                optional=False)
            param.setMetadata({
                'widget_wrapper': {
                    'class':
                    'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
                }
            })
        tooltip = tr('The PostgreSQL connection to the clone database.')
        if Qgis.QGIS_VERSION_INT >= 31600:
            param.setHelp(tooltip)
        else:
            param.tooltip_3liz = tooltip
        self.addParameter(param)

        # OUTPUTS
        # Add output for message
        self.addOutput(
            QgsProcessingOutputNumber(self.OUTPUT_STATUS, tr('Output status')))
        self.addOutput(
            QgsProcessingOutputString(self.OUTPUT_STRING,
                                      tr('Output message')))
Example #51
0
File: i.py Project: FERRATON/QGIS
def regroupRasters(alg,
                   parameters,
                   context,
                   src,
                   group,
                   subgroup=None,
                   extFile=None):
    """
    Group multiple input rasters into a group
    * If there is a subgroupField, a subgroup will automatically be created.
    * When an external file is provided, the file is copied into the respective
    directory of the subgroup.
    :param parameters:
    :param context:
    :param src: name of input parameter with multiple rasters.
    :param group: name of group.
    :param subgroup: name of subgroup.
    :param extFile: dict : parameterName:directory name
    """
    # Create a group parameter
    groupName = 'group_{}'.format(os.path.basename(getTempFilename()))
    param = QgsProcessingParameterString(group, 'virtual group', groupName,
                                         False, False)
    alg.addParameter(param)

    # Create a subgroup
    subgroupName = None
    if subgroup:
        subgroupName = 'subgroup_{}'.format(os.path.basename(
            getTempFilename()))
        param = QgsProcessingParameterString(subgroup, 'virtual subgroup',
                                             subgroupName, False, False)
        alg.addParameter(param)

    # Compute raster names
    rasters = alg.parameterAsLayerList(parameters, src, context)
    rasterNames = []
    for idx, raster in enumerate(rasters):
        name = '{}_{}'.format(src, idx)
        if name in alg.exportedLayers:
            rasterNames.append(alg.exportedLayers[name])

    # Insert a i.group command
    command = 'i.group group={}{} input={}'.format(
        groupName, ' subgroup={}'.format(subgroupName) if subgroup else '',
        ','.join(rasterNames))
    alg.commands.append(command)

    # Handle external files
    # if subgroupField and extFile:
    #     for ext in extFile.keys():
    #         extFileName = new_parameters[ext]
    #         if extFileName:
    #             shortFileName = os.path.basename(extFileName)
    #             destPath = os.path.join(Grass7Utils.grassMapsetFolder(),
    #                                     'PERMANENT',
    #                                     'group', new_parameters[group.name()],
    #                                     'subgroup', new_parameters[subgroup.name()],
    #                                     extFile[ext], shortFileName)
    #             copyFile(alg, extFileName, destPath)

    alg.removeParameter(src)

    return groupName, subgroupName
Example #52
0
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterMultipleLayers(self.INPUT,
                                                 self.tr('Input layers'),
                                                 QgsProcessing.TypeRaster))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.PCT,
                self.tr('Grab pseudocolor table from first layer'),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.SEPARATE,
                self.tr('Place each input file into a separate band'),
                defaultValue=False))

        nodata_param = QgsProcessingParameterNumber(
            self.NODATA_INPUT,
            self.tr('Input pixel value to treat as "nodata"'),
            type=QgsProcessingParameterNumber.Integer,
            defaultValue=None,
            optional=True)
        nodata_param.setFlags(nodata_param.flags()
                              | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(nodata_param)

        nodata_out_param = QgsProcessingParameterNumber(
            self.NODATA_OUTPUT,
            self.tr('Assign specified "nodata" value to output'),
            type=QgsProcessingParameterNumber.Integer,
            defaultValue=None,
            optional=True)
        nodata_out_param.setFlags(
            nodata_out_param.flags()
            | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(nodata_out_param)

        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation options'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        self.addParameter(
            QgsProcessingParameterEnum(self.DATA_TYPE,
                                       self.tr('Output data type'),
                                       self.TYPES,
                                       allowMultiple=False,
                                       defaultValue=5))

        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Merged')))
Example #53
0
    def initAlgorithm(self, config=None):
        self.profiles = ((self.tr('Mercator'), 'mercator'),
                         (self.tr('Geodetic'), 'geodetic'), (self.tr('Raster'),
                                                             'raster'))

        self.methods = ((self.tr('Average'),
                         'average'), (self.tr('Nearest neighbour'), 'near'),
                        (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'),
                                       options=[i[0] for i in self.profiles],
                                       allowMultiple=False,
                                       defaultValue=0))
        self.addParameter(
            QgsProcessingParameterString(self.ZOOM,
                                         self.tr('Zoom levels to render'),
                                         defaultValue='',
                                         optional=True))
        self.addParameter(
            QgsProcessingParameterEnum(self.VIEWER,
                                       self.tr('Web viewer to generate'),
                                       options=[i[0] for i in self.viewers],
                                       allowMultiple=False,
                                       defaultValue=0))
        self.addParameter(
            QgsProcessingParameterString(self.TITLE,
                                         self.tr('Title of the map'),
                                         optional=True))
        self.addParameter(
            QgsProcessingParameterString(self.COPYRIGHT,
                                         self.tr('Copyright of the map'),
                                         optional=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.addParameter(
            QgsProcessingParameterFolderDestination(
                self.OUTPUT, self.tr('Output directory')))
Example #54
0
    def initAlgorithm(self, config=None):
        self.DIRECTIONS = OrderedDict([
            (self.tr('Forward direction'), QgsVectorLayerDirector.DirectionForward),
            (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward),
            (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)])

        self.STRATEGIES = [self.tr('Shortest'),
                           self.tr('Fastest')
                           ]

        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
                                                              self.tr('Vector layer representing network'),
                                                              [QgsProcessing.TypeVectorLine]))
        self.addParameter(QgsProcessingParameterPoint(self.START_POINT,
                                                      self.tr('Start point')))
        self.addParameter(QgsProcessingParameterEnum(self.STRATEGY,
                                                     self.tr('Path type to calculate'),
                                                     self.STRATEGIES,
                                                     defaultValue=0))
        self.addParameter(QgsProcessingParameterNumber(self.TRAVEL_COST,
                                                       self.tr('Travel cost (distance for "Shortest", time for "Fastest")'),
                                                       QgsProcessingParameterNumber.Double,
                                                       0.0, False, 0))

        params = []
        params.append(QgsProcessingParameterField(self.DIRECTION_FIELD,
                                                  self.tr('Direction field'),
                                                  None,
                                                  self.INPUT,
                                                  optional=True))
        params.append(QgsProcessingParameterString(self.VALUE_FORWARD,
                                                   self.tr('Value for forward direction'),
                                                   optional=True))
        params.append(QgsProcessingParameterString(self.VALUE_BACKWARD,
                                                   self.tr('Value for backward direction'),
                                                   optional=True))
        params.append(QgsProcessingParameterString(self.VALUE_BOTH,
                                                   self.tr('Value for both directions'),
                                                   optional=True))
        params.append(QgsProcessingParameterEnum(self.DEFAULT_DIRECTION,
                                                 self.tr('Default direction'),
                                                 list(self.DIRECTIONS.keys()),
                                                 defaultValue=2))
        params.append(QgsProcessingParameterField(self.SPEED_FIELD,
                                                  self.tr('Speed field'),
                                                  None,
                                                  self.INPUT,
                                                  optional=True))
        params.append(QgsProcessingParameterNumber(self.DEFAULT_SPEED,
                                                   self.tr('Default speed (km/h)'),
                                                   QgsProcessingParameterNumber.Double,
                                                   5.0, False, 0))
        params.append(QgsProcessingParameterDistance(self.TOLERANCE,
                                                     self.tr('Topology tolerance'),
                                                     0.0, self.INPUT, False, 0))
        params.append(QgsProcessingParameterBoolean(self.INCLUDE_BOUNDS,
                                                    self.tr('Include upper/lower bound points'),
                                                    defaultValue=False))

        for p in params:
            p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
            self.addParameter(p)

        lines_output = QgsProcessingParameterFeatureSink(self.OUTPUT_LINES,
                                                         self.tr('Service area (lines)'),
                                                         QgsProcessing.TypeVectorLine, optional=True)
        lines_output.setCreateByDefault(True)
        self.addParameter(lines_output)

        nodes_output = QgsProcessingParameterFeatureSink(self.OUTPUT,
                                                         self.tr('Service area (boundary nodes)'),
                                                         QgsProcessing.TypeVectorPoint, optional=True)
        nodes_output.setCreateByDefault(False)
        self.addParameter(nodes_output)
Example #55
0
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT,
                                              self.tr('Input layer')))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND,
                                       self.tr('Band number'),
                                       parentLayerParameterName=self.INPUT))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.INTERVAL,
                self.tr('Interval between contour lines'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=10.0))
        self.addParameter(
            QgsProcessingParameterString(
                self.FIELD_NAME,
                self.
                tr('Attribute name (if not set, no elevation attribute is attached)'
                   ),
                defaultValue='ELEV',
                optional=True))

        create_3d_param = QgsProcessingParameterBoolean(
            self.CREATE_3D, self.tr('Produce 3D vector'), defaultValue=False)
        create_3d_param.setFlags(
            create_3d_param.flags()
            | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(create_3d_param)

        ignore_nodata_param = QgsProcessingParameterBoolean(
            self.IGNORE_NODATA,
            self.tr('Treat all raster values as valid'),
            defaultValue=False)
        ignore_nodata_param.setFlags(
            ignore_nodata_param.flags()
            | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(ignore_nodata_param)

        nodata_param = QgsProcessingParameterNumber(
            self.NODATA,
            self.tr('Input pixel value to treat as "nodata"'),
            type=QgsProcessingParameterNumber.Double,
            defaultValue=0.0,
            optional=True)
        nodata_param.setFlags(nodata_param.flags()
                              | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(nodata_param)

        offset_param = QgsProcessingParameterNumber(
            self.OFFSET,
            self.tr(
                'Offset from zero relative to which to interpret intervals'),
            type=QgsProcessingParameterNumber.Double,
            defaultValue=0.0,
            optional=True)
        nodata_param.setFlags(offset_param.flags()
                              | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(offset_param)

        self.addParameter(
            QgsProcessingParameterVectorDestination(
                self.OUTPUT, self.tr('Contours'),
                QgsProcessing.TypeVectorLine))
Example #56
0
    def defineCharacteristicsFromFile(self):
        """
        Create algorithm parameters and outputs from a text file.
        """
        with open(self.descriptionFile) as lines:
            # First line of the file is the Grass algorithm name
            line = lines.readline().strip('\n').strip()
            self.grass7Name = line
            # Second line if the algorithm name in Processing
            line = lines.readline().strip('\n').strip()
            self._name = line
            self._display_name = QCoreApplication.translate(
                "GrassAlgorithm", line)
            if " - " not in self._name:
                self._name = self.grass7Name + " - " + self._name
                self._display_name = self.grass7Name + " - " + self._display_name

            self._name = self._name[:self._name.find(' ')].lower()
            # Read the grass group
            line = lines.readline().strip('\n').strip()
            self._group = QCoreApplication.translate("GrassAlgorithm", line)
            self._groupId = self.groupIdRegex.search(line).group(0).lower()
            hasRasterOutput = False
            hasRasterInput = False
            hasVectorInput = False
            vectorOutputs = False
            # Then you have parameters/output definition
            line = lines.readline().strip('\n').strip()
            while line != '':
                try:
                    line = line.strip('\n').strip()
                    if line.startswith('Hardcoded'):
                        self.hardcodedStrings.append(line[len('Hardcoded|'):])
                    parameter = getParameterFromString(line)
                    if parameter is not None:
                        self.params.append(parameter)
                        if isinstance(parameter,
                                      QgsProcessingParameterVectorLayer):
                            hasVectorInput = True
                        elif isinstance(parameter,
                                        QgsProcessingParameterRasterLayer):
                            hasRasterInput = True
                        elif isinstance(parameter,
                                        QgsProcessingParameterMultipleLayers):
                            if parameter.layerType(
                            ) < 3 or parameter.layerType() == 5:
                                hasVectorInput = True
                            elif parameter.layerType() == 3:
                                hasRasterInput = True
                        elif isinstance(
                                parameter,
                                QgsProcessingParameterVectorDestination):
                            vectorOutputs = True
                        elif isinstance(
                                parameter,
                                QgsProcessingParameterRasterDestination):
                            hasRasterOutput = True
                    line = lines.readline().strip('\n').strip()
                except Exception as e:
                    QgsMessageLog.logMessage(
                        self.tr(
                            'Could not open GRASS GIS 7 algorithm: {0}\n{1}').
                        format(self.descriptionFile, line),
                        self.tr('Processing'), Qgis.Critical)
                    raise e

        param = QgsProcessingParameterExtent(
            self.GRASS_REGION_EXTENT_PARAMETER,
            self.tr('GRASS GIS 7 region extent'),
            optional=True)
        param.setFlags(param.flags()
                       | QgsProcessingParameterDefinition.FlagAdvanced)
        self.params.append(param)

        if hasRasterOutput or hasRasterInput:
            # Add a cellsize parameter
            param = QgsProcessingParameterNumber(
                self.GRASS_REGION_CELLSIZE_PARAMETER,
                self.tr('GRASS GIS 7 region cellsize (leave 0 for default)'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                maxValue=sys.float_info.max + 1,
                defaultValue=0.0)
            param.setFlags(param.flags()
                           | QgsProcessingParameterDefinition.FlagAdvanced)
            self.params.append(param)

        if hasRasterOutput:
            # Add a createopt parameter for format export
            param = QgsProcessingParameterString(
                self.GRASS_RASTER_FORMAT_OPT,
                self.tr('Output Rasters format options (createopt)'),
                multiLine=True,
                optional=True)
            param.setFlags(param.flags()
                           | QgsProcessingParameterDefinition.FlagAdvanced)
            self.params.append(param)

            # Add a metadata parameter for format export
            param = QgsProcessingParameterString(
                self.GRASS_RASTER_FORMAT_META,
                self.tr('Output Rasters format metadata options (metaopt)'),
                multiLine=True,
                optional=True)
            param.setFlags(param.flags()
                           | QgsProcessingParameterDefinition.FlagAdvanced)
            self.params.append(param)

        if hasVectorInput:
            param = QgsProcessingParameterNumber(
                self.GRASS_SNAP_TOLERANCE_PARAMETER,
                self.tr('v.in.ogr snap tolerance (-1 = no snap)'),
                type=QgsProcessingParameterNumber.Double,
                minValue=-1.0,
                maxValue=sys.float_info.max + 1,
                defaultValue=-1.0)
            param.setFlags(param.flags()
                           | QgsProcessingParameterDefinition.FlagAdvanced)
            self.params.append(param)
            param = QgsProcessingParameterNumber(
                self.GRASS_MIN_AREA_PARAMETER,
                self.tr('v.in.ogr min area'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                maxValue=sys.float_info.max + 1,
                defaultValue=0.0001)
            param.setFlags(param.flags()
                           | QgsProcessingParameterDefinition.FlagAdvanced)
            self.params.append(param)

        if vectorOutputs:
            param = QgsProcessingParameterEnum(
                self.GRASS_OUTPUT_TYPE_PARAMETER,
                self.tr('v.out.ogr output type'), self.OUTPUT_TYPES)
            param.setFlags(param.flags()
                           | QgsProcessingParameterDefinition.FlagAdvanced)
            self.params.append(param)
Example #57
0
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterFeatureSource(self.INPUT,
                                                self.tr('Layer to import')))

        db_param = QgsProcessingParameterString(
            self.DATABASE, self.tr('Database (connection name)'))
        db_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
            }
        })
        self.addParameter(db_param)

        schema_param = QgsProcessingParameterString(
            self.SCHEMA, self.tr('Schema (schema name)'), 'public', False,
            True)
        schema_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
                'connection_param': self.DATABASE
            }
        })
        self.addParameter(schema_param)

        table_param = QgsProcessingParameterString(
            self.TABLENAME,
            self.tr('Table to import to (leave blank to use layer name)'), '',
            False, True)
        table_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.gui.wrappers_postgis.TableWidgetWrapper',
                'schema_param': self.SCHEMA
            }
        })
        self.addParameter(table_param)

        self.addParameter(
            QgsProcessingParameterField(self.PRIMARY_KEY,
                                        self.tr('Primary key field'), None,
                                        self.INPUT,
                                        QgsProcessingParameterField.Any, False,
                                        True))
        self.addParameter(
            QgsProcessingParameterString(self.GEOMETRY_COLUMN,
                                         self.tr('Geometry column'), 'geom'))
        self.addParameter(
            QgsProcessingParameterString(self.ENCODING, self.tr('Encoding'),
                                         'UTF-8', False, True))
        self.addParameter(
            QgsProcessingParameterBoolean(self.OVERWRITE, self.tr('Overwrite'),
                                          True))
        self.addParameter(
            QgsProcessingParameterBoolean(self.CREATEINDEX,
                                          self.tr('Create spatial index'),
                                          True))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.LOWERCASE_NAMES,
                self.tr('Convert field names to lowercase'), True))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.DROP_STRING_LENGTH,
                self.tr('Drop length constraints on character fields'), False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.FORCE_SINGLEPART,
                self.tr('Create single-part geometries instead of multi-part'),
                False))
Example #58
0
    def initAlgorithm(self, config=None):
        self.units = [self.tr("Pixels"), self.tr("Georeferenced units")]

        self.addParameter(
            QgsProcessingParameterFeatureSource(self.INPUT,
                                                self.tr('Input layer')))
        self.addParameter(
            QgsProcessingParameterField(
                self.FIELD,
                self.tr('Field to use for a burn-in value'),
                None,
                self.INPUT,
                QgsProcessingParameterField.Numeric,
                optional=True))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.BURN,
                self.tr('A fixed value to burn'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=0.0,
                optional=True))
        self.addParameter(
            QgsProcessingParameterEnum(self.UNITS,
                                       self.tr('Output raster size units'),
                                       self.units))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.WIDTH,
                self.tr('Width/Horizontal resolution'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=0.0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.HEIGHT,
                self.tr('Height/Vertical resolution'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=0.0))
        self.addParameter(
            QgsProcessingParameterExtent(self.EXTENT,
                                         self.tr('Output extent')))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.NODATA,
                self.tr('Assign a specified nodata value to output bands'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=0.0,
                optional=True))

        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation parameters'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        dataType_param = QgsProcessingParameterEnum(
            self.DATA_TYPE,
            self.tr('Output data type'),
            self.TYPES,
            allowMultiple=False,
            defaultValue=5)
        dataType_param.setFlags(
            dataType_param.flags()
            | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(dataType_param)

        init_param = QgsProcessingParameterNumber(
            self.INIT,
            self.tr('Pre-initialize the output image with value'),
            type=QgsProcessingParameterNumber.Double,
            defaultValue=0.0,
            optional=True)
        init_param.setFlags(init_param.flags()
                            | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(init_param)

        invert_param = QgsProcessingParameterBoolean(
            self.INVERT, self.tr('Invert rasterization'), defaultValue=False)
        invert_param.setFlags(invert_param.flags()
                              | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(invert_param)

        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Rasterized')))
    def accept(self):
        description = self.nameTextBox.text()
        if description.strip() == '':
            QMessageBox.warning(self, self.tr('Unable to define parameter'),
                                self.tr('Invalid parameter name'))
            return
        if self.param is None:
            validChars = \
                'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
            safeName = ''.join(c for c in description if c in validChars)
            name = safeName.lower()
            i = 2
            while self.alg.parameterDefinition(name):
                name = safeName.lower() + str(i)
                i += 1
        else:
            name = self.param.name()
        if (self.paramType == parameters.PARAMETER_BOOLEAN
                or isinstance(self.param, QgsProcessingParameterBoolean)):
            self.param = QgsProcessingParameterBoolean(name, description,
                                                       self.state.isChecked())
        elif (self.paramType == parameters.PARAMETER_TABLE_FIELD
              or isinstance(self.param, QgsProcessingParameterField)):
            if self.parentCombo.currentIndex() < 0:
                QMessageBox.warning(
                    self, self.tr('Unable to define parameter'),
                    self.tr('Wrong or missing parameter values'))
                return
            parent = self.parentCombo.currentData()
            datatype = self.datatypeCombo.currentData()
            default = self.defaultTextBox.text()
            if not default:
                default = None
            self.param = QgsProcessingParameterField(
                name,
                description,
                defaultValue=default,
                parentLayerParameterName=parent,
                type=datatype,
                allowMultiple=self.multipleCheck.isChecked())
        elif (self.paramType == parameters.PARAMETER_BAND
              or isinstance(self.param, QgsProcessingParameterBand)):
            if self.parentCombo.currentIndex() < 0:
                QMessageBox.warning(
                    self, self.tr('Unable to define parameter'),
                    self.tr('Wrong or missing parameter values'))
                return
            parent = self.parentCombo.currentData()
            self.param = QgsProcessingParameterBand(name, description, None,
                                                    parent)
        elif (self.paramType == parameters.PARAMETER_MAP_LAYER
              or isinstance(self.param, QgsProcessingParameterMapLayer)):
            self.param = QgsProcessingParameterMapLayer(name, description)
        elif (self.paramType == parameters.PARAMETER_RASTER
              or isinstance(self.param, QgsProcessingParameterRasterLayer)):
            self.param = QgsProcessingParameterRasterLayer(name, description)
        elif (self.paramType == parameters.PARAMETER_TABLE
              or isinstance(self.param, QgsProcessingParameterVectorLayer)):
            self.param = QgsProcessingParameterVectorLayer(
                name, description, [self.shapetypeCombo.currentData()])
        elif (self.paramType == parameters.PARAMETER_VECTOR
              or isinstance(self.param, QgsProcessingParameterFeatureSource)):
            self.param = QgsProcessingParameterFeatureSource(
                name, description, [self.shapetypeCombo.currentData()])
        elif (self.paramType == parameters.PARAMETER_MULTIPLE
              or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
            self.param = QgsProcessingParameterMultipleLayers(
                name, description, self.datatypeCombo.currentData())
        elif (self.paramType == parameters.PARAMETER_NUMBER or isinstance(
                self.param,
            (QgsProcessingParameterNumber, QgsProcessingParameterDistance))):
            try:
                self.param = QgsProcessingParameterNumber(
                    name, description, QgsProcessingParameterNumber.Double,
                    self.defaultTextBox.text())
                vmin = self.minTextBox.text().strip()
                if not vmin == '':
                    self.param.setMinimum(float(vmin))
                vmax = self.maxTextBox.text().strip()
                if not vmax == '':
                    self.param.setMaximum(float(vmax))
            except:
                QMessageBox.warning(
                    self, self.tr('Unable to define parameter'),
                    self.tr('Wrong or missing parameter values'))
                return
        elif (self.paramType == parameters.PARAMETER_EXPRESSION
              or isinstance(self.param, QgsProcessingParameterExpression)):
            parent = self.parentCombo.currentData()
            self.param = QgsProcessingParameterExpression(
                name, description, str(self.defaultEdit.expression()), parent)
        elif (self.paramType == parameters.PARAMETER_STRING
              or isinstance(self.param, QgsProcessingParameterString)):
            self.param = QgsProcessingParameterString(
                name, description, str(self.defaultTextBox.text()))
        elif (self.paramType == parameters.PARAMETER_EXTENT
              or isinstance(self.param, QgsProcessingParameterExtent)):
            self.param = QgsProcessingParameterExtent(name, description)
        elif (self.paramType == parameters.PARAMETER_FILE
              or isinstance(self.param, QgsProcessingParameterFile)):
            isFolder = self.fileFolderCombo.currentIndex() == 1
            self.param = QgsProcessingParameterFile(
                name, description, QgsProcessingParameterFile.Folder
                if isFolder else QgsProcessingParameterFile.File)
        elif (self.paramType == parameters.PARAMETER_POINT
              or isinstance(self.param, QgsProcessingParameterPoint)):
            self.param = QgsProcessingParameterPoint(
                name, description, str(self.defaultTextBox.text()))
        elif (self.paramType == parameters.PARAMETER_CRS
              or isinstance(self.param, QgsProcessingParameterCrs)):
            self.param = QgsProcessingParameterCrs(
                name, description,
                self.selector.crs().authid())
        elif (self.paramType == parameters.PARAMETER_ENUM
              or isinstance(self.param, QgsProcessingParameterEnum)):
            self.param = QgsProcessingParameterEnum(
                name, description, self.widget.options(),
                self.widget.allowMultiple(), self.widget.defaultOptions())
        elif (self.paramType == parameters.PARAMETER_MATRIX
              or isinstance(self.param, QgsProcessingParameterMatrix)):
            self.param = QgsProcessingParameterMatrix(
                name,
                description,
                hasFixedNumberRows=self.widget.fixedRows(),
                headers=self.widget.headers(),
                defaultValue=self.widget.value())

        # Destination parameter
        elif (isinstance(self.param, QgsProcessingParameterFeatureSink)):
            self.param = QgsProcessingParameterFeatureSink(
                name=name,
                description=self.param.description(),
                type=self.param.dataType(),
                defaultValue=self.defaultWidget.getValue())
        elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
            self.param = QgsProcessingParameterFileDestination(
                name=name,
                description=self.param.description(),
                fileFilter=self.param.fileFilter(),
                defaultValue=self.defaultWidget.getValue())
        elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
            self.param = QgsProcessingParameterFolderDestination(
                name=name,
                description=self.param.description(),
                defaultValue=self.defaultWidget.getValue())
        elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
            self.param = QgsProcessingParameterRasterDestination(
                name=name,
                description=self.param.description(),
                defaultValue=self.defaultWidget.getValue())
        elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
            self.param = QgsProcessingParameterVectorDestination(
                name=name,
                description=self.param.description(),
                type=self.param.dataType(),
                defaultValue=self.defaultWidget.getValue())

        else:
            if self.paramType:
                typeId = self.paramType
            else:
                typeId = self.param.type()

            paramTypeDef = QgsApplication.instance().processingRegistry(
            ).parameterType(typeId)
            if not paramTypeDef:
                msg = self.tr(
                    'The parameter `{}` is not registered, are you missing a required plugin?'
                    .format(typeId))
                raise UndefinedParameterException(msg)
            self.param = paramTypeDef.create(name)
            self.param.setDescription(description)
            self.param.setMetadata(paramTypeDef.metadata())

        if not self.requiredCheck.isChecked():
            self.param.setFlags(
                self.param.flags()
                | QgsProcessingParameterDefinition.FlagOptional)
        else:
            self.param.setFlags(
                self.param.flags()
                & ~QgsProcessingParameterDefinition.FlagOptional)

        settings = QgsSettings()
        settings.setValue(
            "/Processing/modelParametersDefinitionDialogGeometry",
            self.saveGeometry())

        QDialog.accept(self)
Example #60
0
    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT,
                                              self.tr('Input layer')))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND,
                                       self.tr('Band number'),
                                       parentLayerParameterName=self.INPUT))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.Z_FACTOR,
                self.tr('Z factor (vertical exaggeration)'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=1.0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.SCALE,
                self.tr('Scale (ratio of vertical units to horizontal)'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=1.0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.AZIMUTH,
                self.tr('Azimuth of the light'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                maxValue=360,
                defaultValue=315.0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.ALTITUDE,
                self.tr('Altitude of the light'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=45.0))
        self.addParameter(
            QgsProcessingParameterBoolean(self.COMPUTE_EDGES,
                                          self.tr('Compute edges'),
                                          defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.ZEVENBERGEN,
                self.
                tr("Use Zevenbergen&Thorne formula instead of the Horn's one"),
                defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(self.COMBINED,
                                          self.tr("Combined shading"),
                                          defaultValue=False))
        self.addParameter(
            QgsProcessingParameterBoolean(self.MULTIDIRECTIONAL,
                                          self.tr("Multidirectional shading"),
                                          defaultValue=False))

        options_param = QgsProcessingParameterString(
            self.OPTIONS,
            self.tr('Additional creation parameters'),
            defaultValue='',
            optional=True)
        options_param.setFlags(options_param.flags()
                               | QgsProcessingParameterDefinition.FlagAdvanced)
        options_param.setMetadata({
            'widget_wrapper': {
                'class':
                'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
            }
        })
        self.addParameter(options_param)

        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Hillshade')))