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.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):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_A,
self.tr('Input layer A'),
optional=False))
self.addParameter(
QgsProcessingParameterBand(self.BAND_A,
self.tr('Number of raster band for A'),
parentLayerParameterName=self.INPUT_A))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_B,
self.tr('Input layer B'),
optional=True))
self.addParameter(
QgsProcessingParameterBand(self.BAND_B,
self.tr('Number of raster band for B'),
parentLayerParameterName=self.INPUT_B,
optional=True))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_C,
self.tr('Input layer C'),
optional=True))
self.addParameter(
QgsProcessingParameterBand(self.BAND_C,
self.tr('Number of raster band for C'),
parentLayerParameterName=self.INPUT_C,
optional=True))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_D,
self.tr('Input layer D'),
optional=True))
self.addParameter(
QgsProcessingParameterBand(self.BAND_D,
self.tr('Number of raster band for D'),
parentLayerParameterName=self.INPUT_D,
optional=True))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_E,
self.tr('Input layer E'),
optional=True))
self.addParameter(
QgsProcessingParameterBand(self.BAND_E,
self.tr('Number of raster band for E'),
parentLayerParameterName=self.INPUT_E,
optional=True))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_F,
self.tr('Input layer F'),
optional=True))
self.addParameter(
QgsProcessingParameterBand(self.BAND_F,
self.tr('Number of raster band for F'),
parentLayerParameterName=self.INPUT_F,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.FORMULA,
self.
tr('Calculation in gdalnumeric syntax using +-/* or any numpy array functions (i.e. logical_and())'
),
'A*2',
optional=False))
self.addParameter(
QgsProcessingParameterNumber(
self.NO_DATA,
self.tr('Set output nodata value'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.RTYPE,
self.tr('Output raster type'),
options=self.TYPE,
defaultValue=5))
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
self.addParameter(options_param)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Calculated')))
def initAlgorithm(self, config=None):
self.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.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterBand(self.BAND,
self.tr('Band number'),
1,
parentLayerParameterName=self.INPUT))
self.addParameter(
QgsProcessingParameterNumber(
self.DISTANCE,
self.
tr('Maximum distance (in pixels) to search out for values to interpolate'
),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=10))
self.addParameter(
QgsProcessingParameterNumber(
self.ITERATIONS,
self.
tr('Number of smoothing iterations to run after the interpolation'
),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(
self.NO_MASK,
self.tr(
'Do not use the default validity mask for the input band'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterRasterLayer(self.MASK_LAYER,
self.tr('Validity mask'),
optional=True))
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
self.addParameter(options_param)
extra_param = QgsProcessingParameterString(
self.EXTRA,
self.tr('Additional command-line parameters'),
defaultValue=None,
optional=True)
extra_param.setFlags(extra_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_param)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Filled')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
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.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 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):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# We add the input vector features source. It can have any kind of
# geometry.
self.addParameter(
QgsProcessingParameterRasterLayer(self.TI,
self.tr('Training raster')))
self.addParameter(
QgsProcessingParameterBand(self.BANDS_TI,
self.tr('Selected band(s)'),
None,
self.TI,
allowMultiple=True))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT, self.tr('Raster on which to simulate')))
self.addParameter(
QgsProcessingParameterBand(self.BANDS_INPUT,
self.tr('Selected band(s)'),
None,
self.INPUT,
allowMultiple=True))
# We add a feature sink in which to store our processed features (this
# usually takes the form of a newly created vector layer when the
# algorithm is run in QGIS).
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('QS simulation')))
self.addParameter(
QgsProcessingParameterNumber(
self.PARAM_K,
self.tr('Parameter k'),
QgsProcessingParameterNumber.Double,
1.2,
minValue=1,
))
self.addParameter(
QgsProcessingParameterNumber(
self.PARAM_N,
self.tr('Parameter N'),
QgsProcessingParameterNumber.Integer,
30,
minValue=1,
))
self.addParameter(
QgsProcessingParameterEnum(self.KERNEL_TYPE,
self.tr('Type of kernel'), [
self.tr('Uniform'),
self.tr('Exponential'),
self.tr('Gaussian')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.KERNEL_ALPHA,
self.tr('Kernel Alpha OR Max radius'),
QgsProcessingParameterNumber.Double,
1,
minValue=0.001,
optional=True))
paramj = QgsProcessingParameterNumber(
self.PARAM_J,
self.
tr('Parallelization, interger for number of cores, and decimal ]0,1[, for porcentage of total cores'
),
QgsProcessingParameterNumber.Double,
0.5,
minValue=0.001,
optional=True)
paramj.setFlags(paramj.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
paramSA = QgsProcessingParameterString(
self.PARAM_SA,
self.tr('DNS name or IP of the G2S server'),
'localhost',
optional=True)
paramSA.setFlags(paramSA.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
ignoreResolution = QgsProcessingParameterBoolean(
self.PARAM_IGNORE_RESOLUTION,
self.tr('ignore resolution check'),
False,
optional=True)
ignoreResolution.setFlags(
ignoreResolution.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(paramj)
self.addParameter(paramSA)
self.addParameter(ignoreResolution)
def initAlgorithm(self, config):
"""
Define inputs and output of the algorithm.
"""
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT_RASTER,
self.tr('Input DEM (meters above sea level)')))
self.addParameter(
QgsProcessingParameterBand(self.RASTER_BAND,
self.tr('Band number'), 1,
self.INPUT_RASTER))
model = LTOP()
self.addParameter(
QgsProcessingParameterNumber(self.TAU_C,
self.tr("Conversion time (seconds)"),
QgsProcessingParameterNumber.Double,
defaultValue=model.tau_c,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(self.TAU_F,
self.tr("Fallout time (seconds)"),
QgsProcessingParameterNumber.Double,
defaultValue=model.tau_f,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.P0,
self.tr("Background precipitation rate (mm/hour)"),
QgsProcessingParameterNumber.Double,
defaultValue=model.P0,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(self.P_SCALE,
self.tr("Precipitation scale factor"),
QgsProcessingParameterNumber.Double,
defaultValue=1.0,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.NM,
self.tr("Moist stability frequency (1/second)"),
QgsProcessingParameterNumber.Double,
defaultValue=model.Nm,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.HW,
self.tr("Water vapor scale height (meters)"),
QgsProcessingParameterNumber.Double,
defaultValue=model.Hw,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.LATITUDE,
self.tr("Latitude used to compute the Coriolis force"),
QgsProcessingParameterNumber.Double,
defaultValue=model.latitude,
minValue=-90.0,
maxValue=90.0))
self.addParameter(
QgsProcessingParameterNumber(
self.WIND_DIRECTION,
self.
tr("The direction the wind is coming from (0 is north, 270 is west)"
),
QgsProcessingParameterNumber.Double,
defaultValue=model.direction,
minValue=0.0,
maxValue=360.0))
self.addParameter(
QgsProcessingParameterNumber(self.WIND_SPEED,
self.tr("Wind speed (m/second)"),
QgsProcessingParameterNumber.Double,
defaultValue=model.speed,
minValue=0.0))
self.addParameter(
QgsProcessingParameterBoolean(
self.TRUNCATE,
self.tr("Truncate negative precipitation"),
defaultValue=True))
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Precipitation')))
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):
"""
Here we define the inputs and output of the algorithm, along
with some other properties. Theses will be asked to the user.
"""
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT_COST_RASTER,
self.tr('Cost raster layer'),
)
)
self.addParameter(
QgsProcessingParameterBand(
self.INPUT_RASTER_BAND,
self.tr('Cost raster band'),
0,
self.INPUT_COST_RASTER,
)
)
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT_POLYGONS_TO_ACCESS,
self.tr('Polygons to access via the generated roads'),
[QgsProcessing.TypeVectorPolygon]
)
)
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT_ROADS_TO_CONNECT_TO,
self.tr('Roads to connect the polygons to access to'),
[QgsProcessing.TypeVectorLine]
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.SKIDDING_DISTANCE,
self.tr('Skidding distance (in CRS units)'),
type=QgsProcessingParameterNumber.Double,
defaultValue=100,
optional=False,
minValue=0
)
)
self.addParameter(
QgsProcessingParameterEnum(
self.METHOD_OF_GENERATION,
self.tr('Method of generation of the road network'),
['Random', 'Closest first', 'Farthest first'],
defaultValue=1
)
)
self.addParameter(
QgsProcessingParameterField(
self.HEURISTIC_IN_POLYGONS,
self.tr('Attribute field of the harvest polygons that indicates the order in which they must be reached'),
parentLayerParameterName=self.INPUT_POLYGONS_TO_ACCESS,
type=QgsProcessingParameterField.Numeric,
optional=True
)
)
self.addParameter(
QgsProcessingParameterEnum(
self.ANGLES_CONSIDERED,
self.tr('Should the angles of the roads be considered in the cost ?'),
['Yes', 'No'],
defaultValue=1
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.PUNISHER_45DEGREES,
self.tr('Punishing multiplier for a 45 degrees turning angle'),
type=QgsProcessingParameterNumber.Double,
defaultValue=1.25,
optional=True,
minValue=1
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.PUNISHER_90DEGREES,
self.tr('Punishing multiplier for a 90 degrees turning angle'),
type=QgsProcessingParameterNumber.Double,
defaultValue=2,
optional=True,
minValue=1
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.PUNISHER_135DEGREES,
self.tr('Punishing multiplier for a 135 degrees turning angle'),
type=QgsProcessingParameterNumber.Double,
defaultValue=5,
optional=True,
minValue=1
)
)
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT,
self.tr('Output of the algorithm')
)
)
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_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, types=[self.datatypeCombo.currentData()])
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_SCALE
or isinstance(self.param, QgsProcessingParameterScale)):
self.param = QgsProcessingParameterScale(
name, description, self.defaultTextBox.text())
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
# Destination parameter
elif (isinstance(self.param, QgsProcessingParameterFeatureSink)):
self.param = QgsProcessingParameterFeatureSink(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
self.param = QgsProcessingParameterFileDestination(
name=name,
description=self.param.description(),
fileFilter=self.param.fileFilter(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
self.param = QgsProcessingParameterFolderDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
self.param = QgsProcessingParameterRasterDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
self.param = QgsProcessingParameterVectorDestination(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.value())
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)
if self.advancedCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagAdvanced)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
