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 = []
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)
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')))
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)
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))
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)
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')))
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')))
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 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)')))
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))
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)
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))
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)')))
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')))
def initAlgorithm(self, config=None): self.addParameter( QgsProcessingParameterRasterLayer(self.INPUT_A, self.tr('Input layer A'), optional=False)) self.addParameter( QgsProcessingParameterBand(self.BAND_A, self.tr('Number of raster band for A'), parentLayerParameterName=self.INPUT_A)) self.addParameter( QgsProcessingParameterRasterLayer(self.INPUT_B, self.tr('Input layer B'), optional=True)) self.addParameter( QgsProcessingParameterBand(self.BAND_B, self.tr('Number of raster band for B'), parentLayerParameterName=self.INPUT_B, optional=True)) self.addParameter( QgsProcessingParameterRasterLayer(self.INPUT_C, self.tr('Input layer C'), optional=True)) self.addParameter( QgsProcessingParameterBand(self.BAND_C, self.tr('Number of raster band for C'), parentLayerParameterName=self.INPUT_C, optional=True)) self.addParameter( QgsProcessingParameterRasterLayer(self.INPUT_D, self.tr('Input layer D'), optional=True)) self.addParameter( QgsProcessingParameterBand(self.BAND_D, self.tr('Number of raster band for D'), parentLayerParameterName=self.INPUT_D, optional=True)) self.addParameter( QgsProcessingParameterRasterLayer(self.INPUT_E, self.tr('Input layer E'), optional=True)) self.addParameter( QgsProcessingParameterBand(self.BAND_E, self.tr('Number of raster band for E'), parentLayerParameterName=self.INPUT_E, optional=True)) self.addParameter( QgsProcessingParameterRasterLayer(self.INPUT_F, self.tr('Input layer F'), optional=True)) self.addParameter( QgsProcessingParameterBand(self.BAND_F, self.tr('Number of raster band for F'), parentLayerParameterName=self.INPUT_F, optional=True)) self.addParameter( QgsProcessingParameterString( self.FORMULA, self. tr('Calculation in gdalnumeric syntax using +-/* or any numpy array functions (i.e. logical_and())' ), 'A*2', optional=False)) self.addParameter( QgsProcessingParameterNumber( self.NO_DATA, self.tr('Set output nodata value'), type=QgsProcessingParameterNumber.Double, defaultValue=None, optional=True)) self.addParameter( QgsProcessingParameterEnum(self.RTYPE, self.tr('Output raster type'), options=self.TYPE, defaultValue=5)) options_param = QgsProcessingParameterString( self.OPTIONS, self.tr('Additional creation options'), defaultValue='', optional=True) options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced) options_param.setMetadata({ 'widget_wrapper': { 'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper' } }) self.addParameter(options_param) self.addParameter( QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Calculated')))
def initParameters(self, config=None): self.addParameter( QgsProcessingParameterNumber( self.INTERVAL, self.tr('Interval between vertices to add'), QgsProcessingParameterNumber.Double, 1, False, 0, 10000000))
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)
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')))
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))
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)')))
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')))
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))
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')))
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)
def initParameters(self, config=None): self.addParameter( QgsProcessingParameterNumber(self.Z_VALUE, self.tr('Z Value'), QgsProcessingParameterNumber.Double, defaultValue=0.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')))
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')) )
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')))
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')))
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))
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')))
def initParameters(self, config=None): self.addParameter( QgsProcessingParameterNumber(self.VERTICES, self.tr('Vertices to add'), QgsProcessingParameterNumber.Integer, 1, False, 1, 10000000))
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))