def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Input layer'),
types=[QgsProcessing.TypeVector]))
self.addParameter(QgsProcessingParameterString(self.FIELD_NAME,
self.tr('Result field name')))
self.addParameter(QgsProcessingParameterEnum(self.FIELD_TYPE,
self.tr('Field type'), options=self.type_names))
self.addParameter(QgsProcessingParameterNumber(self.FIELD_LENGTH,
self.tr('Field length'), minValue=1, maxValue=255, defaultValue=10))
self.addParameter(QgsProcessingParameterNumber(self.FIELD_PRECISION,
self.tr('Field precision'), minValue=0, maxValue=15, defaultValue=3))
self.addParameter(QgsProcessingParameterBoolean(self.NEW_FIELD,
self.tr('Create new field'), defaultValue=True))
self.addParameter(QgsProcessingParameterExpression(self.FORMULA, self.tr('Formula')))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Calculated')))
def initAlgorithm(self, config):
# Define all common DEPARTURE and ARRIVAL parameters
super().initAlgorithm(config)
# Remove unused parameters
self.removeParameter("INPUT_DEPARTURE_TRAVEL_TIME")
self.removeParameter("INPUT_ARRIVAL_TRAVEL_TIME")
# Define additional input parameters
self.addParameter(
QgsProcessingParameterFeatureSource(
"INPUT_LOCATIONS",
tr("Locations"),
[QgsProcessing.TypeVectorPoint],
optional=False,
),
help_text=tr(
"Define your locations to use later in departure_searches or arrival_searches"
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_LOCATIONS_ID",
"Locations ID",
optional=True,
defaultValue="'locations_' || $id",
parentLayerParameterName="INPUT_LOCATIONS",
),
help_text=tr(
"You will have to reference this id in your searches. It will also be used in the response body. MUST be unique among all locations."
),
)
# Define output parameters
self.addParameter(
QgsProcessingParameterEnum(
"OUTPUT_RESULT_TYPE",
tr("Output style"),
options=self.RESULT_TYPE,
defaultValue=0,
),
help_text=tr(
"Normal will return a simple linestring for each route. Detailed will return several segments for each type of transportation for each route."
),
)
def initAlgorithm(self, config):
"""Initialize algorithm with inputs and output parameters."""
self.addParameter(
QgsProcessingParameterFeatureSource(
self.ORIG_INPUT,
self.tr('Original layer'),
types=[QgsProcessing.TypeVector],
))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.NEW_INPUT,
self.tr('New layer'),
types=[QgsProcessing.TypeVector],
))
self.addParameter(
QgsProcessingParameterField(
self.FIELDS_TO_COMPARE,
self.tr('Fields to compare'),
None,
self.NEW_INPUT,
allowMultiple=True,
))
self.addParameter(
QgsProcessingParameterEnum(
self.HIGHLIGHT_METHOD,
self.tr('Highlight method'),
options=[
self.tr('Only highlight different lines'),
self.
tr('Highligt different lines and inta-line character changes (Slower on '
'large layers)'),
],
defaultValue=0,
))
self.addParameter(
QgsProcessingParameterExpression(
self.SORT_EXPRESSION,
self.tr('Sort expression'),
parentLayerParameterName=self.NEW_INPUT,
defaultValue='',
))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_HTML_FILE, self.tr('HTML report'),
self.tr('HTML files (*.html)'), None, True))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr("Input layer"),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.CLIP_LAYER,
description=self.tr("Clip layer"),
types=[QgsProcessing.TypeVectorPolygon],
optional=True))
self.addParameter(
QgsProcessingParameterExpression(self.SELECT_EXPR,
self.tr("Selection expression"),
"", self.INPUT))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr("Output layer")))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
nom_ij = "i+'-'+j"
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Network'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterExpression(
self.IJ,
self.tr('ij'),
parentLayerParameterName=self.INPUT,
defaultValue=nom_ij))
self.addParameter(
QgsProcessingParameterField(
self.LIGNE,
self.tr('Line'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.String,
optional=True))
self.addParameter(
QgsProcessingParameterString(self.VOLAU, self.tr('Flows'),
"volau"))
self.addParameter(
QgsProcessingParameterString(self.TYPE,
self.tr('Link type'),
defaultValue='type'))
self.addParameter(
QgsProcessingParameterFile(self.FICHIER_AFF,
self.tr('aff output file'),
QgsProcessingParameterFile.File, "TXT"))
self.addParameter(
QgsProcessingParameterString(self.ENCODAGE, self.tr('Encoding'),
"utf_8_sig"))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Flows layer')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Input point layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterBoolean(self.CLOSE_PATH,
self.tr('Close path'),
defaultValue=False))
order_field_param = QgsProcessingParameterField(
self.ORDER_FIELD,
self.tr('Order field'),
parentLayerParameterName=self.INPUT,
optional=True)
order_field_param.setFlags(
order_field_param.flags()
| QgsProcessingParameterDefinition.FlagHidden)
self.addParameter(order_field_param)
self.addParameter(
QgsProcessingParameterExpression(
self.ORDER_EXPRESSION,
self.tr('Order expression'),
parentLayerParameterName=self.INPUT,
optional=True))
self.addParameter(
QgsProcessingParameterField(self.GROUP_FIELD,
self.tr('Group field'),
parentLayerParameterName=self.INPUT,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.DATE_FORMAT,
self.tr('Date format (if order field is DateTime)'),
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Paths'),
QgsProcessing.TypeVectorLine))
output_dir_param = QgsProcessingParameterFolderDestination(
self.OUTPUT_TEXT_DIR,
self.tr('Directory for text output'),
optional=True)
output_dir_param.setCreateByDefault(False)
self.addParameter(output_dir_param)
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(
QgsProcessingParameterExtent(self.EXTENT,
self.tr('Extent'),
optional=True))
self.addParameter(
QgsProcessingParameterField(self.IMAGE_ATTRIBUTE,
self.tr('Image attribute'), None,
'INPUT',
QgsProcessingParameterField.String))
self.addParameter(
QgsProcessingParameterBoolean(self.ADD_TO_CANVAS,
self.tr('Add to canvas'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(self.UNIQUE_LOAD,
self.tr('Unique load'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterExpression(self.GROUP_EXPRESSION,
self.tr('Group expression'),
defaultValue="",
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.NAME_TAG,
self.tr('String used as prefix in images'),
defaultValue="",
optional=True))
self.addOutput(
QgsProcessingOutputMultipleLayers(self.OUTPUT,
self.tr('Loaded raster layers')))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(self.INPUT,
self.tr('Input layer'),
types=[QgsProcessing.TypeVector
]))
self.addParameter(
QgsProcessingParameterExpression(
self.EXPRESSION,
self.tr('Expression'),
parentLayerParameterName=self.INPUT))
self.addOutput(
QgsProcessingOutputVectorLayer(self.OUTPUT,
self.tr('Selected (attribute)')))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.DAWA_ADDRESS_TYPES = [("adresser", self.tr("Adresser")), ("adgangsadresser", self.tr("Adgangsadresser"))]
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT,
self.tr('Input adressedata'),
[QgsProcessing.TypeVector]
)
)
self.addParameter(
QgsProcessingParameterEnum(
self.ADDRESS_TYPE,
self.tr('Input adressetype'),
options=[x[1] for x in self.DAWA_ADDRESS_TYPES],
defaultValue=0
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.EXPRESSION,
self.tr('Adresse-udtryk'),
parentLayerParameterName = self.INPUT
)
)
# 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 lag')
)
)
def initAlgorithm(self, config):
super().initAlgorithm(config)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_QUERY_FIELD",
tr("Search expression"),
parentLayerParameterName="INPUT_DATA",
),
help_text=tr(
"The field containing the query to geocode. Can be an address, a postcode or a venue. For example SW1A 0AA or Victoria street, London. Providing a country or city the request will get you more accurate results"
),
)
self.addParameter(
QgsProcessingParameterPoint("INPUT_FOCUS",
tr("Focus point"),
optional=True),
help_text=tr(
"This will prioritize results around this point. Note that this does not exclude results that are far away from the focus point"
),
)
def initAlgorithm(self, config=None):
self.strategies = [self.tr('Points count'),
self.tr('Points density')]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(QgsProcessingParameterEnum(self.STRATEGY,
self.tr('Sampling strategy'),
self.strategies,
False,
0))
self.addParameter(QgsProcessingParameterExpression(self.EXPRESSION,
self.tr('Expression'),
parentLayerParameterName=self.INPUT))
self.addParameter(QgsProcessingParameterDistance(self.MIN_DISTANCE,
self.tr('Minimum distance between points'),
0, self.INPUT, False, 0, 1000000000))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Random points'),
type=QgsProcessing.TypeVectorPoint))
def initParameters(self, config=None):
self.addParameter(
QgsProcessingParameterEnum(self.OUTPUT_GEOMETRY,
self.tr('Output geometry type'),
options=self.geometry_types,
defaultValue=0))
self.addParameter(
QgsProcessingParameterBoolean(
self.WITH_Z,
self.tr('Output geometry has z dimension'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.WITH_M,
self.tr('Output geometry has m values'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterExpression(self.EXPRESSION,
self.tr("Geometry expression"),
defaultValue='$geometry',
parentLayerParameterName='INPUT'))
def __init__(self):
super().__init__()
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterExpression(self.EXPRESSION,
self.tr('Expression'), None,
self.INPUT))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Matching features')))
self.addOutput(
QgsProcessingOutputVectorLayer(self.OUTPUT,
self.tr('Matching (expression)')))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.FAIL_OUTPUT, self.tr('Non-matching'),
QgsProcessingParameterDefinition.TypeVectorAny, None, True))
self.addOutput(
QgsProcessingOutputVectorLayer(
self.FAIL_OUTPUT, self.tr('Non-matching (expression)')))
def initAlgorithm(self, config):
"""
Parameter setting.
"""
self.addParameter(
QgsProcessingParameterMultipleLayers(
self.INPUT_LAYERS,
self.tr('Input Layers'),
QgsProcessing.TypeVector
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.CATEGORY_EXPRESSION,
self.tr('Expression used to find out the category'),
defaultValue="regexp_substr(@layer_name ,'([^_]+)')"
)
)
self.addOutput(
QgsProcessingOutputMultipleLayers(
self.OUTPUT,
self.tr('Original reorganized layers')
)
)
def accept(self):
description = str(self.nameTextBox.text())
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD
or isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(
name,
description,
defaultValue=default,
parentLayerParameterName=parent,
type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BAND
or isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None,
parent)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
try:
self.param = QgsProcessingParameterNumber(
name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(
name, description, QgsProcessingParameterFile.Folder
if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def initAlgorithm(self, config=None):
self.cap_styles = [self.tr('Round'), 'Flat', 'Square']
self.addParameter(
QgsProcessingParameterFeatureSource(
self.ROADS, self.tr('Roads layer'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterExpression(
self.SELECT_EXPR,
self.tr(
'Expression to select features (all features if empty)'),
defaultValue=RoadsExtentGrpAlg.DEFAULT_EXPR,
optional=True,
parentLayerParameterName=self.ROADS))
self.addParameter(
QgsProcessingParameterExpression(
self.BUFFER_EXPR,
self.tr('Roads buffer value'),
defaultValue=self.DEFAULT_BUFFER_EXPR,
parentLayerParameterName=self.ROADS))
self.addParameter(
QgsProcessingParameterEnum(self.END_CAP_STYLE,
self.tr('End cap style'),
options=self.cap_styles,
defaultValue=0))
# Join parameters
self.addParameter(
QgsProcessingParameterBoolean(self.DISSOLVE,
self.tr('Join roads by name'),
defaultValue=True))
paramNameField = QgsProcessingParameterField(
self.NAME_FIELD,
self.tr('Roads name field'),
defaultValue=self.DEFAULT_NAME_FIELD,
parentLayerParameterName=self.ROADS)
# paramIncludeNull = self.addParameter(
# QgsProcessingParameterBoolean(
# self.INCLUDE_NULL,
# self.tr('Include roads with NULL name'),
# defaultValue=True))
paramJoinExpr = QgsProcessingParameterExpression(
self.JOIN_EXPR,
self.tr('Expression to select entities to join'),
defaultValue=self.DEFAULT_JOIN_EXPR,
parentLayerParameterName=self.ROADS)
paramsJoin = [paramNameField, paramJoinExpr]
for param in paramsJoin:
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
# self.addParameter(
# QgsProcessingParameterMultipleLayers(
# self.POLYGON_LAYERS,
# self.tr('Polygon layers to include'),
# layerType=QgsProcessing.TypeVectorPolygon,
# optional=True))
self.addParameter(
QgsProcessingParameterVectorDestination(self.OUTPUT,
self.tr('Output layer')))
self.addParameter(
QgsProcessingParameterVectorDestination(self.OUTPUT_LINEAR,
self.tr('Linear output'),
optional=True))
def accept(self):
description = self.nameTextBox.text()
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType == parameters.PARAMETER_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType == parameters.PARAMETER_TABLE_FIELD
or isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(
name,
description,
defaultValue=default,
parentLayerParameterName=parent,
type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == parameters.PARAMETER_BAND
or isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None,
parent)
elif (self.paramType == parameters.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType == parameters.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType == parameters.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType == parameters.PARAMETER_NUMBER or isinstance(
self.param,
(QgsProcessingParameterNumber, QgsProcessingParameterDistance))):
try:
self.param = QgsProcessingParameterNumber(
name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType == parameters.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType == parameters.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == parameters.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(
name, description, QgsProcessingParameterFile.Folder
if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType == parameters.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
elif (self.paramType == parameters.PARAMETER_ENUM
or isinstance(self.param, QgsProcessingParameterEnum)):
self.param = QgsProcessingParameterEnum(
name, description, self.widget.options(),
self.widget.allowMultiple(), self.widget.defaultOptions())
elif (self.paramType == parameters.PARAMETER_MATRIX
or isinstance(self.param, QgsProcessingParameterMatrix)):
self.param = QgsProcessingParameterMatrix(
name,
description,
hasFixedNumberRows=self.widget.fixedRows(),
headers=self.widget.headers(),
defaultValue=self.widget.value())
# Destination parameter
elif (isinstance(self.param, QgsProcessingParameterFeatureSink)):
self.param = QgsProcessingParameterFeatureSink(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
self.param = QgsProcessingParameterFileDestination(
name=name,
description=self.param.description(),
fileFilter=self.param.fileFilter(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
self.param = QgsProcessingParameterFolderDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
self.param = QgsProcessingParameterRasterDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
self.param = QgsProcessingParameterVectorDestination(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
else:
if self.paramType:
typeId = self.paramType
else:
typeId = self.param.type()
paramTypeDef = QgsApplication.instance().processingRegistry(
).parameterType(typeId)
if not paramTypeDef:
msg = self.tr(
'The parameter `{}` is not registered, are you missing a required plugin?'
.format(typeId))
raise UndefinedParameterException(msg)
self.param = paramTypeDef.create(name)
self.param.setDescription(description)
self.param.setMetadata(paramTypeDef.metadata())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def initAlgorithm(self, config):
"""Base setup of the algorithm.
This will setup parameters corresponding to departure_searches and arrival_searches,
since they are common to all main algorithms.
Subclasses should call this and then define their own parameters.
Note that there are slight differences on the API side on the departure_searches and
arrival_searches parameters: for the time-map endpoint, the coords are included in these
parameters, while for the time-filter and routes endpoints, the coords are all defined
in a list of locations.
Here we will implement everything as it is for the time-map endpoint, as it maps better
to normal GIS workflow, where you usually have the list to filter and the inputs points
as different datasets. The mapping to the different API data model will be done in the
processing algorithm by the time-filter and routes subclasses.
"""
for DEPARR in ['DEPARTURE', 'ARRIVAL']:
self.addParameter(
QgsProcessingParameterFeatureSource('INPUT_'+DEPARR+'_SEARCHES',
'{} / Searches'.format(DEPARR.title()),
[QgsProcessing.TypeVectorPoint],
optional=True, )
)
self.addParameter(
QgsProcessingParameterExpression('INPUT_'+DEPARR+'_ID',
'{} / ID'.format(DEPARR.title()),
optional=True,
defaultValue="'"+DEPARR.lower()+"_searches_' || $id",
parentLayerParameterName='INPUT_'+DEPARR+'_SEARCHES',)
)
# Transportation
self.addParameter(
QgsProcessingParameterExpression('INPUT_'+DEPARR+'_TRNSPT_TYPE',
'{} / Transportation / type'.format(DEPARR.title()),
optional=True,
defaultValue="'walking'",
parentLayerParameterName='INPUT_'+DEPARR+'_SEARCHES',)
)
self.addAdvancedParamter(
QgsProcessingParameterExpression('INPUT_'+DEPARR+'_TRNSPT_PT_CHANGE_DELAY',
'{} / Transportation / change delay'.format(DEPARR.title()),
optional=True,
defaultValue="0",
parentLayerParameterName='INPUT_'+DEPARR+'_SEARCHES',)
)
self.addAdvancedParamter(
QgsProcessingParameterExpression('INPUT_'+DEPARR+'_TRNSPT_WALKING_TIME',
'{} / Transportation / walking time'.format(DEPARR.title()),
optional=True,
defaultValue="900",
parentLayerParameterName='INPUT_'+DEPARR+'_SEARCHES',)
)
self.addAdvancedParamter(
QgsProcessingParameterExpression('INPUT_'+DEPARR+'_TRNSPT_DRIVING_TIME_TO_STATION',
'{} / Transportation / driving time to station'.format(DEPARR.title()),
optional=True,
defaultValue="1800",
parentLayerParameterName='INPUT_'+DEPARR+'_SEARCHES',)
)
self.addAdvancedParamter(
QgsProcessingParameterExpression('INPUT_'+DEPARR+'_TRNSPT_PARKING_TIME',
'{} / Transportation / parking time'.format(DEPARR.title()),
optional=True,
defaultValue="300",
parentLayerParameterName='INPUT_'+DEPARR+'_SEARCHES',)
)
self.addAdvancedParamter(
QgsProcessingParameterExpression('INPUT_'+DEPARR+'_TRNSPT_BOARDING_TIME',
'{} / Transportation / boarding time'.format(DEPARR.title()),
optional=True,
defaultValue="0",
parentLayerParameterName='INPUT_'+DEPARR+'_SEARCHES',)
)
self.addAdvancedParamter(
QgsProcessingParameterExpression('INPUT_'+DEPARR+'_RANGE_WIDTH',
'{} / Search range width '.format(DEPARR.title()),
optional=True,
defaultValue="null",
parentLayerParameterName='INPUT_'+DEPARR+'_SEARCHES',)
)
self.addParameter(
QgsProcessingParameterExpression('INPUT_'+DEPARR+'_TIME',
'{} / Time'.format(DEPARR.title()),
optional=True,
defaultValue="'{}'".format(utils.now_iso()),
parentLayerParameterName='INPUT_'+DEPARR+'_SEARCHES',)
)
self.addParameter(
QgsProcessingParameterExpression('INPUT_'+DEPARR+'_TRAVEL_TIME',
'{} / Travel time'.format(DEPARR.title()),
optional=True,
defaultValue="900",
parentLayerParameterName='INPUT_'+DEPARR+'_SEARCHES',)
)
def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# We add the point input vector features source
#QgsProcessingFeatureSourceDefinition
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT_L,
self.tr('Input sorgente dati'),
[QgsProcessing.TypeMapLayer],
""))
self.addParameter(
QgsProcessingParameterField(
self.INPUT_F,
self.tr('Selezionare i campi da inserire nel file Html'),
allowMultiple=True,
defaultValue=[],
parentLayerParameterName=self.INPUT_L))
self.addParameter(
QgsProcessingParameterExpression(
self.GROUP_BY,
self.tr('Espressione filtro'),
defaultValue=[],
optional=True,
parentLayerParameterName=self.INPUT_L))
self.addParameter(
QgsProcessingParameterExpression(
self.INPUT_T,
self.tr('Titolo pagina'),
defaultValue=[],
optional=True,
parentLayerParameterName=self.INPUT_L))
# We add the input icon source
self.addParameter(
QgsProcessingParameterFile(
self.INPUT_I,
'Icona Gruppo',
behavior=QgsProcessingParameterFile.File,
fileFilter='Image file (*.gif; *.jpeg; *.jpg; *.png; *.svg)',
defaultValue='',
optional=True))
# We add the input css
self.addParameter(
QgsProcessingParameterFile(
self.INPUT_S,
'Foglio di stile CSS',
behavior=QgsProcessingParameterFile.File,
fileFilter='Css file (*.css)',
defaultValue="",
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.INPUT_D,
'Dimensioni icona Gruppo e foto [base x altezza in pt, px, mm, auto]',
'25px; 25px; auto; 10%'))
# We add a file output of type HTML
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT,
self.tr('Tabella HTML'),
'HTML files (*.html)',
))
self.addParameter(
QgsProcessingParameterBoolean(self.INPUT_ABS,
'Percorsi file relativi', 0))
def initAlgorithm(self, config):
"""Initialize algorithm with inputs and output parameters."""
if HAS_DB_PROCESSING_PARAMETER:
db_param = QgsProcessingParameterProviderConnection(
self.DATABASE,
self.tr('PostgreSQL database (connection name)'),
'postgres',
)
schema_param = QgsProcessingParameterDatabaseSchema(
self.SCHEMA,
self.tr('PostgreSQL schema name'),
connectionParameterName=self.DATABASE,
defaultValue='public',
)
table_param = QgsProcessingParameterDatabaseTable(
self.TABLENAME,
self.tr('PostgreSQL original table name'),
connectionParameterName=self.DATABASE,
schemaParameterName=self.SCHEMA)
else:
db_param = QgsProcessingParameterString(
self.DATABASE,
self.tr('PostgreSQL database (connection name)'),
)
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
schema_param = QgsProcessingParameterString(
self.SCHEMA,
self.tr('PostgreSQL schema name'),
'public',
False,
True,
)
schema_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
'connection_param': self.DATABASE,
}
})
table_param = QgsProcessingParameterString(
self.TABLENAME,
self.tr('PostgreSQL original table name'),
'',
False,
True,
)
table_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.TableWidgetWrapper',
'schema_param': self.SCHEMA,
}
})
self.addParameter(db_param)
self.addParameter(schema_param)
self.addParameter(table_param)
self.addParameter(
QgsProcessingParameterFeatureSource(
self.NEW_INPUT,
self.tr('New layer'),
types=[QgsProcessing.TypeVector],
))
self.addParameter(
QgsProcessingParameterField(
self.FIELDS_TO_COMPARE,
self.tr('Fields to compare'),
None,
self.NEW_INPUT,
allowMultiple=True,
))
self.addParameter(
QgsProcessingParameterEnum(
self.HIGHLIGHT_METHOD,
self.tr('Highlight method'),
options=[
self.tr('Only highlight different lines'),
self.
tr('Highligt different lines and inta-line character changes (Slower on '
'large layers)'),
],
defaultValue=0,
))
self.addParameter(
QgsProcessingParameterExpression(
self.SORT_EXPRESSION,
self.tr('Sort expression (put in ORDER BY clause)'),
parentLayerParameterName=self.NEW_INPUT,
defaultValue='',
))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_HTML_FILE, self.tr('HTML report'),
self.tr('HTML files (*.html)'), None, True))
def initAlgorithm(self, config):
"""Base setup of the algorithm.
This will setup parameters corresponding to departure_searches and arrival_searches,
since they are common to all main algorithms.
Subclasses should call this and then define their own parameters.
Note that there are slight differences on the API side on the departure_searches and
arrival_searches parameters: for the time-map endpoint, the coords are included in these
parameters, while for the time-filter and routes endpoints, the coords are all defined
in a list of locations.
Here we will implement everything as it is for the time-map endpoint, as it maps better
to normal GIS workflow, where you usually have the list to filter and the inputs points
as different datasets. The mapping to the different API data model will be done in the
processing algorithm by the time-filter and routes subclasses.
"""
for DEPARR in ["DEPARTURE", "ARRIVAL"]:
self.addParameter(
QgsProcessingParameterFeatureSource(
"INPUT_" + DEPARR + "_SEARCHES",
"{} / Searches".format(DEPARR.title()),
[QgsProcessing.TypeVectorPoint],
optional=True,
),
help_text=tr(
"Searches based on departure time. Leave departure location at no earlier than given time. You can define a maximum of 10 searches"
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_ID",
"{} / ID".format(DEPARR.title()),
optional=True,
defaultValue="'" + DEPARR.lower() + "_searches_' || $id",
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
help_text=tr(
"Used to identify this specific search in the results array. MUST be unique among all searches."
),
)
# Transportation
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_TRNSPT_TYPE",
"{} / Transportation / type".format(DEPARR.title()),
optional=True,
defaultValue="'public_transport'",
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
help_text=tr(
"cycling, driving, driving+train (only in Great Britain), public_transport, walking, coach, bus, train, ferry, driving+ferry, cycling+ferry or cycling+public_transport (only in Netherlands)"
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_TRNSPT_PT_CHANGE_DELAY",
"{} / Transportation / change delay".format(
DEPARR.title()),
optional=True,
defaultValue="0",
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
advanced=True,
help_text=tr(
"Time (in seconds) needed to board public transportation vehicle. Default is 0. Cannot be higher than travel_time. Used in public_transport, coach, bus, train, driving+train and cycling+public_transport transportation modes"
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_TRNSPT_WALKING_TIME",
"{} / Transportation / walking time".format(
DEPARR.title()),
optional=True,
defaultValue="900",
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
advanced=True,
help_text=tr(
"Maximum time (in seconds) of walking from source to a station/stop and from station/stop to destination. Default value is 900. Cannot be higher than travel_time. Used in public_transport, coach, bus, train, driving+train and cycling+public_transport transportation modes"
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_TRNSPT_DRIVING_TIME_TO_STATION",
"{} / Transportation / driving time to station".format(
DEPARR.title()),
optional=True,
defaultValue="1800",
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
advanced=True,
help_text=tr(
"Maximum time (in seconds) of driving from source to train station. Default value is 1800. Cannot be higher than travel_time. Used in driving+train transportation mode"
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_TRNSPT_CYCLING_TIME_TO_STATION",
"{} / Transportation / cycling time to station".format(
DEPARR.title()),
optional=True,
defaultValue="900",
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
advanced=True,
help_text=tr(
"Maximum time (in seconds) of cycling (including any ferry transfers) from source to a station or stop. Default value is 900. Cannot be higher than travel_time. Used in cycling+public_transport transportation mode"
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_TRNSPT_PARKING_TIME",
"{} / Transportation / parking time".format(
DEPARR.title()),
optional=True,
defaultValue="300",
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
advanced=True,
help_text=tr(
"Time (in seconds) required to park a car or a bike. Default is 300. Cannot be higher than travel_time. Used in driving+train and cycling+public_transport transportation modes."
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_TRNSPT_BOARDING_TIME",
"{} / Transportation / boarding time".format(
DEPARR.title()),
optional=True,
defaultValue="0",
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
advanced=True,
help_text=tr(
"Time (in seconds) required to board a ferry. Default is 0. Cannot be higher than travel_time. Used in public_transport, ferry, driving+ferry, cycling+ferry and cycling+public_transport transportation modes. For public_transport mode, pt_change_delay is used instead"
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_RANGE_WIDTH",
"{} / Search range width ".format(DEPARR.title()),
optional=True,
defaultValue="null",
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
advanced=True,
help_text=tr(
"Search range width in seconds. width along with departure_time specify departure interval. For example, if you set departure_time to 9am and width to 1 hour, we will return a combined shape of all possible journeys that have departure time between 9am and 10am. Range width is limited to 12 hours"
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_TIME",
"{} / Time".format(DEPARR.title()),
optional=True,
defaultValue="'{}'".format(utils.now_iso()),
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
help_text=tr(
"Leave departure location at no earlier than given time. Example - 2017-10-18T08:00:00Z"
),
)
self.addParameter(
QgsProcessingParameterExpression(
"INPUT_" + DEPARR + "_TRAVEL_TIME",
"{} / Travel time".format(DEPARR.title()),
optional=True,
defaultValue="900",
parentLayerParameterName="INPUT_" + DEPARR + "_SEARCHES",
),
help_text=tr(
"Travel time in seconds. Maximum value is 14400 (4 hours)"
),
)
# Define output parameters
self.addParameter(
QgsProcessingParameterFeatureSink("OUTPUT",
tr("Output"),
type=self.output_type))
def initAlgorithm(self, config):
"""
Set up parameters for the ContourGenerator algorithm
"""
#Would be cleaner to create a widget, at least for the contour levels.
# Add the input point vector features source.
# geometry.
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PrmInputLayer, tr('Input point layer'),
[QgsProcessing.TypeVectorPoint]))
# Define the field/expression to contour
self.addParameter(
QgsProcessingParameterExpression(
self.PrmInputField,
tr('Value to contour'),
parentLayerParameterName=self.PrmInputLayer))
# Duplicate point radius - discards points if closer than
# this to each other (approximately). 0 means don't discard
self.addParameter(
QgsProcessingParameterNumber(self.PrmDuplicatePointTolerance,
tr('Duplicate point tolerance'),
QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0,
optional=True))
# Define the contour type
self.addParameter(
self._enumParameter(self.PrmContourType, tr("Contour type")))
self.addParameter(
self._enumParameter(self.PrmExtendContour,
tr("Extend filled contour options"),
optional=True))
# Define the contour level calculation method
self.addParameter(
self._enumParameter(
self.PrmContourMethod,
tr('Method used to calculate the contour levels')))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmNContour,
tr('Number (or max number) of contours'),
defaultValue=20,
minValue=1,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmMinContourValue,
tr('Minimum contour level (omit to use data minimum)'),
type=QgsProcessingParameterNumber.Double,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmMaxContourValue,
tr('Maximum contour level (omit to use data maximum)'),
type=QgsProcessingParameterNumber.Double,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.PrmContourInterval,
tr('Contour interval'),
QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=1.0,
optional=True))
self.addParameter(
QgsProcessingParameterString(self.PrmContourLevels,
tr('User selected contour levels'),
multiLine=True,
optional=True))
# Define label formatting - number of significant digits and
# whether trailiing zeros are trimmed.
self.addParameter(
QgsProcessingParameterNumber(
self.PrmLabelDecimalPlaces,
tr('Label decimal places (-1 for auto)'),
QgsProcessingParameterNumber.Integer,
defaultValue=-1,
minValue=-1,
maxValue=10,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PrmLabelTrimZeros,
tr("Trim trailing zeros from labels"),
False,
optional=True))
self.addParameter(
QgsProcessingParameterString(self.PrmLabelUnits,
tr("Units to append to label values"),
"",
optional=True))
# Output layer for the contours
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputLayer,
tr('Output layer')))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Road network'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterExtent(
self.RECTANGLE,
self.tr('Window'),
))
self.addParameter(
QgsProcessingParameterField(
self.SENS,
self.tr('Direction'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.String))
self.addParameter(
QgsProcessingParameterField(
self.TEMPS,
self.tr('Time'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.Numeric))
self.addParameter(
QgsProcessingParameterField(
self.LONGUEUR,
self.tr('Length'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.Numeric))
self.addParameter(
QgsProcessingParameterField(
self.I,
self.tr('i-node'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.String))
self.addParameter(
QgsProcessingParameterField(
self.J,
self.tr('j-node'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.String))
self.addParameter(
QgsProcessingParameterString(self.PERIODE,
self.tr('Time category id'), "-1"))
self.addParameter(
QgsProcessingParameterString(self.NUM_PLAGE,
self.tr('Time period id'), "-1"))
self.addParameter(
QgsProcessingParameterString(self.DEBUT_PERIODE,
self.tr('Start time'), "-1"))
self.addParameter(
QgsProcessingParameterString(self.FIN_PERIODE, self.tr('End time'),
"-1"))
self.addParameter(
QgsProcessingParameterString(self.CALENDRIER, self.tr('Calendar'),
"-1"))
self.addParameter(
QgsProcessingParameterField(
self.TEXTE_ARC,
self.tr('Arc label'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.String))
self.addParameter(
QgsProcessingParameterExpression(self.MODE, self.tr('Mode'), "'m'",
self.INPUT))
# 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(
QgsProcessingParameterFileDestination(self.OUTPUT,
self.tr('Musliw network'),
'*.txt'))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterExpression(
self.GROUP_BY,
self.tr('Group by expression (NULL to group all features)'),
defaultValue='NULL',
optional=False,
parentLayerParameterName=self.INPUT))
class ParameterAggregates(QgsProcessingParameterDefinition):
def __init__(self,
name,
description,
parentLayerParameterName='INPUT'):
super().__init__(name, description)
self._parentLayerParameter = parentLayerParameterName
def clone(self):
copy = ParameterAggregates(self.name(), self.description(),
self._parentLayerParameter)
return copy
def type(self):
return 'aggregates'
def checkValueIsAcceptable(self, value, context=None):
if not isinstance(value, list):
return False
for field_def in value:
if not isinstance(field_def, dict):
return False
if not field_def.get('input', False):
return False
if not field_def.get('aggregate', False):
return False
if not field_def.get('name', False):
return False
if not field_def.get('type', False):
return False
return True
def valueAsPythonString(self, value, context):
return str(value)
def asScriptCode(self):
raise NotImplementedError()
@classmethod
def fromScriptCode(cls, name, description, isOptional, definition):
raise NotImplementedError()
def parentLayerParameter(self):
return self._parentLayerParameter
self.addParameter(
ParameterAggregates(self.AGGREGATES,
description=self.tr('Aggregates')))
self.parameterDefinition(self.AGGREGATES).setMetadata({
'widget_wrapper':
'processing.algs.qgis.ui.AggregatesPanel.AggregatesWidgetWrapper'
})
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Aggregated')))
def initAlgorithm(
self,
configuration,
p_str=None,
Any=None,
*args,
**kwargs
):
self.addParameter(
QgsProcessingParameterString(
REPORT_HANDLER_INPUT_NAME,
self.tr('Input validation report'),
defaultValue='{}',
multiLine=True
)
)
self.addParameter(
QgsProcessingParameterEnum(
self.INPUT_REPORT_FORMAT,
self.tr('Report format'),
options=[i[0] for i in self.REPORT_FORMATS],
defaultValue=self.REPORT_FORMATS[0][0],
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.INPUT_SENDER_ADDRESS,
self.tr('Sender email'),
defaultValue=f'@{QGIS_VARIABLE_PREFIX}_sender_address',
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.INPUT_SENDER_PASSWORD,
self.tr('Sender password'),
defaultValue=f'@{QGIS_VARIABLE_PREFIX}_sender_password',
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.INPUT_RECIPIENTS,
self.tr('Recipients'),
defaultValue=(
f'string_to_array(@{QGIS_VARIABLE_PREFIX}_recipients)'),
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.INPUT_SMTP_HOST,
self.tr('SMTP host'),
defaultValue=(
f'coalesce(@{QGIS_VARIABLE_PREFIX}_smtp_host, '
f'\'smtp.gmail.com\')'
),
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.INPUT_SMTP_PORT,
self.tr('SMTP port'),
defaultValue=(
f'coalesce(@{QGIS_VARIABLE_PREFIX}_smtp_port, 587)'),
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.INPUT_SMTP_SECURE_CONNECTION,
self.tr('Connection security method to use when sending email'),
defaultValue=(
f'coalesce(@{QGIS_VARIABLE_PREFIX}_smtp_secure_connection,'
f'\'starttls\')'
),
)
)
self.addOutput(
QgsProcessingOutputBoolean(
self.OUTPUT_MAIL_SENT, 'Was the email sent or not')
)
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
#e=iface.mapCanvas().extent()
#etendue=str(tuple([e.xMinimum(),e.xMaximum(), e.yMinimum(), e.yMaximum()]))[1:-1]
self.addParameter(
QgsProcessingParameterVectorLayer(self.RESEAU, self.tr('Network'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterExtent(
self.FENETRE,
self.tr('Window'),
#etendue
))
self.addParameter(
QgsProcessingParameterExpression(self.COUT_I, self.tr('i-cost'),
None, self.RESEAU))
self.addParameter(
QgsProcessingParameterExpression(self.COUT_J, self.tr('j-cost'),
None, self.RESEAU))
self.addParameter(
QgsProcessingParameterExpression(self.SENS, self.tr('Direction'),
"'1'", self.RESEAU))
self.addParameter(
QgsProcessingParameterExpression(self.DIFFUSION, self.tr('Spread'),
"'3'", self.RESEAU))
self.addParameter(
QgsProcessingParameterExpression(self.TRAVERSABILITE,
self.tr('Impassibility'), "'3'",
self.RESEAU))
self.addParameter(
QgsProcessingParameterNumber(
self.NB_PIXELS_X,
self.tr('Pixels nb x'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=200))
self.addParameter(
QgsProcessingParameterNumber(
self.NB_PIXELS_Y,
self.tr('Pixels nb y'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=200))
self.addParameter(
QgsProcessingParameterNumber(
self.TAILLE_PIXEL_X,
self.tr('Pixel size x'),
type=QgsProcessingParameterNumber.Double,
defaultValue=-1.0))
self.addParameter(
QgsProcessingParameterNumber(
self.TAILLE_PIXEL_Y,
self.tr('Pixel size y'),
type=QgsProcessingParameterNumber.Double,
defaultValue=-1.0))
self.addParameter(
QgsProcessingParameterNumber(
self.DECIMALES,
self.tr('Decimals'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=5))
self.addParameter(
QgsProcessingParameterNumber(
self.RAYON,
self.tr('Radius(m)'),
type=QgsProcessingParameterNumber.Double,
defaultValue=500.0))
self.addParameter(
QgsProcessingParameterExpression(self.VITESSE_DIFFUSION,
self.tr('Spread speed'), '4.0',
self.RESEAU))
self.addParameter(
QgsProcessingParameterBoolean(self.INTRAVERSABLE,
self.tr('Impassable?'), False))
self.addParameter(
QgsProcessingParameterExpression(self.IND_VALUES,
self.tr('Individual values'),
"'.'", self.RESEAU))
self.addParameter(
QgsProcessingParameterRasterDestination(self.RESULTAT,
self.tr('Raster file')))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT,
self.tr('Layer'),
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.EXISTANT,
self.tr('Field'),
parentLayerParameterName=self.INPUT,
optional=False
)
)
self.addParameter(
QgsProcessingParameterEnum(
self.TYPE,
self.tr('Type'),
options=self.types_data,
defaultValue=0
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.TAILLE,
self.tr('Size'),
QgsProcessingParameterNumber.Integer,
defaultValue=255,
minValue=1,
maxValue=20
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.PRECISION,
self.tr('Precision'),
QgsProcessingParameterNumber.Integer,
defaultValue=15,
minValue=0,
maxValue=15
)
)
self.addParameter(
QgsProcessingParameterExpression(
self.FILTRE,
self.tr('Filter'),
None,
self.INPUT,
optional=True
)
)
# We add a feature sink in which to store our processed features (this
# usually takes the form of a newly created vector layer when the
# algorithm is run in QGIS).
self.addParameter(
QgsProcessingParameterExpression(
self.FORMULE,
self.tr('Formula'),
None,
self.INPUT
)
)
def initAlgorithm(self, config, label=True):
if DEBUG_MODE:
logMessage("initAlgorithm(): {}".format(self.__class__.__name__),
False)
qgis_iface = qgis.utils.plugins["Qgis2threejs"].iface
self.controller = Q3DController(qgis_iface)
self.controller.settings.loadSettingsFromFile(None)
self.addParameter(
QgsProcessingParameterFolderDestination(
self.OUTPUT, self.tr("Output Directory")))
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT, self.tr("Coverage Layer"),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterField(self.TITLE_FIELD,
self.tr("Title Field"), None,
self.INPUT,
QgsProcessingParameterField.Any))
self.addParameter(
QgsProcessingParameterBoolean(self.CF_FILTER,
self.tr("Current Feature Filter")))
self.addAdvancedParameter(
QgsProcessingParameterEnum(
self.SCALE, self.tr("Scale Mode"),
["Fit to Geometry", "Fixed Scale (based on map canvas)"]))
self.addAdvancedParameter(
QgsProcessingParameterNumber(self.BUFFER,
self.tr("Buffer (%)"),
defaultValue=10))
self.addAdvancedParameter(
QgsProcessingParameterNumber(self.TEX_WIDTH,
self.tr("Texture base width (px)"),
defaultValue=1024))
self.addAdvancedParameter(
QgsProcessingParameterNumber(
self.TEX_HEIGHT,
self.tr('Texture base height (px)\n'\
' Leave this zero to respect aspect ratio of buffered geometry bounding box (in "Fit to Geometry" scale mode)\n'\
' or map canvas (in "Fixed scale" scale mode).'),
defaultValue=0
#,optional=True
)
)
if label:
self.addAdvancedParameter(
QgsProcessingParameterExpression(
self.HEADER, self.tr("Header Label"), "'{}'".format(
self.controller.settings.headerLabel().replace(
"'", "''")), self.INPUT))
self.addAdvancedParameter(
QgsProcessingParameterExpression(
self.FOOTER, self.tr("Footer Label"), "'{}'".format(
self.controller.settings.footerLabel().replace(
"'", "''")), self.INPUT))
self.addAdvancedParameter(
QgsProcessingParameterFile(
self.SETTINGS,
self.tr('Export Settings File (.qto3settings)'),
extension="qto3settings",
optional=True))
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# We add the input vector features source. It can have any kind of
# geometry.
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT_LAYER,
self.tr('Input Vector Layer'),
[QgsProcessing.TypeVectorAnyGeometry]
)
)
self.addParameter(
QgsProcessingParameterString(
self.BASE_URL,
self.tr('WMS-Base-URL'),
defaultValue='',
optional=False
)
)
self.addParameter(
QgsProcessingParameterString(
self.LAYERS,
self.tr('Layers (layer1,layer2,...)'),
defaultValue='',
optional=False
)
)
self.addParameter(
QgsProcessingParameterString(
self.STYLE_NAME,
self.tr('Style names'),
defaultValue='',
optional=True
)
)
self.addParameter(
QgsProcessingParameterString(
self.WMS_VERSION,
self.tr('Wms Version'),
defaultValue='1.1.1',
optional=False
)
)
self.addParameter(QgsProcessingParameterEnum(
self.IMAGE_FORMAT,
self.tr('Image Format'),
options=self.imageFormats, defaultValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PIXEL_SIZE,
self.tr('spatial resolution (pixel size)'),
type=QgsProcessingParameterNumber.Double,
defaultValue=10,
optional=False,
#minValue=0,
#maxValue=100
)
)
# self.addParameter(
# QgsProcessingParameterField(
# self.FILENAME_FIELD,
# self.tr('Field with Filenames'),
# None,
# self.INPUT_LAYER,
# QgsProcessingParameterField.Any,
# optional=False
# )
# )
self.addParameter(
QgsProcessingParameterExpression(
self.FILENAME_FIELD,
self.tr('Filenames'),
parentLayerParameterName=self.INPUT_LAYER
)
)
self.addParameter(
QgsProcessingParameterFolderDestination(
self.DOWNLOAD_DIR,
self.tr('Download Directory')
)
)
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT,
self.tr('Features With File Link')
)
)
def initAlgorithm(self, config=None):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
#print("initAlgorithm")
# We add the input vector features source. It can have any kind of
# geometry.
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUTPOINTLAYER,
self.tr('Point Layer'),
[QgsProcessing.TypeVectorPoint]
)
)
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUTBASELINE,
self.tr('Profile Multi Baseline Layer'),
[QgsProcessing.TypeVectorLine]
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUTBUFFER,
self.tr('Baseline Buffer(used if no points selection)'),
type=QgsProcessingParameterNumber.Double,
defaultValue=100,
optional=False,
minValue=0,
maxValue=10000
)
)
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUTRASTER,
self.tr('Elevation Raster'),
None,
False
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.INPUTZFACTOR,
self.tr('Z-Factor / Ueberhoehung'),
type=QgsProcessingParameterNumber.Double,
defaultValue=10,
optional=False,
minValue=0,
maxValue=100
)
)
self.addParameter(
QgsProcessingParameterField(
self.INPUTZFIELD,
self.tr('Z-Value Field'),
None,
self.INPUTPOINTLAYER,
QgsProcessingParameterField.Numeric,
optional=True
)
)
self.addParameter(
QgsProcessingParameterField(
self.INPUTZFIELDSTART,
self.tr('Depth (Start)'),
None,
self.INPUTPOINTLAYER,
QgsProcessingParameterField.Numeric,
optional=True
)
)
self.addParameter(
QgsProcessingParameterField(
self.INPUTZFIELDEND,
self.tr('Depth Field (End)'),
None,
self.INPUTPOINTLAYER,
QgsProcessingParameterField.Numeric,
optional=True
)
)
#fieldRichtungHz
#fieldAzimut
self.addParameter(
QgsProcessingParameterExpression(
self.SOURCE_BASLINE_ID,
self.tr('Field with baseline primary key (must be unique!)'),
parentLayerParameterName=self.INPUTBASELINE
)
)
# 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('Profil_Points')
)
)
