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=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 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')
)
)
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, 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):
"""
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, label=True):
if DEBUG_MODE:
logMessage("initAlgorithm(): {}".format(self.__class__.__name__),
False)
qgis_iface = qgis.utils.plugins["Qgis2threejs"].iface
self.settings.loadSettingsFromFile()
self.settings.setMapSettings(qgis_iface.mapCanvas().mapSettings())
self.addParameter(
QgsProcessingParameterFolderDestination(
self.OUTPUT, self.tr("Output Directory")))
self.addParameter(
QgsProcessingParameterVectorLayer(
self.INPUT, self.tr("Coverage Layer"),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterField(self.TITLE_FIELD,
self.tr("Title Field"), None,
self.INPUT,
QgsProcessingParameterField.Any))
self.addParameter(
QgsProcessingParameterBoolean(self.CF_FILTER,
self.tr("Current Feature Filter")))
enum = ["Fit to Geometry", "Fixed Scale (based on map canvas)"]
self.addAdvancedParameter(
QgsProcessingParameterEnum(self.SCALE,
self.tr("Scale Mode"),
enum,
defaultValue=enum[0]))
self.addAdvancedParameter(
QgsProcessingParameterNumber(self.BUFFER,
self.tr("Buffer (%)"),
defaultValue=10))
self.addAdvancedParameter(
QgsProcessingParameterNumber(self.TEX_WIDTH,
self.tr("Texture base width (px)"),
defaultValue=1024))
self.addAdvancedParameter(
QgsProcessingParameterNumber(
self.TEX_HEIGHT,
self.
tr('Texture base height (px)\n'
' Leave this zero to respect aspect ratio of buffered geometry bounding box (in "Fit to Geometry" scale mode)\n'
' or map canvas (in "Fixed scale" scale mode).'),
defaultValue=0
# ,optional=True
))
if label:
self.addAdvancedParameter(
QgsProcessingParameterExpression(
self.HEADER, self.tr("Header Label"),
"'{}'".format(self.settings.headerLabel().replace(
"'", "''")), self.INPUT))
self.addAdvancedParameter(
QgsProcessingParameterExpression(
self.FOOTER, self.tr("Footer Label"),
"'{}'".format(self.settings.footerLabel().replace(
"'", "''")), self.INPUT))
self.addAdvancedParameter(
QgsProcessingParameterFile(
self.SETTINGS,
self.tr('Export Settings File (.qto3settings)'),
extension="qto3settings",
optional=True))
def initAlgorithm(self, config=None):
# Call function to look for precalculated values in layer "Bounding Geometry"
self.look_for_precalculated_values()
self.addParameter(
QgsProcessingParameterVectorLayer(
'sites',
'LEC',
types=[QgsProcessing.TypeVectorPoint],
defaultValue=None))
self.addParameter(
QgsProcessingParameterField(
'hubdistlecradii',
'HubDist_LEC_Radii',
type=QgsProcessingParameterField.Numeric,
parentLayerParameterName='sites',
allowMultiple=False,
defaultValue='HubDist'))
self.addParameter(
QgsProcessingParameterNumber(
'gridcellsize',
'Grid_Cellsize',
type=QgsProcessingParameterNumber.Integer,
defaultValue=1000))
self.addParameter(
QgsProcessingParameterExpression(
'formel',
'Formel',
parentLayerParameterName='',
defaultValue=self.formula_default))
self.addParameter(
QgsProcessingParameterNumber(
'lagdist',
'LagDist',
type=QgsProcessingParameterNumber.Double,
defaultValue=self.lag_dist_default))
self.addParameter(
QgsProcessingParameterBoolean('BlockKriging',
'Block_Kriging',
defaultValue=True))
self.addParameter(
QgsProcessingParameterNumber(
'blocksize',
'Block_Size',
type=QgsProcessingParameterNumber.Integer,
defaultValue=100))
self.addParameter(
QgsProcessingParameterNumber(
'maxsearchdist',
'Max_Search_Dist',
type=QgsProcessingParameterNumber.Integer,
defaultValue=self.max_search_dist_default))
self.addParameter(
QgsProcessingParameterNumber(
'numberofptsmin',
'Number_of_Pts_Min',
type=QgsProcessingParameterNumber.Integer,
defaultValue=3))
self.addParameter(
QgsProcessingParameterNumber(
'numberofptsmax',
'Number_of_Pts_Max',
type=QgsProcessingParameterNumber.Integer,
defaultValue=10))
self.addParameter(
QgsProcessingParameterRasterDestination(
'Kriging_raster',
'Kriging_Raster',
createByDefault=True,
defaultValue="Kriging.sdat"))
self.addParameter(
QgsProcessingParameterRasterDestination(
'Quality_measure',
'Quality_Measure',
optional=True,
createByDefault=False,
defaultValue="Variance.sdat"))
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=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=None):
self.addParameter(QgsProcessingParameterExpression('dbconnectionnameexpression', 'DB connection name', parentLayerParameterName='', defaultValue=' @dominode_db_connection_name '))
self.addParameter(QgsProcessingParameterVectorLayer('inputlayer', 'Input layer', types=[QgsProcessing.TypeVectorAnyGeometry], defaultValue=None))
self.addParameter(QgsProcessingParameterString('layername', 'output table name', multiLine=False, defaultValue=''))
self.addParameter(QgsProcessingParameterBoolean('VERBOSE_LOG', 'Verbose logging', optional=True, defaultValue=False))
def initAlgorithm(self, config=None):
# layer
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
# x fields (or expression)
self.addParameter(
QgsProcessingParameterExpression(
self.XEXPRESSION,
self.tr('X Field'),
parentLayerParameterName=self.INPUT))
# y field (or expression)
self.addParameter(
QgsProcessingParameterExpression(
self.YEXPRESSION,
self.tr('Y Field'),
parentLayerParameterName=self.INPUT))
# size
size_param = QgsProcessingParameterNumber(self.SIZE,
self.tr('Marker size'),
defaultValue=10)
size_param.setIsDynamic(True)
size_param.setDynamicLayerParameterName(self.INPUT)
size_param.setDynamicPropertyDefinition(
QgsPropertyDefinition(
"SIZE",
self.tr("Size"),
QgsPropertyDefinition.Double,
))
self.addParameter(size_param)
# color
color_param = QgsProcessingParameterColor(self.COLOR,
self.tr('Color'),
optional=True,
defaultValue='#8ebad9')
color_param.setIsDynamic(True)
color_param.setDynamicLayerParameterName(self.INPUT)
color_param.setDynamicPropertyDefinition(
QgsPropertyDefinition(
"COLOR",
self.tr("Color"),
QgsPropertyDefinition.Double,
))
self.addParameter(color_param)
facet_row = QgsProcessingParameterExpression(
self.FACET_ROW,
self.tr('Facet row'),
parentLayerParameterName=self.INPUT)
facet_row.setFlags(QgsProcessingParameterDefinition.FlagAdvanced
| QgsProcessingParameterDefinition.FlagOptional)
self.addParameter(facet_row)
facet_col = QgsProcessingParameterExpression(
self.FACET_COL,
self.tr('Facet col'),
optional=True,
parentLayerParameterName=self.INPUT)
facet_col.setFlags(QgsProcessingParameterDefinition.FlagAdvanced
| QgsProcessingParameterDefinition.FlagOptional)
self.addParameter(facet_col)
# offline parameter
offline_param = QgsProcessingParameterBoolean(
self.OFFLINE,
self.tr('Complete offline usage'),
defaultValue=False)
offline_param.setFlags(QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(offline_param)
# html file output
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_HTML_FILE, self.tr('Scatter Plot'),
self.tr('HTML files (*.html)')))
# json file output
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_JSON_FILE,
self.tr('JSON file'),
self.tr('JSON Files (*.json)'),
createByDefault=False,
optional=True))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterString(self.TITLE,
self.tr('Flight plan description'),
'QGIS flight plan'))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Flight waypoints layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterField(
self.NAME_FIELD,
self.tr('Waypoints name field'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.String,
optional=True))
elevation_param = QgsProcessingParameterField(
self.ELEVATION_FIELD,
self.tr('Waypoints elevation field'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.Numeric,
optional=True)
elevation_param.setFlags(
elevation_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(elevation_param)
orderby_param = QgsProcessingParameterExpression(
self.ORDERBY_EXPRESSION,
self.tr('Waypoints ordering by expression'),
parentLayerParameterName=self.INPUT,
optional=True)
orderby_param.setFlags(orderby_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(orderby_param)
departure_airport_param = QgsProcessingParameterString(
self.DEPARTURE_AIRPORT,
self.tr('Custom departure airport ICAO ID'),
'',
optional=True)
departure_airport_param.setFlags(
departure_airport_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(departure_airport_param)
destination_airport_param = QgsProcessingParameterString(
self.DESTINATION_AIRPORT,
self.tr('Custom destination airport ICAO ID'),
'',
optional=True)
destination_airport_param.setFlags(
destination_airport_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(destination_airport_param)
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT,
self.tr('Output flight plan file (.PLN)'),
fileFilter='Flight plan files (*.PLN *.pln)'))
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,
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 accept(self):
description = self.nameTextBox.text()
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType == parameters.PARAMETER_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType == parameters.PARAMETER_TABLE_FIELD
or isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(
name,
description,
defaultValue=default,
parentLayerParameterName=parent,
type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == parameters.PARAMETER_BAND
or isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None,
parent)
elif (self.paramType == parameters.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType == parameters.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType == parameters.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType == parameters.PARAMETER_NUMBER or isinstance(
self.param,
(QgsProcessingParameterNumber, QgsProcessingParameterDistance))):
try:
self.param = QgsProcessingParameterNumber(
name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType == parameters.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType == parameters.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == parameters.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(
name, description, QgsProcessingParameterFile.Folder
if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType == parameters.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
elif (self.paramType == parameters.PARAMETER_ENUM
or isinstance(self.param, QgsProcessingParameterEnum)):
self.param = QgsProcessingParameterEnum(
name, description, self.widget.options(),
self.widget.allowMultiple(), self.widget.defaultOptions())
elif (self.paramType == parameters.PARAMETER_MATRIX
or isinstance(self.param, QgsProcessingParameterMatrix)):
self.param = QgsProcessingParameterMatrix(
name,
description,
hasFixedNumberRows=self.widget.fixedRows(),
headers=self.widget.headers(),
defaultValue=self.widget.value())
# Destination parameter
elif (isinstance(self.param, QgsProcessingParameterFeatureSink)):
self.param = QgsProcessingParameterFeatureSink(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
self.param = QgsProcessingParameterFileDestination(
name=name,
description=self.param.description(),
fileFilter=self.param.fileFilter(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
self.param = QgsProcessingParameterFolderDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
self.param = QgsProcessingParameterRasterDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
self.param = QgsProcessingParameterVectorDestination(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
else:
if self.paramType:
typeId = self.paramType
else:
typeId = self.param.type()
paramTypeDef = QgsApplication.instance().processingRegistry(
).parameterType(typeId)
if not paramTypeDef:
msg = self.tr(
'The parameter `{}` is not registered, are you missing a required plugin?'
.format(typeId))
raise UndefinedParameterException(msg)
self.param = paramTypeDef.create(name)
self.param.setDescription(description)
self.param.setMetadata(paramTypeDef.metadata())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def initAlgorithm(self, config=None):
"""Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# The parameters
description = self.tr(
'Source value expression. Use <code>COALESCE("field_name", 0)</code> to treat <code>NULL</code> values as 0.'
)
self.addParameter(
QgsProcessingParameterExpression(
self.VALUE_EXPRESSION,
description=description,
parentLayerParameterName=self.REACH_LAYER))
description = self.tr('Branch behavior')
self.addParameter(
QgsProcessingParameterEnum(self.BRANCH_BEHAVIOR,
description=description,
options=[
self.tr('Minimum'),
self.tr('Maximum'),
self.tr('Average')
]))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Summed up')))
description = self.tr('Create a layer with nodes in loops')
self.addAdvancedParameter(
QgsProcessingParameterBoolean(self.CREATE_LOOP_LAYER,
description=description,
defaultValue=False))
self.addAdvancedParameter(
QgsProcessingParameterFeatureSink(
self.LOOP_OUTPUT,
self.
tr('Loop nodes (Only created if "Crate a layer with nodes in loops" option is activated)'
),
optional=True))
description = self.tr('Reach Layer')
self.addAdvancedParameter(
QgsProcessingParameterVectorLayer(
self.REACH_LAYER,
description=description,
types=[QgsProcessing.TypeVectorLine],
defaultValue='vw_qgep_reach'))
description = self.tr('Wastewater Node Layer')
self.addAdvancedParameter(
QgsProcessingParameterVectorLayer(
self.WASTEWATER_NODE_LAYER,
description=description,
types=[QgsProcessing.TypeVector],
defaultValue='vw_wastewater_node'))
description = self.tr('Primary Key Field Reach')
self.addAdvancedParameter(
QgsProcessingParameterField(
self.REACH_PK_NAME,
description=description,
parentLayerParameterName=self.REACH_LAYER,
defaultValue='obj_id'))
description = self.tr('Primary Key Field Node')
self.addAdvancedParameter(
QgsProcessingParameterField(
self.NODE_PK_NAME,
description=description,
parentLayerParameterName=self.WASTEWATER_NODE_LAYER,
defaultValue='obj_id'))
description = self.tr('Foreign Key Field From')
self.addAdvancedParameter(
QgsProcessingParameterField(
self.NODE_FROM_FK_NAME,
description=description,
parentLayerParameterName=self.REACH_LAYER,
defaultValue='rp_from_fk_wastewater_networkelement'))
description = self.tr('Foreign Key Field To')
self.addAdvancedParameter(
QgsProcessingParameterField(
self.NODE_TO_FK_NAME,
description=description,
parentLayerParameterName=self.REACH_LAYER,
defaultValue='rp_to_fk_wastewater_networkelement'))
