Пример #1
0
    def __init__(self, name='', description='', layersData=None, extent=None, minValue=None, default=None, optional=False):
        QgsProcessingParameterNumber.__init__(self, name, description, QgsProcessingParameterNumber.Double, default, optional, minValue)
        self.setMetadata({
            'widget_wrapper': 'processing.algs.qgis.ui.InterpolationWidgets.PixelSizeWidgetWrapper'
        })

        self.layersData = layersData
        self.extent = extent
        self.layers = []
Пример #2
0
    def initParameters(self, config=None):
        self.addParameter(QgsProcessingParameterNumber(self.ANGLE_TOLERANCE,
                                                       self.tr('Maximum angle tolerance (degrees)'),
                                                       type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0, maxValue=45.0, defaultValue=15.0))

        max_iterations = QgsProcessingParameterNumber(self.MAX_ITERATIONS,
                                                      self.tr('Maximum algorithm iterations'),
                                                      type=QgsProcessingParameterNumber.Integer,
                                                      minValue=1, maxValue=10000, defaultValue=1000)
        max_iterations.setFlags(max_iterations.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(max_iterations)
Пример #3
0
    def initAlgorithm(self, config=None):

        self.addParameter(ParameterInterpolationData(self.INTERPOLATION_DATA,
                                                     self.tr('Input layer(s)')))
        self.addParameter(QgsProcessingParameterNumber(self.DISTANCE_COEFFICIENT,
                                                       self.tr('Distance coefficient P'), type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0, maxValue=99.99, defaultValue=2.0))
        self.addParameter(QgsProcessingParameterExtent(self.EXTENT,
                                                       self.tr('Extent'),
                                                       optional=False))
        pixel_size_param = ParameterPixelSize(self.PIXEL_SIZE,
                                              self.tr('Output raster size'),
                                              layersData=self.INTERPOLATION_DATA,
                                              extent=self.EXTENT,
                                              minValue=0.0,
                                              default=0.1)
        self.addParameter(pixel_size_param)

        cols_param = QgsProcessingParameterNumber(self.COLUMNS,
                                                  self.tr('Number of columns'),
                                                  optional=True,
                                                  minValue=0, maxValue=10000000)
        cols_param.setFlags(cols_param.flags() | QgsProcessingParameterDefinition.FlagHidden)
        self.addParameter(cols_param)

        rows_param = QgsProcessingParameterNumber(self.ROWS,
                                                  self.tr('Number of rows'),
                                                  optional=True,
                                                  minValue=0, maxValue=10000000)
        rows_param.setFlags(rows_param.flags() | QgsProcessingParameterDefinition.FlagHidden)
        self.addParameter(rows_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Interpolated')))
Пример #4
0
 def initParameters(self, config=None):
     m_param = QgsProcessingParameterNumber(self.M_VALUE,
                                            self.tr('M Value'), QgsProcessingParameterNumber.Double, defaultValue=0.0)
     m_param.setIsDynamic(True)
     m_param.setDynamicLayerParameterName('INPUT')
     m_param.setDynamicPropertyDefinition(QgsPropertyDefinition(self.M_VALUE, self.tr("M Value"), QgsPropertyDefinition.Double))
     self.addParameter(m_param)
Пример #5
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))
Пример #6
0
    def initAlgorithm(self, config=None):
        self.METHODS = [self.tr('Linear'),
                        self.tr('Clough-Toucher (cubic)')
                        ]

        self.addParameter(ParameterInterpolationData(self.INTERPOLATION_DATA,
                                                     self.tr('Input layer(s)')))
        self.addParameter(QgsProcessingParameterEnum(self.METHOD,
                                                     self.tr('Interpolation method'),
                                                     options=self.METHODS,
                                                     defaultValue=0))
        self.addParameter(QgsProcessingParameterExtent(self.EXTENT,
                                                       self.tr('Extent'),
                                                       optional=False))
        pixel_size_param = ParameterPixelSize(self.PIXEL_SIZE,
                                              self.tr('Output raster size'),
                                              layersData=self.INTERPOLATION_DATA,
                                              extent=self.EXTENT,
                                              minValue=0.0,
                                              default=0.1)
        self.addParameter(pixel_size_param)

        cols_param = QgsProcessingParameterNumber(self.COLUMNS,
                                                  self.tr('Number of columns'),
                                                  optional=True,
                                                  minValue=0, maxValue=10000000)
        cols_param.setFlags(cols_param.flags() | QgsProcessingParameterDefinition.FlagHidden)
        self.addParameter(cols_param)

        rows_param = QgsProcessingParameterNumber(self.ROWS,
                                                  self.tr('Number of rows'),
                                                  optional=True,
                                                  minValue=0, maxValue=10000000)
        rows_param.setFlags(rows_param.flags() | QgsProcessingParameterDefinition.FlagHidden)
        self.addParameter(rows_param)

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

        triangulation_file_param = QgsProcessingParameterFeatureSink(self.TRIANGULATION,
                                                                     self.tr('Triangulation'),
                                                                     type=QgsProcessing.TypeVectorLine,
                                                                     optional=True)
        triangulation_file_param.setCreateByDefault(False)
        self.addParameter(triangulation_file_param)
