def initAlgorithm(self, config):
        self.addParameter(
            QgsProcessingParameterRasterLayer(
                self.PrmInput,
                tr('Input image'))
        )
        param = QgsProcessingParameterNumber(
            self.PrmNorthLatitude,
            tr('North latitude'),
            QgsProcessingParameterNumber.Double,
            defaultValue=0,
            optional=False)
        param.setMetadata({'widget_wrapper': { 'decimals': 14 }})
        self.addParameter(param)

        param = QgsProcessingParameterNumber(
            self.PrmSouthLatitude,
            tr('South latitude'),
            QgsProcessingParameterNumber.Double,
            defaultValue=0,
            optional=False)
        param.setMetadata({'widget_wrapper': { 'decimals': 14 }})
        self.addParameter(param)

        param = QgsProcessingParameterNumber(
            self.PrmEastLongitude,
            tr('East longitude'),
            QgsProcessingParameterNumber.Double,
            defaultValue=0,
            optional=False)
        param.setMetadata({'widget_wrapper': { 'decimals': 14 }})
        self.addParameter(param)

        param = QgsProcessingParameterNumber(
            self.PrmWestLongitude,
            tr('West longitude'),
            QgsProcessingParameterNumber.Double,
            defaultValue=0,
            optional=False)
        param.setMetadata({'widget_wrapper': { 'decimals': 14 }})
        self.addParameter(param)

        param = QgsProcessingParameterNumber(
            self.PrmRotation,
            tr('Rotation'),
            QgsProcessingParameterNumber.Double,
            defaultValue=0,
            optional=False)
        param.setMetadata({'widget_wrapper': { 'decimals': 14 }})
        self.addParameter(param)

        param=QgsProcessingParameterFileDestination(
            self.PrmOutputRaster,
            tr('Output GeoTIFF Image'),
            optional=False)
        param.setFileFilter('*.tif')
        self.addParameter(param)
コード例 #2
0
def test_freeform_metadata():
    param = QgsProcessingParameterNumber("TEST", "LiteralInteger",
                  type=QgsProcessingParameterNumber.Integer,
                  minValue=1, defaultValue=10)

    param.setMetadata({'meta1':'value1', 'meta2':'value2' })

    inp = parse_input_definition(param)
    assert get_metadata(inp,'processing:meta:meta1')[0].href == 'value1'
    assert get_metadata(inp,'processing:meta:meta2')[0].href == 'value2'
