def initAlgorithm(self, config=None):
self.bandlist = [
'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B10',
'B11', 'B12'
]
self.combinations = [
'True color', 'False color', 'False color (urban)', 'SWIR',
'Custom'
]
self.combi_dict = {
'True color': ['B4', 'B3', 'B2'],
'False color': ['B8', 'B4', 'B3'],
'False color (urban)': ['B12', 'B11', 'B4'],
'SWIR': ['B12', 'B8A', 'B4'],
'Custom': ['B12', 'B8', 'B4']
}
self.addParameter(
QgsProcessingParameterExtent(self.EXTENT, 'Mosaic extent:'))
self.addParameter(
QgsProcessingParameterBoolean(
self.DATEFROMPOINT,
'Get dates interval from points layer.',
defaultValue=False,
optional=False))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT,
'Points layer:',
types=[QgsProcessing.TypeVectorPoint],
optional=True))
#self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, 'Points layer:', types=[QgsProcessing.TypeVectorPoint], optional=False))
self.addParameter(
QgsProcessingParameterDateTime(self.DATE,
'Date (last date for mosaic):',
type=1))
self.addParameter(
QgsProcessingParameterNumber(
self.INTERVAL_B,
'Interval before (days before "Date"):',
defaultValue=0,
optional=False,
minValue=0,
maxValue=90))
self.addParameter(
QgsProcessingParameterNumber(self.INTERVAL_A,
'Interval after (days after "Date"):',
defaultValue=0,
optional=False,
minValue=0,
maxValue=90))
self.addParameter(
QgsProcessingParameterBoolean(self.SINGLEDATE,
'Generate single-date layers.',
defaultValue=True,
optional=False))
self.addParameter(
QgsProcessingParameterBoolean(self.COMPOSITE,
'Generate composite layer.',
defaultValue=False,
optional=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.PREYEAR,
'Generate composite layer for previous year.',
defaultValue=False,
optional=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.POSTYEAR,
'Generate composite layer for following year.',
defaultValue=False,
optional=False))
self.addParameter(
QgsProcessingParameterString(self.PREFIX,
'Layer prefix:',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.COMBI,
'Channels combination:',
self.combinations,
defaultValue=4))
self.addParameter(
QgsProcessingParameterEnum(self.BAND1,
'Band1 (red):',
self.bandlist,
defaultValue=12))
self.addParameter(
QgsProcessingParameterEnum(self.BAND2,
'Band2 (green):',
self.bandlist,
defaultValue=7))
self.addParameter(
QgsProcessingParameterEnum(self.BAND3,
'Band3 (blue):',
self.bandlist,
defaultValue=3))
self.addParameter(
QgsProcessingParameterBoolean(
self.CLOUDFILTERS,
'Apply cloud filter for sinlelayers.',
defaultValue=True,
optional=False))
self.addParameter(
QgsProcessingParameterNumber(self.CLOUDS,
'Cloudness for sinlelayers:',
defaultValue=25,
optional=False,
minValue=0,
maxValue=100))
self.addParameter(
QgsProcessingParameterBoolean(
self.CLOUDFILTERC,
'Apply cloud filter for composite layers.',
defaultValue=True,
optional=False))
self.addParameter(
QgsProcessingParameterNumber(self.CLOUDC,
'Cloudness for composite layers:',
defaultValue=1,
optional=False,
minValue=0,
maxValue=100))
self.addParameter(
QgsProcessingParameterNumber(self.VIS_MIN,
'Vis_min:',
defaultValue=30,
optional=False,
minValue=0,
maxValue=10000))
self.addParameter(
QgsProcessingParameterNumber(self.VIS_MAX,
'Vis_max:',
defaultValue=7000,
optional=False,
minValue=0,
maxValue=10000))
self.addParameter(
QgsProcessingParameterBoolean(self.VISIBLE,
'Make result layer visible.',
defaultValue=True,
optional=False))
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PrmInputLayer, tr('Input point layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterEnum(self.PrmShapeType,
tr('Shape type'),
options=SHAPE_TYPE,
defaultValue=0,
optional=False))
self.addParameter(
QgsProcessingParameterField(
self.PrmStarPointsField,
tr('Number of star points field'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmOuterRadiusField,
tr('Outer radius field'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmInnerRadiusField,
tr('Inner radius field'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PrmStartingAngleField,
tr('Starting angle field'),
parentLayerParameterName=self.PrmInputLayer,
type=QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmDefaultStarPoints,
tr('Default number of points on the star'),
QgsProcessingParameterNumber.Integer,
defaultValue=5,
minValue=3,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.PrmDefaultOuterRadius,
tr('Default outer radius'),
QgsProcessingParameterNumber.Double,
defaultValue=20.0,
minValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.PrmDefaultInnerRadius,
tr('Default inner radius'),
QgsProcessingParameterNumber.Double,
defaultValue=10.0,
minValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.PrmDefaultStartingAngle,
tr('Default starting angle'),
QgsProcessingParameterNumber.Double,
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.PrmUnitsOfMeasure,
tr('Radius units'),
options=DISTANCE_LABELS,
defaultValue=0,
optional=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.PrmExportInputGeometry,
tr('Add input geometry fields to output table'),
False,
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputLayer,
tr('Output layer')))
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.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 distance'),
self.tr('Fastest time')
]
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Network Layer'),
[QgsProcessing.TypeVectorLine]))
self.addParameter(
QgsProcessingParameterPoint(self.START_POINT,
self.tr('Start point')))
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 (km/h)'),
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(
QgsProcessingParameterNumber(self.TOLERANCE,
self.tr('Topology tolerance'),
QgsProcessingParameterNumber.Double,
0.00001, 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 Layer'),
QgsProcessing.TypeVectorLine))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.MASK, self.tr('Mask layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterNumber(
self.NODATA,
self.tr('Assign a specified nodata value to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.ALPHA_BAND,
self.tr('Create an output alpha band'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.CROP_TO_CUTLINE,
self.
tr('Crop the extent of the target dataset to the extent of the cutline'
),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.KEEP_RESOLUTION,
self.tr('Keep resolution of output raster'),
defaultValue=False))
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation parameters'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
self.addParameter(options_param)
dataType_param = QgsProcessingParameterEnum(
self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=5)
dataType_param.setFlags(
dataType_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Clipped (mask)')))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterEnum(self.METHOD,
self.tr('Calculate using'), options=self.calc_methods, defaultValue=0))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Added geom info')))
def initAlgorithm(self, config=None):
self.units = [self.tr("Pixels"),
self.tr("Georeferenced units")]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterField(self.FIELD,
self.tr('Field to use for a burn-in value'),
None,
self.INPUT,
QgsProcessingParameterField.Numeric,
optional=True))
self.addParameter(QgsProcessingParameterNumber(self.BURN,
self.tr('A fixed value to burn'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True))
self.addParameter(QgsProcessingParameterEnum(self.UNITS,
self.tr('Output raster size units'),
self.units))
self.addParameter(QgsProcessingParameterNumber(self.WIDTH,
self.tr('Width/Horizontal resolution'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterNumber(self.HEIGHT,
self.tr('Height/Vertical resolution'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterExtent(self.EXTENT,
self.tr('Output extent')))
self.addParameter(QgsProcessingParameterNumber(self.NODATA,
self.tr('Assign a specified nodata value to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True))
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation parameters'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=5)
dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
init_param = QgsProcessingParameterNumber(self.INIT,
self.tr('Pre-initialize the output image with value'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0,
optional=True)
init_param.setFlags(init_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(init_param)
invert_param = QgsProcessingParameterBoolean(self.INVERT,
self.tr('Invert rasterization'),
defaultValue=False)
invert_param.setFlags(invert_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(invert_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Rasterized')))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Input layer'), [QgsProcessing.TypeVectorPoint]))
self.addParameter(QgsProcessingParameterNumber(self.BUFFER, self.tr('Buffer region'), type=QgsProcessingParameterNumber.Double,
minValue=0.0, maxValue=9999999999, defaultValue=0.0))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Voronoi polygons'), type=QgsProcessing.TypeVectorPolygon))
def initAlgorithm(self,
configuration,
p_str=None,
Any=None,
*args,
**kwargs):
providers = [provider['name'] for provider in self.providers]
self.addParameter(
QgsProcessingParameterEnum(self.IN_PROVIDER,
"Provider",
providers,
defaultValue=providers[0]))
self.addParameter(
QgsProcessingParameterFeatureSource(
name=self.IN_START,
description="Input Start Point layer",
types=[QgsProcessing.TypeVectorPoint],
))
self.addParameter(
QgsProcessingParameterField(
name=self.IN_START_FIELD,
description="Start ID Field (can be used for joining)",
parentLayerParameterName=self.IN_START,
))
self.addParameter(
QgsProcessingParameterFeatureSource(
name=self.IN_END,
description="Input End Point layer",
types=[QgsProcessing.TypeVectorPoint],
))
self.addParameter(
QgsProcessingParameterField(
name=self.IN_END_FIELD,
description="End ID Field (can be used for joining)",
parentLayerParameterName=self.IN_END,
))
self.addParameter(
QgsProcessingParameterEnum(self.IN_PROFILE,
"Travel mode",
PROFILES,
defaultValue=PROFILES[0]))
self.addParameter(
QgsProcessingParameterEnum(self.IN_PREFERENCE,
"Travel preference",
PREFERENCES,
defaultValue=PREFERENCES[0]))
self.addParameter(
QgsProcessingParameterEnum(self.IN_MODE,
"Layer mode",
self.MODE_SELECTION,
defaultValue=self.MODE_SELECTION[0]))
self.addParameter(
QgsProcessingParameterFeatureSink(
name=self.OUT,
description="Directions",
))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.MASK, self.tr('Mask layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterCrs(self.SOURCE_CRS,
self.tr('Source CRS'),
optional=True))
self.addParameter(
QgsProcessingParameterCrs(self.TARGET_CRS,
self.tr('Target CRS'),
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.NODATA,
self.tr('Assign a specified nodata value to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.ALPHA_BAND,
self.tr('Create an output alpha band'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.CROP_TO_CUTLINE,
self.
tr('Match the extent of the clipped raster to the extent of the mask layer'
),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.KEEP_RESOLUTION,
self.tr('Keep resolution of input raster'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.SET_RESOLUTION,
self.tr('Set output file resolution'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterNumber(
self.X_RESOLUTION,
self.tr('X Resolution to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.Y_RESOLUTION,
self.tr('Y Resolution to output bands'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
multithreading_param = QgsProcessingParameterBoolean(
self.MULTITHREADING,
self.tr('Use multithreaded warping implementation'),
defaultValue=False)
multithreading_param.setFlags(
multithreading_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(multithreading_param)
options_param = QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class':
'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'
}
})
self.addParameter(options_param)
dataType_param = QgsProcessingParameterEnum(
self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=0)
dataType_param.setFlags(
dataType_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
self.addParameter(
QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Clipped (mask)')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterField(self.FIELD,
self.tr('Dissolve field'),
None,
self.INPUT,
QgsProcessingParameterField.Any,
optional=True))
self.addParameter(
QgsProcessingParameterString(self.GEOMETRY,
self.tr('Geometry column name'),
defaultValue='geometry'))
params = []
params.append(
QgsProcessingParameterBoolean(
self.EXPLODE_COLLECTIONS,
self.
tr('Produce one feature for each geometry in any kind of geometry collection in the source file'
),
defaultValue=False))
params.append(
QgsProcessingParameterBoolean(self.KEEP_ATTRIBUTES,
self.tr('Keep input attributes'),
defaultValue=False))
params.append(
QgsProcessingParameterBoolean(self.COUNT_FEATURES,
self.tr('Count dissolved features'),
defaultValue=False))
params.append(
QgsProcessingParameterBoolean(
self.COMPUTE_AREA,
self.tr('Compute area and perimeter of dissolved features'),
defaultValue=False))
params.append(
QgsProcessingParameterBoolean(
self.COMPUTE_STATISTICS,
self.tr('Compute min/max/sum/mean for attribute'),
defaultValue=False))
params.append(
QgsProcessingParameterField(
self.STATISTICS_ATTRIBUTE,
self.tr('Numeric attribute to calculate statistics on'),
None,
self.INPUT,
QgsProcessingParameterField.Numeric,
optional=True))
params.append(
QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True))
for param in params:
param.setFlags(param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
self.addParameter(
QgsProcessingParameterVectorDestination(self.OUTPUT,
self.tr('Dissolved')))
def initAlgorithm(self, config=None):
"""
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(
QgsProcessingParameterFeatureSource(
self.INPUT,
self.tr('Input table'),
[QgsProcessing.TypeVector]
)
)
self.keys = ['accommodation',
'administrative-areas-buildings',
'administrative-region',
'airport',
'ambulance-services',
'amusement-holiday-park',
'atm-bank-exchange',
'bar-pub',
'body-of-water',
'bookshop',
'building',
'business-industry',
'business-services',
'camping',
'car-dealer-repair',
'car-rental',
'casino',
'cinema',
'city-town-village',
'clothing-accessories-shop',
'coffee',
'coffee-tea',
'communication-media',
'dance-night-club',
'department-store',
'eat-drink',
'education-facility',
'electronics-shop',
'ev-charging-station',
'facilities',
'facility',
'fair-convention-facility',
'ferry-terminal',
'fire-department',
'food-drink',
'forest-heath-vegetation',
'going-out',
'government-community-facility',
'hardware-house-garden-shop',
'hospital-health-care-facility',
'hospital-health-care-facility',
'hostel',
'hotel',
'intersection',
'kiosk-convenience-store',
'landmark-attraction',
'leisure-outdoor',
'library',
'mall',
'motel',
'mountain-hill',
'museum',
'natural-geographical',
'outdoor-area-complex',
'parking-facility',
'petrol-station',
'pharmacy',
'police-emergency',
'police-station',
'post-office',
'postal-area',
'public-transport',
'railway-station',
'recreation',
'religious-place',
'restaurant',
'service',
'shop',
'shopping',
'sights-museums',
'snacks-fast-food',
'sport-outdoor-shop',
'sports-facility-venue',
'street-square',
'taxi-stand',
'tea',
'theatre-music-culture',
'toilet-rest-area',
'tourist-information',
'transport',
'travel-agency',
'undersea-feature',
'wine-and-liquor',
'zoo']
self.addParameter(
QgsProcessingParameterEnum(
self.KEYS,
self.tr('POI Categories'),
options=self.keys,
#defaultValue=0,
optional=False,
allowMultiple=True
)
)
self.modes = [
"walk", #indicates that the user is on foot.
"drive", #indicates that the user is driving.
"public_transport", #indicates that the user is on public transport.
"bicycle", #indicates that the user is on bicycle.
"none" #if the user is neither on foot nor driving.
]
self.addParameter(
QgsProcessingParameterEnum(
self.MODES,
self.tr('Traffic Mode'),
options=self.modes,
#defaultValue=0,
optional=False,
allowMultiple=False
)
)
self.addParameter(
QgsProcessingParameterNumber(
self.RADIUS,
self.tr('Radius around Points [m]'),
#parentParameterName=self.INPUT,
#options=self.keys,
defaultValue=100,
minValue=1,
maxValue=100000,
# defaultUnit="DistanceMeters",
optional=False,
)#.setDefaultUnit(QgsUnitTypes.DistanceMeters)
)
# 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('POI layer')
)
)
def initAlgorithm(self, config):
"""Here we define the inputs and output of the algorithm, along
with some other properties.
"""
self.addParameter(
QgsProcessingParameterFeatureSource(
self.OBSERVER_POINTS, self.tr('Observer location(s)'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.DEM, self.tr('Digital elevation model ')))
self.addParameter(
QgsProcessingParameterField(
self.OBSERVER_ID,
self.tr('Observer ids (leave unchanged to use feature ids)'),
parentLayerParameterName=self.OBSERVER_POINTS,
optional=True))
##
self.addParameter(
QgsProcessingParameterNumber(self.RADIUS,
self.tr("Radius of analysis, meters"),
QgsProcessingParameterNumber.Integer,
defaultValue=5000))
self.addParameter(
QgsProcessingParameterField(
self.RADIUS_FIELD,
self.tr('Field value for analysis radius'),
parentLayerParameterName=self.OBSERVER_POINTS,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.OBS_HEIGHT,
self.tr('Observer height, meters'),
QgsProcessingParameterNumber.Double,
defaultValue=1.6))
self.addParameter(
QgsProcessingParameterField(
self.OBS_HEIGHT_FIELD,
self.tr('Field value for observer height'),
parentLayerParameterName=self.OBSERVER_POINTS,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(self.TARGET_HEIGHT,
self.tr('Target height, meters'),
QgsProcessingParameterNumber.Double,
defaultValue=0.0))
self.addParameter(
QgsProcessingParameterField(
self.TARGET_HEIGHT_FIELD,
self.tr('Field value for target height, meters'),
parentLayerParameterName=self.OBSERVER_POINTS,
optional=True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Output layer')))
def initAlgorithm(self, config=None):
self.predicates = (('intersects', self.tr('intersects')),
('contains', self.tr('contains')),
('equals', self.tr('equals')), ('touches',
self.tr('touches')),
('overlaps', self.tr('overlaps')),
('within', self.tr('within')), ('crosses',
self.tr('crosses')))
self.reversed_predicates = {
'intersects': 'intersects',
'contains': 'within',
'isEqual': 'isEqual',
'touches': 'touches',
'overlaps': 'overlaps',
'within': 'contains',
'crosses': 'crosses'
}
self.methods = [
self.tr('Create separate feature for each located feature'),
self.tr('Take attributes of the first located feature only')
]
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.JOIN, self.tr('Join layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
predicate = QgsProcessingParameterEnum(
self.PREDICATE,
self.tr('Geometric predicate'),
options=[p[1] for p in self.predicates],
allowMultiple=True,
defaultValue=[0])
predicate.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers.EnumWidgetWrapper',
'useCheckBoxes': True,
'columns': 2
}
})
self.addParameter(predicate)
self.addParameter(
QgsProcessingParameterField(
self.JOIN_FIELDS,
self.tr('Fields to add (leave empty to use all fields)'),
parentLayerParameterName=self.JOIN,
allowMultiple=True,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.METHOD, self.tr('Join type'),
self.methods))
self.addParameter(
QgsProcessingParameterBoolean(
self.DISCARD_NONMATCHING,
self.tr('Discard records which could not be joined'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Joined layer')))
def accept(self):
description = self.nameTextBox.text()
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType == parameters.PARAMETER_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType == parameters.PARAMETER_TABLE_FIELD
or isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(
name,
description,
defaultValue=default,
parentLayerParameterName=parent,
type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == parameters.PARAMETER_BAND
or isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None,
parent)
elif (self.paramType == parameters.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType == parameters.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType == parameters.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType == parameters.PARAMETER_NUMBER or isinstance(
self.param,
(QgsProcessingParameterNumber, QgsProcessingParameterDistance))):
try:
self.param = QgsProcessingParameterNumber(
name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType == parameters.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType == parameters.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == parameters.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(
name, description, QgsProcessingParameterFile.Folder
if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType == parameters.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
elif (self.paramType == parameters.PARAMETER_ENUM
or isinstance(self.param, QgsProcessingParameterEnum)):
self.param = QgsProcessingParameterEnum(
name, description, self.widget.options(),
self.widget.allowMultiple(), self.widget.defaultOptions())
elif (self.paramType == parameters.PARAMETER_MATRIX
or isinstance(self.param, QgsProcessingParameterMatrix)):
self.param = QgsProcessingParameterMatrix(
name,
description,
hasFixedNumberRows=self.widget.fixedRows(),
headers=self.widget.headers(),
defaultValue=self.widget.value())
# Destination parameter
elif (isinstance(self.param, QgsProcessingParameterFeatureSink)):
self.param = QgsProcessingParameterFeatureSink(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
self.param = QgsProcessingParameterFileDestination(
name=name,
description=self.param.description(),
fileFilter=self.param.fileFilter(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
self.param = QgsProcessingParameterFolderDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
self.param = QgsProcessingParameterRasterDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
self.param = QgsProcessingParameterVectorDestination(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
else:
if self.paramType:
typeId = self.paramType
else:
typeId = self.param.type()
paramTypeDef = QgsApplication.instance().processingRegistry(
).parameterType(typeId)
if not paramTypeDef:
msg = self.tr(
'The parameter `{}` is not registered, are you missing a required plugin?'
.format(typeId))
raise UndefinedParameterException(msg)
self.param = paramTypeDef.create(name)
self.param.setDescription(description)
self.param.setMetadata(paramTypeDef.metadata())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def initAlgorithm(self, config=None):
db_param = QgsProcessingParameterString(
self.DATABASE, self.tr('Database (connection name)'))
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
self.addParameter(db_param)
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT,
self.tr('Input layer'),
types=[QgsProcessing.TypeVector]))
self.addParameter(
QgsProcessingParameterString(self.SHAPE_ENCODING,
self.tr('Shape encoding'),
"",
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.GTYPE,
self.tr('Output geometry type'),
options=self.GEOMTYPE,
defaultValue=0))
self.addParameter(
QgsProcessingParameterCrs(self.A_SRS,
self.tr('Assign an output CRS'),
defaultValue='',
optional=False))
self.addParameter(
QgsProcessingParameterCrs(
self.T_SRS,
self.tr('Reproject to this CRS on output '),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterCrs(self.S_SRS,
self.tr('Override source CRS'),
defaultValue='',
optional=True))
schema_param = QgsProcessingParameterString(
self.SCHEMA, self.tr('Schema (schema name)'), 'public', False,
True)
schema_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
'connection_param': self.DATABASE
}
})
self.addParameter(schema_param)
table_param = QgsProcessingParameterString(
self.TABLE,
self.tr('Table to import to (leave blank to use layer name)'), '',
False, True)
table_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers_postgis.TableWidgetWrapper',
'schema_param': self.SCHEMA
}
})
self.addParameter(table_param)
self.addParameter(
QgsProcessingParameterString(self.PK,
self.tr('Primary key (new field)'),
defaultValue='id',
optional=True))
self.addParameter(
QgsProcessingParameterField(
self.PRIMARY_KEY,
self.
tr('Primary key (existing field, used if the above option is left empty)'
),
parentLayerParameterName=self.INPUT,
optional=True))
self.addParameter(
QgsProcessingParameterString(self.GEOCOLUMN,
self.tr('Geometry column name'),
defaultValue='geom',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(self.DIM,
self.tr('Vector dimensions'),
options=self.DIMLIST,
defaultValue=0))
self.addParameter(
QgsProcessingParameterString(
self.SIMPLIFY,
self.tr('Distance tolerance for simplification'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.SEGMENTIZE,
self.tr('Maximum distance between 2 nodes (densification)'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterExtent(
self.SPAT,
self.tr(
'Select features by extent (defined in input layer CRS)'),
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.CLIP,
self.tr(
'Clip the input layer using the above (rectangle) extent'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterString(
self.WHERE,
self.
tr('Select features using a SQL "WHERE" statement (Ex: column=\'value\')'
),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.GT,
self.tr('Group N features per transaction (Default: 20000)'),
defaultValue='',
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(self.OVERWRITE,
self.tr('Overwrite existing table'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(self.APPEND,
self.tr('Append to existing table'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.ADDFIELDS,
self.tr('Append and add new fields to existing table'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.LAUNDER,
self.tr('Do not launder columns/table names'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.INDEX,
self.tr('Do not create spatial index'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(
self.SKIPFAILURES,
self.tr(
'Continue after a failure, skipping the failed feature'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterBoolean(self.PROMOTETOMULTI,
self.tr('Promote to Multipart'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PRECISION,
self.tr('Keep width and precision of input attributes'),
defaultValue=True))
self.addParameter(
QgsProcessingParameterString(
self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT_RASTER,
self.tr('Raster layer')))
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT_VECTOR,
self.tr('Vector layer'), [QgsProcessing.TypeVectorPolygon]))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Points inside polygons'), QgsProcessing.TypeVectorPoint))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT,
self.tr('Input layer'),
types=[QgsProcessing.TypeVector]))
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=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(QgsProcessingParameterNumber(self.RADIUS,
self.tr('Radius (layer units)'),
QgsProcessingParameterNumber.Double,
100.0, False, 0.0, 9999999999.99))
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, maxValue=None,
default=None, optional=False):
QgsProcessingParameterNumber.__init__(self, name, description, QgsProcessingParameterNumber.Double, default, optional, minValue, maxValue)
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,
maxValue=9999999999,
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.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Input layer'), [QgsProcessing.TypeVectorPoint]))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Delaunay triangulation'), type=QgsProcessing.TypeVectorPolygon))
def initAlgorithm(self, config=None):
self.predicates = (('intersects', self.tr('intersects')),
('contains', self.tr('contains')),
('equals', self.tr('equals')), ('touches',
self.tr('touches')),
('overlaps', self.tr('overlaps')),
('within', self.tr('within')), ('crosses',
self.tr('crosses')))
self.statistics = [('count', self.tr('count')),
('unique', self.tr('unique')),
('min', self.tr('min')), ('max', self.tr('max')),
('range', self.tr('range')),
('sum', self.tr('sum')), ('mean', self.tr('mean')),
('median', self.tr('median')),
('stddev', self.tr('stddev')),
('minority', self.tr('minority')),
('majority', self.tr('majority')),
('q1', self.tr('q1')), ('q3', self.tr('q3')),
('iqr', self.tr('iqr')),
('empty', self.tr('empty')),
('filled', self.tr('filled')),
('min_length', self.tr('min_length')),
('max_length', self.tr('max_length')),
('mean_length', self.tr('mean_length'))]
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.JOIN, self.tr('Join layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
predicate = QgsProcessingParameterEnum(
self.PREDICATE,
self.tr('Geometric predicate'),
options=[p[1] for p in self.predicates],
allowMultiple=True,
defaultValue=[0])
predicate.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers.EnumWidgetWrapper',
'useCheckBoxes': True,
'columns': 2
}
})
self.addParameter(predicate)
self.addParameter(
QgsProcessingParameterField(
self.JOIN_FIELDS,
self.tr('Fields to summarise (leave empty to use all fields)'),
parentLayerParameterName=self.JOIN,
allowMultiple=True,
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.SUMMARIES,
self.tr(
'Summaries to calculate (leave empty to use all available)'
),
options=[p[1] for p in self.statistics],
allowMultiple=True,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.DISCARD_NONMATCHING,
self.tr('Discard records which could not be joined'),
defaultValue=False))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Joined layer')))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Cleaned')))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer')))
self.addParameter(QgsProcessingParameterString(self.SHAPE_ENCODING,
self.tr('Shape encoding'), "", optional=True))
self.addParameter(QgsProcessingParameterEnum(self.GTYPE,
self.tr('Output geometry type'), options=self.GEOMTYPE, defaultValue=0))
self.addParameter(QgsProcessingParameterCrs(self.A_SRS,
self.tr('Assign an output CRS'), defaultValue='', optional=False))
self.addParameter(QgsProcessingParameterCrs(self.T_SRS,
self.tr('Reproject to this CRS on output '), defaultValue='', optional=True))
self.addParameter(QgsProcessingParameterCrs(self.S_SRS,
self.tr('Override source CRS'), defaultValue='', optional=True))
self.addParameter(QgsProcessingParameterString(self.HOST,
self.tr('Host'), defaultValue='localhost', optional=True))
self.addParameter(QgsProcessingParameterString(self.PORT,
self.tr('Port'), defaultValue='5432', optional=True))
self.addParameter(QgsProcessingParameterString(self.USER,
self.tr('Username'), defaultValue='', optional=True))
self.addParameter(QgsProcessingParameterString(self.DBNAME,
self.tr('Database name'), defaultValue='', optional=True))
self.addParameter(QgsProcessingParameterString(self.PASSWORD,
self.tr('Password'), defaultValue='', optional=True))
self.addParameter(QgsProcessingParameterString(self.SCHEMA,
self.tr('Schema name'), defaultValue='public', optional=True))
self.addParameter(QgsProcessingParameterString(self.TABLE,
self.tr('Table name, leave blank to use input name'),
defaultValue='', optional=True))
self.addParameter(QgsProcessingParameterString(self.PK,
self.tr('Primary key (new field)'), defaultValue='id', optional=True))
self.addParameter(QgsProcessingParameterField(self.PRIMARY_KEY,
self.tr('Primary key (existing field, used if the above option is left empty)'), parentLayerParameterName=self.INPUT, optional=True))
self.addParameter(QgsProcessingParameterString(self.GEOCOLUMN,
self.tr('Geometry column name'), defaultValue='geom', optional=True))
self.addParameter(QgsProcessingParameterEnum(self.DIM,
self.tr('Vector dimensions'), options=self.DIMLIST, defaultValue=0))
self.addParameter(QgsProcessingParameterString(self.SIMPLIFY,
self.tr('Distance tolerance for simplification'),
defaultValue='', optional=True))
self.addParameter(QgsProcessingParameterString(self.SEGMENTIZE,
self.tr('Maximum distance between 2 nodes (densification)'),
defaultValue='', optional=True))
self.addParameter(QgsProcessingParameterExtent(self.SPAT,
self.tr('Select features by extent (defined in input layer CRS)'), optional=True))
self.addParameter(QgsProcessingParameterBoolean(self.CLIP,
self.tr('Clip the input layer using the above (rectangle) extent'),
defaultValue=False))
self.addParameter(QgsProcessingParameterString(self.WHERE,
self.tr('Select features using a SQL "WHERE" statement (Ex: column=\'value\')'),
defaultValue='', optional=True))
self.addParameter(QgsProcessingParameterString(self.GT,
self.tr('Group N features per transaction (Default: 20000)'),
defaultValue='', optional=True))
self.addParameter(QgsProcessingParameterBoolean(self.OVERWRITE,
self.tr('Overwrite existing table'), defaultValue=True))
self.addParameter(QgsProcessingParameterBoolean(self.APPEND,
self.tr('Append to existing table'), defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.ADDFIELDS,
self.tr('Append and add new fields to existing table'), defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.LAUNDER,
self.tr('Do not launder columns/table names'), defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.INDEX,
self.tr('Do not create spatial index'), defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.SKIPFAILURES,
self.tr('Continue after a failure, skipping the failed feature'), defaultValue=False))
self.addParameter(QgsProcessingParameterBoolean(self.PROMOTETOMULTI,
self.tr('Promote to Multipart'),
defaultValue=True))
self.addParameter(QgsProcessingParameterBoolean(self.PRECISION,
self.tr('Keep width and precision of input attributes'),
defaultValue=True))
self.addParameter(QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation options'), defaultValue='', optional=True))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Layer to import')))
db_param = QgsProcessingParameterString(
self.DATABASE, self.tr('Database (connection name)'))
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
self.addParameter(db_param)
schema_param = QgsProcessingParameterString(
self.SCHEMA, self.tr('Schema (schema name)'), 'public', False,
True)
schema_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
'connection_param': self.DATABASE
}
})
self.addParameter(schema_param)
table_param = QgsProcessingParameterString(
self.TABLENAME,
self.tr('Table to import to (leave blank to use layer name)'), '',
False, True)
table_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers_postgis.TableWidgetWrapper',
'schema_param': self.SCHEMA
}
})
self.addParameter(table_param)
self.addParameter(
QgsProcessingParameterField(self.PRIMARY_KEY,
self.tr('Primary key field'), None,
self.INPUT,
QgsProcessingParameterField.Any, False,
True))
self.addParameter(
QgsProcessingParameterString(self.GEOMETRY_COLUMN,
self.tr('Geometry column'), 'geom'))
self.addParameter(
QgsProcessingParameterString(self.ENCODING, self.tr('Encoding'),
'UTF-8', False, True))
self.addParameter(
QgsProcessingParameterBoolean(self.OVERWRITE, self.tr('Overwrite'),
True))
self.addParameter(
QgsProcessingParameterBoolean(self.CREATEINDEX,
self.tr('Create spatial index'),
True))
self.addParameter(
QgsProcessingParameterBoolean(
self.LOWERCASE_NAMES,
self.tr('Convert field names to lowercase'), True))
self.addParameter(
QgsProcessingParameterBoolean(
self.DROP_STRING_LENGTH,
self.tr('Drop length constraints on character fields'), False))
self.addParameter(
QgsProcessingParameterBoolean(
self.FORCE_SINGLEPART,
self.tr('Create single-part geometries instead of multi-part'),
False))
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT_LAYER,
self.tr('Input layer'),
types=[QgsProcessing.TypeVector]))
self.addParameter(
QgsProcessingParameterField(
self.FIELD_NAME, self.tr('Field to calculate statistics on'),
None, self.INPUT_LAYER, QgsProcessingParameterField.Any))
self.addParameter(
QgsProcessingParameterFileDestination(
self.OUTPUT_HTML_FILE, self.tr('Statistics'),
self.tr('HTML files (*.html)'), None, True))
self.addOutput(QgsProcessingOutputNumber(self.COUNT, self.tr('Count')))
self.addOutput(
QgsProcessingOutputNumber(self.UNIQUE,
self.tr('Number of unique values')))
self.addOutput(
QgsProcessingOutputNumber(
self.EMPTY, self.tr('Number of empty (null) values')))
self.addOutput(
QgsProcessingOutputNumber(self.FILLED,
self.tr('Number of non-empty values')))
self.addOutput(
QgsProcessingOutputNumber(self.MIN, self.tr('Minimum value')))
self.addOutput(
QgsProcessingOutputNumber(self.MAX, self.tr('Maximum value')))
self.addOutput(
QgsProcessingOutputNumber(self.MIN_LENGTH,
self.tr('Minimum length')))
self.addOutput(
QgsProcessingOutputNumber(self.MAX_LENGTH,
self.tr('Maximum length')))
self.addOutput(
QgsProcessingOutputNumber(self.MEAN_LENGTH,
self.tr('Mean length')))
self.addOutput(
QgsProcessingOutputNumber(self.CV,
self.tr('Coefficient of Variation')))
self.addOutput(QgsProcessingOutputNumber(self.SUM, self.tr('Sum')))
self.addOutput(
QgsProcessingOutputNumber(self.MEAN, self.tr('Mean value')))
self.addOutput(
QgsProcessingOutputNumber(self.STD_DEV,
self.tr('Standard deviation')))
self.addOutput(QgsProcessingOutputNumber(self.RANGE, self.tr('Range')))
self.addOutput(
QgsProcessingOutputNumber(self.MEDIAN, self.tr('Median')))
self.addOutput(
QgsProcessingOutputNumber(
self.MINORITY, self.tr('Minority (rarest occurring value)')))
self.addOutput(
QgsProcessingOutputNumber(
self.MAJORITY,
self.tr('Majority (most frequently occurring value)')))
self.addOutput(
QgsProcessingOutputNumber(self.FIRSTQUARTILE,
self.tr('First quartile')))
self.addOutput(
QgsProcessingOutputNumber(self.THIRDQUARTILE,
self.tr('Third quartile')))
self.addOutput(
QgsProcessingOutputNumber(self.IQR,
self.tr('Interquartile Range (IQR)')))
def initAlgorithm(self, config=None):
self.predicates = (
('intersects', self.tr('intersects')),
('contains', self.tr('contains')),
('isEqual', self.tr('equals')),
('touches', self.tr('touches')),
('overlaps', self.tr('overlaps')),
('within', self.tr('within')),
('crosses', self.tr('crosses')))
self.reversed_predicates = {'intersects': 'intersects',
'contains': 'within',
'isEqual': 'isEqual',
'touches': 'touches',
'overlaps': 'overlaps',
'within': 'contains',
'crosses': 'crosses'}
self.methods = [
self.tr('Create separate feature for each located feature (one-to-many)'),
self.tr('Take attributes of the first located feature only (one-to-one)')
]
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Input layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
self.addParameter(QgsProcessingParameterFeatureSource(self.JOIN,
self.tr('Join layer'),
[QgsProcessing.TypeVectorAnyGeometry]))
predicate = QgsProcessingParameterEnum(self.PREDICATE,
self.tr('Geometric predicate'),
options=[p[1] for p in self.predicates],
allowMultiple=True, defaultValue=[0])
predicate.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers.EnumWidgetWrapper',
'useCheckBoxes': True,
'columns': 2}})
self.addParameter(predicate)
self.addParameter(QgsProcessingParameterField(self.JOIN_FIELDS,
self.tr('Fields to add (leave empty to use all fields)'),
parentLayerParameterName=self.JOIN,
allowMultiple=True, optional=True))
self.addParameter(QgsProcessingParameterEnum(self.METHOD,
self.tr('Join type'), self.methods))
self.addParameter(QgsProcessingParameterBoolean(self.DISCARD_NONMATCHING,
self.tr('Discard records which could not be joined'),
defaultValue=False))
self.addParameter(QgsProcessingParameterString(self.PREFIX,
self.tr('Joined field prefix'), optional=True))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Joined layer'),
QgsProcessing.TypeVectorAnyGeometry,
defaultValue=None, optional=True, createByDefault=True))
non_matching = QgsProcessingParameterFeatureSink(self.NON_MATCHING,
self.tr('Unjoinable features from first layer'),
QgsProcessing.TypeVectorAnyGeometry,
defaultValue=None, optional=True, createByDefault=False)
# TODO GUI doesn't support advanced outputs yet
# non_matching.setFlags(non_matching.flags() | QgsProcessingParameterDefinition.FlagAdvanced )
self.addParameter(non_matching)
self.addOutput(QgsProcessingOutputNumber(self.JOINED_COUNT, self.tr("Number of joined features from input table")))
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT,
self.tr('Point layer'),
[QgsProcessing.TypeVectorPoint]))
z_field_param = QgsProcessingParameterField(self.Z_FIELD,
self.tr('Z value from field'),
None,
self.INPUT,
QgsProcessingParameterField.Numeric,
optional=True)
z_field_param.setFlags(z_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(z_field_param)
self.addParameter(QgsProcessingParameterNumber(self.POWER,
self.tr('Weighting power'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
maxValue=100.0,
defaultValue=2.0))
self.addParameter(QgsProcessingParameterNumber(self.SMOOTHING,
self.tr('Smoothing'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterNumber(self.RADIUS_1,
self.tr('The first radius of search ellipse'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterNumber(self.RADIUS_2,
self.tr('The second radius of search ellipse'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterNumber(self.ANGLE,
self.tr('Angle of search ellipse rotation in degrees (counter clockwise)'),
type=QgsProcessingParameterNumber.Double,
minValue=0.0,
maxValue=360.0,
defaultValue=0.0))
self.addParameter(QgsProcessingParameterNumber(self.MAX_POINTS,
self.tr('Maximum number of data points to use'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=0))
self.addParameter(QgsProcessingParameterNumber(self.MIN_POINTS,
self.tr('Minimum number of data points to use'),
type=QgsProcessingParameterNumber.Integer,
minValue=0,
defaultValue=0))
self.addParameter(QgsProcessingParameterNumber(self.NODATA,
self.tr('NODATA marker to fill empty points'),
type=QgsProcessingParameterNumber.Double,
defaultValue=0.0))
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation parameters'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
dataType_param = QgsProcessingParameterEnum(self.DATA_TYPE,
self.tr('Output data type'),
self.TYPES,
allowMultiple=False,
defaultValue=5)
dataType_param.setFlags(dataType_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(dataType_param)
self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT,
self.tr('Interpolated (IDW)')))
def initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PrmInputLayer, tr('Input point vector layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterEnum(self.PrmOutputFormat,
tr('Output format'),
options=[
tr('Coordinates in 2 fields'),
tr('Coordinates in 1 field'),
tr('GeoJSON'),
tr('WKT'),
tr('MGRS'),
tr('Plus Codes'),
tr('Standard UTM')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterString(self.PrmXFieldName,
tr('Longitude (X) field name'),
defaultValue='x',
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.PrmYFieldName,
tr('Latitude (Y) & all other formats field name'),
defaultValue='y',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmCoordinateOrder,
tr('Coordinate order when using 1 field'),
options=[
tr('Lat,Lon (Y,X) - Google map order'),
tr('Lon,Lat (X,Y) order')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.PrmCoordinateDelimiter,
tr('Delimiter between coordinates when using 1 field'),
defaultValue=',',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmOutputCRSType,
tr('Output CRS of coordinates added to a field'),
options=[
tr('WGS 84'),
tr('Layer CRS'),
tr('Project CRS'),
tr('Custom CRS')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterCrs(
self.PrmCustomCRS,
tr('Custom CRS for coordinates added to a field'),
'EPSG:4326',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmWgs84NumberFormat,
tr('Select Decimal or DMS degress for WGS 84 numbers'),
options=[tr('Decimal degrees'),
tr('DMS'),
tr('DDMMSS')],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmCoordinatePrecision,
tr('Decimal number precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=8,
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmDMSSecondPrecision,
tr('DMS second / UTM precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=0,
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmPlusCodesLength,
tr('Plus Codes length'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=11,
optional=True,
minValue=10,
maxValue=20))
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputLayer,
tr('Output layer')))
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(
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,
99999999.99))
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))
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 initAlgorithm(self, config):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.PrmInputLayer, tr('Input point vector layer'),
[QgsProcessing.TypeVectorPoint]))
self.addParameter(
QgsProcessingParameterEnum(self.PrmOutputFormat,
tr('Output coordinate format'),
options=[
tr('Coordinates in 2 fields'),
tr('Coordinates in 1 field'),
tr('GeoJSON'),
tr('WKT'),
tr('MGRS'),
tr('Plus Codes'),
tr('Geohash'),
tr('Standard UTM'),
tr('Maidenhead grid locator')
],
defaultValue=0,
optional=False))
self.addParameter(
QgsProcessingParameterString(
self.PrmYFieldName,
tr('Name for the field containing both coordinates, or the Y (latitude) coordinate'
),
defaultValue='y',
optional=False))
self.addParameter(
QgsProcessingParameterString(
self.PrmXFieldName,
tr('Name of the field containing the X (longitude) portion of the coordinate'
),
defaultValue='x',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmCoordinateOrder,
tr('Coordinate order when using 1 field'),
options=[
tr('Lat,Lon (Y,X) - Google map order'),
tr('Lon,Lat (X,Y) order')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.PrmCoordinateDelimiter,
tr('Delimiter between coordinates when using 1 field'),
defaultValue=',',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmOutputCRSType,
tr('Output CRS of coordinates added to a field'),
options=[
tr('WGS 84'),
tr('Layer CRS'),
tr('Project CRS'),
tr('Custom CRS')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterCrs(
self.PrmCustomCRS,
tr('Custom CRS for coordinates added to a field'),
'EPSG:4326',
optional=True))
self.addParameter(
QgsProcessingParameterEnum(
self.PrmWgs84NumberFormat,
tr('Select Decimal or DMS degress for WGS 84 numbers'),
options=[
tr('Decimal degrees'),
tr('D°M\'S"'),
tr('D°M.MM\''),
tr('DDMMSS')
],
defaultValue=0,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PrmDmsAddSpace,
tr('Add space between D° M\' S" and D° M.MM\' numbers'),
False,
optional=True))
self.addParameter(
QgsProcessingParameterBoolean(
self.PrmDmsPadWithSpace,
tr('Pad D°M\'S" and D°M.MM\' ccoordinates with leading zeros'),
False,
optional=True))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmCoordinatePrecision,
tr('Decimal number precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=8,
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmDmsSecondPrecision,
tr('DMS / Degrees Minutes / UTM precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=0,
optional=True,
minValue=0))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmPlusCodesLength,
tr('Plus Codes length'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=11,
optional=True,
minValue=10,
maxValue=20))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmGeohashPrecision,
tr('Geohash precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=12,
optional=True,
minValue=1,
maxValue=30))
self.addParameter(
QgsProcessingParameterNumber(
self.PrmMaidenheadPrecision,
tr('Maidenhead grid locator precision'),
type=QgsProcessingParameterNumber.Integer,
defaultValue=3,
optional=True,
minValue=1,
maxValue=4))
self.addParameter(
QgsProcessingParameterFeatureSink(self.PrmOutputLayer,
tr('Output layer')))
