def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterMapLayer(self.INPUT, self.tr('Input layer')))
round_to_parameter = QgsProcessingParameterDistance(self.ROUND_TO,
self.tr('Round values to'),
parentParameterName=self.INPUT,
minValue=0,
defaultValue=0)
round_to_parameter.setFlags(round_to_parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(round_to_parameter)
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Extent'), type=QgsProcessing.TypeVectorPolygon))
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_LAYOUTITEM
or isinstance(self.param, QgsProcessingParameterLayoutItem)):
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 = QgsProcessingParameterLayoutItem(
name, description, None, parent)
elif (self.paramType == parameters.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType == parameters.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType == parameters.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType == parameters.PARAMETER_DISTANCE
or isinstance(self.param, QgsProcessingParameterDistance)):
self.param = QgsProcessingParameterDistance(
name, description, self.defaultTextBox.text())
try:
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
if parent:
self.param.setParentParameterName(parent)
elif (self.paramType == parameters.PARAMETER_SCALE
or isinstance(self.param, QgsProcessingParameterScale)):
self.param = QgsProcessingParameterScale(
name, description, self.defaultTextBox.text())
elif (self.paramType == parameters.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
type = self.type_combo.currentData()
self.param = QgsProcessingParameterNumber(
name, description, type, self.defaultTextBox.text())
try:
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType == parameters.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType == parameters.PARAMETER_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):
self.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'), QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward),
(self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)])
self.STRATEGIES = [self.tr('Shortest'),
self.tr('Fastest')
]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Vector layer representing network'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(QgsProcessingParameterPoint(self.START_POINT,
self.tr('Start point')))
self.addParameter(QgsProcessingParameterEnum(self.STRATEGY,
self.tr('Path type to calculate'),
self.STRATEGIES,
defaultValue=0))
self.addParameter(QgsProcessingParameterNumber(self.TRAVEL_COST,
self.tr('Travel cost (distance for "Shortest", time for "Fastest")'),
QgsProcessingParameterNumber.Double,
0.0, False, 0))
params = []
params.append(QgsProcessingParameterField(self.DIRECTION_FIELD,
self.tr('Direction field'),
None,
self.INPUT,
optional=True))
params.append(QgsProcessingParameterString(self.VALUE_FORWARD,
self.tr('Value for forward direction'),
optional=True))
params.append(QgsProcessingParameterString(self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
optional=True))
params.append(QgsProcessingParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
optional=True))
params.append(QgsProcessingParameterEnum(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
defaultValue=2))
params.append(QgsProcessingParameterField(self.SPEED_FIELD,
self.tr('Speed field'),
None,
self.INPUT,
optional=True))
params.append(QgsProcessingParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'),
QgsProcessingParameterNumber.Double,
5.0, False, 0))
params.append(QgsProcessingParameterDistance(self.TOLERANCE,
self.tr('Topology tolerance'),
0.0, self.INPUT, False, 0))
params.append(QgsProcessingParameterBoolean(self.INCLUDE_BOUNDS,
self.tr('Include upper/lower bound points'),
defaultValue=False))
for p in params:
p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
lines_output = QgsProcessingParameterFeatureSink(self.OUTPUT_LINES,
self.tr('Service area (lines)'),
QgsProcessing.TypeVectorLine, optional=True)
lines_output.setCreateByDefault(True)
self.addParameter(lines_output)
nodes_output = QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Service area (boundary nodes)'),
QgsProcessing.TypeVectorPoint, optional=True)
nodes_output.setCreateByDefault(False)
self.addParameter(nodes_output)
def initParameters(self, config=None):
self.addParameter(QgsProcessingParameterDistance(self.START_DISTANCE,
self.tr('Start distance'), defaultValue=0.0, parentParameterName='INPUT'))
self.addParameter(QgsProcessingParameterDistance(self.END_DISTANCE,
self.tr('End distance'), defaultValue=0.0, parentParameterName='INPUT'))
def initParameters(self, config=None):
self.addParameter(QgsProcessingParameterDistance(self.INTERVAL,
self.tr('Interval between vertices to add'),
1, 'INPUT', False, 0, 10000000))
def initAlgorithm(self, config=None):
self.KERNELS = OrderedDict([
(self.tr('Quartic'), QgsKernelDensityEstimation.KernelQuartic),
(self.tr('Triangular'),
QgsKernelDensityEstimation.KernelTriangular),
(self.tr('Uniform'), QgsKernelDensityEstimation.KernelUniform),
(self.tr('Triweight'), QgsKernelDensityEstimation.KernelTriweight),
(self.tr('Epanechnikov'),
QgsKernelDensityEstimation.KernelEpanechnikov)
])
self.OUTPUT_VALUES = OrderedDict([
(self.tr('Raw'), QgsKernelDensityEstimation.OutputRaw),
(self.tr('Scaled'), QgsKernelDensityEstimation.OutputScaled)
])
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Point layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterDistance(self.RADIUS, self.tr('Radius'),
100.0, self.INPUT, False, 0.0))
radius_field_param = QgsProcessingParameterField(
self.RADIUS_FIELD,
self.tr('Radius from field'),
None,
self.INPUT,
QgsProcessingParameterField.Numeric,
optional=True)
radius_field_param.setFlags(
radius_field_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(radius_field_param)
class ParameterHeatmapPixelSize(QgsProcessingParameterNumber):
def __init__(self,
name='',
description='',
parent_layer=None,
radius_param=None,
radius_field_param=None,
minValue=None,
default=None,
optional=False):
QgsProcessingParameterNumber.__init__(
self, name, description,
QgsProcessingParameterNumber.Double, default, optional,
minValue)
self.parent_layer = parent_layer
self.radius_param = radius_param
self.radius_field_param = radius_field_param
def clone(self):
copy = ParameterHeatmapPixelSize(
self.name(), self.description(), self.parent_layer,
self.radius_param, self.radius_field_param, self.minimum(),
self.maximum(),
self.defaultValue(
(),
self.flags()
& QgsProcessingParameterDefinition.FlagOptional))
return copy
pixel_size_param = ParameterHeatmapPixelSize(
self.PIXEL_SIZE,
self.tr('Output raster size'),
parent_layer=self.INPUT,
radius_param=self.RADIUS,
radius_field_param=self.RADIUS_FIELD,
minValue=0.0,
default=0.1)
pixel_size_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.qgis.ui.HeatmapWidgets.HeatmapPixelSizeWidgetWrapper'
}
})
self.addParameter(pixel_size_param)
weight_field_param = QgsProcessingParameterField(
self.WEIGHT_FIELD,
self.tr('Weight from field'),
None,
self.INPUT,
QgsProcessingParameterField.Numeric,
optional=True)
weight_field_param.setFlags(
weight_field_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(weight_field_param)
keys = list(self.KERNELS.keys())
kernel_shape_param = QgsProcessingParameterEnum(
self.KERNEL,
self.tr('Kernel shape'),
keys,
allowMultiple=False,
defaultValue=0)
kernel_shape_param.setFlags(
kernel_shape_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(kernel_shape_param)
decay_ratio = QgsProcessingParameterNumber(
self.DECAY, self.tr('Decay ratio (Triangular kernels only)'),
QgsProcessingParameterNumber.Double, 0.0, True, -100.0, 100.0)
decay_ratio.setFlags(decay_ratio.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(decay_ratio)
keys = list(self.OUTPUT_VALUES.keys())
output_scaling = QgsProcessingParameterEnum(
self.OUTPUT_VALUE,
self.tr('Output value scaling'),
keys,
allowMultiple=False,
defaultValue=0)
output_scaling.setFlags(
output_scaling.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(output_scaling)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Heatmap')))
def initAlgorithm(self, config=None):
self.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'), QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward),
(self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)])
self.STRATEGIES = [self.tr('Shortest'),
self.tr('Fastest')
]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Vector layer representing network'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(QgsProcessingParameterFeatureSource(self.START_POINTS,
self.tr('Vector layer with start points'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(QgsProcessingParameterPoint(self.END_POINT,
self.tr('End point')))
self.addParameter(QgsProcessingParameterEnum(self.STRATEGY,
self.tr('Path type to calculate'),
self.STRATEGIES,
defaultValue=0))
params = []
params.append(QgsProcessingParameterField(self.DIRECTION_FIELD,
self.tr('Direction field'),
None,
self.INPUT,
optional=True))
params.append(QgsProcessingParameterString(self.VALUE_FORWARD,
self.tr('Value for forward direction'),
optional=True))
params.append(QgsProcessingParameterString(self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
optional=True))
params.append(QgsProcessingParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
optional=True))
params.append(QgsProcessingParameterEnum(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
defaultValue=2))
params.append(QgsProcessingParameterField(self.SPEED_FIELD,
self.tr('Speed field'),
None,
self.INPUT,
optional=True))
params.append(QgsProcessingParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'),
QgsProcessingParameterNumber.Double,
5.0, False, 0, 99999999.99))
params.append(QgsProcessingParameterDistance(self.TOLERANCE,
self.tr('Topology tolerance'),
0.0, self.INPUT, False, 0, 99999999.99))
for p in params:
p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Shortest path'),
QgsProcessing.TypeVectorLine))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Input layer'), [QgsProcessing.TypeVectorPoint]))
self.addParameter(QgsProcessingParameterDistance(self.BUFFER, self.tr('Buffer region'), parentParameterName=self.INPUT,
minValue=0.0, maxValue=9999999999, defaultValue=0.0))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Voronoi polygons'), type=QgsProcessing.TypeVectorPolygon))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterBand(self.BAND,
self.tr('Band number'),
1,
parentLayerParameterName=self.INPUT))
self.addParameter(
QgsProcessingParameterPoint(self.OBSERVER,
self.tr('Observer location')))
self.addParameter(
QgsProcessingParameterNumber(
self.OBSERVER_HEIGHT,
self.tr('Observer height, DEM units'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=1.0))
self.addParameter(
QgsProcessingParameterNumber(
self.TARGET_HEIGHT,
self.tr('Target height, DEM units'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=1.0))
self.addParameter(
QgsProcessingParameterDistance(
self.MAX_DISTANCE,
self.tr(
'Maximum distance from observer to compute visibility'),
parentParameterName=self.INPUT,
minValue=0.0,
defaultValue=100.0))
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
self.addParameter(options_param)
extra_param = QgsProcessingParameterString(
self.EXTRA,
self.tr('Additional command-line parameters'),
defaultValue=None,
optional=True)
extra_param.setFlags(extra_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_param)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Output')))
def initAlgorithm(self, config=None):
"""
Initialisation de l'algorithme: définition des
paramètres en entrée et en sortie
"""
# Données source
self.addParameter(
QgsProcessingParameterFeatureSource(
self.POI1,
self.tr("Couche d'interet 1 (par exemple les gares SNCF) "),
[QgsProcessing.TypeVectorAnyGeometry]))
# Distance du tampon
self.addParameter(
QgsProcessingParameterDistance(
'BUFFERDIST1',
self.tr('Distance du tampon'),
defaultValue=1000.0,
# Make distance units match the INPUT layer units:
parentParameterName='POI1'))
# Données source
self.addParameter(
QgsProcessingParameterFeatureSource(
self.POI2,
self.tr(
"Couche d'interet 2 ( par exemple les stations de metro)"),
[QgsProcessing.TypeVectorAnyGeometry]))
# Distance du tampon
self.addParameter(
QgsProcessingParameterDistance(
'BUFFERDIST2',
self.tr('Distance du tampon'),
defaultValue=300.0,
# Make distance units match the INPUT layer units:
parentParameterName='POI2'))
# Données source
self.addParameter(
QgsProcessingParameterFeatureSource(
self.POI3,
self.tr("Couche d'interet 3 (par exemple les espaces verts)"),
[QgsProcessing.TypeVectorAnyGeometry]))
# Distance du tampon
self.addParameter(
QgsProcessingParameterDistance(
'BUFFERDIST3',
self.tr('Distance du tampon'),
defaultValue=200.0,
# Make distance units match the INPUT layer units:
parentParameterName='POI3'))
# Données source
self.addParameter(
QgsProcessingParameterFeatureSource(
self.POI4,
self.tr("Couche d'interet 4 (par exemples les piscines)"),
[QgsProcessing.TypeVectorAnyGeometry]))
# Distance du tampon
self.addParameter(
QgsProcessingParameterDistance(
'BUFFERDIST4',
self.tr('Distance du tampon'),
defaultValue=500.0,
# Make distance units match the INPUT layer units:
parentParameterName='POI4'))
# Récupération de la destination.
self.addParameter(
QgsProcessingParameterVectorDestination(self.OUTPUT,
self.tr('Sortie')))
def initAlgorithm(self, config: Dict[str, Any]) -> None:
self.addParameter(
QgsProcessingParameterFeatureSource(
name=self.CANALS,
description='Input A (LINES)',
types=[QgsProcessing.TypeVectorLine],
defaultValue=None
)
)
self.addParameter(
QgsProcessingParameterFeatureSource(
name=self.DELIVERYPOINTS,
description='Input B (POINTS)',
types=[QgsProcessing.TypeVectorPoint],
defaultValue=None
)
)
self.addParameter(
QgsProcessingParameterField(
name=self.CANALSFIELD,
description='LINE NAME attribute (INPUT A)',
type=QgsProcessingParameterField.Any,
parentLayerParameterName=self.CANALS,
allowMultiple=False,
defaultValue=options.get(self.CANALSFIELD, None)
)
)
self.parameterDefinition(self.CANALSFIELD).setMetadata({
'widget_wrapper': CustomFieldWrapper
})
self.addParameter(
QgsProcessingParameterField(
name=self.POINTSFIELD,
description='LINE NAME attribute (INPUT B)',
type=QgsProcessingParameterField.Any,
parentLayerParameterName=self.DELIVERYPOINTS,
allowMultiple=False,
defaultValue=options.get(self.POINTSFIELD, None)
)
)
self.parameterDefinition(self.POINTSFIELD).setMetadata({
'widget_wrapper': CustomFieldWrapper
})
self.addParameter(
QgsProcessingParameterField(
name=self.TYPEFIELD,
description='TYPE attribute for points',
type=QgsProcessingParameterField.String,
parentLayerParameterName=self.DELIVERYPOINTS,
allowMultiple=False,
defaultValue=options.get(self.TYPEFIELD, None)
)
)
self.parameterDefinition(self.TYPEFIELD).setMetadata({
'widget_wrapper': CustomFieldWrapper
})
self.addParameter(
QgsProcessingParameterString(
name=self.TYPEVALUE,
description='type VALUE for intersection points',
multiLine=False,
defaultValue=options.get(self.TYPEVALUE, None)
)
)
self.addParameter(
QgsProcessingParameterDistance(
name=self.TOLERANCECANALS,
description='snapping threshold for lines',
parentParameterName=self.CANALS,
defaultValue=options.get(self.TOLERANCECANALS, None)
)
)
self.addParameter(
QgsProcessingParameterDistance(
name=self.TOLERANCEPOINTS,
description='snapping threshold for points',
parentParameterName=self.CANALS,
defaultValue=options.get(self.TOLERANCEPOINTS, None),
# defaultValue=None
)
)
self.addParameter(
QgsProcessingParameterFeatureSink(
name=self.POINTSWITHUUID,
description='Source points with uuid4 added (OUTPUT A)',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue=None
)
)
self.addParameter(
QgsProcessingParameterFeatureSink(
name=self.SNAPPEDPOINTS,
description='Processed points (OUTPUT B)',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
supportsAppend=True,
defaultValue=None
)
)
self.addParameter(
QgsProcessingParameterFeatureSink(
name=self.SNAPPEDCANALS,
description='Processed lines (OUTPUT C)',
type=QgsProcessing.TypeVectorAnyGeometry,
createByDefault=True,
defaultValue=None
)
)
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.POINTS_INPUT, self.tr("Points Input"),
[QgsProcessing.TypeVectorPoint]))
# have to use QgsProcessingParameterFile to account for rasters too large to load in qgis
self.addParameter(
QgsProcessingParameterFile(self.RASTER_INPUT,
self.tr("Raster File Input")))
param = QgsProcessingParameterDistance(
self.GRAB_RADIUS_INPUT,
self.tr("Grab Radius"),
parentParameterName=self.POINTS_INPUT,
optional=True)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
param = QgsProcessingParameterNumber(
self.GRAB_AREA_DISTANCE_WEIGHT_INPUT,
self.tr("Grab Area Distance Weight"),
type=QgsProcessingParameterNumber.Double,
optional=True)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
param = QgsProcessingParameterFile(self.GRAB_FUNCTION_INPUT,
self.tr("Grab Function"),
optional=True)
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
self.addParameter(
QgsProcessingParameterFeatureSink(
self.POINTS_WITH_VALUES_OUTPUT,
self.tr("Points with Grabbed Values")))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.LINES,
self.tr('Lines'),
types=[QgsProcessing.TypeVectorLine],
defaultValue=None))
self.addParameter(
QgsProcessingParameterDistance(self.SEGMENT_SIZE,
self.tr('Size of the segments'),
parentParameterName=self.LINES,
defaultValue=200))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.POINTS,
self.tr('Point Layer'),
types=[QgsProcessing.TypeVectorPoint],
defaultValue=None))
self.addParameter(
QgsProcessingParameterDistance(
self.DIST,
self.tr('Maximum distance to the line'),
parentParameterName=self.POINTS,
defaultValue=100))
lroad_fied = QgsProcessingParameterField(
self.LINES_ROAD_NAMES,
self.tr('Names of roads in line layer'),
type=QgsProcessingParameterField.String,
parentLayerParameterName=self.LINES,
allowMultiple=False,
defaultValue=None,
optional=True)
lroad_fied.setFlags(lroad_fied.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(lroad_fied)
proad_field = QgsProcessingParameterField(
self.POINTS_ROAD_NAMES,
self.tr('Names of roads in point layer'),
type=QgsProcessingParameterField.String,
parentLayerParameterName=self.POINTS,
allowMultiple=False,
defaultValue=None,
optional=True)
proad_field.setFlags(proad_field.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(proad_field)
count_field = QgsProcessingParameterString(self.FIELD,
self.tr('Count field name'),
defaultValue='NUMPOINTS')
count_field.setFlags(count_field.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(count_field)
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT_LINE,
self.tr('Graduated Line Map'),
QgsProcessing.TypeVectorLine))
self.addParameter(
QgsProcessingParameterFeatureSink(
self.OUTPUT_POINT, self.tr('Points linked to Line Map'),
QgsProcessing.TypeVectorPoint))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT,
self.tr('Input layer'),
types=[QgsProcessing.TypeVectorAnyGeometry]
)
)
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INTERPOLATE,
self.tr('Interpolation layer'),
types=[QgsProcessing.TypeVectorAnyGeometry]
)
)
self.addParameter(
QgsProcessingParameterField(
self.INTERPOLATE_FIELD,
self.tr('Interpolating field'),
parentLayerParameterName=self.INTERPOLATE,
type=QgsProcessingParameterField.Numeric
)
)
power = QgsProcessingParameterNumber(
self.POWER,
self.tr('Power parameter for interpolation'),
type=QgsProcessingParameterNumber.Double,
defaultValue=2,
optional=True
)
power.setMetadata({
'widget_wrapper': {
'decimals': 2
}
})
self.addParameter(power)
self.addParameter(
QgsProcessingParameterNumber(
self.NUMBER_NEIGHBOR,
self.tr('Number of neighbors'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=12,
optional=True
)
)
search_radius = QgsProcessingParameterDistance(
self.SEARCH_RADIUS,
self.tr('Search radius'),
defaultValue=None,
parentParameterName=self.INTERPOLATE,
optional=True
)
search_radius.setMetadata({
'widget_wrapper': {
'decimals': 2
}
})
self.addParameter(search_radius)
self.addParameter(
QgsProcessingParameterEnum(
self.DATA_TYPE,
self.tr('Output data type'),
options=[dtype[1] for dtype in self.data_type],
defaultValue=1,
optional=True
)
)
self.addParameter(
QgsProcessingParameterString(
name=self.OUTPUT_FIELD,
description=self.tr('Output field name'),
)
)
self.addParameter(
QgsProcessingParameterVectorDestination(
self.OUTPUT,
self.tr('Output layer')
)
)