Пример #7
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')))
Пример #8
0
    def add_bottom_parameters(self):
        parameter = QgsProcessingParameterNumber(
            self.TIMEOUT, tr('Timeout'), defaultValue=25, minValue=5)
        parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(parameter)

        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)

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

        self.addOutput(
            QgsProcessingOutputString(
                self.OUTPUT_OQL_QUERY, tr('Raw query as OQL')))
Пример #9
0
 def __init__(self, name='', description='', parent_layer=None, radius_param=None, radius_field_param=None, minValue=None,
              default=None, optional=False):
     QgsProcessingParameterNumber.__init__(self, name, description, QgsProcessingParameterNumber.Double, default, optional, minValue)
     self.parent_layer = parent_layer
     self.radius_param = radius_param
     self.radius_field_param = radius_field_param
Пример #10
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)')))
Пример #11
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 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(QgsProcessingParameterFeatureSource(self.START_POINTS,
                                                              self.tr('Start Points'),
                                                              [QgsProcessing.TypeVectorPoint]))
        self.addParameter(QgsProcessingParameterField(self.ID_FIELD,
                                                       self.tr('Unique Point ID Field'),
                                                       None,
                                                       self.START_POINTS,
                                                       optional=False))
        self.addParameter(QgsProcessingParameterNumber(self.MAX_DIST,
                                                   self.tr('Size of Iso-Area (distance or time value)'),
                                                   QgsProcessingParameterNumber.Double,
                                                   2500.0, False, 0, 99999999.99))
        self.addParameter(QgsProcessingParameterNumber(self.INTERVAL,
                                                   self.tr('Contour Interval (distance or time value)'),
                                                   QgsProcessingParameterNumber.Double,
                                                   500.0, False, 0, 99999999.99))
        self.addParameter(QgsProcessingParameterNumber(self.CELL_SIZE,
                                                    self.tr('Cellsize of interpolation raster'),
                                                    QgsProcessingParameterNumber.Integer,
                                                    10, False, 1, 99999999))
        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.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT_INTERPOLATION, self.tr('Output Interpolation')))
        self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT_POLYGONS, self.tr('Output Polygon'), QgsProcessing.TypeVectorPolygon))