コード例 #3
0
    def initAlgorithm(self, config=None):
        # === INPUT PARAMETERS ===
        inputAscParam = QgsProcessingParameterRasterLayer(
            name=self.INPUT_LAYER_ASC, description=self.tr('Input layer asc'))

        inputAscParam.setMetadata({
            'widget_wrapper': {
                'class':
                'Chloe.chloe_algorithm_dialog.ChloeAscRasterWidgetWrapper'
            }
        })
        self.addParameter(inputAscParam)

        # ANALYZE TYPE

        analyzeTypeParam = QgsProcessingParameterEnum(
            name=self.ANALYZE_TYPE,
            description=self.tr('Analyze type'),
            options=self.types_of_analyze)

        analyzeTypeParam.setMetadata({
            'widget_wrapper': {
                'class':
                'Chloe.chloe_algorithm_dialog.ChloeEnumUpdateStateWidgetWrapper',
                'dependantWidgetConfig': [{
                    'paramName': self.DISTANCE_FUNCTION,
                    'enableValue': 1
                }]
            }
        })

        self.addParameter(analyzeTypeParam)

        # DISTANCE FUNCTION

        self.addParameter(
            QgsProcessingParameterString(
                name=self.DISTANCE_FUNCTION,
                description=self.tr('Distance function'),
                optional=True))

        # WINDOWS SHAPE

        windowShapeParam = QgsProcessingParameterEnum(
            name=self.WINDOW_SHAPE,
            description=self.tr('Window shape'),
            options=self.types_of_shape)

        windowShapeParam.setMetadata({
            'widget_wrapper': {
                'class':
                'Chloe.chloe_algorithm_dialog.ChloeEnumUpdateStateWidgetWrapper',
                'dependantWidgetConfig': [{
                    'paramName': self.FRICTION_FILE,
                    'enableValue': 2
                }]
            }
        })

        self.addParameter(windowShapeParam)

        # FRICTION FILE

        self.addParameter(
            QgsProcessingParameterFile(name=self.FRICTION_FILE,
                                       description=self.tr('Friction file'),
                                       optional=True))

        # WINDOWS SIZE
        windowSizeParam = QgsProcessingParameterNumber(
            name=self.WINDOW_SIZES,
            description=self.tr('Windows sizes (pixels)'))
        windowSizeParam.setMetadata({
            'widget_wrapper': {
                'class': 'Chloe.chloe_algorithm_dialog.ChloeIntSpinboxWrapper',
                'initialValue': 3,
                'minValue': 3,
                'maxValue': 100001,
                'oddNum': True
            }
        })

        self.addParameter(windowSizeParam)

        pointPixelParam = QgsProcessingParameterEnum(
            name=self.PIXELS_POINTS_SELECT,
            description=self.tr('Pixels/points selection'),
            options=self.types_of_pixel_point_select)

        pointPixelParam.setMetadata({
            'widget_wrapper': {
                'class':
                'Chloe.chloe_algorithm_dialog.ChloeEnumUpdateStateWidgetWrapper',
                'dependantWidgetConfig': [{
                    'paramName': self.PIXELS_FILE,
                    'enableValue': 0
                }, {
                    'paramName': self.POINTS_FILE,
                    'enableValue': 1
                }]
            }
        })

        self.addParameter(pointPixelParam)

        self.addParameter(
            QgsProcessingParameterFile(name=self.PIXELS_FILE,
                                       description=self.tr('Pixels file'),
                                       optional=True))

        self.addParameter(
            QgsProcessingParameterFile(name=self.POINTS_FILE,
                                       description=self.tr('Points file'),
                                       optional=True))

        self.addParameter(
            QgsProcessingParameterNumber(
                name=self.MAXIMUM_RATE_MISSING_VALUES,
                description=self.tr('Maximum rate of missing values'),
                minValue=0,
                maxValue=100,
                defaultValue=100))

        metricsParam = QgsProcessingParameterString(
            name=self.METRICS, description=self.tr('Select metrics'))

        metricsParam.setMetadata({
            'widget_wrapper': {
                'class':
                'Chloe.chloe_algorithm_dialog.ChloeDoubleComboboxWidgetWrapper',
                'dictValues': self.types_of_metrics,
                'initialValue': 'value metrics',
                'rasterLayerParamName': self.INPUT_LAYER_ASC,
                'parentWidgetConfig': {
                    'paramName': self.INPUT_LAYER_ASC,
                    'refreshMethod': 'refreshMappingCombobox'
                }
            }
        })

        self.addParameter(metricsParam)

        # === OUTPUT PARAMETERS ===

        self.addParameter(
            ChloeCSVParameterFileDestination(
                name=self.OUTPUT_CSV, description=self.tr('Output csv')))

        fieldsParam = ChloeASCParameterFileDestination(
            name=self.OUTPUT_ASC, description=self.tr('Output Raster ascii'))
        self.addParameter(fieldsParam, createOutput=True)

        self.addParameter(
            QgsProcessingParameterFileDestination(
                name=self.SAVE_PROPERTIES,
                description=self.tr('Properties file'),
                fileFilter='Properties (*.properties)'))
