def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.FLOOD_POLYGON_INPUT,
self.tr('Flood Extent')
# [QgsProcessing.TypeVectorPolygon]
))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.DEM_INPUT, self.tr('Digital Elevation Model')))
# 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(
QgsProcessingParameterFolderDestination(
self.FLOOD_DEPTH_OUTPUT, self.tr('Output Directory')))
def initAlgorithm(self, config=None):
self.methods = [
self.tr('Number of selected features'),
self.tr('Percentage of selected features')
]
self.addParameter(
QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterField(self.FIELD, self.tr('ID field'), None,
self.INPUT))
self.addParameter(
QgsProcessingParameterEnum(self.METHOD, self.tr('Method'),
self.methods, False, 0))
self.addParameter(
QgsProcessingParameterNumber(
self.NUMBER, self.tr('Number/percentage of selected features'),
QgsProcessingParameterNumber.Integer, 10, False, 0.0,
999999999999.0))
self.addOutput(
QgsProcessingOutputVectorLayer(
self.OUTPUT, self.tr('Selected (stratified random)')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterVectorLayer(
name=self.INPUT,
description=self.tr('Input Vector Layer'),
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None,
optional=False)
)
self.addParameter(
QgsProcessingParameterBoolean(
name=self.M2,
description=self.tr('Square Meters'),
optional=False,
defaultValue=self.m2)
)
self.addParameter(
QgsProcessingParameterBoolean(
name=self.KM2,
description=self.tr('Square Kilometers'),
optional=False,
defaultValue=self.km2)
)
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterMultipleLayers(
self.INPUTLAYERS, self.tr('Coverage Polygon Layers'),
QgsProcessing.TypeVectorPolygon))
self.addParameter(
QgsProcessingParameterBoolean(
self.SELECTED, self.tr('Process only selected features')))
self.addParameter(
QgsProcessingParameterVectorLayer(
self.FRAMELAYER,
self.tr('Frame Layer'), [QgsProcessing.TypeVectorPolygon],
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.FLAGS,
self.tr('{0} Flags').format(self.displayName())))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT_LAYER, 'Input layer',
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterField(self.FIELDS,
'Attributes to keep',
None,
self.INPUT_LAYER,
allowMultiple=True))
self.addParameter(
QgsProcessingParameterString(self.SCHEMA, 'Output schema',
'public'))
self.addParameter(
QgsProcessingParameterString(self.TABLE, 'Output table name',
'validlayer'))
self.addParameter(
QgsProcessingParameterString(
self.OPTIONS,
'Additional creation options (see ogr2ogr manual)',
'',
optional=True))
def initAlgorithm(self, config=None):
self.i18n_operators = ['=',
'!=',
'>',
'>=',
'<',
'<=',
self.tr('begins with'),
self.tr('contains'),
self.tr('is null'),
self.tr('is not null'),
self.tr('does not contain')
]
self.addParameter(QgsProcessingParameterVectorLayer(self.INPUT, self.tr('Input layer'), types=[QgsProcessing.TypeVector]))
self.addParameter(QgsProcessingParameterField(self.FIELD,
self.tr('Selection attribute'), parentLayerParameterName=self.INPUT))
self.addParameter(QgsProcessingParameterEnum(self.OPERATOR,
self.tr('Operator'), self.i18n_operators))
self.addParameter(QgsProcessingParameterString(self.VALUE, self.tr('Value')))
self.addOutput(QgsProcessingOutputVectorLayer(self.OUTPUT, self.tr('Selected (attribute)')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterVectorLayer(
'vectorwithclassificationandreference',
'Vector with reference data',
types=[QgsProcessing.TypeVector],
defaultValue=None))
#self.addParameter(QgsProcessingParameterVectorLayer('vectorwithclassificationandreference', 'Vector with classification', types=[QgsProcessing.TypeVector], defaultValue='C:/Users/Gorica/Documents/Teaching_2020_2021/Lab/Sampling points/stratified_random_sampling1_classified.gpkg'))
self.addParameter(
QgsProcessingParameterField(
'reference',
'Reference data column',
type=QgsProcessingParameterField.Numeric,
parentLayerParameterName='vectorwithclassificationandreference',
allowMultiple=False,
defaultValue=None))
self.addParameter(
QgsProcessingParameterString('Newfieldname',
'Name of new field for raster values',
multiLine=False,
defaultValue='Thematic_class'))
self.addParameter(
QgsProcessingParameterRasterLayer('raster',
'Raster to be sampled',
defaultValue=None))
self.addParameter(
QgsProcessingParameterFileDestination(
'Outputfolder',
'Error matrix output path',
fileFilter='CSV Files (*.csv)',
defaultValue=None))
self.addParameter(
QgsProcessingParameterFeatureSink(
'Sampled',
'Sampled',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True)) #, defaultValue=None))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(
self.DINF_FLOWDIR, self.tr("D-infinity flow directions")))
self.addParameter(
QgsProcessingParameterRasterLayer(self.TRANSPORT_SUPPLY,
self.tr("Transport supply")))
self.addParameter(
QgsProcessingParameterRasterLayer(self.TRANSPORT_CAPACITY,
self.tr("Transport capacity")))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_CONCENTRATION,
self.tr("Input concentration"),
optional=True))
self.addParameter(
QgsProcessingParameterVectorLayer(
self.OUTLETS,
self.tr("Outlets"),
types=[QgsProcessing.TypeVectorPoint],
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.EDGE_CONTAMINATION,
self.tr("Check for edge contamination"),
defaultValue=False))
self.addParameter(
QgsProcessingParameterRasterDestination(
self.TRANLIM_ACCUM, self.tr("Transport limited accumulation")))
self.addParameter(
QgsProcessingParameterRasterDestination(self.DEPOSITION,
self.tr("Deposition")))
self.addParameter(
QgsProcessingParameterRasterDestination(
self.OUTPUT_CONCENTRATION,
self.tr("Output concentration"),
optional=True))
def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterDistance(self.INPUT_DISTANCE,
self.tr('Distance of the buffer')))
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT_DEM,
self.tr('Input DEM'),
defaultValue=None))
self.addParameter(
QgsProcessingParameterVectorLayer(self.INPUT_POINTS,
self.tr('Input points'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterVectorDestination(
self.OUTPUT_SUMMIT,
self.tr('Local summits near the points of interest'),
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue=None))
self.addParameter(
QgsProcessingParameterField(
self.INPUT_FIELD,
self.tr("Unique ID field"),
optional=True,
type=QgsProcessingParameterField.Any,
parentLayerParameterName=self.INPUT_POINTS,
allowMultiple=False,
defaultValue=None))
self.addParameter(
QgsProcessingParameterFolderDestination(
self.OUTPUT_FOLDER,
self.tr("Folder for intermediate results")))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFile(self.DBPATH,
'Morpheo database',
extension='sqlite'))
self.addParameter(
QgsProcessingParameterVectorLayer(self.WAY_LAYER, 'Ways layer',
[QgsProcessing.TypeVectorLine]))
# Options controlling ways
self.addParameter(
QgsProcessingParameterField(
self.WAY_ATTRIBUTE,
'Attribute for mesh structure',
parentLayerParameterName=self.WAY_LAYER,
type=QgsProcessingParameterField.String))
self.addParameter(
QgsProcessingParameterNumber(
self.PERCENTILE,
'The percentile for computing the mesh structure',
minValue=1.,
maxValue=99,
defaultValue=5))
self.addParameter(
QgsProcessingParameterBoolean(
self.USE_WAY, 'Use ways for computing mesh components', False))
self.addParameter(
QgsProcessingParameterMorpheoDestination(
self.OUTPUT_MESH,
"Mesh output",
type=QgsProcessing.TypeVectorLine))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input Point Layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterNumber(
self.BUFFER_REGION,
self.tr('Buffer Region'),
defaultValue=0.0,
minValue=-0.0,
type=QgsProcessingParameterNumber.Double,
optional=True))
self.addParameter(
QgsProcessingParameterExtent(self.EXTENT,
description=self.tr('Extent'),
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('ThiessenPolygons'),
QgsProcessing.TypeVectorPolygon))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterVectorLayer(
name=self.INPUT,
description=self.tr('Input Vector Layer'),
types=[QgsProcessing.TypeVectorLine],
defaultValue=None,
optional=False))
self.addParameter(
QgsProcessingParameterBoolean(name=self.M,
description=self.tr('Meters'),
optional=False,
defaultValue=self.m))
self.addParameter(
QgsProcessingParameterBoolean(name=self.KM,
description=self.tr('Kilometers'),
optional=False,
defaultValue=self.km))
self.addParameter(
QgsProcessingParameterBoolean(
name=self.NM,
description=self.tr('Nautical Miles'),
optional=False,
defaultValue=self.nm))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT_POLYGONS, self.tr("Input polygon layer"),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT_ADDITIONAL, self.tr("Additional input layer"),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterField(
self.VALUE_FIELD,
self.tr("Attribute field"),
parentLayerParameterName=self.INPUT_ADDITIONAL,
type=0,
optional=False))
self.vals = [self.tr("Maximum"), self.tr("Minimum")]
self.addParameter(
QgsProcessingParameterEnum(self.M_VAL,
self.tr("Select Value"),
options=self.vals,
defaultValue=0))
self.methods = [
self.tr('creating new selection'),
self.tr('adding to current selection'),
self.tr('removing from current selection'),
self.tr('selecting within current selection')
]
self.addParameter(
QgsProcessingParameterEnum(self.METHOD,
self.tr('Modify current selection by'),
options=self.methods,
defaultValue=0))
self.addOutput(
QgsProcessingOutputVectorLayer(self.OUTPUT,
self.tr('Selected (attribute)')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterVectorLayer(
'addresslayer',
'住所レイヤ',
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None))
self.addParameter(
QgsProcessingParameterField(
'addressfield',
'住所フィールド',
type=QgsProcessingParameterField.String,
parentLayerParameterName='addresslayer',
allowMultiple=False,
defaultValue=None))
#self.addParameter(QgsProcessingParameterFile('CSVfile', 'CSV file', behavior=QgsProcessingParameterFile.File, fileFilter='All Files（*.*）', defaultValue=None))
self.addParameter(
QgsProcessingParameterFile('CSVfile',
'入力csvファイル指定',
extension='csv'))
self.addParameter(
QgsProcessingParameterEnum('encode',
'ENCODE',
options=['SJIS', 'UTF-8'],
allowMultiple=False,
defaultValue=None))
self.addParameter(
QgsProcessingParameterVectorDestination(
'GeojsonOutput',
'出力geojsonファイル名',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue=None))
def initAlgorithm(self, config=None):
self.operators = ['=',
'≠',
'>',
'>=',
'<',
'<=',
self.tr('begins with'),
self.tr('contains'),
self.tr('is null'),
self.tr('is not null'),
self.tr('does not contain')
]
self.methods = [self.tr('creating new selection'),
self.tr('adding to current selection'),
self.tr('removing from current selection'),
self.tr('selecting within current selection')]
self.addParameter(QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input layer'),
types=[QgsProcessing.TypeVector]))
self.addParameter(QgsProcessingParameterField(self.FIELD,
self.tr('Selection attribute'),
parentLayerParameterName=self.INPUT))
self.addParameter(QgsProcessingParameterEnum(self.OPERATOR,
self.tr('Operator'), self.operators))
self.addParameter(QgsProcessingParameterString(self.VALUE,
self.tr('Value'),
optional=True))
self.addParameter(QgsProcessingParameterEnum(self.METHOD,
self.tr('Modify current selection by'),
self.methods,
0))
self.addOutput(QgsProcessingOutputVectorLayer(self.OUTPUT, self.tr('Selected (attribute)')))
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT, self.tr('Input Polygon Layer'),
[QgsProcessing.TypeVectorPolygon]))
self.scales = [
'1000k', '500k', '250k', '100k', '50k', '25k', '10k', '5k', '2k',
'1k'
]
self.addParameter(
QgsProcessingParameterEnum(self.STOP_SCALE,
self.tr('Desired scale'),
options=self.scales,
defaultValue=0))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Created Frames')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT,
self.tr("Input"),
types=[QgsProcessing.TypeVectorLine],
defaultValue=None,
))
self.addParameter(
QgsProcessingParameterString(self.LAYER_NAME,
self.tr("Layer name"),
defaultValue=None))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.DEM,
self.tr("Digital Elevation Model"),
defaultValue=None))
self.addParameter(
QgsProcessingParameterBand(
self.BAND,
self.tr("Band number"),
1,
"RASTER",
))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterMultipleLayers(
'INPUT',
'Input rasters',
layerType=QgsProcessing.TypeRaster,
defaultValue=None))
self.addParameter(
QgsProcessingParameterVectorLayer(
'Masklayer',
'Mask layer',
types=[QgsProcessing.TypeVectorPolygon],
defaultValue=None))
param = QgsProcessingParameterFile(
'OUTFOLDER',
'Folder to store clipped rasters',
behavior=QgsProcessingParameterFile.Folder,
defaultValue=None,
optional=True)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param, createOutput=True)
self.addOutput(
QgsProcessingOutputMultipleLayers('OUTPUT', 'Clipped rasters'))
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]
)
)
self.addParameter(
QgsProcessingParameterBoolean(
self.SELECTED,
self.tr('Process only selected features')
)
)
self.addOutput(QgsProcessingOutputVectorLayer(
self.INPUT,
self.tr('Original layer updated')
)
)
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input Vector Layer'),
[QgsProcessing.TypeVector]))
self.addParameter(
QgsProcessingParameterNumber(
self.MAX_DISTANCE,
self.tr('Maximum Distance'),
defaultValue=-1.0,
minValue=-1.0,
type=QgsProcessingParameterNumber.Double,
optional=True))
self.addParameter(
QgsProcessingParameterExtent(self.EXTENT,
description=self.tr('Extent'),
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.CELL_SIZE,
self.tr('Cell Size'),
defaultValue=0.0,
minValue=0.0,
type=QgsProcessingParameterNumber.Double,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.RASTER_TYPE,
self.tr('Raster Type'),
self.RASTER_TYPES,
0,
optional=True))
self.addParameter(
QgsProcessingParameterRasterDestination(
self.OUTPUT, self.tr('Distance raster')))
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT, self.tr('Input layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterBoolean(
self.SELECTED, self.tr('Process only selected features')))
self.addParameter(
QgsProcessingParameterNumber(
self.TOLERANCE,
self.tr('Angular tolerance in decimal degrees'),
minValue=0,
defaultValue=0.1,
type=QgsProcessingParameterNumber.Double))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.FLAGS,
self.tr('{0} Flags').format(self.displayName())))
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT, self.tr('Input layer'), [
QgsProcessing.TypeVectorLine,
QgsProcessing.TypeVectorPolygon
]))
self.addParameter(
QgsProcessingParameterBoolean(
self.SELECTED, self.tr('Process only selected features')))
self.addParameter(
QgsProcessingParameterDistance(self.SEARCH_RADIUS,
self.tr('Search Radius'),
defaultValue=1.0))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.FLAGS,
self.tr('{0} Flags').format(self.displayName())))
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT, self.tr('Input layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterBoolean(
self.SELECTED, self.tr('Process only selected features')))
self.addParameter(
QgsProcessingParameterNumber(self.MIN_AREA,
self.tr('Max dissolve area'),
minValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterField(self.ATTRIBUTE_BLACK_LIST,
self.tr('Fields to ignore'),
None,
'INPUT',
QgsProcessingParameterField.Any,
allowMultiple=True,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(self.IGNORE_VIRTUAL_FIELDS,
self.tr('Ignore virtual fields'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(self.IGNORE_PK_FIELDS,
self.tr('Ignore primary key fields'),
defaultValue=True))
self.addOutput(
QgsProcessingOutputVectorLayer(
self.OUTPUT,
self.tr('Original layer with dissolved polygons')))
def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT, self.tr('Fichier vectoriel'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterField(self.INSEE_CODE, 'Code INSEE', '',
self.INPUT))
self.addParameter(
QgsProcessingParameterField(self.COMMUNE_NAME, 'Nom', '',
self.INPUT))
self.addParameter(
QgsProcessingParameterNumber(
name=self.EPSG_CODE,
description=self.tr('Code EPSG'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=2154))
self.addOutput(
QgsProcessingOutputMultipleLayers(self.OUTPUT_LAYERS,
self.tr('Output layers')))
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]
)
)
self.addParameter(
QgsProcessingParameterBoolean(
self.SELECTED,
self.tr('Process only selected features')
)
)
self.addParameter(
QgsProcessingParameterBoolean(
self.TYPE,
self.tr('Fix input geometries'),
defaultValue=False
)
)
self.addParameter(
QgsProcessingParameterFeatureSink(
self.FLAGS,
self.tr('{0} Flags').format(self.displayName())
)
)
self.addOutput(
QgsProcessingOutputVectorLayer(
self.OUTPUT,
self.tr('Original layer (has fixed geometries if fix mode is chosen)')
)
)
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterRasterLayer(self.DINF_FLOWDIR,
self.tr("D-infinity flow directions")))
self.addParameter(QgsProcessingParameterRasterLayer(self.DECAY_MULTIPLIER,
self.tr("Decay multiplier")))
self.addParameter(QgsProcessingParameterRasterLayer(self.DISTURBANCE_INDICATOR,
self.tr("Disturbance indicator")))
self.addParameter(QgsProcessingParameterRasterLayer(self.RUNOFF_WEIGHT,
self.tr("Effective runoff weight")))
self.addParameter(QgsProcessingParameterVectorLayer(self.OUTLETS,
self.tr("Outlets"),
types=[QgsProcessing.TypeVectorPoint],
optional=True))
self.addParameter(QgsProcessingParameterNumber(self.CONCENTRATION_THRESHOLD,
self.tr("Concentration threshold"),
QgsProcessingParameterNumber.Double,
1,
True))
self.addParameter(QgsProcessingParameterBoolean(self.EDGE_CONTAMINATION,
self.tr("Check for edge contamination"),
defaultValue=False))
self.addParameter(QgsProcessingParameterRasterDestination(self.CONCENTRATION,
self.tr("Concentration")))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input Layer'),
[QgsProcessing.TypeVectorPolygon, QgsProcessing.TypeVectorPoint, QgsProcessing.TypeVectorLine]))
self.addOutput(QgsProcessingOutputVectorLayer(self.OUTPUT, self.tr('Indexed 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_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType == parameters.PARAMETER_TABLE_FIELD
or isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(
name,
description,
defaultValue=default,
parentLayerParameterName=parent,
type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == parameters.PARAMETER_BAND
or isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None,
parent)
elif (self.paramType == parameters.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType == parameters.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType == parameters.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType == parameters.PARAMETER_NUMBER or isinstance(
self.param,
(QgsProcessingParameterNumber, QgsProcessingParameterDistance))):
try:
self.param = QgsProcessingParameterNumber(
name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType == parameters.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType == parameters.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == parameters.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(
name, description, QgsProcessingParameterFile.Folder
if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType == parameters.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
elif (self.paramType == parameters.PARAMETER_ENUM
or isinstance(self.param, QgsProcessingParameterEnum)):
self.param = QgsProcessingParameterEnum(
name, description, self.widget.options(),
self.widget.allowMultiple(), self.widget.defaultOptions())
elif (self.paramType == parameters.PARAMETER_MATRIX
or isinstance(self.param, QgsProcessingParameterMatrix)):
self.param = QgsProcessingParameterMatrix(
name,
description,
hasFixedNumberRows=self.widget.fixedRows(),
headers=self.widget.headers(),
defaultValue=self.widget.value())
# Destination parameter
elif (isinstance(self.param, QgsProcessingParameterFeatureSink)):
self.param = QgsProcessingParameterFeatureSink(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
self.param = QgsProcessingParameterFileDestination(
name=name,
description=self.param.description(),
fileFilter=self.param.fileFilter(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
self.param = QgsProcessingParameterFolderDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
self.param = QgsProcessingParameterRasterDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
self.param = QgsProcessingParameterVectorDestination(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
else:
if self.paramType:
typeId = self.paramType
else:
typeId = self.param.type()
paramTypeDef = QgsApplication.instance().processingRegistry(
).parameterType(typeId)
if not paramTypeDef:
msg = self.tr(
'The parameter `{}` is not registered, are you missing a required plugin?'
.format(typeId))
raise UndefinedParameterException(msg)
self.param = paramTypeDef.create(name)
self.param.setDescription(description)
self.param.setMetadata(paramTypeDef.metadata())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def accept(self):
description = str(self.nameTextBox.text())
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD
or isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(
name,
description,
defaultValue=default,
parentLayerParameterName=parent,
type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BAND
or isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None,
parent)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
try:
self.param = QgsProcessingParameterNumber(
name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(
name, description, QgsProcessingParameterFile.Folder
if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# We add the input vector features source.
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVectorPolygon]
)
)
# We add a feature sink in which to store our processed features (this
# usually takes the form of a newly created vector layer when the
# algorithm is run in QGIS).
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT,
self.tr('Output layer')
)
)
# Add barrier source. It can have any kind of
# geometry.
self.addParameter(
QgsProcessingParameterVectorLayer(
self.BARRIER,
self.tr('Barrier layer'),
[QgsProcessing.TypeVectorAnyGeometry],
optional = True
)
)
# Add SEARCH_DIST
self.addParameter(
QgsProcessingParameterDistance(
self.SEARCH_DIST,
self.tr('Distance for aggregation'),
500,
'INPUT'
)
)
# Add SIMPLIFY_DIST
self.addParameter(
QgsProcessingParameterDistance(
self.SIMPLIFY_DIST,
self.tr('Simplify input polygons (reduces processing time)'),
1,
'INPUT'
)
)
# Add DISSOLVE_WITH_INPUT
self.addParameter(
QgsProcessingParameterBoolean(
self.DISSOLVE_WITH_INPUT,
self.tr('Dissolve result with input layer'),
True
)
)