Пример #13
0
    def initAlgorithm(self, config=None):

        self.bandlist = [
            'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10',
            'B11', 'B12'
        ]
        self.combinations = [
            'True color', 'False color', 'False color (urban)', 'SWIR',
            'Custom'
        ]
        self.combi_dict = {
            'True color': ['B4', 'B3', 'B2'],
            'False color': ['B8', 'B4', 'B3'],
            'False color (urban)': ['B12', 'B11', 'B4'],
            'SWIR': ['B12', 'B8A', 'B4'],
            'Custom': ['B12', 'B8', 'B4']
        }
        self.addParameter(
            QgsProcessingParameterExtent(self.EXTENT, 'Mosaic extent:'))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.DATEFROMPOINT,
                'Get dates interval from points layer.',
                defaultValue=False,
                optional=False))
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT,
                'Points layer:',
                types=[QgsProcessing.TypeVectorPoint],
                optional=True))
        #self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, 'Points layer:', types=[QgsProcessing.TypeVectorPoint], optional=False))
        self.addParameter(
            QgsProcessingParameterDateTime(self.DATE,
                                           'Date (last date for mosaic):',
                                           type=1))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.INTERVAL_B,
                'Interval before (days before "Date"):',
                defaultValue=0,
                optional=False,
                minValue=0,
                maxValue=90))
        self.addParameter(
            QgsProcessingParameterNumber(self.INTERVAL_A,
                                         'Interval after (days after "Date"):',
                                         defaultValue=0,
                                         optional=False,
                                         minValue=0,
                                         maxValue=90))
        self.addParameter(
            QgsProcessingParameterBoolean(self.SINGLEDATE,
                                          'Generate single-date layers.',
                                          defaultValue=True,
                                          optional=False))
        self.addParameter(
            QgsProcessingParameterBoolean(self.COMPOSITE,
                                          'Generate composite layer.',
                                          defaultValue=False,
                                          optional=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.PREYEAR,
                'Generate composite layer for previous year.',
                defaultValue=False,
                optional=False))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.POSTYEAR,
                'Generate composite layer for following year.',
                defaultValue=False,
                optional=False))
        self.addParameter(
            QgsProcessingParameterString(self.PREFIX,
                                         'Layer prefix:',
                                         optional=True))
        self.addParameter(
            QgsProcessingParameterEnum(self.COMBI,
                                       'Channels combination:',
                                       self.combinations,
                                       defaultValue=4))
        self.addParameter(
            QgsProcessingParameterEnum(self.BAND1,
                                       'Band1 (red):',
                                       self.bandlist,
                                       defaultValue=12))
        self.addParameter(
            QgsProcessingParameterEnum(self.BAND2,
                                       'Band2 (green):',
                                       self.bandlist,
                                       defaultValue=7))
        self.addParameter(
            QgsProcessingParameterEnum(self.BAND3,
                                       'Band3 (blue):',
                                       self.bandlist,
                                       defaultValue=3))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.CLOUDFILTERS,
                'Apply cloud filter for sinlelayers.',
                defaultValue=True,
                optional=False))
        self.addParameter(
            QgsProcessingParameterNumber(self.CLOUDS,
                                         'Cloudness for sinlelayers:',
                                         defaultValue=25,
                                         optional=False,
                                         minValue=0,
                                         maxValue=100))
        self.addParameter(
            QgsProcessingParameterBoolean(
                self.CLOUDFILTERC,
                'Apply cloud filter for composite layers.',
                defaultValue=True,
                optional=False))
        self.addParameter(
            QgsProcessingParameterNumber(self.CLOUDC,
                                         'Cloudness for composite layers:',
                                         defaultValue=1,
                                         optional=False,
                                         minValue=0,
                                         maxValue=100))
        self.addParameter(
            QgsProcessingParameterNumber(self.VIS_MIN,
                                         'Vis_min:',
                                         defaultValue=30,
                                         optional=False,
                                         minValue=0,
                                         maxValue=10000))
        self.addParameter(
            QgsProcessingParameterNumber(self.VIS_MAX,
                                         'Vis_max:',
                                         defaultValue=7000,
                                         optional=False,
                                         minValue=0,
                                         maxValue=10000))
        self.addParameter(
            QgsProcessingParameterBoolean(self.VISIBLE,
                                          'Make result layer visible.',
                                          defaultValue=True,
                                          optional=False))
    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 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 (IDW with NN search)')))
    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)
Пример #16
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(
            QgsProcessingParameterFeatureSource(
                self.START_POINTS, self.tr('Vector layer with start points'),
                [QgsProcessing.TypeVectorPoint]))
        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,
                99999999.99))

        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.addParameter(
            QgsProcessingParameterFeatureSink(
                self.OUTPUT, self.tr('Service area (boundary nodes)'),
                QgsProcessing.TypeVectorPoint))
Пример #17
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)')))
Пример #18
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')))
Пример #19
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')))
Пример #20
0
 def initParameters(self, config=None):
     self.addParameter(
         QgsProcessingParameterNumber(
             self.INTERVAL, self.tr('Interval between vertices to add'),
             QgsProcessingParameterNumber.Double, 1, False, 0, 10000000))
Пример #21
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._short_description = line
            if " - " not in line:
                self._name = self.grass7Name
            else:
                self._name = line[:line.find(' ')].lower()
            self._display_name = self._name
            # 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,
                                       QgsProcessingParameterFeatureSource)):
                            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:
            # Add an optional output type
            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)

            # Add a DSCO parameter for format export
            param = QgsProcessingParameterString(
                self.GRASS_VECTOR_DSCO,
                self.tr('v.out.ogr output data source options (dsco)'),
                multiLine=True,
                optional=True)
            param.setFlags(param.flags()
                           | QgsProcessingParameterDefinition.FlagAdvanced)
            self.params.append(param)

            # Add a LCO parameter for format export
            param = QgsProcessingParameterString(
                self.GRASS_VECTOR_LCO,
                self.tr('v.out.ogr output layer options (lco)'),
                multiLine=True,
                optional=True)
            param.setFlags(param.flags()
                           | QgsProcessingParameterDefinition.FlagAdvanced)
            self.params.append(param)
Пример #22
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')))
Пример #23
0
 def initParameters(self, config=None):
     self.addParameter(
         QgsProcessingParameterNumber(
             self.MIN_AREA, self.tr('Remove holes with area less than'),
             QgsProcessingParameterNumber.Double, 0, True, 0.0, 10000000.0))