コード例 #4
0
    def initAlgorithm(self, config=None):
        """
        Here we define the inputs and output of the algorithm, along
        with some other properties.
        """

        # INPUTS
        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT_PAN,
                                              self.tr('Panchromatic layer')))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_PAN, self.tr('Pan Band'), 1,
                                       self.INPUT_PAN))

        self.addParameter(
            QgsProcessingParameterRasterLayer(self.INPUT_XS,
                                              self.tr('Multispectral layer')))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_R, self.tr('Red Band'), 1,
                                       self.INPUT_XS))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_G, self.tr('Green Band'), 2,
                                       self.INPUT_XS))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_B, self.tr('Blue Band'), 3,
                                       self.INPUT_XS))
        self.addParameter(
            QgsProcessingParameterBand(self.BAND_NIR,
                                       self.tr('NIR Band'),
                                       0,
                                       self.INPUT_XS,
                                       optional=True))

        weight_r = QgsProcessingParameterNumber(
            self.WEIGHT_R,
            self.tr('Weight Red Band'),
            type=QgsProcessingParameterNumber.Double,
            defaultValue=0.25,
            minValue=0,
            maxValue=1)
        weight_g = QgsProcessingParameterNumber(
            self.WEIGHT_G,
            self.tr('Weight Green Band'),
            type=QgsProcessingParameterNumber.Double,
            defaultValue=0.25,
            minValue=0,
            maxValue=1)
        weight_b = QgsProcessingParameterNumber(
            self.WEIGHT_B,
            self.tr('Weight Blue Band'),
            type=QgsProcessingParameterNumber.Double,
            defaultValue=0.25,
            minValue=0,
            maxValue=1)
        weight_nir = QgsProcessingParameterNumber(
            self.WEIGHT_NIR,
            self.tr('Weight NIR Band'),
            type=QgsProcessingParameterNumber.Double,
            defaultValue=0.25,
            minValue=0,
            maxValue=1,
            optional=True)

        weight_r.setMetadata({'widget_wrapper': {'decimals': 2}})
        weight_g.setMetadata({'widget_wrapper': {'decimals': 2}})
        weight_b.setMetadata({'widget_wrapper': {'decimals': 2}})
        weight_nir.setMetadata({'widget_wrapper': {'decimals': 2}})

        self.addParameter(weight_r)
        self.addParameter(weight_g)
        self.addParameter(weight_b)
        self.addParameter(weight_nir)

        self.addParameter(
            QgsProcessingParameterExtent(self.OUT_EXTENT,
                                         self.tr('Output extent')))
        self.addParameter(
            QgsProcessingParameterCrs(self.OUT_CRS,
                                      self.tr('Output CRS'),
                                      None,
                                      optional=True))

        # OUTPUT
        self.addParameter(
            QgsProcessingParameterRasterDestination(self.OUTPUT,
                                                    self.tr('Output layer')))
コード例 #5
0
ファイル: idw.py プロジェクト: chjch/lucis_qgis
 def initAlgorithm(self, config=None):
     self.addParameter(
         QgsProcessingParameterFeatureSource(
             self.INPUT,
             self.tr('Input layer'),
             types=[QgsProcessing.TypeVectorAnyGeometry]
         )
     )
     self.addParameter(
         QgsProcessingParameterFeatureSource(
             self.INTERPOLATE,
             self.tr('Interpolation layer'),
             types=[QgsProcessing.TypeVectorAnyGeometry]
         )
     )
     self.addParameter(
         QgsProcessingParameterField(
             self.INTERPOLATE_FIELD,
             self.tr('Interpolating field'),
             parentLayerParameterName=self.INTERPOLATE,
             type=QgsProcessingParameterField.Numeric
         )
     )
     power = QgsProcessingParameterNumber(
         self.POWER,
         self.tr('Power parameter for interpolation'),
         type=QgsProcessingParameterNumber.Double,
         defaultValue=2,
         optional=True
     )
     power.setMetadata({
         'widget_wrapper': {
             'decimals': 2
         }
     })
     self.addParameter(power)
     self.addParameter(
         QgsProcessingParameterNumber(
             self.NUMBER_NEIGHBOR,
             self.tr('Number of neighbors'),
             type=QgsProcessingParameterNumber.Integer,
             defaultValue=12,
             optional=True
         )
     )
     search_radius = QgsProcessingParameterDistance(
         self.SEARCH_RADIUS,
         self.tr('Search radius'),
         defaultValue=None,
         parentParameterName=self.INTERPOLATE,
         optional=True
     )
     search_radius.setMetadata({
         'widget_wrapper': {
             'decimals': 2
         }
     })
     self.addParameter(search_radius)
     self.addParameter(
         QgsProcessingParameterEnum(
             self.DATA_TYPE,
             self.tr('Output data type'),
             options=[dtype[1] for dtype in self.data_type],
             defaultValue=1,
             optional=True
         )
     )
     self.addParameter(
         QgsProcessingParameterString(
             name=self.OUTPUT_FIELD,
             description=self.tr('Output field name'),
         )
     )
     self.addParameter(
         QgsProcessingParameterVectorDestination(
             self.OUTPUT,
             self.tr('Output layer')
         )
     )