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')))
self.addOutput(
QgsProcessingOutputFolder(self.OUTPUT,
self.tr('Output directory')))
def initAlgorithm(self, config=None):
self.methods = ((self.tr('Nearest neighbour'), 'near'),
(self.tr('Bilinear'), 'bilinear'),
(self.tr('Cubic'), 'cubic'),
(self.tr('Cubic spline'), 'cubicspline'),
(self.tr('Lanczos windowed sinc'), 'lanczos'),)
self.addParameter(QgsProcessingParameterMultipleLayers(self.INPUT,
self.tr('Input files'),
QgsProcessing.TypeRaster))
self.addParameter(QgsProcessingParameterNumber(self.TILE_SIZE_X,
self.tr('Tile width'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=256))
self.addParameter(QgsProcessingParameterNumber(self.TILE_SIZE_Y,
self.tr('Tile height'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=256))
self.addParameter(QgsProcessingParameterNumber(self.OVERLAP,
self.tr('Overlap in pixels between consecutive tiles'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=0))
self.addParameter(QgsProcessingParameterNumber(self.LEVELS,
self.tr('Number of pyramids levels to build'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=1))
params = []
params.append(QgsProcessingParameterCrs(self.SOURCE_CRS,
self.tr('Source coordinate reference system'),
optional=True))
params.append(QgsProcessingParameterEnum(self.RESAMPLING,
self.tr('Resampling method'),
options=[i[0] for i in self.methods],
allowMultiple=False,
defaultValue=0))
params.append(QgsProcessingParameterString(self.DELIMITER,
self.tr('Column delimiter used in the CSV file'),
defaultValue=';',
optional=True))
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation parameters'),
defaultValue='',
optional=True)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
params.append(options_param)
params.append(QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=5))
params.append(QgsProcessingParameterBoolean(self.ONLY_PYRAMIDS,
self.tr('Build only the pyramids'),
defaultValue=False))
params.append(QgsProcessingParameterBoolean(self.DIR_FOR_ROW,
self.tr('Use separate directory for each tiles row'),
defaultValue=False))
for param in params:
param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
self.addParameter(QgsProcessingParameterFolderDestination(self.OUTPUT,
self.tr('Output directory')))
output_csv_param = QgsProcessingParameterFileDestination(self.OUTPUT_CSV,
self.tr('CSV file containing the tile(s) georeferencing information'),
'CSV files (*.csv)',
optional=True)
output_csv_param.setCreateByDefault(False)
self.addParameter(output_csv_param)
def 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):
print('initAlgorithm()')
#super(MappiaPublisherAlgorithm, self).initAlgorithm()
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
options = OptionsCfg.read()
self.last_update_date = options[OptionsCfg.UPDATE_CHECK]
#self.addParameter(
# QgsProcessingParameterEnum(
# self.OPERATION,
# self.tr('Operation Type'),
# options=[self.tr(curOption) for curOption in OperationType.getOptions()],
# defaultValue=9
# )
#)
#TODO Implement layer attribute later.
# self.addParameter(
# QgsProcessingParameterString(
# self.LAYER_ATTRIBUTE,
# self.tr('Layer style name (Change to different style names only if interested in publishing multiple (layers or attributes) of the same file.)'),
# optional=False,
# defaultValue=options['attrName']
# )
# )
self.addParameter(
QgsProcessingParameterString(
self.GITHUB_REPOSITORY,
self.tr('* Repository name (or map group name)'),
optional=False,
defaultValue=options['gh_repository']))
# We add the input vector features source. It can have any kind of
# geometry.
layerParam = QgsProcessingParameterMultipleLayers(
self.LAYERS, self.tr('* Maps to display online'),
QgsProcessing.TypeMapLayer
#, defaultValue=[layer.id() for layer in iface.mapCanvas().layers()]#[layer.dataProvider().dataSourceUri(False) for layer in iface.mapCanvas().layers()]
)
layerParam.setMinimumNumberInputs(1)
self.addParameter(layerParam)
self.m_layerParam = layerParam
maxZoomParameter = QgsProcessingParameterNumber(
self.ZOOM_MAX,
self.tr('Map max Zoom level [1 ~ 13] (lower is faster)'),
minValue=1,
maxValue=13,
defaultValue=options["zoom_max"])
maxZoomParameter.setFlags(
maxZoomParameter.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(maxZoomParameter)
includeSourceDownload = QgsProcessingParameterBoolean(
self.INCLUDE_DOWNLOAD,
self.tr(
'Upload maps for further download (2GB limit per unique map)'),
defaultValue=options['include_dl'])
includeSourceDownload.setFlags(
includeSourceDownload.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(includeSourceDownload)
gitExeParameter = QgsProcessingParameterString(
self.GIT_EXECUTABLE,
self.tr('Git client executable path.'),
optional=True,
defaultValue=UTILS.getGitDefault(options['git_exe']))
gitExeParameter.setFlags(
gitExeParameter.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(gitExeParameter)
ghUserParameter = QgsProcessingParameterString(
self.GITHUB_USER,
self.tr('Github USERNAME (Credentials for https://github.com)'),
optional=True,
defaultValue=options['gh_user'])
ghUserParameter.setFlags(
ghUserParameter.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(ghUserParameter)
# ghPassParameter = QgsProcessingParameterString(
# self.GITHUB_PASS,
# self.tr('Github Access Token *'),
# optional=True,
# defaultValue=options['gh_pass']
# )
# ghPassParameter.setFlags(ghPassParameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
# self.addParameter(ghPassParameter)
askUserConfirmation = QgsProcessingParameterBoolean(
self.ASK_USER,
self.tr('Ask user confirmation before each step.'),
defaultValue=options['ask_user'])
askUserConfirmation.setFlags(
askUserConfirmation.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(askUserConfirmation)
outputDirParameter = QgsProcessingParameterFolderDestination(
self.OUTPUT_DIRECTORY,
self.tr('Output directory'),
optional=True,
defaultValue=options["folder"] or None)
outputDirParameter.setFlags(
outputDirParameter.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(outputDirParameter)
def initAlgorithm(self, config, label=True):
if DEBUG_MODE:
logMessage("initAlgorithm(): {}".format(self.__class__.__name__),
False)
qgis_iface = qgis.utils.plugins["Qgis2threejs"].iface
self.settings.loadSettingsFromFile()
self.settings.setMapSettings(qgis_iface.mapCanvas().mapSettings())
self.addParameter(
QgsProcessingParameterFolderDestination(
self.OUTPUT, self.tr("Output Directory")))
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT, self.tr("Coverage Layer"),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterField(self.TITLE_FIELD,
self.tr("Title Field"), None,
self.INPUT,
QgsProcessingParameterField.Any))
self.addParameter(
QgsProcessingParameterBoolean(self.CF_FILTER,
self.tr("Current Feature Filter")))
enum = ["Fit to Geometry", "Fixed Scale (based on map canvas)"]
self.addAdvancedParameter(
QgsProcessingParameterEnum(self.SCALE,
self.tr("Scale Mode"),
enum,
defaultValue=enum[0]))
self.addAdvancedParameter(
QgsProcessingParameterNumber(self.BUFFER,
self.tr("Buffer (%)"),
defaultValue=10))
self.addAdvancedParameter(
QgsProcessingParameterNumber(self.TEX_WIDTH,
self.tr("Texture base width (px)"),
defaultValue=1024))
self.addAdvancedParameter(
QgsProcessingParameterNumber(
self.TEX_HEIGHT,
self.
tr('Texture base height (px)\n'
' Leave this zero to respect aspect ratio of buffered geometry bounding box (in "Fit to Geometry" scale mode)\n'
' or map canvas (in "Fixed scale" scale mode).'),
defaultValue=0
# ,optional=True
))
if label:
self.addAdvancedParameter(
QgsProcessingParameterExpression(
self.HEADER, self.tr("Header Label"),
"'{}'".format(self.settings.headerLabel().replace(
"'", "''")), self.INPUT))
self.addAdvancedParameter(
QgsProcessingParameterExpression(
self.FOOTER, self.tr("Footer Label"),
"'{}'".format(self.settings.footerLabel().replace(
"'", "''")), self.INPUT))
self.addAdvancedParameter(
QgsProcessingParameterFile(
self.SETTINGS,
self.tr('Export Settings File (.qto3settings)'),
extension="qto3settings",
optional=True))
def addParametersOutputDirectoryGUI(self):
self.addParameter(
QgsProcessingParameterFolderDestination(
LAStoolsAlgorithm.OUTPUT_DIRECTORY, "output directory", None,
True))
def addParametersTemporaryDirectoryGUI(self):
self.addParameter(
QgsProcessingParameterFolderDestination(
LAStoolsAlgorithm.TEMPORARY_DIRECTORY,
"temporary directory (must be empty!!!)", None, False))
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()
# Destination parameter
if (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)
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')))
# 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
# DISTANCE
self.addParameter(
QgsProcessingParameterNumber(
self.DISTANCE,
self.tr('Distance in pixels'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
maxValue=99999,
defaultValue=100))
# MAX ITER
self.addParameter(
QgsProcessingParameterNumber(
self.MAXITER,
self.
tr('Maximum iteration (default : 0 e.g. class with min effective)'
),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
maxValue=99999,
defaultValue=0))
#
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):
label = tr("Connexion à la base de données")
tooltip = 'Nom de la connexion dans QGIS pour se connecter à la base de données'
if Qgis.QGIS_VERSION_INT >= 31400:
param = QgsProcessingParameterProviderConnection(
self.DATABASE,
label,
"postgres",
optional=False,
)
else:
param = QgsProcessingParameterString(self.DATABASE, label)
param.setMetadata(
{
"widget_wrapper": {
"class": "processing.gui.wrappers_postgis.ConnectionWidgetWrapper"
}
}
)
if Qgis.QGIS_VERSION_INT >= 31600:
param.setHelp(tooltip)
else:
param.tooltip_3liz = tooltip
self.addParameter(param)
# Schema de destination
label = tr("Schéma")
tooltip = 'Nom du schéma où importer les données'
default = 'veloroutes'
if Qgis.QGIS_VERSION_INT >= 31400:
param = QgsProcessingParameterDatabaseSchema(
self.SCHEMA,
label,
self.DATABASE,
defaultValue=default,
optional=False,
)
else:
param = QgsProcessingParameterString(self.SCHEMA, label, default, False, True)
param.setMetadata(
{
"widget_wrapper": {
"class": "processing.gui.wrappers_postgis.SchemaWidgetWrapper",
"connection_param": self.DATABASE,
}
}
)
if Qgis.QGIS_VERSION_INT >= 31600:
param.setHelp(tooltip)
else:
param.tooltip_3liz = tooltip
self.addParameter(param)
# Table à exporter
table_param = QgsProcessingParameterEnum(
self.TABLE,
tr("Donnée à exporter"),
options=self.EXPORTABLES,
defaultValue="",
)
table_param.tooltip_3liz = 'Nom de la table à exporter'
self.addParameter(table_param)
# Nom du département pour le fichier d'export
depparam = QgsProcessingParameterString(
self.DPT,
tr("Département au format XXX"),
'066',
optional=False
)
depparam.tooltip_3liz = 'Pour le département de l\'Ain, mettre 001'
self.addParameter(depparam)
# Chemin du dossier de destination
outparam = QgsProcessingParameterFolderDestination(
self.PROJECTS_FOLDER,
description=tr("Chemin de destination")
)
outparam.tooltip_3liz = 'Chemin de destination pour enregistrer les exports Shapefile'
self.addParameter(outparam)
param = QgsProcessingParameterBoolean(
self.CHARGER,
tr("Charger le fichier d'export dans le projet"),
defaultValue=False,
optional=False,
)
param.tooltip_3liz = 'Si le traitement doit charger la couche Shapefile dans le projet'
self.addParameter(param)
output = QgsProcessingOutputVectorLayer(self.OUTPUT, tr("Couches de sortie"))
output.tooltip_3liz = 'Les couches de l\'export'
self.addOutput(output)
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)
def initAlgorithm(self, config=None):
"""
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(
# QgsProcessingParameterFeatureSource(
# self.INPUT,
# self.tr('Input'),
# [QgsProcessing.TypeVectorAnyGeometry]
# )
#)
#self.addParameter(
# QgsProcessingParameterString(
# self.IN_DATE_MIN,
# self.tr('Date minimale'))
# )
#self.addParameter(
# QgsProcessingParameterString(
# self.IN_DATE_MAX,
# self.tr('Date maximale'))
# )
datDeb = QgsProcessingParameterString(self.IN_DATE_MIN, 'Date minimale')
datDeb.setMetadata({
'widget_wrapper': {
'class': DateWidget}})
self.addParameter(datDeb)
datFin = QgsProcessingParameterString(self.IN_DATE_MAX, 'Date maximale')
datFin.setMetadata({
'widget_wrapper': {
'class': DateWidget}})
self.addParameter(datFin)
self.addParameter(
QgsProcessingParameterExtent(
self.IN_EXTENT,
'Emprise du projet',
defaultValue=None))
self.addParameter(
QgsProcessingParameterEnum(
self.IN_LEVEL,
tr('Niveau de traitement'),
options=[tr('LEVEL2A'), tr('LEVEL3A')],
defaultValue=0,
optional=False)
)
self.addParameter(
QgsProcessingParameterFolderDestination(
self.OUTPUT,
self.tr('Images S2')
)
)
# 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(
# QgsProcessingParameterFeatureSink(
# self.OUTPUT,
# self.tr('Output layer')
# )
#)
params = []
params.append(QgsProcessingParameterString(self.IN_ID,
self.tr('Utilisateur'),
optional=False))
params.append(QgsProcessingParameterString(self.IN_PW,
self.tr('Mot de passe'),
optional=False))
params.append(QgsProcessingParameterBoolean(self.IN_SAVE_PW,
description="garder en mémoire",
optional=True,
defaultValue=False))
for p in params:
p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
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):
super().initAlgorithm(config)
self.addParameter(QgsProcessingParameterFolderDestination(
self.OUTPUT_DATA_FOLDER, 'Folder to store converted data in'))