Пример #24
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))

        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)')))
Пример #25
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')))
Пример #26
0
 def initAlgorithm(self, config):
     self.addParameter(
         QgsProcessingParameterFeatureSource(
             self.PrmInputLayer, tr('Input point vector layer'),
             [QgsProcessing.TypeVectorPoint]))
     self.addParameter(
         QgsProcessingParameterEnum(self.PrmOutputFormat,
                                    tr('Output coordinate format'),
                                    options=[
                                        tr('Coordinates in 2 fields'),
                                        tr('Coordinates in 1 field'),
                                        tr('GeoJSON'),
                                        tr('WKT'),
                                        tr('MGRS'),
                                        tr('Plus Codes'),
                                        tr('Geohash'),
                                        tr('Standard UTM'),
                                        tr('Maidenhead grid locator')
                                    ],
                                    defaultValue=0,
                                    optional=False))
     self.addParameter(
         QgsProcessingParameterString(
             self.PrmYFieldName,
             tr('Name for the field containing both coordinates, or the Y (latitude) coordinate'
                ),
             defaultValue='y',
             optional=False))
     self.addParameter(
         QgsProcessingParameterString(
             self.PrmXFieldName,
             tr('Name of the field containing the X (longitude) portion of the coordinate'
                ),
             defaultValue='x',
             optional=True))
     self.addParameter(
         QgsProcessingParameterEnum(
             self.PrmCoordinateOrder,
             tr('Coordinate order when using 1 field'),
             options=[
                 tr('Lat,Lon (Y,X) - Google map order'),
                 tr('Lon,Lat (X,Y) order')
             ],
             defaultValue=0,
             optional=True))
     self.addParameter(
         QgsProcessingParameterString(
             self.PrmCoordinateDelimiter,
             tr('Delimiter between coordinates when using 1 field'),
             defaultValue=',',
             optional=True))
     self.addParameter(
         QgsProcessingParameterEnum(
             self.PrmOutputCRSType,
             tr('Output CRS of coordinates added to a field'),
             options=[
                 tr('WGS 84'),
                 tr('Layer CRS'),
                 tr('Project CRS'),
                 tr('Custom CRS')
             ],
             defaultValue=0,
             optional=True))
     self.addParameter(
         QgsProcessingParameterCrs(
             self.PrmCustomCRS,
             tr('Custom CRS for coordinates added to a field'),
             'EPSG:4326',
             optional=True))
     self.addParameter(
         QgsProcessingParameterEnum(
             self.PrmWgs84NumberFormat,
             tr('Select Decimal or DMS degress for WGS 84 numbers'),
             options=[
                 tr('Decimal degrees'),
                 tr('D°M\'S"'),
                 tr('D°M.MM\''),
                 tr('DDMMSS')
             ],
             defaultValue=0,
             optional=True))
     self.addParameter(
         QgsProcessingParameterBoolean(
             self.PrmDmsAddSpace,
             tr('Add space between D° M\' S" and D° M.MM\' numbers'),
             False,
             optional=True))
     self.addParameter(
         QgsProcessingParameterBoolean(
             self.PrmDmsPadWithSpace,
             tr('Pad D°M\'S" and D°M.MM\' ccoordinates with leading zeros'),
             False,
             optional=True))
     self.addParameter(
         QgsProcessingParameterNumber(
             self.PrmCoordinatePrecision,
             tr('Decimal number precision'),
             type=QgsProcessingParameterNumber.Integer,
             defaultValue=8,
             optional=True,
             minValue=0))
     self.addParameter(
         QgsProcessingParameterNumber(
             self.PrmDmsSecondPrecision,
             tr('DMS / Degrees Minutes / UTM precision'),
             type=QgsProcessingParameterNumber.Integer,
             defaultValue=0,
             optional=True,
             minValue=0))
     self.addParameter(
         QgsProcessingParameterNumber(
             self.PrmPlusCodesLength,
             tr('Plus Codes length'),
             type=QgsProcessingParameterNumber.Integer,
             defaultValue=11,
             optional=True,
             minValue=10,
             maxValue=20))
     self.addParameter(
         QgsProcessingParameterNumber(
             self.PrmGeohashPrecision,
             tr('Geohash precision'),
             type=QgsProcessingParameterNumber.Integer,
             defaultValue=12,
             optional=True,
             minValue=1,
             maxValue=30))
     self.addParameter(
         QgsProcessingParameterNumber(
             self.PrmMaidenheadPrecision,
             tr('Maidenhead grid locator precision'),
             type=QgsProcessingParameterNumber.Integer,
             defaultValue=3,
             optional=True,
             minValue=1,
             maxValue=4))
     self.addParameter(
         QgsProcessingParameterFeatureSink(self.PrmOutputLayer,
                                           tr('Output layer')))
