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))
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)
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):
class ParameterVrtDestination(QgsProcessingParameterRasterDestination):
def __init__(self, name, description):
super().__init__(name, description)
def clone(self):
copy = ParameterVrtDestination(self.name(), self.description())
return copy
def type(self):
return 'vrt_destination'
def defaultFileExtension(self):
return 'vrt'
self.addParameter(QgsProcessingParameterMultipleLayers(self.INPUT,
self.tr('Input layers'),
QgsProcessing.TypeRaster))
self.addParameter(QgsProcessingParameterEnum(self.RESOLUTION,
self.tr('Resolution'),
options=self.RESOLUTION_OPTIONS,
defaultValue=0))
self.addParameter(QgsProcessingParameterBoolean(self.SEPARATE,
self.tr('Place each input file into a separate band'),
defaultValue=True))
self.addParameter(QgsProcessingParameterBoolean(self.PROJ_DIFFERENCE,
self.tr('Allow projection difference'),
defaultValue=False))
add_alpha_param = QgsProcessingParameterBoolean(self.ADD_ALPHA,
self.tr('Add alpha mask band to VRT when source raster has none'),
defaultValue=False)
add_alpha_param.setFlags(add_alpha_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(add_alpha_param)
assign_crs = QgsProcessingParameterCrs(self.ASSIGN_CRS,
self.tr('Override projection for the output file'),
defaultValue=None, optional=True)
assign_crs.setFlags(assign_crs.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(assign_crs)
resampling = QgsProcessingParameterEnum(self.RESAMPLING,
self.tr('Resampling algorithm'),
options=self.RESAMPLING_OPTIONS,
defaultValue=0)
resampling.setFlags(resampling.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(resampling)
src_nodata_param = QgsProcessingParameterString(self.SRC_NODATA,
self.tr('Nodata value(s) for input bands (space separated)'),
defaultValue=None,
optional=True)
src_nodata_param.setFlags(src_nodata_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(src_nodata_param)
self.addParameter(ParameterVrtDestination(self.OUTPUT, QCoreApplication.translate("ParameterVrtDestination", 'Virtual')))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
extent_parameter = QgsProcessingParameterExtent(self.TARGET_AREA,
self.tr('Target area for layer'))
self.addParameter(extent_parameter)
# deprecated
crs_param = QgsProcessingParameterCrs(self.TARGET_AREA_CRS, 'Target area CRS', optional=True)
crs_param.setFlags(crs_param.flags() | QgsProcessingParameterDefinition.FlagHidden)
self.addParameter(crs_param)
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('CRS candidates')))
def initAlgorithm(self, config=None):
self.formats = ((self.tr('Auto'), 'AUTO'),
(self.tr('Well-known text (WKT)'), 'WKT'),
(self.tr('EPSG'), 'EPSG'),
(self.tr('Proj.4'), 'PROJ'))
self.addParameter(QgsProcessingParameterMultipleLayers(self.LAYERS,
self.tr('Input files'),
QgsProcessing.TypeRaster))
self.addParameter(QgsProcessingParameterString(self.PATH_FIELD_NAME,
self.tr('Field name to hold the file path to the indexed rasters'),
defaultValue='location'))
self.addParameter(QgsProcessingParameterBoolean(self.ABSOLUTE_PATH,
self.tr('Store absolute path to the indexed rasters'),
defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.PROJ_DIFFERENCE,
self.tr('Skip files with different projection reference'),
defaultValue=False))
target_crs_param = QgsProcessingParameterCrs(self.TARGET_CRS,
self.tr('Transform geometries to the given CRS'),
optional=True)
target_crs_param.setFlags(target_crs_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(target_crs_param)
crs_field_param = QgsProcessingParameterString(self.CRS_FIELD_NAME,
self.tr('The name of the field to store the SRS of each tile'),
optional=True)
crs_field_param.setFlags(crs_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(crs_field_param)
crs_format_param = QgsProcessingParameterEnum(self.CRS_FORMAT,
self.tr('The format in which the CRS of each tile must be written'),
options=[i[0] for i in self.formats],
allowMultiple=False,
defaultValue=0)
crs_format_param.setFlags(crs_format_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(crs_format_param)
self.addParameter(QgsProcessingParameterVectorDestination(self.OUTPUT,
self.tr('Tile index'),
QgsProcessing.TypeVectorPolygon))
class ModelerParameterDefinitionDialog(QDialog):
PARAMETER_NUMBER = 'Number'
PARAMETER_RASTER = 'Raster Layer'
PARAMETER_TABLE = 'Vector Layer'
PARAMETER_VECTOR = 'Feature Source'
PARAMETER_STRING = 'String'
PARAMETER_EXPRESSION = 'Expression'
PARAMETER_BOOLEAN = 'Boolean'
PARAMETER_TABLE_FIELD = 'Layer Field'
PARAMETER_EXTENT = 'Extent'
PARAMETER_FILE = 'File'
PARAMETER_POINT = 'Point'
PARAMETER_CRS = 'CRS'
PARAMETER_MULTIPLE = 'Multiple Input'
PARAMETER_BAND = 'Raster Band'
PARAMETER_MAP_LAYER = 'Map Layer'
paramTypes = [
PARAMETER_BOOLEAN,
PARAMETER_EXTENT,
PARAMETER_FILE,
PARAMETER_NUMBER,
PARAMETER_RASTER,
PARAMETER_STRING,
PARAMETER_EXPRESSION,
PARAMETER_MAP_LAYER,
PARAMETER_TABLE,
PARAMETER_TABLE_FIELD,
PARAMETER_VECTOR,
PARAMETER_POINT,
PARAMETER_CRS,
PARAMETER_MULTIPLE,
PARAMETER_BAND
]
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
settings = QgsSettings()
self.restoreGeometry(settings.value("/Processing/modelParametersDefinitionDialogGeometry", QByteArray()))
def closeEvent(self, event):
settings = QgsSettings()
settings.setValue("/Processing/modelParametersDefinitionDialogGeometry", self.saveGeometry())
super(ModelerParameterDefinitionDialog, self).closeEvent(event)
def setupUi(self):
self.setWindowTitle(self.tr('Parameter definition'))
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(20)
self.label = QLabel(self.tr('Parameter name'))
self.verticalLayout.addWidget(self.label)
self.nameTextBox = QLineEdit()
self.verticalLayout.addWidget(self.nameTextBox)
if isinstance(self.param, QgsProcessingParameterDefinition):
self.nameTextBox.setText(self.param.description())
if self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or \
isinstance(self.param, QgsProcessingParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(bool(self.param.defaultValue()))
self.verticalLayout.addWidget(self.state)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or \
isinstance(self.param, QgsProcessingParameterField):
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(param.parameterName())
if isinstance(definition, (QgsProcessingParameterFeatureSource, QgsProcessingParameterVectorLayer)):
self.parentCombo.addItem(definition.description(), definition.name())
if self.param is not None:
if self.param.parentLayerParameterName() == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
# add the datatype selector
self.verticalLayout.addWidget(QLabel(self.tr('Allowed data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Any'), -1)
self.datatypeCombo.addItem(self.tr('Number'), 0)
self.datatypeCombo.addItem(self.tr('String'), 1)
self.datatypeCombo.addItem(self.tr('Date/time'), 2)
self.verticalLayout.addWidget(self.datatypeCombo)
if self.param is not None and self.param.dataType() is not None:
# QComboBoxes indexes start at 0,
# self.param.datatype start with -1 that is why I need to do +1
datatypeIndex = self.param.dataType() + 1
self.datatypeCombo.setCurrentIndex(datatypeIndex)
self.multipleCheck = QCheckBox()
self.multipleCheck.setText(self.tr('Accept multiple fields'))
self.multipleCheck.setChecked(False)
if self.param is not None:
self.multipleCheck.setChecked(self.param.allowMultiple())
self.verticalLayout.addWidget(self.multipleCheck)
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
self.defaultTextBox.setToolTip(
self.tr('Default field name, or ; separated list of field names for multiple field parameters'))
if self.param is not None:
default = self.param.defaultValue()
if default is not None:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BAND or \
isinstance(self.param, QgsProcessingParameterBand):
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(param.parameterName())
if isinstance(definition, (QgsProcessingParameterRasterLayer)):
self.parentCombo.addItem(definition.description(), definition.name())
if self.param is not None:
if self.param.parentLayerParameterName() == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType in (
ModelerParameterDefinitionDialog.PARAMETER_VECTOR, ModelerParameterDefinitionDialog.PARAMETER_TABLE) or
isinstance(self.param, (QgsProcessingParameterFeatureSource, QgsProcessingParameterVectorLayer))):
self.verticalLayout.addWidget(QLabel(self.tr('Geometry type')))
self.shapetypeCombo = QComboBox()
self.shapetypeCombo.addItem(self.tr('Geometry Not Required'), QgsProcessing.TypeVector)
self.shapetypeCombo.addItem(self.tr('Point'), QgsProcessing.TypeVectorPoint)
self.shapetypeCombo.addItem(self.tr('Line'), QgsProcessing.TypeVectorLine)
self.shapetypeCombo.addItem(self.tr('Polygon'), QgsProcessing.TypeVectorPolygon)
self.shapetypeCombo.addItem(self.tr('Any Geometry Type'), QgsProcessing.TypeVectorAnyGeometry)
if self.param is not None:
self.shapetypeCombo.setCurrentIndex(self.shapetypeCombo.findData(self.param.dataTypes()[0]))
self.verticalLayout.addWidget(self.shapetypeCombo)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or
isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.verticalLayout.addWidget(QLabel(self.tr('Data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Any Map Layer'), QgsProcessing.TypeMapLayer)
self.datatypeCombo.addItem(self.tr('Vector (No Geometry Required)'), QgsProcessing.TypeVector)
self.datatypeCombo.addItem(self.tr('Vector (Point)'), QgsProcessing.TypeVectorPoint)
self.datatypeCombo.addItem(self.tr('Vector (Line)'), QgsProcessing.TypeVectorLine)
self.datatypeCombo.addItem(self.tr('Vector (Polygon)'), QgsProcessing.TypeVectorPolygon)
self.datatypeCombo.addItem(self.tr('Vector (Any Geometry Type)'), QgsProcessing.TypeVectorAnyGeometry)
self.datatypeCombo.addItem(self.tr('Raster'), QgsProcessing.TypeRaster)
self.datatypeCombo.addItem(self.tr('File'), QgsProcessing.TypeFile)
if self.param is not None:
self.datatypeCombo.setCurrentIndex(self.datatypeCombo.findData(self.param.layerType()))
self.verticalLayout.addWidget(self.datatypeCombo)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or
isinstance(self.param, QgsProcessingParameterNumber)):
self.verticalLayout.addWidget(QLabel(self.tr('Min value')))
self.minTextBox = QLineEdit()
self.verticalLayout.addWidget(self.minTextBox)
self.verticalLayout.addWidget(QLabel(self.tr('Max value')))
self.maxTextBox = QLineEdit()
self.verticalLayout.addWidget(self.maxTextBox)
if self.param is not None:
self.minTextBox.setText(str(self.param.minimum()))
self.maxTextBox.setText(str(self.param.maximum()))
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
self.defaultTextBox.setText(self.tr('0'))
if self.param is not None:
default = self.param.defaultValue()
if self.param.dataType() == QgsProcessingParameterNumber.Integer:
default = int(math.floor(default))
if default:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION or
isinstance(self.param, QgsProcessingParameterExpression)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultEdit = QgsExpressionLineEdit()
if self.param is not None:
self.defaultEdit.setExpression(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultEdit)
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
self.parentCombo.addItem(self.tr("None"), None)
idx = 1
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(param.parameterName())
if isinstance(definition, (QgsProcessingParameterFeatureSource, QgsProcessingParameterVectorLayer)):
self.parentCombo.addItem(definition.description(), definition.name())
if self.param is not None:
if self.param.parentLayerParameterName() == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or
isinstance(self.param, QgsProcessingParameterString)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE or
isinstance(self.param, QgsProcessingParameterFile)):
self.verticalLayout.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(
1 if self.param.behavior() == QgsProcessingParameterFile.Folder else 0)
self.verticalLayout.addWidget(self.fileFolderCombo)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or
isinstance(self.param, QgsProcessingParameterPoint)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS or
isinstance(self.param, QgsProcessingParameterCrs)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.selector = QgsProjectionSelectionWidget()
if self.param is not None:
self.selector.setCrs(QgsCoordinateReferenceSystem(self.param.defaultValue()))
else:
self.selector.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.verticalLayout.addWidget(self.selector)
self.verticalLayout.addSpacing(20)
self.requiredCheck = QCheckBox()
self.requiredCheck.setText(self.tr('Mandatory'))
self.requiredCheck.setChecked(True)
if self.param is not None:
self.requiredCheck.setChecked(not self.param.flags() & QgsProcessingParameterDefinition.FlagOptional)
self.verticalLayout.addWidget(self.requiredCheck)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel |
QDialogButtonBox.Ok)
self.buttonBox.setObjectName('buttonBox')
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.verticalLayout.addStretch()
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
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 reject(self):
self.param = None
settings = QgsSettings()
settings.setValue("/Processing/modelParametersDefinitionDialogGeometry", self.saveGeometry())
QDialog.reject(self)
def initAlgorithm(self, config):
'''
Here we define the inputs and output of the algorithm, along
with some other properties.
'''
self.addParameter(
QgsProcessingParameterVectorLayer(self.NETWORK,
self.tr('Network layer'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterVectorLayer(self.TRAJECTORY,
self.tr('Trajectory layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterField(
self.TRAJECTORY_ID,
self.tr('Trajectory ID'),
parentLayerParameterName=self.TRAJECTORY,
type=QgsProcessingParameterField.Any))
self.addParameter(
QgsProcessingParameterCrs(self.CRS,
self.tr('CRS of the Output layer'),
defaultValue='EPSG:4326'))
self.addParameter(
QgsProcessingParameterNumber(
self.MAX_SEARCH_DISTANCE,
self.tr('Maximum Search Distance [m]'),
type=QgsProcessingParameterNumber.Double,
defaultValue=20.0,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.SIGMA,
self.tr('Standard Deviation'),
type=QgsProcessingParameterNumber.Double,
defaultValue=50.0,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.MY,
self.tr('Expected Value'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(
self.BETA,
self.tr('Transition Weight'),
type=QgsProcessingParameterNumber.Double,
defaultValue=30.0,
minValue=0.0))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Matched Trajectory')))
def initAlgorithm(self, config=None):
self.profiles = ((self.tr('Mercator'), 'mercator'),
(self.tr('Geodetic'), 'geodetic'), (self.tr('Raster'),
'raster'))
self.methods = ((self.tr('Average'),
'average'), (self.tr('Nearest neighbour'), 'near'),
(self.tr('Bilinear'), 'bilinear'),
(self.tr('Cubic'), 'cubic'), (self.tr('Cubic spline'),
'cubicspline'),
(self.tr('Lanczos windowed sinc'),
'lanczos'), (self.tr('Antialias'), 'antialias'))
self.viewers = ((self.tr('All'), 'all'), (self.tr('GoogleMaps'),
'google'),
(self.tr('OpenLayers'),
'openlayers'), (self.tr('Leaflet'),
'leaflet'), (self.tr('None'), 'none'))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterEnum(self.PROFILE,
self.tr('Tile cutting profile'),
options=[i[0] for i in self.profiles],
allowMultiple=False,
defaultValue=0))
self.addParameter(
QgsProcessingParameterString(self.ZOOM,
self.tr('Zoom levels to render'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.VIEWER,
self.tr('Web viewer to generate'),
options=[i[0] for i in self.viewers],
allowMultiple=False,
defaultValue=0))
self.addParameter(
QgsProcessingParameterString(self.TITLE,
self.tr('Title of the map'),
optional=True))
self.addParameter(
QgsProcessingParameterString(self.COPYRIGHT,
self.tr('Copyright of the map'),
optional=True))
params = []
params.append(
QgsProcessingParameterEnum(self.RESAMPLING,
self.tr('Resampling method'),
options=[i[0] for i in self.methods],
allowMultiple=False,
defaultValue=0))
params.append(
QgsProcessingParameterCrs(
self.SOURCE_CRS,
self.
tr('The spatial reference system used for the source input data'
),
optional=True))
params.append(
QgsProcessingParameterNumber(
self.NODATA,
self.tr('Transparency value to assign to the input data'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0,
optional=True))
params.append(
QgsProcessingParameterString(
self.URL,
self.
tr('URL address where the generated tiles are going to be published'
),
optional=True))
params.append(
QgsProcessingParameterString(
self.GOOGLE_KEY,
self.
tr('Google Maps API key (http://code.google.com/apis/maps/signup.html)'
),
optional=True))
params.append(
QgsProcessingParameterString(
self.BING_KEY,
self.tr('Bing Maps API key (https://www.bingmapsportal.com/)'),
optional=True))
params.append(
QgsProcessingParameterBoolean(
self.RESUME,
self.tr('Generate only missing files'),
defaultValue=False))
params.append(
QgsProcessingParameterBoolean(
self.KML,
self.tr('Generate KML for Google Earth'),
defaultValue=False))
params.append(
QgsProcessingParameterBoolean(
self.NO_KML,
self.tr(
'Avoid automatic generation of KML files for EPSG:4326'),
defaultValue=False))
for param in params:
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
self.addParameter(
QgsProcessingParameterFolderDestination(
self.OUTPUT, self.tr('Output directory')))
def initAlgorithm(self, config=None):
self.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 okPressed(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()
self.param = QgsProcessingParameterField(
name, description, None, parent, datatype,
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_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)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentIndex() - 1])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description,
self.datatypeCombo.currentIndex() - 1)
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)
self.close()
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')))
self.addOutput(
QgsProcessingOutputFolder(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 initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterFile(self.INPUT, 'CSVファイル', extension='csv'))
# encoding of input file
#encParam = QgsProcessingParameterEnum(
# self.ENCODING,
# 'CSVファイルエンコーディング'
# )
#encParam.setOptions(self.encode)
#encParam.setAllowMultiple(False)
#encParam.setDefaultValue(QVariant('SJIS'))
# file encoding
#self.addParameter(
# encParam
#)
self.addParameter(
QgsProcessingParameterEnum('ENCODING',
'CSVファイルエンコーディング',
options=['SJIS', 'UTF-8'],
allowMultiple=False,
defaultValue='SJIS'))
self.addParameter(
QgsProcessingParameterVectorLayer(
'addresslayer',
'住所レイヤ',
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None))
self.addParameter(
QgsProcessingParameterField(
'addressfield',
'住所フィールド',
type=QgsProcessingParameterField.String,
parentLayerParameterName='addresslayer',
allowMultiple=False,
defaultValue=None))
self.addParameter(
QgsProcessingParameterVectorLayer(
'meshlayer',
'メッシュレイヤ',
types=[QgsProcessing.TypeVectorPolygon],
optional=False,
defaultValue=None))
self.addParameter(
QgsProcessingParameterField(
'meshid',
'メッシュIDフィールド',
type=QgsProcessingParameterField.String,
parentLayerParameterName='meshlayer',
optional=False,
allowMultiple=False))
self.addParameter(
QgsProcessingParameterNumber('limit_sample',
'最小サンプル数',
defaultValue=3))
self.addParameter(
QgsProcessingParameterNumber('maxdivide', '最大分割回数',
defaultValue=4))
self.addParameter(
QgsProcessingParameterBoolean('uneven_div',
'不均等分割',
defaultValue=False))
# propotinal division method
#propParam = QgsProcessingParameterEnum(
# "PROPDIV",
# self.tr('按分方法選択')
# )
#propParam.setOptions(self.proportional_div)
#propParam.setAllowMultiple(False)
#propParam.setDefaultValue(QVariant('人口'))
# file encoding
#self.addParameter(
# propParam
#)
#self.addParameter(QgsProcessingParameterVectorLayer('poplayer', '人口レイヤ',
# types=[QgsProcessing.TypeVectorPolygon], optional=True, defaultValue=None))
#self.addParameter(QgsProcessingParameterField('popfield', '人口フィールド',
# type=QgsProcessingParameterField.String, parentLayerParameterName='addresslayer', optional=True, allowMultiple=False, defaultValue=None))
# 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(
QgsProcessingParameterCrs('CRS', "出力ファイル座標系", optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Output layer')))
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)
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
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_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
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)
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):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PrmInputLayer, tr('Input point vector layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterEnum(self.PrmOutputFormat,
tr('Output format'),
options=[
tr('Coordinates in 2 fields'),
tr('Coordinates in 1 field'),
'GeoJSON', 'WKT', 'MGRS',
'Plus Codes'
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.PrmYFieldName,
tr('Latitude (Y), GeoJSON, WKT, MGRS, or Plus Codes field name'
),
defaultValue='y',
optional=True))
self.addParameter(
QgsProcessingParameterString(self.PrmXFieldName,
tr('Longitude (X) field name'),
defaultValue='x',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmCoordinateOrder,
tr('Coordinate order when using 1 field'),
options=[
tr('Lat,Lon (Y,X) - Google map order'),
tr('Lon,Lat (X,Y) order')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmCoordinateDelimiter,
tr('Coordinate delimiter when using 1 field'),
options=[tr('Comma'),
tr('Space'),
tr('Tab'),
tr('Other')],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.PrmOtherDelimiter,
tr('Other delimiter when using 1 field'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmOutputCRSType,
tr('Output CRS of coordinates added to a field'),
options=[
tr('WGS 84'),
tr('Layer CRS'),
tr('Project CRS'),
tr('Custom CRS')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterCrs(
self.PrmCustomCRS,
tr('Custom CRS for coordinates added to a field'),
'EPSG:4326',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmWgs84NumberFormat,
tr('Select Decimal or DMS degress for WGS 84 numbers'),
options=[tr('Decimal degrees'),
tr('DMS'),
tr('DDMMSS')],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmCoordinatePrecision,
tr('Decimal number precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=8,
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmDMSSecondPrecision,
tr('DMS second precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=0,
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmPlusCodesLength,
'Plus Codes length',
type=QgsProcessingParameterNumber.Integer,
defaultValue=11,
optional=False,
minValue=10,
maxValue=20))
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputLayer,
'Output layer'))
def initAlgorithm(self, config=None):
class ParameterVrtDestination(QgsProcessingParameterRasterDestination):
def __init__(self, name, description):
super().__init__(name, description)
def clone(self):
copy = ParameterVrtDestination(self.name(), self.description())
return copy
def defaultFileExtension(self):
return 'vrt'
def createFileFilter(self):
return '{} (*.vrt *.VRT)'.format(
QCoreApplication.translate("GdalAlgorithm", 'VRT files'))
def supportedOutputRasterLayerExtensions(self):
return ['vrt']
def parameterAsOutputLayer(self, definition, value, context):
return super(QgsProcessingParameterRasterDestination,
self).parameterAsOutputLayer(
definition, value, context)
def isSupportedOutputValue(self, value, context):
output_path = QgsProcessingParameters.parameterAsOutputLayer(
self, value, context)
if pathlib.Path(output_path).suffix.lower() != '.vrt':
return False, QCoreApplication.translate(
"GdalAlgorithm",
'Output filename must use a .vrt extension')
return True, ''
self.RESAMPLING_OPTIONS = ((self.tr('Nearest Neighbour'), 'nearest'),
(self.tr('Bilinear'), 'bilinear'),
(self.tr('Cubic Convolution'),
'cubic'), (self.tr('B-Spline Convolution'),
'cubicspline'),
(self.tr('Lanczos Windowed Sinc'),
'lanczos'), (self.tr('Average'),
'average'), (self.tr('Mode'),
'mode'))
self.RESOLUTION_OPTIONS = ((self.tr('Average'), 'average'),
(self.tr('Highest'),
'highest'), (self.tr('Lowest'), 'lowest'))
self.addParameter(
QgsProcessingParameterMultipleLayers(self.INPUT,
self.tr('Input layers'),
QgsProcessing.TypeRaster))
self.addParameter(
QgsProcessingParameterEnum(
self.RESOLUTION,
self.tr('Resolution'),
options=[i[0] for i in self.RESOLUTION_OPTIONS],
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(
self.SEPARATE,
self.tr('Place each input file into a separate band'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PROJ_DIFFERENCE,
self.tr('Allow projection difference'),
defaultValue=False))
add_alpha_param = QgsProcessingParameterBoolean(
self.ADD_ALPHA,
self.tr('Add alpha mask band to VRT when source raster has none'),
defaultValue=False)
add_alpha_param.setFlags(
add_alpha_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(add_alpha_param)
assign_crs = QgsProcessingParameterCrs(
self.ASSIGN_CRS,
self.tr('Override projection for the output file'),
defaultValue=None,
optional=True)
assign_crs.setFlags(assign_crs.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(assign_crs)
resampling = QgsProcessingParameterEnum(
self.RESAMPLING,
self.tr('Resampling algorithm'),
options=[i[0] for i in self.RESAMPLING_OPTIONS],
defaultValue=0)
resampling.setFlags(resampling.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(resampling)
src_nodata_param = QgsProcessingParameterString(
self.SRC_NODATA,
self.tr('Nodata value(s) for input bands (space separated)'),
defaultValue=None,
optional=True)
src_nodata_param.setFlags(
src_nodata_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(src_nodata_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(
ParameterVrtDestination(
self.OUTPUT,
QCoreApplication.translate("ParameterVrtDestination",
'Virtual')))
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(
QgsProcessingParameterString(self.ILIMODELS,
self.tr('Interlis models')))
self.addParameter(
QgsProcessingParameterString(
self.ILIDIR,
self.tr('Interlis model search path'),
defaultValue='http://models.geo.admin.ch/'))
self.addParameter(
QgsProcessingParameterFile(
'iliLocalPath',
self.tr('Local model directory'),
behavior=QgsProcessingParameterFile.Folder,
optional=True))
self.addParameter(
QgsProcessingParameterEnum('tableNaming',
self.tr('Table naming convention:'),
options=self.TABLE_NAMING,
defaultValue=1))
self.addParameter(
QgsProcessingParameterEnum(
'inheritanceMapping',
self.tr('Inheritance mapping strategy:'),
options=self.INHERTIANCE_MAPPINGS,
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(
'sqlNotNull',
self.tr('Create NOT NULL constraints'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
'createNumChecks',
self.tr('Create constraints for numeric data types'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean('createBasketCol',
self.tr('Generate T_basket column'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
'createDatasetCol',
self.tr('Generate T_datasetname column'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
'createFk',
self.tr('Generate foreign key constraints'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
'createFkIdx',
self.tr('Create an index on foreign key columns'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
'createGeomIdx',
self.tr('Create a spatial index on geometry columns'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean('strokeArcs',
self.tr('Stroke ARCS on import'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
'createEnumTabs',
self.tr('Generate tables with enum definitions'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterCrs('defaultSrsCode',
self.tr('Default SRS code (EPSG)'),
defaultValue=21781))
self.db_connections = dbConnectionNames()
self.addParameter(
QgsProcessingParameterEnum(self.DB,
self.tr('Database (connection name)'),
self.db_connections))
self.addParameter(
QgsProcessingParameterString('dbschema',
self.tr('Database schema name'),
defaultValue='public'))
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.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT,
self.tr('Input layer'),
types=[QgsProcessing.TypeVector]))
self.addParameter(
QgsProcessingParameterString(self.SHAPE_ENCODING,
self.tr('Shape encoding'),
"",
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.GTYPE,
self.tr('Output geometry type'),
options=self.GEOMTYPE,
defaultValue=0))
self.addParameter(
QgsProcessingParameterCrs(self.A_SRS,
self.tr('Assign an output CRS'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterCrs(
self.T_SRS,
self.tr('Reproject to this CRS on output '),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterCrs(self.S_SRS,
self.tr('Override source CRS'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(self.HOST,
self.tr('Host'),
defaultValue='localhost',
optional=True))
self.addParameter(
QgsProcessingParameterString(self.PORT,
self.tr('Port'),
defaultValue='5432',
optional=True))
self.addParameter(
QgsProcessingParameterString(self.USER,
self.tr('Username'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(self.DBNAME,
self.tr('Database name'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(self.PASSWORD,
self.tr('Password'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(self.SCHEMA,
self.tr('Schema name'),
defaultValue='public',
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.TABLE,
self.tr('Table name, leave blank to use input name'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(self.PK,
self.tr('Primary key (new field)'),
defaultValue='id',
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PRIMARY_KEY,
self.
tr('Primary key (existing field, used if the above option is left empty)'
),
parentLayerParameterName=self.INPUT,
optional=True))
self.addParameter(
QgsProcessingParameterString(self.GEOCOLUMN,
self.tr('Geometry column name'),
defaultValue='geom',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.DIM,
self.tr('Vector dimensions'),
options=self.DIMLIST,
defaultValue=0))
self.addParameter(
QgsProcessingParameterString(
self.SIMPLIFY,
self.tr('Distance tolerance for simplification'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.SEGMENTIZE,
self.tr('Maximum distance between 2 nodes (densification)'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterExtent(
self.SPAT,
self.tr(
'Select features by extent (defined in input layer CRS)'),
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.CLIP,
self.tr(
'Clip the input layer using the above (rectangle) extent'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterField(
self.FIELDS,
self.tr('Fields to include (leave empty to use all fields)'),
parentLayerParameterName=self.INPUT,
allowMultiple=True,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.WHERE,
self.
tr('Select features using a SQL "WHERE" statement (Ex: column=\'value\')'
),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.GT,
self.tr('Group N features per transaction (Default: 20000)'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(self.OVERWRITE,
self.tr('Overwrite existing table'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(self.APPEND,
self.tr('Append to existing table'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.ADDFIELDS,
self.tr('Append and add new fields to existing table'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.LAUNDER,
self.tr('Do not launder columns/table names'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.INDEX,
self.tr('Do not create spatial index'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.SKIPFAILURES,
self.tr(
'Continue after a failure, skipping the failed feature'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(self.PROMOTETOMULTI,
self.tr('Promote to Multipart'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PRECISION,
self.tr('Keep width and precision of input attributes'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True))
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PrmInputLayer, tr('Input layer'),
[QgsProcessing.TypeFile | QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterCrs(
self.PrmInputCRS,
tr('Input CRS for coordinates within the vector fields'),
'EPSG:4326'))
self.addParameter(
QgsProcessingParameterCrs(self.PrmOutputCRS,
tr('Output layer CRS'), 'EPSG:4326'))
self.addParameter(
QgsProcessingParameterEnum(self.PrmLineType,
tr('Line type'),
options=self.LINE_TYPE,
defaultValue=0,
optional=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.PrmStartUseLayerGeom,
tr('Use the point geometry for the line starting point'),
False,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmStartXField,
tr('Starting X Field (lon)'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmStartYField,
tr('Starting Y Field (lat)'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PrmEndUseLayerGeom,
tr('Use the point geometry for the line ending point'),
False,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmEndXField,
tr('Ending X Field (lon)'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmEndYField,
tr('Ending Y Field (lat)'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(self.PrmShowStartPoint,
tr('Show starting point'),
True,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(self.PrmShowEndPoint,
tr('Show ending point'),
True,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PrmDateLineBreak,
tr('Break lines at -180, 180 boundary for better rendering'),
False,
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputLineLayer,
tr('Output line layer')))
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputPointLayer,
tr('Output point layer'),
optional=True,
createByDefault=True))
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(
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)')))
class ModelerParameterDefinitionDialog(QDialog):
PARAMETER_NUMBER = 'Number'
PARAMETER_RASTER = 'Raster Layer'
PARAMETER_TABLE = 'Vector Layer'
PARAMETER_VECTOR = 'Vector Features'
PARAMETER_STRING = 'String'
PARAMETER_EXPRESSION = 'Expression'
PARAMETER_BOOLEAN = 'Boolean'
PARAMETER_TABLE_FIELD = 'Vector Field'
PARAMETER_EXTENT = 'Extent'
PARAMETER_FILE = 'File'
PARAMETER_POINT = 'Point'
PARAMETER_CRS = 'CRS'
PARAMETER_MULTIPLE = 'Multiple Input'
PARAMETER_BAND = 'Raster Band'
PARAMETER_MAP_LAYER = 'Map Layer'
paramTypes = [
PARAMETER_BOOLEAN, PARAMETER_EXTENT, PARAMETER_FILE, PARAMETER_NUMBER,
PARAMETER_RASTER, PARAMETER_STRING, PARAMETER_EXPRESSION,
PARAMETER_MAP_LAYER, PARAMETER_TABLE, PARAMETER_TABLE_FIELD,
PARAMETER_VECTOR, PARAMETER_POINT, PARAMETER_CRS, PARAMETER_MULTIPLE,
PARAMETER_BAND
]
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
settings = QgsSettings()
self.restoreGeometry(
settings.value(
"/Processing/modelParametersDefinitionDialogGeometry",
QByteArray()))
def closeEvent(self, event):
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
super(ModelerParameterDefinitionDialog, self).closeEvent(event)
def setupUi(self):
self.setWindowTitle(self.tr('Parameter Definition'))
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(20)
self.label = QLabel(self.tr('Parameter name'))
self.verticalLayout.addWidget(self.label)
self.nameTextBox = QLineEdit()
self.verticalLayout.addWidget(self.nameTextBox)
if isinstance(self.param, QgsProcessingParameterDefinition):
self.nameTextBox.setText(self.param.description())
if self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or \
isinstance(self.param, QgsProcessingParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(bool(self.param.defaultValue()))
self.verticalLayout.addWidget(self.state)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or \
isinstance(self.param, QgsProcessingParameterField):
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(
param.parameterName())
if isinstance(definition, (QgsProcessingParameterFeatureSource,
QgsProcessingParameterVectorLayer)):
self.parentCombo.addItem(definition.description(),
definition.name())
if self.param is not None:
if self.param.parentLayerParameterName(
) == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
# add the datatype selector
self.verticalLayout.addWidget(QLabel(self.tr('Allowed data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Any'), -1)
self.datatypeCombo.addItem(self.tr('Number'), 0)
self.datatypeCombo.addItem(self.tr('String'), 1)
self.datatypeCombo.addItem(self.tr('Date/time'), 2)
self.verticalLayout.addWidget(self.datatypeCombo)
if self.param is not None and self.param.dataType() is not None:
# QComboBoxes indexes start at 0,
# self.param.datatype start with -1 that is why I need to do +1
datatypeIndex = self.param.dataType() + 1
self.datatypeCombo.setCurrentIndex(datatypeIndex)
self.multipleCheck = QCheckBox()
self.multipleCheck.setText(self.tr('Accept multiple fields'))
self.multipleCheck.setChecked(False)
if self.param is not None:
self.multipleCheck.setChecked(self.param.allowMultiple())
self.verticalLayout.addWidget(self.multipleCheck)
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
self.defaultTextBox.setToolTip(
self.
tr('Default field name, or ; separated list of field names for multiple field parameters'
))
if self.param is not None:
default = self.param.defaultValue()
if default is not None:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BAND or \
isinstance(self.param, QgsProcessingParameterBand):
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(
param.parameterName())
if isinstance(definition, (QgsProcessingParameterRasterLayer)):
self.parentCombo.addItem(definition.description(),
definition.name())
if self.param is not None:
if self.param.parentLayerParameterName(
) == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType
in (ModelerParameterDefinitionDialog.PARAMETER_VECTOR,
ModelerParameterDefinitionDialog.PARAMETER_TABLE)
or isinstance(self.param, (QgsProcessingParameterFeatureSource,
QgsProcessingParameterVectorLayer))):
self.verticalLayout.addWidget(QLabel(self.tr('Geometry type')))
self.shapetypeCombo = QComboBox()
self.shapetypeCombo.addItem(self.tr('Geometry Not Required'),
QgsProcessing.TypeVector)
self.shapetypeCombo.addItem(self.tr('Point'),
QgsProcessing.TypeVectorPoint)
self.shapetypeCombo.addItem(self.tr('Line'),
QgsProcessing.TypeVectorLine)
self.shapetypeCombo.addItem(self.tr('Polygon'),
QgsProcessing.TypeVectorPolygon)
self.shapetypeCombo.addItem(self.tr('Any Geometry Type'),
QgsProcessing.TypeVectorAnyGeometry)
if self.param is not None:
self.shapetypeCombo.setCurrentIndex(
self.shapetypeCombo.findData(self.param.dataTypes()[0]))
self.verticalLayout.addWidget(self.shapetypeCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.verticalLayout.addWidget(QLabel(self.tr('Data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Any Map Layer'),
QgsProcessing.TypeMapLayer)
self.datatypeCombo.addItem(
self.tr('Vector (No Geometry Required)'),
QgsProcessing.TypeVector)
self.datatypeCombo.addItem(self.tr('Vector (Point)'),
QgsProcessing.TypeVectorPoint)
self.datatypeCombo.addItem(self.tr('Vector (Line)'),
QgsProcessing.TypeVectorLine)
self.datatypeCombo.addItem(self.tr('Vector (Polygon)'),
QgsProcessing.TypeVectorPolygon)
self.datatypeCombo.addItem(self.tr('Vector (Any Geometry Type)'),
QgsProcessing.TypeVectorAnyGeometry)
self.datatypeCombo.addItem(self.tr('Raster'),
QgsProcessing.TypeRaster)
self.datatypeCombo.addItem(self.tr('File'), QgsProcessing.TypeFile)
if self.param is not None:
self.datatypeCombo.setCurrentIndex(
self.datatypeCombo.findData(self.param.layerType()))
self.verticalLayout.addWidget(self.datatypeCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
self.verticalLayout.addWidget(QLabel(self.tr('Min value')))
self.minTextBox = QLineEdit()
self.verticalLayout.addWidget(self.minTextBox)
self.verticalLayout.addWidget(QLabel(self.tr('Max value')))
self.maxTextBox = QLineEdit()
self.verticalLayout.addWidget(self.maxTextBox)
if self.param is not None:
self.minTextBox.setText(str(self.param.minimum()))
self.maxTextBox.setText(str(self.param.maximum()))
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
self.defaultTextBox.setText(self.tr('0'))
if self.param is not None:
default = self.param.defaultValue()
if self.param.dataType(
) == QgsProcessingParameterNumber.Integer:
default = int(math.floor(default))
if default:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultEdit = QgsExpressionLineEdit()
if self.param is not None:
self.defaultEdit.setExpression(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultEdit)
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
self.parentCombo.addItem(self.tr("None"), None)
idx = 1
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(
param.parameterName())
if isinstance(definition, (QgsProcessingParameterFeatureSource,
QgsProcessingParameterVectorLayer)):
self.parentCombo.addItem(definition.description(),
definition.name())
if self.param is not None:
if self.param.parentLayerParameterName(
) == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
self.verticalLayout.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(1 if self.param.behavior(
) == QgsProcessingParameterFile.Folder else 0)
self.verticalLayout.addWidget(self.fileFolderCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.selector = QgsProjectionSelectionWidget()
if self.param is not None:
self.selector.setCrs(
QgsCoordinateReferenceSystem(self.param.defaultValue()))
else:
self.selector.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.verticalLayout.addWidget(self.selector)
self.verticalLayout.addSpacing(20)
self.requiredCheck = QCheckBox()
self.requiredCheck.setText(self.tr('Mandatory'))
self.requiredCheck.setChecked(True)
if self.param is not None:
self.requiredCheck.setChecked(
not self.param.flags()
& QgsProcessingParameterDefinition.FlagOptional)
self.verticalLayout.addWidget(self.requiredCheck)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.buttonBox.setObjectName('buttonBox')
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.verticalLayout.addStretch()
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
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 reject(self):
self.param = None
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.reject(self)
@staticmethod
def inputTooltip(input_type):
tooltips = {
ModelerParameterDefinitionDialog.PARAMETER_NUMBER:
QCoreApplication.translate(
'Processing',
'A numeric parameter, including float or integer values.'),
ModelerParameterDefinitionDialog.PARAMETER_RASTER:
QCoreApplication.translate('Processing',
'A raster layer parameter.'),
ModelerParameterDefinitionDialog.PARAMETER_TABLE:
QCoreApplication.translate(
'Processing',
'A vector layer parameter, e.g. for algorithms which change layer styles, edit layers in place, or other operations which affect an entire layer.'
),
ModelerParameterDefinitionDialog.PARAMETER_VECTOR:
QCoreApplication.translate(
'Processing',
'A vector feature parameter, e.g. for algorithms which operate on the features within a layer.'
),
ModelerParameterDefinitionDialog.PARAMETER_STRING:
QCoreApplication.translate('Processing',
'A freeform string parameter.'),
ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION:
QCoreApplication.translate(
'Processing',
'A QGIS expression parameter, which presents an expression builder widget to users.'
),
ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN:
QCoreApplication.translate(
'Processing', 'A boolean parameter, for true/false values.'),
ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD:
QCoreApplication.translate(
'Processing',
'A vector field parameter, for selecting an existing field from a vector source.'
),
ModelerParameterDefinitionDialog.PARAMETER_EXTENT:
QCoreApplication.translate('Processing',
'A map extent parameter.'),
ModelerParameterDefinitionDialog.PARAMETER_FILE:
QCoreApplication.translate(
'Processing',
'A file parameter, for use with non-map layer file sources.'),
ModelerParameterDefinitionDialog.PARAMETER_POINT:
QCoreApplication.translate('Processing',
'A geographic point parameter.'),
ModelerParameterDefinitionDialog.PARAMETER_CRS:
QCoreApplication.translate(
'Processing',
'A coordinate reference system (CRS) input parameter.'),
ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE:
QCoreApplication.translate(
'Processing',
'An input allowing selection of multiple sources, including multiple map layers or file sources.'
),
ModelerParameterDefinitionDialog.PARAMETER_BAND:
QCoreApplication.translate(
'Processing',
'A raster band parameter, for selecting an existing band from a raster source.'
),
ModelerParameterDefinitionDialog.PARAMETER_MAP_LAYER:
QCoreApplication.translate(
'Processing',
'A generic map layer parameter, which accepts either vector or raster layers.'
)
}
return tooltips[input_type]
def initAlgorithm(self, config=None):
class ParameterVrtDestination(QgsProcessingParameterRasterDestination):
def __init__(self, name, description):
super().__init__(name, description)
def clone(self):
copy = ParameterVrtDestination(self.name(), self.description())
return copy
def type(self):
return 'vrt_destination'
def defaultFileExtension(self):
return 'vrt'
self.addParameter(
QgsProcessingParameterMultipleLayers(self.INPUT,
self.tr('Input layers'),
QgsProcessing.TypeRaster))
self.addParameter(
QgsProcessingParameterEnum(self.RESOLUTION,
self.tr('Resolution'),
options=self.RESOLUTION_OPTIONS,
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(
self.SEPARATE,
self.tr('Place each input file into a separate band'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PROJ_DIFFERENCE,
self.tr('Allow projection difference'),
defaultValue=False))
add_alpha_param = QgsProcessingParameterBoolean(
self.ADD_ALPHA,
self.tr('Add alpha mask band to VRT when source raster has none'),
defaultValue=False)
add_alpha_param.setFlags(
add_alpha_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(add_alpha_param)
assign_crs = QgsProcessingParameterCrs(
self.ASSIGN_CRS,
self.tr('Override projection for the output file'),
defaultValue=None,
optional=True)
assign_crs.setFlags(assign_crs.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(assign_crs)
resampling = QgsProcessingParameterEnum(
self.RESAMPLING,
self.tr('Resampling algorithm'),
options=self.RESAMPLING_OPTIONS,
defaultValue=0)
resampling.setFlags(resampling.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(resampling)
src_nodata_param = QgsProcessingParameterString(
self.SRC_NODATA,
self.tr('Nodata value(s) for input bands (space separated)'),
defaultValue=None,
optional=True)
src_nodata_param.setFlags(
src_nodata_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(src_nodata_param)
self.addParameter(
ParameterVrtDestination(
self.OUTPUT,
QCoreApplication.translate("ParameterVrtDestination",
'Virtual')))
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(
QgsProcessingParameterCrs(
self.TARGET_CRS,
self.tr('Override the projection for the output file'),
defaultValue=None,
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.COPY_SUBDATASETS,
self.
tr('Copy all subdatasets of this file to individual output files'
),
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)
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)
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('Converted')))
class ModelerParameterDefinitionDialog(QDialog):
PARAMETER_NUMBER = 'Number'
PARAMETER_RASTER = 'Raster Layer'
PARAMETER_TABLE = 'Vector Layer'
PARAMETER_VECTOR = 'Feature Source'
PARAMETER_STRING = 'String'
PARAMETER_EXPRESSION = 'Expression'
PARAMETER_BOOLEAN = 'Boolean'
PARAMETER_TABLE_FIELD = 'Layer Field'
PARAMETER_EXTENT = 'Extent'
PARAMETER_FILE = 'File'
PARAMETER_POINT = 'Point'
PARAMETER_CRS = 'CRS'
PARAMETER_MULTIPLE = 'Multiple Input'
PARAMETER_BAND = 'Raster band'
paramTypes = [
PARAMETER_BOOLEAN, PARAMETER_EXTENT, PARAMETER_FILE, PARAMETER_NUMBER,
PARAMETER_RASTER, PARAMETER_STRING, PARAMETER_EXPRESSION,
PARAMETER_TABLE, PARAMETER_TABLE_FIELD, PARAMETER_VECTOR,
PARAMETER_POINT, PARAMETER_CRS, PARAMETER_MULTIPLE, PARAMETER_BAND
]
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
settings = QgsSettings()
self.restoreGeometry(
settings.value(
"/Processing/modelParametersDefinitionDialogGeometry",
QByteArray()))
def closeEvent(self, event):
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
super(ModelerParameterDefinitionDialog, self).closeEvent(event)
def setupUi(self):
self.setWindowTitle(self.tr('Parameter definition'))
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(20)
self.label = QLabel(self.tr('Parameter name'))
self.verticalLayout.addWidget(self.label)
self.nameTextBox = QLineEdit()
self.verticalLayout.addWidget(self.nameTextBox)
if isinstance(self.param, QgsProcessingParameterDefinition):
self.nameTextBox.setText(self.param.description())
if self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or \
isinstance(self.param, QgsProcessingParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(bool(self.param.defaultValue()))
self.verticalLayout.addWidget(self.state)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or \
isinstance(self.param, QgsProcessingParameterField):
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(
param.parameterName())
if isinstance(definition, (QgsProcessingParameterFeatureSource,
QgsProcessingParameterVectorLayer)):
self.parentCombo.addItem(definition.description(),
definition.name())
if self.param is not None:
if self.param.parentLayerParameterName(
) == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
# add the datatype selector
self.verticalLayout.addWidget(QLabel(self.tr('Allowed data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Any'), -1)
self.datatypeCombo.addItem(self.tr('Number'), 0)
self.datatypeCombo.addItem(self.tr('String'), 1)
self.datatypeCombo.addItem(self.tr('Date/time'), 2)
self.verticalLayout.addWidget(self.datatypeCombo)
if self.param is not None and self.param.dataType() is not None:
# QComboBoxes indexes start at 0,
# self.param.datatype start with -1 that is why I need to do +1
datatypeIndex = self.param.dataType() + 1
self.datatypeCombo.setCurrentIndex(datatypeIndex)
self.multipleCheck = QCheckBox()
self.multipleCheck.setText(self.tr('Accept multiple fields'))
self.multipleCheck.setChecked(False)
if self.param is not None:
self.multipleCheck.setChecked(self.param.allowMultiple())
self.verticalLayout.addWidget(self.multipleCheck)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BAND or \
isinstance(self.param, QgsProcessingParameterBand):
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(
param.parameterName())
if isinstance(definition, (QgsProcessingParameterRasterLayer)):
self.parentCombo.addItem(definition.description(),
definition.name())
if self.param is not None:
if self.param.parentLayerParameterName(
) == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.verticalLayout.addWidget(QLabel(self.tr('Shape type')))
self.shapetypeCombo = QComboBox()
self.shapetypeCombo.addItem(self.tr('Any'))
self.shapetypeCombo.addItem(self.tr('Point'))
self.shapetypeCombo.addItem(self.tr('Line'))
self.shapetypeCombo.addItem(self.tr('Polygon'))
if self.param is not None:
self.shapetypeCombo.setCurrentIndex(self.param.dataTypes()[0] +
1)
self.verticalLayout.addWidget(self.shapetypeCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.verticalLayout.addWidget(QLabel(self.tr('Data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Vector (any)'))
self.datatypeCombo.addItem(self.tr('Vector (point)'))
self.datatypeCombo.addItem(self.tr('Vector (line)'))
self.datatypeCombo.addItem(self.tr('Vector (polygon)'))
self.datatypeCombo.addItem(self.tr('Raster'))
self.datatypeCombo.addItem(self.tr('File'))
if self.param is not None:
self.datatypeCombo.setCurrentIndex(self.param.layerType() + 1)
self.verticalLayout.addWidget(self.datatypeCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
self.verticalLayout.addWidget(QLabel(self.tr('Min value')))
self.minTextBox = QLineEdit()
self.verticalLayout.addWidget(self.minTextBox)
self.verticalLayout.addWidget(QLabel(self.tr('Max value')))
self.maxTextBox = QLineEdit()
self.verticalLayout.addWidget(self.maxTextBox)
if self.param is not None:
self.minTextBox.setText(str(self.param.minimum()))
self.maxTextBox.setText(str(self.param.maximum()))
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
self.defaultTextBox.setText(self.tr('0'))
if self.param is not None:
default = self.param.defaultValue()
if self.param.dataType(
) == QgsProcessingParameterNumber.Integer:
default = int(math.floor(default))
if default:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultEdit = QgsExpressionLineEdit()
if self.param is not None:
self.defaultEdit.setExpression(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultEdit)
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
self.parentCombo.addItem(self.tr("None"), None)
idx = 1
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(
param.parameterName())
if isinstance(definition, (QgsProcessingParameterFeatureSource,
QgsProcessingParameterVectorLayer)):
self.parentCombo.addItem(definition.description(),
definition.name())
if self.param is not None:
if self.param.parentLayerParameterName(
) == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
self.verticalLayout.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(1 if self.param.behavior(
) == QgsProcessingParameterFile.Folder else 0)
self.verticalLayout.addWidget(self.fileFolderCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.selector = QgsProjectionSelectionWidget()
if self.param is not None:
self.selector.setCrs(
QgsCoordinateReferenceSystem(self.param.defaultValue()))
else:
self.selector.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.verticalLayout.addWidget(self.selector)
self.verticalLayout.addSpacing(20)
self.requiredCheck = QCheckBox()
self.requiredCheck.setText(self.tr('Mandatory'))
self.requiredCheck.setChecked(True)
if self.param is not None:
self.requiredCheck.setChecked(
not self.param.flags()
& QgsProcessingParameterDefinition.FlagOptional)
self.verticalLayout.addWidget(self.requiredCheck)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.buttonBox.setObjectName('buttonBox')
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.verticalLayout.addStretch()
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
def okPressed(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()
self.param = QgsProcessingParameterField(
name, description, None, parent, datatype,
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_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)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentIndex() - 1])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description,
self.datatypeCombo.currentIndex() - 1)
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)
self.close()
def cancelPressed(self):
self.param = None
self.close()
def initAlgorithm(self, config=None):
class ParameterRasterCalculatorExpression(QgsProcessingParameterString
):
def __init__(self, name='', description='', multiLine=False):
super().__init__(name, description, multiLine=multiLine)
self.setMetadata({
'widget_wrapper':
'processing.algs.qgis.ui.RasterCalculatorWidgets.ExpressionWidgetWrapper'
})
def type(self):
return 'raster_calc_expression'
def clone(self):
return ParameterRasterCalculatorExpression(
self.name(), self.description(), self.multiLine())
def evaluateForModeler(self, value, model):
for i in list(model.inputs.values()):
param = i.param
if isinstance(param, QgsProcessingParameterRasterLayer):
new = "{}@".format(os.path.basename(param.value))
old = "{}@".format(param.name())
value = value.replace(old, new)
for alg in list(model.algs.values()):
for out in alg.algorithm.outputs:
if isinstance(out, QgsProcessingOutputRasterLayer):
if out.value:
new = "{}@".format(
os.path.basename(out.value))
old = "{}:{}@".format(
alg.modeler_name, out.name)
value = value.replace(old, new)
return value
self.addParameter(
ParameterRasterCalculatorExpression(self.EXPRESSION,
self.tr('Expression'),
multiLine=True))
self.addParameter(
QgsProcessingParameterMultipleLayers(
self.LAYERS,
self.
tr('Reference layer(s) (used for automated extent, cellsize, and CRS)'
),
layerType=QgsProcessing.TypeRaster,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.CELLSIZE,
self.tr('Cell size (use 0 or empty to set it automatically)'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0,
optional=True))
self.addParameter(
QgsProcessingParameterExtent(self.EXTENT,
self.tr('Output extent'),
optional=True))
self.addParameter(
QgsProcessingParameterCrs(self.CRS, 'Output CRS', optional=True))
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Output')))
def initAlgorithm(self, config=None):
db_param = QgsProcessingParameterString(
self.DATABASE, self.tr('Database (connection name)'))
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
self.addParameter(db_param)
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterString(self.SHAPE_ENCODING,
self.tr('Shape encoding'),
"",
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.GTYPE,
self.tr('Output geometry type'),
options=self.GEOMTYPE,
defaultValue=0))
self.addParameter(
QgsProcessingParameterCrs(self.A_SRS,
self.tr('Assign an output CRS'),
defaultValue='',
optional=False))
self.addParameter(
QgsProcessingParameterCrs(
self.T_SRS,
self.tr('Reproject to this CRS on output '),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterCrs(self.S_SRS,
self.tr('Override source CRS'),
defaultValue='',
optional=True))
schema_param = QgsProcessingParameterString(
self.SCHEMA, self.tr('Schema (schema name)'), 'public', False,
True)
schema_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
'connection_param': self.DATABASE
}
})
self.addParameter(schema_param)
table_param = QgsProcessingParameterString(
self.TABLE,
self.tr('Table to import to (leave blank to use layer name)'), '',
False, True)
table_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers_postgis.TableWidgetWrapper',
'schema_param': self.SCHEMA
}
})
self.addParameter(table_param)
self.addParameter(
QgsProcessingParameterString(self.PK,
self.tr('Primary key (new field)'),
defaultValue='id',
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PRIMARY_KEY,
self.
tr('Primary key (existing field, used if the above option is left empty)'
),
parentLayerParameterName=self.INPUT,
optional=True))
self.addParameter(
QgsProcessingParameterString(self.GEOCOLUMN,
self.tr('Geometry column name'),
defaultValue='geom',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.DIM,
self.tr('Vector dimensions'),
options=self.DIMLIST,
defaultValue=0))
self.addParameter(
QgsProcessingParameterString(
self.SIMPLIFY,
self.tr('Distance tolerance for simplification'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.SEGMENTIZE,
self.tr('Maximum distance between 2 nodes (densification)'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterExtent(
self.SPAT,
self.tr(
'Select features by extent (defined in input layer CRS)'),
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.CLIP,
self.tr(
'Clip the input layer using the above (rectangle) extent'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterString(
self.WHERE,
self.
tr('Select features using a SQL "WHERE" statement (Ex: column=\'value\')'
),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.GT,
self.tr('Group N features per transaction (Default: 20000)'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(self.OVERWRITE,
self.tr('Overwrite existing table'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(self.APPEND,
self.tr('Append to existing table'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.ADDFIELDS,
self.tr('Append and add new fields to existing table'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.LAUNDER,
self.tr('Do not launder columns/table names'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.INDEX,
self.tr('Do not create spatial index'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.SKIPFAILURES,
self.tr(
'Continue after a failure, skipping the failed feature'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(self.PROMOTETOMULTI,
self.tr('Promote to Multipart'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PRECISION,
self.tr('Keep width and precision of input attributes'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT,
self.tr('Elevation raster')
)
)
self.addParameter(
QgsProcessingParameterCrs(
self.CRS,
self.tr('Projected CRS for denoising (choose on that fits the region)')
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.PIXELSIZE,
self.tr('Pixel size in meters of the input elevation data'),
defaultValue=30.0
)
)
self.addParameter(
QgsProcessingParameterBoolean(
self.REPROJECT,
self.tr('Reproject the raster back into the original CRS?')
)
)
self.addParameter(
QgsProcessingParameterFile(
self.MDENOISE,
self.tr('Location of the mdenoise executable'),
defaultValue = r'C:/Users/GIS/bin/MDenoise.exe'
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.N,
self.tr('Number of iterations'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=10
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.T,
self.tr('Threshold'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.95
)
)
self.addParameter(
QgsProcessingParameterRasterDestination(
self.OUTPUT,
self.tr('Smoothed elevation')
)
)
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input Layer'), types=[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(QgsProcessingParameterCrs(self.CRS, 'CRS'))
self.addOutput(QgsProcessingOutputVectorLayer(self.INPUT,
self.tr('Layer with projection')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterMultipleLayers(self.INPUT_LAYERS,
self.tr('Input layers'),
QgsProcessing.TypeRaster))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT_FOOTPRINTS,
self.tr('Images footprint'),
QgsProcessing.TypeVectorPolygon))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT_NADIRS,
self.tr('Images nadir'),
QgsProcessing.TypeVectorPoint))
self.addParameter(
QgsProcessingParameterEnum(
self.CAMERA_MODEL,
self.tr('Camera model defining FOV values'),
options=list(self.CAMERA_DATA.keys())))
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'))
# horizontal referred to flight direction => means wide angle
parameter = QgsProcessingParameterNumber(
self.HORIZONTAL_FOV,
self.tr('Wide camera angle'),
type=QgsProcessingParameterNumber.Double,
defaultValue=84.0,
minValue=0,
maxValue=360)
parameter.setFlags(parameter.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(parameter)
# vertical referred to flight direction => means tall angle
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.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 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: 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.CRS,
self.tr('Desired CRS')))
self.addOutput(QgsProcessingOutputRasterLayer(self.OUTPUT, self.tr('Layer with projection')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterNumber(
self.OUTSIZE,
self.tr('Set the size of the output file (In pixels or %)'),
minValue=1,
defaultValue=100))
self.addParameter(
QgsProcessingParameterBoolean(
self.OUTSIZE_PERC,
self.tr('Output size is a percentage of input size'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterString(
self.NO_DATA,
self.
tr("Nodata value, leave blank to take the nodata value from input"
),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.EXPAND,
self.tr('Expand'),
options=['none', 'gray', 'rgb', 'rgba'],
defaultValue=0))
self.addParameter(
QgsProcessingParameterCrs(
self.SRS,
self.
tr('Output projection for output file [leave blank to use input projection]'
),
defaultValue=None,
optional=True))
self.addParameter(
QgsProcessingParameterExtent(
self.PROJWIN,
self.tr('Subset based on georeferenced coordinates'),
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.SDS,
self.
tr('Copy all subdatasets of this file to individual output files'
),
defaultValue=False))
create_options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
optional=True)
create_options_param.setMetadata({
'widget_wrapper':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
})
self.addParameter(create_options_param)
self.addParameter(
QgsProcessingParameterEnum(self.RTYPE,
self.tr('Output raster type'),
options=self.TYPE,
defaultValue=5))
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Converted')))
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):
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, config):
x_min = -100e3
x_max = 200e3
y_min = -150e3
y_max = 150e3
dx = 750
dy = 750
x0 = -25e3
y0 = 0.0
sigma_x = 15e3
sigma_y = 15e3
self.addParameter(
QgsProcessingParameterCrs(self.TARGET_CRS, self.tr('Target CRS'),
'ProjectCrs'))
self.addParameter(
QgsProcessingParameterExtent(
self.EXTENT, self.tr('Extent'),
"{}, {}, {}, {}".format(x_min, x_max, y_min, y_max)))
self.addParameter(
QgsProcessingParameterNumber(self.DX,
self.tr("Grid spacing (dx, meters)"),
QgsProcessingParameterNumber.Double,
defaultValue=dx,
minValue=0.0))
self.addParameter(
QgsProcessingParameterNumber(self.DY,
self.tr("Grid spacing (dy, meters)"),
QgsProcessingParameterNumber.Double,
defaultValue=dy,
minValue=0.0))
self.addParameter(
QgsProcessingParameterPoint(self.CENTER, self.tr("Center"),
"{}, {}".format(x0, y0)))
s_x = QgsProcessingParameterNumber(
self.SIGMA_X,
self.tr("Spread in the X direction (sigma_x)"),
QgsProcessingParameterNumber.Double,
defaultValue=sigma_x,
minValue=0.0)
s_x.setFlags(s_x.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(s_x)
s_y = QgsProcessingParameterNumber(
self.SIGMA_Y,
self.tr("Spread in the Y direction (sigma_y)"),
QgsProcessingParameterNumber.Double,
defaultValue=sigma_y,
minValue=0.0)
s_y.setFlags(s_y.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(s_y)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Testing DEM')))
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PrmInputLayer, tr('Input point vector layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterEnum(self.PrmOutputFormat,
tr('Output format'),
options=[
tr('Coordinates in 2 fields'),
tr('Coordinates in 1 field'),
tr('GeoJSON'),
tr('WKT'),
tr('MGRS'),
tr('Plus Codes'),
tr('Geohash'),
tr('Standard UTM')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.PrmYFieldName,
tr('Name of latitude (Y) field & all other single field coordinates'
),
defaultValue='y',
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.PrmXFieldName,
tr('Name of longitude (X) field when coordinates are in two fields'
),
defaultValue='x',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmCoordinateOrder,
tr('Coordinate order when using 1 field'),
options=[
tr('Lat,Lon (Y,X) - Google map order'),
tr('Lon,Lat (X,Y) order')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.PrmCoordinateDelimiter,
tr('Delimiter between coordinates when using 1 field'),
defaultValue=',',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmOutputCRSType,
tr('Output CRS of coordinates added to a field'),
options=[
tr('WGS 84'),
tr('Layer CRS'),
tr('Project CRS'),
tr('Custom CRS')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterCrs(
self.PrmCustomCRS,
tr('Custom CRS for coordinates added to a field'),
'EPSG:4326',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmWgs84NumberFormat,
tr('Select Decimal or DMS degress for WGS 84 numbers'),
options=[
tr('Decimal degrees'),
tr('D° M\' S"'),
tr('D° M.MM'),
tr('DDMMSS')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PrmDmsAddSpace,
tr('Add space between DMS and D M.MM numbers'),
False,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmCoordinatePrecision,
tr('Decimal number precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=8,
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmDMSSecondPrecision,
tr('DMS / Degrees Minutes / UTM precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=0,
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmPlusCodesLength,
tr('Plus Codes length'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=11,
optional=True,
minValue=10,
maxValue=20))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmGeohashPrecision,
tr('Geohash precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=12,
optional=True,
minValue=1,
maxValue=30))
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputLayer,
tr('Output layer')))
