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=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.units = ((self.tr('Meters'), 'm'),
(self.tr('Feet'), 'f'))
self.csystems = ((self.tr('Unknown'), '0'),
(self.tr('UTM'), '1'),
(self.tr('State plane'), '2'))
self.hdatums = ((self.tr('Unknown'), '0'),
(self.tr('NAD27'), '1'),
(self.tr('NAD83'), '2'))
self.vdatums = ((self.tr('Unknown'), '0'),
(self.tr('NGVD29'), '1'),
(self.tr('NAVD88'), '2'),
(self.tr('GRS80'), '3'))
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Surface raster')))
self.addParameter(QgsProcessingParameterEnum(self.XYUNITS,
self.tr('Units for LIDAR data XY'),
options=[i[0] for i in self.units],
defaultValue=0))
self.addParameter(QgsProcessingParameterEnum(self.ZUNITS,
self.tr('Units for LIDAR data elevations'),
options=[i[0] for i in self.units],
defaultValue=0))
self.addParameter(QgsProcessingParameterEnum(self.COORDSYS,
self.tr('Coordinate system'),
options=[i[0] for i in self.csystems],
defaultValue=0))
self.addParameter(QgsProcessingParameterNumber(self.ZONE,
self.tr('Coordinate system zone (0 for unknown)'),
QgsProcessingParameterNumber.Integer,
minValue=0,
maxValue=60,
defaultValue=0))
self.addParameter(QgsProcessingParameterEnum(self.HDATUM,
self.tr('Horizontal datum'),
options=[i[0] for i in self.hdatums],
defaultValue=0))
self.addParameter(QgsProcessingParameterEnum(self.VDATUM,
self.tr('Vertical datum'),
options=[i[0] for i in self.vdatums],
defaultValue=0))
params = []
params.append(QgsProcessingParameterNumber(self.MULTIPLIER,
self.tr('Multiply all data values by the constant'),
QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
params.append(QgsProcessingParameterNumber(self.OFFSET,
self.tr('Add the constant to all data values'),
QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
params.append(QgsProcessingParameterBoolean(self.NAN,
self.tr('Use more robust (but slower) logic for parsing NAN values'),
defaultValue=None,
optional=True))
for p in params:
p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
self.addParameter(QgsProcessingParameterFileDestination(self.OUTPUT,
self.tr('Output'),
self.tr('DTM files (*.dtm *.DTM)')))
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 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_LAYOUTITEM
or isinstance(self.param, QgsProcessingParameterLayoutItem)):
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 = QgsProcessingParameterLayoutItem(
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_DISTANCE
or isinstance(self.param, QgsProcessingParameterDistance)):
self.param = QgsProcessingParameterDistance(
name, description, self.defaultTextBox.text())
try:
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
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()
if parent:
self.param.setParentParameterName(parent)
elif (self.paramType == parameters.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
type = self.type_combo.currentData()
self.param = QgsProcessingParameterNumber(
name, description, type, self.defaultTextBox.text())
try:
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.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterBand(self.BAND,
self.tr('Band number'),
parentLayerParameterName=self.INPUT))
self.addParameter(
QgsProcessingParameterNumber(
self.Z_FACTOR,
self.tr('Z factor (vertical exaggeration)'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=1.0))
self.addParameter(
QgsProcessingParameterNumber(
self.SCALE,
self.tr('Scale (ratio of vertical units to horizontal)'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=1.0))
self.addParameter(
QgsProcessingParameterNumber(
self.AZIMUTH,
self.tr('Azimuth of the light'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
maxValue=360,
defaultValue=315.0))
self.addParameter(
QgsProcessingParameterNumber(
self.ALTITUDE,
self.tr('Altitude of the light'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=45.0))
self.addParameter(
QgsProcessingParameterBoolean(self.COMPUTE_EDGES,
self.tr('Compute edges'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.ZEVENBERGEN,
self.
tr("Use Zevenbergen&Thorne formula instead of the Horn's one"),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(self.COMBINED,
self.tr("Combined shading"),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(self.MULTIDIRECTIONAL,
self.tr("Multidirectional shading"),
defaultValue=False))
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation parameters'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
self.addParameter(options_param)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Hillshade')))
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): # pylint: disable=unused-argument
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
self.addParameter(QgsProcessingParameterRasterDestination(self.R, self.tr('Output R band layer')))
self.addParameter(QgsProcessingParameterRasterDestination(self.G, self.tr('Output G band layer')))
self.addParameter(QgsProcessingParameterRasterDestination(self.B, self.tr('Output B band layer')))
def accept(self):
description = str(self.nameTextBox.text())
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD
or isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
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 == ModelerParameterDefinitionDialog.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
== ModelerParameterDefinitionDialog.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
try:
self.param = QgsProcessingParameterNumber(
name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(
name, description, QgsProcessingParameterFile.Folder
if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterBand(self.BAND,
self.tr('Band number'),
1,
parentLayerParameterName=self.INPUT))
self.addParameter(
QgsProcessingParameterNumber(
self.DISTANCE,
self.
tr('Maximum distance (in pixels) to search out for values to interpolate'
),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=10))
self.addParameter(
QgsProcessingParameterNumber(
self.ITERATIONS,
self.
tr('Number of smoothing iterations to run after the interpolation'
),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(
self.NO_MASK,
self.tr(
'Do not use the default validity mask for the input band'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterRasterLayer(self.MASK_LAYER,
self.tr('Validity mask'),
optional=True))
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
self.addParameter(options_param)
extra_param = QgsProcessingParameterString(
self.EXTRA,
self.tr('Additional command-line parameters'),
defaultValue=None,
optional=True)
extra_param.setFlags(extra_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_param)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Filled')))
def initAlgorithm(self, config=None):
# === 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)
self.addParameter(
QgsProcessingParameterNumber(
name=self.GRID_SIZES,
description=self.tr('Grid size (pixels)'),
defaultValue=2,
minValue=1))
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)
self.addParameter(
QgsProcessingParameterNumber(
name=self.MAXIMUM_RATE_MISSING_VALUES,
description=self.tr('Maximum rate of mising values'),
minValue=0,
maxValue=100,
defaultValue=100))
# self.addParameter(QgsProcessingParameterString(
# name=self.COMMENT,
# description=self.tr('Comment'))
# )
# === OUTPUT PARAMETERS ===
self.addParameter(
ChloeCSVParameterFileDestination(name=self.OUTPUT_CSV,
description=self.tr('Output csv'),
addToMapDefaultState=False))
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)'))
def initAlgorithm(self, config: Dict[str, Any]) -> None:
# Описываем входные параметры
self.addParameter(
QgsProcessingParameterFeatureSource(
name=self.SAMPLES,
description='Input layer',
types=[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterRasterLayer(name=self.MOSAIC,
description='Rater mosaic layer',
optional=True))
self.addParameter(
QgsProcessingParameterCrs(name=self.CRS,
description='CRS',
defaultValue=options.get(self.CRS,
None)))
self.addParameter(
QgsProcessingParameterNumber(
name=self.HORRESOLUTION,
description='Horizontal resolution',
type=QgsProcessingParameterNumber.Double,
defaultValue=options.get(self.HORRESOLUTION, None)))
self.addParameter(
QgsProcessingParameterNumber(
name=self.VERTRESOLUTION,
description='Vertical resolution',
type=QgsProcessingParameterNumber.Double,
defaultValue=options.get(self.VERTRESOLUTION, None)))
self.addParameter(
QgsProcessingParameterNumber(
name=self.WIDTH,
description='Width (pixel)',
type=QgsProcessingParameterNumber.Integer,
defaultValue=options.get(self.WIDTH, None)))
self.addParameter(
QgsProcessingParameterNumber(
name=self.HEIGHT,
description='Height (pixel)',
type=QgsProcessingParameterNumber.Integer,
defaultValue=options.get(self.HEIGHT, None)))
self.addParameter(
QgsProcessingParameterFolderDestination(
name=self.FOLDER,
description='Output folder for mosail tiles',
defaultValue=options.get(self.FOLDER, None),
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
name=self.SAVEONESAMPLE,
description='Save one sample as raster',
defaultValue=options.get(self.SAVEONESAMPLE, None),
optional=False))
self.addParameter(
QgsProcessingParameterFeatureSink(name=self.INTERSECTION,
description='Samples per tiles',
createByDefault=True,
supportsAppend=True,
defaultValue='TEMPORARY_OUTPUT'))
self.addParameter(
QgsProcessingParameterFeatureSink(name=self.GRID,
description='Grid layer',
createByDefault=True,
supportsAppend=True,
defaultValue='TEMPORARY_OUTPUT'))
self.addParameter(
QgsProcessingParameterFeatureSink(name=self.RLE,
description='RLE',
createByDefault=True,
supportsAppend=True,
defaultValue='TEMPORARY_OUTPUT'))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer'),
optional=False))
self.addParameter(
QgsProcessingParameterCrs(self.SOURCE_SRS,
self.tr('Source SRS'),
optional=True))
self.addParameter(
QgsProcessingParameterCrs(self.DEST_SRS,
self.tr('Destination SRS'), 'EPSG:4326'))
self.addParameter(
QgsProcessingParameterString(
self.NO_DATA,
self.
tr("Nodata value, leave blank to take the nodata value from input"
),
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.TR,
self.
tr('Output file resolution in target georeferenced units (leave 0 for no change)'
),
minValue=0.0,
defaultValue=0.0))
self.addParameter(
QgsProcessingParameterEnum(self.METHOD,
self.tr('Resampling method'),
self.METHOD_OPTIONS))
self.addParameter(
QgsProcessingParameterBoolean(
self.USE_RASTER_EXTENT,
self.tr('Set georeferenced extents of output file'), False))
self.addParameter(
QgsProcessingParameterExtent(self.RASTER_EXTENT,
self.tr('Raster extent'),
optional=True))
self.addParameter(
QgsProcessingParameterCrs(
self.EXTENT_CRS,
self.
tr('CRS of the raster extent, leave blank for using Destination SRS'
),
optional=True))
co = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
optional=True)
co.setMetadata({
'widget_wrapper':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
})
self.addParameter(co)
self.addParameter(
QgsProcessingParameterBoolean(
self.MULTITHREADING,
self.tr('Use multithreaded warping implementation'), False))
self.addParameter(
QgsProcessingParameterEnum(self.RTYPE,
self.tr('Output raster type'),
self.TYPE,
defaultValue=5))
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Reprojected')))
def initAlgorithm(self, configuration): #pylint: disable=unused-argument,missing-docstring
self.addParameter(
QgsProcessingParameterRasterLayer(self.FLOW_ACC,
self.tr('Flow Accumulation')))
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')))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, self.tr('Input layer')))
self.addParameter(QgsProcessingParameterRasterDestination(self.R, self.tr('Output R band layer')))
self.addParameter(QgsProcessingParameterRasterDestination(self.G, self.tr('Output G band layer')))
self.addParameter(QgsProcessingParameterRasterDestination(self.B, self.tr('Output B band layer')))
def initAlgorithm(self, config):
for par in self.param:
pl = par.split('|')
if pl[0] == 'ParameterRaster':
self.addParameter(
QgsProcessingParameterRasterLayer(pl[1],
self.tr(pl[2]), '',
bool(strtobool(pl[3]))))
if pl[0] == 'ParameterVector':
self.addParameter(
QgsProcessingParameterVectorLayer(pl[1], self.tr(
pl[2]), [QgsProcessing.TypeVector], '',
bool(strtobool(pl[4]))))
if pl[0] == 'ParameterNumber':
try:
int(pl[5])
if pl[4] != 'None':
self.addParameter(
QgsProcessingParameterNumber(
pl[1], self.tr(pl[2]), 0, int(pl[5]), False,
int(pl[3]), int(pl[4])))
else:
self.addParameter(
QgsProcessingParameterNumber(
pl[1], self.tr(pl[2]), 0, int(pl[5]), False,
int(pl[3])))
except ValueError:
if pl[4] != 'None':
self.addParameter(
QgsProcessingParameterNumber(
pl[1], self.tr(pl[2]), 1, float(pl[5]), False,
float(pl[3]), float(pl[4])))
else:
self.addParameter(
QgsProcessingParameterNumber(
pl[1], self.tr(pl[2]), 1, float(pl[5]), False,
float(pl[3])))
if pl[0] == 'ParameterBoolean':
self.addParameter(
QgsProcessingParameterBoolean(pl[1], self.tr(pl[2]),
bool(strtobool(pl[3])),
False))
if pl[0] == 'ParameterEnum':
self.addParameter(
QgsProcessingParameterEnum(pl[1], self.tr(pl[2]),
literal_eval(pl[3]), False,
pl[4], False))
for out in self.outputline:
ol = out.split('|')
if ol[0] == 'OutputRaster':
self.addParameter(
QgsProcessingParameterRasterDestination(
ol[1][1:], self.tr(ol[2])))
if ol[0] == 'OutputVector':
self.addParameter(
QgsProcessingParameterVectorDestination(
ol[1][1:], self.tr(ol[2])))
if ol[0] == 'OutputFile':
self.addParameter(
QgsProcessingParameterFileDestination(
ol[1][1:], self.tr(ol[2])))
def initAlgorithm(self, config=None):
self.TYPES = [self.tr('Use Input Layer Data Type'), 'Byte', 'Int16', 'UInt16', 'UInt32', 'Int32', 'Float32', 'Float64', 'CInt16', 'CInt32', 'CFloat32', 'CFloat64']
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterFeatureSource(self.MASK,
self.tr('Mask layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(QgsProcessingParameterCrs(self.SOURCE_CRS,
self.tr('Source CRS'),
optional=True))
self.addParameter(QgsProcessingParameterCrs(self.TARGET_CRS,
self.tr('Target CRS'),
optional=True))
self.addParameter(QgsProcessingParameterNumber(self.NODATA,
self.tr('Assign a specified nodata value to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
self.addParameter(QgsProcessingParameterBoolean(self.ALPHA_BAND,
self.tr('Create an output alpha band'),
defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.CROP_TO_CUTLINE,
self.tr('Match the extent of the clipped raster to the extent of the mask layer'),
defaultValue=True))
self.addParameter(QgsProcessingParameterBoolean(self.KEEP_RESOLUTION,
self.tr('Keep resolution of input raster'),
defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.SET_RESOLUTION,
self.tr('Set output file resolution'),
defaultValue=False))
self.addParameter(QgsProcessingParameterNumber(self.X_RESOLUTION,
self.tr('X Resolution to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
self.addParameter(QgsProcessingParameterNumber(self.Y_RESOLUTION,
self.tr('Y Resolution to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
multithreading_param = QgsProcessingParameterBoolean(self.MULTITHREADING,
self.tr('Use multithreaded warping implementation'),
defaultValue=False)
multithreading_param.setFlags(multithreading_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(multithreading_param)
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=0)
dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Clipped (mask)')))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT_RASTER,
self.tr('Raster layer')))
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT_VECTOR,
self.tr('Vector layer'), [QgsProcessing.TypeVectorLine]))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Points from polygons'), QgsProcessing.TypeVectorPoint))
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(
QgsProcessingParameterPoint(self.OBSERVER,
self.tr('Observer location')))
self.addParameter(
QgsProcessingParameterNumber(
self.OBSERVER_HEIGHT,
self.tr('Observer height, DEM units'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=1.0))
self.addParameter(
QgsProcessingParameterNumber(
self.TARGET_HEIGHT,
self.tr('Target height, DEM units'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=1.0))
self.addParameter(
QgsProcessingParameterDistance(
self.MAX_DISTANCE,
self.tr(
'Maximum distance from observer to compute visibility'),
parentParameterName=self.INPUT,
minValue=0.0,
defaultValue=100.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)
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('Output')))
def initAlgorithm(self, config=None):
self.methods = ((self.tr('Nearest neighbour'),
'near'), (self.tr('Bilinear'), 'bilinear'),
(self.tr('Cubic'), 'cubic'), (self.tr('Cubic spline'),
'cubicspline'),
(self.tr('Lanczos windowed sinc'),
'lanczos'), (self.tr('Average'), 'average'),
(self.tr('Mode'), 'mode'), (self.tr('Maximum'), 'max'),
(self.tr('Minimum'),
'min'), (self.tr('Median'),
'med'), (self.tr('First quartile'), 'q1'),
(self.tr('Third quartile'), 'q3'))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterCrs(self.SOURCE_CRS,
self.tr('Source CRS'),
optional=True))
self.addParameter(
QgsProcessingParameterCrs(self.TARGET_CRS, self.tr('Target CRS'),
'EPSG:4326'))
self.addParameter(
QgsProcessingParameterNumber(
self.NODATA,
self.tr('Nodata value for output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.TARGET_RESOLUTION,
self.tr(
'Output file resolution in target georeferenced units'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=None))
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation parameters'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
self.addParameter(options_param)
self.addParameter(
QgsProcessingParameterEnum(self.RESAMPLING,
self.tr('Resampling method to use'),
options=[i[0] for i in self.methods],
defaultValue=0))
dataType_param = QgsProcessingParameterEnum(
self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=5)
dataType_param.setFlags(
dataType_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
target_extent_param = QgsProcessingParameterExtent(
self.TARGET_EXTENT,
self.tr('Georeferenced extents of output file to be created'),
optional=True)
target_extent_param.setFlags(
target_extent_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_extent_param)
target_extent_crs_param = QgsProcessingParameterCrs(
self.TARGET_EXTENT_CRS,
self.tr('CRS of the target raster extent'),
optional=True)
target_extent_crs_param.setFlags(
target_extent_crs_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_extent_crs_param)
multithreading_param = QgsProcessingParameterBoolean(
self.MULTITHREADING,
self.tr('Use multithreaded warping implementation'),
defaultValue=False)
multithreading_param.setFlags(
multithreading_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(multithreading_param)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Reprojected')))
def initAlgorithm( self, config=None ):
""" Virtual override
see https://qgis.org/api/classQgsProcessingAlgorithm.html
"""
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT, 'Raster Layer'))
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))
#self.addParameter(ParameterBoolean(
# self.DEBUG, self.tr('Print debugging information'), False))
self.addParameter(
QgsProcessingParameterString(
self.EXTRA,
self.tr('Additional creation parameters'),
'',
optional=True))
# advanced raster params
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation parameters'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
self.addParameter(options_param)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Calculated')))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Raster layer')))
self.addParameter(QgsProcessingParameterFile(self.STYLE,
self.tr('Style file'), extension='qml'))
self.addOutput(QgsProcessingOutputRasterLayer(self.INPUT, self.tr('Styled')))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT,
self.tr('Raster layer')
)
)
self.addParameter(
QgsProcessingParameterEnum(
self.INPUT_METHOD_ECH,
self.tr("Sampling method"),
['Random sampling', 'Stratified sampling']
)
)
self.addParameter(
QgsProcessingParameterEnum(
self.INPUT_METHOD_CLASS,
self.tr('Classification method (for stratified sampling)'),
['Quantiles', 'Equal intervals','K-means']
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_N_CLASS,
self.tr('Number of classes'),
QgsProcessingParameterNumber.Integer,
4,
False,
2,
10
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUT_ECHANTILLON,
self.tr("Number of samples"),
QgsProcessingParameterNumber.Integer,
10,
False,
2,
100
)
)
self.addParameter(
QgsProcessingParameterVectorDestination(
self.OUTPUT,
self.tr('Sampling points')
)
)
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input image'))
)
self.addParameter(
QgsProcessingParameterVectorDestination (
self.OUTPUT_FOOTPRINT,
self.tr('Image footprint'),
QgsProcessing.TypeVectorPolygon
)
)
self.addParameter(
QgsProcessingParameterFeatureSink (
self.OUTPUT_NADIR,
self.tr('Drone nadir point'),
QgsProcessing.TypeVectorPoint
)
)
self.addParameter(
QgsProcessingParameterCrs(
self.SOURCE_CRS,
self.tr('Source CRS'),
defaultValue='EPSG:4326'
)
)
self.addParameter(
QgsProcessingParameterCrs(
self.DESTINATION_CRS,
self.tr('Destination CRS'),
optional = True,
defaultValue='ProjectCrs'
)
)
# horizontar referred to flight direction => means wide angle
self.addParameter(
QgsProcessingParameterNumber(
self.HORIZONTAL_FOV,
self.tr('Wide camera angle'),
type = QgsProcessingParameterNumber.Double,
defaultValue = 84.0,
minValue = 0,
maxValue = 360
)
)
# vertical referred to flight direction => means tall angle
parameter = QgsProcessingParameterBoolean(self.USE_IMAGE_RATIO_FOR_VERTICAL_FOV,
self.tr('Calc vertical FOV using image ratio'),
defaultValue = True)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
parameter = QgsProcessingParameterNumber(self.VERTICAL_FOV,
self.tr('Tall camera angle'),
type = QgsProcessingParameterNumber.Double,
defaultValue = 54.0,
minValue = 0,
maxValue = 360)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
parameter = QgsProcessingParameterNumber(self.VERTICAL_FOV_MULTIPLIER,
self.tr('Empiric multiplier to fix tall FOV basing on image ratio'),
type = QgsProcessingParameterNumber.Double,
defaultValue = 0.855)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
parameter = QgsProcessingParameterNumber(self.NADIR_TO_BOTTOM_OFFSET,
self.tr('Offset to add to bottom distance result'),
type = QgsProcessingParameterNumber.Double)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
parameter = QgsProcessingParameterNumber(self.NADIR_TO_UPPPER_OFFSET,
self.tr('Offset to add to upper distance result'),
type = QgsProcessingParameterNumber.Double)
parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
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 initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT, self.tr('Input DEM raster layer'),
[QgsProcessing.TypeRaster]))
self.addParameter(
QgsProcessingParameterNumber(
name="VE_FACTOR",
description="Vertical exaggeration factor",
type=QgsProcessingParameterNumber.Double,
defaultValue=1,
minValue=-1000,
maxValue=1000))
self.addParameter(
QgsProcessingParameterEnum(name="SKY_MODEL",
description="Sky model",
options=self.sky_model_options,
defaultValue="overcast"))
self.addParameter(
QgsProcessingParameterNumber(
name="NUM_DIRECTIONS",
description="Number of horizon search directions",
type=QgsProcessingParameterNumber.Integer,
defaultValue=32,
minValue=8,
maxValue=128))
self.addParameter(
QgsProcessingParameterNumber(
name="SHADOW_DIST",
description="Max shadow modeling distance",
type=QgsProcessingParameterNumber.Integer,
defaultValue=100,
minValue=10,
maxValue=1000))
self.addParameter(
QgsProcessingParameterNumber(
name="SHADOW_AZIMUTH",
description="Shadow azimuth",
type=QgsProcessingParameterNumber.Double,
defaultValue=315,
minValue=0,
maxValue=360))
self.addParameter(
QgsProcessingParameterNumber(
name="SHADOW_ELEVATION",
description="Shadow elevation",
type=QgsProcessingParameterNumber.Double,
defaultValue=35,
minValue=0,
maxValue=90))
self.addParameter(
QgsProcessingParameterBoolean(name="SAVE_AS_8BIT",
description="Save as 8bit raster",
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(name="FILL_NO_DATA",
description="Fill no-data (holes)",
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(name="KEEP_ORIG_NO_DATA",
description="Keep original no-data",
defaultValue=False))
self.addParameter(
QgsProcessingParameterRasterDestination(
self.OUTPUT, self.tr('Output visualization raster layer')))
def initAlgorithm(self, config=None):
# The name that the user will see in the toolbox
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_RASTER,
self.tr('Input raster')))
# SLOO
self.addParameter(
QgsProcessingParameterBoolean(
self.SLOO,
self.tr(
'Check for Leave-One-Out validation. Uncheck for 50\\50.'),
defaultValue=True))
# Train algorithm
self.addParameter(
QgsProcessingParameterEnum(self.TRAIN, "Select algorithm to train",
self.TRAIN_ALGORITHMS, 0))
# ROI
# VECTOR
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT_LAYER,
'Input layer',
))
# TABLE / COLUMN
self.addParameter(
QgsProcessingParameterField(
self.INPUT_COLUMN,
'Field (column must have classification number (e.g. \'1\' forest, \'2\' water...))',
parentLayerParameterName=self.INPUT_LAYER,
optional=False)) # save model
self.addParameter(
QgsProcessingParameterField(
self.STAND_COLUMN,
'Stand number (column must have unique id per stand)',
parentLayerParameterName=self.INPUT_LAYER,
optional=False)) # save model
self.addParameter(
QgsProcessingParameterNumber(
self.MAXITER,
self.tr('Maximum iteration (default : 5)'),
type=QgsProcessingParameterNumber.Integer,
minValue=1,
maxValue=99999,
defaultValue=5))
self.addParameter(
QgsProcessingParameterString(
self.PARAMGRID,
self.tr('Parameters for the hyperparameters of the algorithm'),
optional=True))
# SAVE AS
# SAVE MODEL
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_MODEL,
self.tr("Output model (to use for classifying)")))
"""
# SAVE CONFUSION MATRIX
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_MATRIX,
self.tr("Output confusion matrix"),
fileFilter='csv'))#,
#ext='csv'))
"""
# SAVE DIR
self.addParameter(
QgsProcessingParameterFolderDestination(
self.SAVEDIR,
self.tr("Directory to save every confusion matrix")))
def initAlgorithm(self, config=None):
"""!
Inputs and output of the algorithm
"""
project = QgsProject.instance()
# Get project crs
project_crs = project.crs()
# Check if project crs changed
prev_project_crs_desc, _ = project.readEntry("qgis2fds", "project_crs",
None)
project_crs_changed = False
if prev_project_crs_desc != project_crs.description():
project_crs_changed = True
defaultValue, _ = project.readEntry("qgis2fds", "chid", "terrain")
self.addParameter(
QgsProcessingParameterString(
"chid",
"FDS case identificator (CHID)",
multiLine=False,
defaultValue=defaultValue,
))
defaultValue, _ = project.readEntry(
"qgis2fds", "path",
QgsProject.instance().readPath("./"))
self.addParameter(
QgsProcessingParameterFile(
"path",
"Save in folder",
behavior=QgsProcessingParameterFile.Folder,
fileFilter="All files (*.*)",
defaultValue=defaultValue,
))
# QGIS issue #37447, solved in QGIS 3.14.1
defaultValue, _ = project.readEntry("qgis2fds", "extent", None)
self.addParameter(
QgsProcessingParameterExtent(
"extent",
"Terrain extent",
defaultValue=defaultValue,
))
defaultValue, _ = project.readEntry("qgis2fds", "dem_layer", None)
if not defaultValue:
try: # first layer name containing "dem"
defaultValue = [
layer.name()
for layer in QgsProject.instance().mapLayers().values()
if "DEM" in layer.name() or "dem" in layer.name()
][0]
except IndexError:
pass
self.addParameter(
QgsProcessingParameterRasterLayer(
"dem_layer",
"DEM layer",
defaultValue=defaultValue,
))
defaultValue, _ = project.readEntry("qgis2fds", "dem_sampling", "1")
param = QgsProcessingParameterNumber(
"dem_sampling",
"DEM layer sampling factor",
defaultValue=defaultValue,
minValue=1,
)
self.addParameter(param)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
defaultValue, _ = project.readEntry("qgis2fds", "landuse_layer", None)
self.addParameter(
QgsProcessingParameterRasterLayer(
"landuse_layer",
"Landuse layer (if not set, landuse is not exported)",
optional=True,
defaultValue=defaultValue,
))
defaultValue, _ = project.readNumEntry("qgis2fds", "landuse_type", 0)
self.addParameter(
QgsProcessingParameterEnum(
"landuse_type",
"Landuse layer type",
options=fds.landuse_types,
allowMultiple=False,
defaultValue=defaultValue,
))
if project_crs_changed:
defaultValue = None
else:
defaultValue, _ = project.readEntry("qgis2fds", "origin", None)
param = QgsProcessingParameterPoint(
"origin",
"Domain origin (if not set, use Terrain Extent centroid)",
optional=True,
defaultValue=defaultValue,
)
self.addParameter(param)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
if project_crs_changed:
defaultValue = None
else:
defaultValue, _ = project.readEntry("qgis2fds", "fire_origin",
None)
param = QgsProcessingParameterPoint(
"fire_origin",
"Fire origin (if not set, use Domain Origin)",
optional=True,
defaultValue=defaultValue,
)
self.addParameter(param)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
defaultValue, _ = project.readEntry("qgis2fds", "tex_layer", None)
param = QgsProcessingParameterRasterLayer(
"tex_layer",
"Texture layer (if not set, current view is exported)",
optional=True,
defaultValue=defaultValue,
)
self.addParameter(param)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
defaultValue, _ = project.readNumEntry("qgis2fds", "tex_pixel_size", 5)
param = QgsProcessingParameterNumber(
"tex_pixel_size",
"Texture layer pixels size (in meters)",
type=QgsProcessingParameterNumber.Double,
defaultValue=defaultValue,
minValue=0.1,
)
self.addParameter(param)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
param = QgsProcessingParameterFeatureSink(
"sampling_layer",
"Sampling grid output layer",
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue=None,
)
self.addParameter(param)