Пример #27
0
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Input layer'), [QgsProcessing.TypeVectorPoint]))
        self.addParameter(QgsProcessingParameterNumber(self.BUFFER, self.tr('Buffer region'), type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0, maxValue=9999999999, defaultValue=0.0))

        self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Voronoi polygons'), type=QgsProcessing.TypeVectorPolygon))
Пример #28
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.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(
            QgsProcessingParameterEnum(self.RESAMPLING,
                                       self.tr('Resampling method to use'),
                                       options=[i[0] for i in self.methods],
                                       defaultValue=0))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.NODATA,
                self.tr('Nodata value for output bands'),
                type=QgsProcessingParameterNumber.Double,
                defaultValue=None,
                optional=True))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.TARGET_RESOLUTION,
                self.tr(
                    'Output file resolution in target georeferenced units'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                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)

        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)

        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('Reprojected')))
Пример #29
0
 def __init__(self, name='', description='', parent_layer=None, radius_param=None, radius_field_param=None, minValue=None,
              default=None, optional=False):
     QgsProcessingParameterNumber.__init__(self, name, description, QgsProcessingParameterNumber.Double, default, optional, minValue)
     self.parent_layer = parent_layer
     self.radius_param = radius_param
     self.radius_field_param = radius_field_param
Пример #30
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 parameters'),
            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)
Пример #31
0
    def initAlgorithm(self, config=None):

        self.addParameter(ParameterInterpolationData(self.INTERPOLATION_DATA,
                                                     self.tr('Input layer(s)')))
        self.addParameter(QgsProcessingParameterNumber(self.DISTANCE_COEFFICIENT,
                                                       self.tr('Distance coefficient P'), type=QgsProcessingParameterNumber.Double,
                                                       minValue=0.0, maxValue=99.99, defaultValue=2.0))
        self.addParameter(QgsProcessingParameterExtent(self.EXTENT,
                                                       self.tr('Extent'),
                                                       optional=False))
        pixel_size_param = ParameterPixelSize(self.PIXEL_SIZE,
                                              self.tr('Output raster size'),
                                              layersData=self.INTERPOLATION_DATA,
                                              extent=self.EXTENT,
                                              minValue=0.0,
                                              default=0.1)
        self.addParameter(pixel_size_param)

        cols_param = QgsProcessingParameterNumber(self.COLUMNS,
                                                  self.tr('Number of columns'),
                                                  optional=True,
                                                  minValue=0, maxValue=10000000)
        cols_param.setFlags(cols_param.flags() | QgsProcessingParameterDefinition.FlagHidden)
        self.addParameter(cols_param)

        rows_param = QgsProcessingParameterNumber(self.ROWS,
                                                  self.tr('Number of rows'),
                                                  optional=True,
                                                  minValue=0, maxValue=10000000)
        rows_param.setFlags(rows_param.flags() | QgsProcessingParameterDefinition.FlagHidden)
        self.addParameter(rows_param)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                                  self.tr('Interpolated')))
Пример #32
0
 def initParameters(self, config=None):
     self.addParameter(
         QgsProcessingParameterNumber(self.Z_VALUE,
                                      self.tr('Z Value'),
                                      QgsProcessingParameterNumber.Double,
                                      defaultValue=0.0))
Пример #33
0
    def initAlgorithm(self, config=None):
        class ParameterRasterCalculatorExpression(QgsProcessingParameterString
                                                  ):
            def __init__(self, name='', description='', multiLine=False):
                super().__init__(name, description, multiLine=multiLine)
                self.setMetadata({
                    'widget_wrapper':
                    'processing.algs.qgis.ui.RasterCalculatorWidgets.ExpressionWidgetWrapper'
                })

            def type(self):
                return 'raster_calc_expression'

            def clone(self):
                return ParameterRasterCalculatorExpression(
                    self.name(), self.description(), self.multiLine())

            def evaluateForModeler(self, value, model):
                for i in list(model.inputs.values()):
                    param = i.param
                    if isinstance(param, QgsProcessingParameterRasterLayer):
                        new = "{}@".format(os.path.basename(param.value))
                        old = "{}@".format(param.name())
                        value = value.replace(old, new)

                    for alg in list(model.algs.values()):
                        for out in alg.algorithm.outputs:
                            if isinstance(out, QgsProcessingOutputRasterLayer):
                                if out.value:
                                    new = "{}@".format(
                                        os.path.basename(out.value))
                                    old = "{}:{}@".format(
                                        alg.modeler_name, out.name)
                                    value = value.replace(old, new)
                return value

        self.addParameter(
            ParameterRasterCalculatorExpression(self.EXPRESSION,
                                                self.tr('Expression'),
                                                multiLine=True))
        self.addParameter(
            QgsProcessingParameterMultipleLayers(
                self.LAYERS,
                self.
                tr('Reference layer(s) (used for automated extent, cellsize, and CRS)'
                   ),
                layerType=QgsProcessing.TypeRaster,
                optional=True))
        self.addParameter(
            QgsProcessingParameterNumber(
                self.CELLSIZE,
                self.tr('Cell size (use 0 or empty to set it automatically)'),
                type=QgsProcessingParameterNumber.Double,
                minValue=0.0,
                defaultValue=0.0,
                optional=True))
        self.addParameter(
            QgsProcessingParameterExtent(self.EXTENT,
                                         self.tr('Output extent'),
                                         optional=True))
        self.addParameter(
            QgsProcessingParameterCrs(self.CRS, 'Output CRS', optional=True))
        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Output')))
Пример #34
0
 def initAlgorithm(self, config):
     self.addParameter(
         QgsProcessingParameterFeatureSource(
             self.PrmInputLayer,
             tr('Input point layer'),
             [QgsProcessing.TypeVectorPoint])
     )
     self.addParameter(
         QgsProcessingParameterEnum(
             self.PrmShapeType,
             tr('Shape type'),
             options=SHAPE_TYPE,
             defaultValue=0,
             optional=False)
     )
     self.addParameter(
         QgsProcessingParameterEnum(
             self.PrmAzimuthMode,
             tr('Azimuth mode'),
             options=[tr('Use beginning and ending azimuths'), tr('Use center azimuth and width')],
             defaultValue=1,
             optional=False)
     )
     self.addParameter(
         QgsProcessingParameterField(
             self.PrmAzimuth1Field,
             tr('Starting azimuth field / Center azimuth field'),
             parentLayerParameterName=self.PrmInputLayer,
             type=QgsProcessingParameterField.Any,
             optional=True
         )
     )
     self.addParameter(
         QgsProcessingParameterField(
             self.PrmAzimuth2Field,
             tr('Ending azimuth field / Azimuth width field'),
             parentLayerParameterName=self.PrmInputLayer,
             type=QgsProcessingParameterField.Any,
             optional=True
         )
     )
     self.addParameter(
         QgsProcessingParameterField(
             self.PrmOuterRadiusField,
             tr('Outer radius field'),
             parentLayerParameterName=self.PrmInputLayer,
             type=QgsProcessingParameterField.Any,
             optional=True
         )
     )
     self.addParameter(
         QgsProcessingParameterField(
             self.PrmInnerRadiusField,
             tr('Inner radius field'),
             parentLayerParameterName=self.PrmInputLayer,
             type=QgsProcessingParameterField.Any,
             optional=True
         )
     )
     self.addParameter(
         QgsProcessingParameterEnum(
             self.PrmUnitsOfMeasure,
             tr('Radius units'),
             options=DISTANCE_LABELS,
             defaultValue=0,
             optional=False)
     )
     self.addParameter(
         QgsProcessingParameterNumber(
             self.PrmDefaultAzimuth1,
             tr('Default starting azimuth / Default center azimuth'),
             QgsProcessingParameterNumber.Double,
             defaultValue=0,
             optional=True)
     )
     self.addParameter(
         QgsProcessingParameterNumber(
             self.PrmDefaultAzimuth2,
             tr('Default ending azimuth / Default azimuth width'),
             QgsProcessingParameterNumber.Double,
             defaultValue=30.0,
             optional=True)
     )
     self.addParameter(
         QgsProcessingParameterNumber(
             self.PrmOuterRadius,
             tr('Default outer radius'),
             QgsProcessingParameterNumber.Double,
             defaultValue=40.0,
             minValue=0,
             optional=True)
     )
     self.addParameter(
         QgsProcessingParameterNumber(
             self.PrmInnerRadius,
             tr('Default inner radius'),
             QgsProcessingParameterNumber.Double,
             defaultValue=20.0,
             minValue=0,
             optional=True)
     )
     self.addParameter(
         QgsProcessingParameterNumber(
             self.PrmDrawingSegments,
             tr('Number of drawing segments'),
             QgsProcessingParameterNumber.Integer,
             defaultValue=36,
             minValue=4,
             optional=True)
     )
     self.addParameter(
         QgsProcessingParameterBoolean(
             self.PrmExportInputGeometry,
             tr('Add input geometry fields to output table'),
             False,
             optional=True)
     )
     self.addParameter(
         QgsProcessingParameterFeatureSink(
             self.PrmOutputLayer,
             tr('Output layer'))
     )
Пример #35
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')))
Пример #36
0
    def initAlgorithm(self, config=None):
        self.KERNELS = OrderedDict([(self.tr('Quartic'), QgsKernelDensityEstimation.KernelQuartic),
                                    (self.tr('Triangular'), QgsKernelDensityEstimation.KernelTriangular),
                                    (self.tr('Uniform'), QgsKernelDensityEstimation.KernelUniform),
                                    (self.tr('Triweight'), QgsKernelDensityEstimation.KernelTriweight),
                                    (self.tr('Epanechnikov'), QgsKernelDensityEstimation.KernelEpanechnikov)])

        self.OUTPUT_VALUES = OrderedDict([(self.tr('Raw'), QgsKernelDensityEstimation.OutputRaw),
                                          (self.tr('Scaled'), QgsKernelDensityEstimation.OutputScaled)])

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

        self.addParameter(QgsProcessingParameterDistance(self.RADIUS,
                                                         self.tr('Radius'),
                                                         100.0, self.INPUT, False, 0.0))

        radius_field_param = QgsProcessingParameterField(self.RADIUS_FIELD,
                                                         self.tr('Radius from field'),
                                                         None,
                                                         self.INPUT,
                                                         QgsProcessingParameterField.Numeric,
                                                         optional=True
                                                         )
        radius_field_param.setFlags(radius_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(radius_field_param)

        class ParameterHeatmapPixelSize(QgsProcessingParameterNumber):

            def __init__(self, name='', description='', parent_layer=None, radius_param=None, radius_field_param=None, minValue=None,
                         default=None, optional=False):
                QgsProcessingParameterNumber.__init__(self, name, description, QgsProcessingParameterNumber.Double, default, optional, minValue)
                self.parent_layer = parent_layer
                self.radius_param = radius_param
                self.radius_field_param = radius_field_param

            def clone(self):
                copy = ParameterHeatmapPixelSize(self.name(), self.description(), self.parent_layer, self.radius_param, self.radius_field_param, self.minimum(), self.maximum(), self.defaultValue((), self.flags() & QgsProcessingParameterDefinition.FlagOptional))
                return copy

        pixel_size_param = ParameterHeatmapPixelSize(self.PIXEL_SIZE,
                                                     self.tr('Output raster size'),
                                                     parent_layer=self.INPUT,
                                                     radius_param=self.RADIUS,
                                                     radius_field_param=self.RADIUS_FIELD,
                                                     minValue=0.0,
                                                     default=0.1)
        pixel_size_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.qgis.ui.HeatmapWidgets.HeatmapPixelSizeWidgetWrapper'}})
        self.addParameter(pixel_size_param)

        weight_field_param = QgsProcessingParameterField(self.WEIGHT_FIELD,
                                                         self.tr('Weight from field'),
                                                         None,
                                                         self.INPUT,
                                                         QgsProcessingParameterField.Numeric,
                                                         optional=True
                                                         )
        weight_field_param.setFlags(weight_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(weight_field_param)

        keys = list(self.KERNELS.keys())
        kernel_shape_param = QgsProcessingParameterEnum(self.KERNEL,
                                                        self.tr('Kernel shape'),
                                                        keys,
                                                        allowMultiple=False,
                                                        defaultValue=0)
        kernel_shape_param.setFlags(kernel_shape_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(kernel_shape_param)

        decay_ratio = QgsProcessingParameterNumber(self.DECAY,
                                                   self.tr('Decay ratio (Triangular kernels only)'),
                                                   QgsProcessingParameterNumber.Double,
                                                   0.0, True, -100.0, 100.0)
        decay_ratio.setFlags(decay_ratio.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(decay_ratio)

        keys = list(self.OUTPUT_VALUES.keys())
        output_scaling = QgsProcessingParameterEnum(self.OUTPUT_VALUE,
                                                    self.tr('Output value scaling'),
                                                    keys,
                                                    allowMultiple=False,
                                                    defaultValue=0)
        output_scaling.setFlags(output_scaling.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(output_scaling)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Heatmap')))
Пример #37
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))
Пример #38
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 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')))
Пример #39
0
    def initAlgorithm(self, config=None):
        self.KERNELS = OrderedDict([(self.tr('Quartic'), QgsKernelDensityEstimation.KernelQuartic),
                                    (self.tr('Triangular'), QgsKernelDensityEstimation.KernelTriangular),
                                    (self.tr('Uniform'), QgsKernelDensityEstimation.KernelUniform),
                                    (self.tr('Triweight'), QgsKernelDensityEstimation.KernelTriweight),
                                    (self.tr('Epanechnikov'), QgsKernelDensityEstimation.KernelEpanechnikov)])

        self.OUTPUT_VALUES = OrderedDict([(self.tr('Raw'), QgsKernelDensityEstimation.OutputRaw),
                                          (self.tr('Scaled'), QgsKernelDensityEstimation.OutputScaled)])

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

        self.addParameter(QgsProcessingParameterDistance(self.RADIUS,
                                                         self.tr('Radius'),
                                                         100.0, self.INPUT, False, 0.0))

        radius_field_param = QgsProcessingParameterField(self.RADIUS_FIELD,
                                                         self.tr('Radius from field'),
                                                         None,
                                                         self.INPUT,
                                                         QgsProcessingParameterField.Numeric,
                                                         optional=True
                                                         )
        radius_field_param.setFlags(radius_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(radius_field_param)

        class ParameterHeatmapPixelSize(QgsProcessingParameterNumber):

            def __init__(self, name='', description='', parent_layer=None, radius_param=None, radius_field_param=None, minValue=None,
                         default=None, optional=False):
                QgsProcessingParameterNumber.__init__(self, name, description, QgsProcessingParameterNumber.Double, default, optional, minValue)
                self.parent_layer = parent_layer
                self.radius_param = radius_param
                self.radius_field_param = radius_field_param

            def clone(self):
                copy = ParameterHeatmapPixelSize(self.name(), self.description(), self.parent_layer, self.radius_param, self.radius_field_param, self.minimum(), self.maximum(), self.defaultValue((), self.flags() & QgsProcessingParameterDefinition.FlagOptional))
                return copy

        pixel_size_param = ParameterHeatmapPixelSize(self.PIXEL_SIZE,
                                                     self.tr('Output raster size'),
                                                     parent_layer=self.INPUT,
                                                     radius_param=self.RADIUS,
                                                     radius_field_param=self.RADIUS_FIELD,
                                                     minValue=0.0,
                                                     default=0.1)
        pixel_size_param.setMetadata({
            'widget_wrapper': {
                'class': 'processing.algs.qgis.ui.HeatmapWidgets.HeatmapPixelSizeWidgetWrapper'}})
        self.addParameter(pixel_size_param)

        weight_field_param = QgsProcessingParameterField(self.WEIGHT_FIELD,
                                                         self.tr('Weight from field'),
                                                         None,
                                                         self.INPUT,
                                                         QgsProcessingParameterField.Numeric,
                                                         optional=True
                                                         )
        weight_field_param.setFlags(weight_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(weight_field_param)

        keys = list(self.KERNELS.keys())
        kernel_shape_param = QgsProcessingParameterEnum(self.KERNEL,
                                                        self.tr('Kernel shape'),
                                                        keys,
                                                        allowMultiple=False,
                                                        defaultValue=0)
        kernel_shape_param.setFlags(kernel_shape_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(kernel_shape_param)

        decay_ratio = QgsProcessingParameterNumber(self.DECAY,
                                                   self.tr('Decay ratio (Triangular kernels only)'),
                                                   QgsProcessingParameterNumber.Double,
                                                   0.0, True, -100.0, 100.0)
        decay_ratio.setFlags(decay_ratio.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(decay_ratio)

        keys = list(self.OUTPUT_VALUES.keys())
        output_scaling = QgsProcessingParameterEnum(self.OUTPUT_VALUE,
                                                    self.tr('Output value scaling'),
                                                    keys,
                                                    allowMultiple=False,
                                                    defaultValue=0)
        output_scaling.setFlags(output_scaling.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
        self.addParameter(output_scaling)

        self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Heatmap')))
Пример #40
0
 def initParameters(self, config=None):
     self.addParameter(
         QgsProcessingParameterNumber(self.VERTICES,
                                      self.tr('Vertices to add'),
                                      QgsProcessingParameterNumber.Integer,
                                      1, False, 1, 10000000))
Пример #41
0
 def initParameters(self, config=None):
     self.addParameter(QgsProcessingParameterNumber(self.START_DISTANCE,
                                                    self.tr('Start distance'), type=QgsProcessingParameterNumber.Double, defaultValue=0.0))
     self.addParameter(QgsProcessingParameterNumber(self.END_DISTANCE,
                                                    self.tr('End distance'), type=QgsProcessingParameterNumber.Double, defaultValue=0.0))