def testOptional(self):
parent_name = "test_parent_layer"
test_data = points()
test_layer = QgsVectorLayer(test_data, parent_name, "ogr")
parent = ParameterVector(parent_name, parent_name)
parent.setValue(test_layer)
parameter = ParameterTableField("myName", "myDesc", parent_name, optional=True)
def testOptional(self):
parent_name = 'test_parent_layer'
test_data = points()
test_layer = QgsVectorLayer(test_data, parent_name, 'ogr')
parent = ParameterVector(parent_name, parent_name)
parent.setValue(test_layer)
ParameterTableField('myName', 'myDesc', parent_name, optional=True)
class ParameterTableMultipleFieldTest(unittest.TestCase):
def setUp(self):
self.parent_name = 'test_parent_layer'
test_data = points2()
test_layer = QgsVectorLayer(test_data, self.parent_name, 'ogr')
self.parent = ParameterVector(self.parent_name,
self.parent_name)
self.parent.setValue(test_layer)
def testGetAsScriptCode(self):
parameter = ParameterTableMultipleField(
'myName', 'myDesc', self.parent_name, optional=False)
self.assertEqual(
parameter.getAsScriptCode(),
'##myName=multiple field test_parent_layer')
# test optional
parameter.optional = True
self.assertEqual(
parameter.getAsScriptCode(),
'##myName=optional multiple field test_parent_layer')
def testOptional(self):
parameter = ParameterTableMultipleField(
'myName', 'myDesc', self.parent_name, optional=True)
parameter.setValue(['my', 'super', 'widget', '77'])
self.assertEqual(parameter.value, 'my;super;widget;77')
parameter.setValue([])
self.assertEqual(parameter.value, None)
parameter.setValue(None)
self.assertEqual(parameter.value, None)
parameter.setValue(['my', 'widget', '77'])
self.assertEqual(parameter.value, 'my;widget;77')
def testSetValue(self):
parameter = ParameterTableMultipleField(
'myName', 'myDesc', self.parent_name, optional=False)
parameter.setValue(['my', 'super', 'widget', '77'])
self.assertEqual(parameter.value, 'my;super;widget;77')
parameter.setValue([])
self.assertEqual(parameter.value, 'my;super;widget;77')
parameter.setValue(None)
self.assertEqual(parameter.value, 'my;super;widget;77')
parameter.setValue(['my', 'widget', '77'])
self.assertEqual(parameter.value, 'my;widget;77')
def setUp(self):
self.parent_name = 'test_parent_layer'
test_data = points2()
test_layer = QgsVectorLayer(test_data, self.parent_name, 'ogr')
self.parent = ParameterVector(self.parent_name,
self.parent_name)
self.parent.setValue(test_layer)
def __init__(self):
super().__init__()
self.addParameter(ParameterVector(self.INPUT_LAYER,
self.tr('Input layer'), [dataobjects.TYPE_VECTOR_LINE]))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Reversed'), datatype=[dataobjects.TYPE_VECTOR_LINE]))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm(
'Import Vector into PostGIS database (available connections)')
self.group, self.i18n_group = self.trAlgorithm('[OGR] Miscellaneous')
self.DB_CONNECTIONS = self.dbConnectionNames()
self.addParameter(
ParameterSelection(self.DATABASE,
self.tr('Database (connection name)'),
self.DB_CONNECTIONS))
self.addParameter(
ParameterVector(self.INPUT_LAYER, self.tr('Input layer'),
[ParameterVector.VECTOR_TYPE_ANY], False))
self.addParameter(
ParameterString(self.SHAPE_ENCODING,
self.tr('Shape encoding'),
"",
optional=True))
self.addParameter(
ParameterSelection(self.GTYPE, self.tr('Output geometry type'),
self.GEOMTYPE, 0))
self.addParameter(
ParameterCrs(self.A_SRS,
self.tr('Assign an output CRS'),
'',
optional=True))
self.addParameter(
ParameterCrs(self.T_SRS,
self.tr('Reproject to this CRS on output '),
'',
optional=True))
self.addParameter(
ParameterCrs(self.S_SRS,
self.tr('Override source CRS'),
'',
optional=True))
self.addParameter(
ParameterString(self.SCHEMA,
self.tr('Schema name'),
'public',
optional=True))
self.addParameter(
ParameterString(
self.TABLE,
self.tr('Table name, leave blank to use input name'),
'',
optional=True))
self.addParameter(
ParameterString(self.PK,
self.tr('Primary key (new field)'),
'id',
optional=True))
self.addParameter(
ParameterTableField(
self.PRIMARY_KEY,
self.
tr('Primary key (existing field, used if the above option is left empty)'
),
self.INPUT_LAYER,
optional=True))
self.addParameter(
ParameterString(self.GEOCOLUMN,
self.tr('Geometry column name'),
'geom',
optional=True))
self.addParameter(
ParameterSelection(self.DIM, self.tr('Vector dimensions'),
self.DIMLIST, 0))
self.addParameter(
ParameterString(self.SIMPLIFY,
self.tr('Distance tolerance for simplification'),
'',
optional=True))
self.addParameter(
ParameterString(
self.SEGMENTIZE,
self.tr('Maximum distance between 2 nodes (densification)'),
'',
optional=True))
self.addParameter(
ParameterExtent(
self.SPAT,
self.tr(
'Select features by extent (defined in input layer CRS)')))
self.addParameter(
ParameterBoolean(
self.CLIP,
self.tr(
'Clip the input layer using the above (rectangle) extent'),
False))
self.addParameter(
ParameterString(
self.WHERE,
self.
tr('Select features using a SQL "WHERE" statement (Ex: column=\'value\')'
),
'',
optional=True))
self.addParameter(
ParameterString(
self.GT,
self.tr('Group N features per transaction (Default: 20000)'),
'',
optional=True))
self.addParameter(
ParameterBoolean(self.OVERWRITE,
self.tr('Overwrite existing table'), True))
self.addParameter(
ParameterBoolean(self.APPEND, self.tr('Append to existing table'),
False))
self.addParameter(
ParameterBoolean(
self.ADDFIELDS,
self.tr('Append and add new fields to existing table'), False))
self.addParameter(
ParameterBoolean(self.LAUNDER,
self.tr('Do not launder columns/table names'),
False))
self.addParameter(
ParameterBoolean(self.INDEX,
self.tr('Do not create spatial index'), False))
self.addParameter(
ParameterBoolean(
self.SKIPFAILURES,
self.tr(
'Continue after a failure, skipping the failed feature'),
False))
self.addParameter(
ParameterBoolean(self.PROMOTETOMULTI,
self.tr('Promote to Multipart'), True))
self.addParameter(
ParameterBoolean(
self.PRECISION,
self.tr('Keep width and precision of input attributes'), True))
self.addParameter(
ParameterString(self.OPTIONS,
self.tr('Additional creation options'),
'',
optional=True))
def defineCharacteristics(self):
self.addParameter(ParameterVector(Difference.INPUT,
self.tr('Input layer')))
self.addParameter(ParameterVector(Difference.OVERLAY,
self.tr('Difference layer')))
self.addOutput(OutputVector(Difference.OUTPUT, self.tr('Difference')))
def __init__(self):
super().__init__()
self.addParameter(
ParameterVector(self.INPUT_LAYER, self.tr('Point layer'),
[dataobjects.TYPE_VECTOR_POINT]))
self.addParameter(
ParameterNumber(self.RADIUS, self.tr('Radius (layer units)'), 0.0,
9999999999, 100.0))
radius_field_param = ParameterTableField(
self.RADIUS_FIELD,
self.tr('Radius from field'),
self.INPUT_LAYER,
optional=True,
datatype=ParameterTableField.DATA_TYPE_NUMBER)
radius_field_param.setFlags(
radius_field_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(radius_field_param)
class ParameterHeatmapPixelSize(ParameterNumber):
def __init__(self,
name='',
description='',
parent_layer=None,
radius_param=None,
radius_field_param=None,
minValue=None,
maxValue=None,
default=None,
optional=False,
metadata={}):
ParameterNumber.__init__(self, name, description, minValue,
maxValue, default, optional, metadata)
self.parent_layer = parent_layer
self.radius_param = radius_param
self.radius_field_param = radius_field_param
self.addParameter(
ParameterHeatmapPixelSize(
self.PIXEL_SIZE,
self.tr('Output raster size'),
parent_layer=self.INPUT_LAYER,
radius_param=self.RADIUS,
radius_field_param=self.RADIUS_FIELD,
minValue=0.0,
maxValue=9999999999,
default=0.1,
metadata={'widget_wrapper': HeatmapPixelSizeWidgetWrapper}))
weight_field_param = ParameterTableField(
self.WEIGHT_FIELD,
self.tr('Weight from field'),
self.INPUT_LAYER,
optional=True,
datatype=ParameterTableField.DATA_TYPE_NUMBER)
weight_field_param.setFlags(
weight_field_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(weight_field_param)
kernel_shape_param = ParameterSelection(self.KERNEL,
self.tr('Kernel shape'),
self.KERNELS)
kernel_shape_param.setFlags(
kernel_shape_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(kernel_shape_param)
decay_ratio = ParameterNumber(
self.DECAY, self.tr('Decay ratio (Triangular kernels only)'),
-100.0, 100.0, 0.0)
decay_ratio.setFlags(decay_ratio.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(decay_ratio)
output_scaling = ParameterSelection(self.OUTPUT_VALUE,
self.tr('Output value scaling'),
self.OUTPUT_VALUES)
output_scaling.setFlags(
output_scaling.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(output_scaling)
self.addOutput(OutputRaster(self.OUTPUT_LAYER, self.tr('Heatmap')))
def okPressed(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 name in self.alg.inputs:
name = safeName.lower() + str(i)
else:
name = self.param.name
if (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or
isinstance(self.param, ParameterBoolean)):
self.param = ParameterBoolean(name, description, self.state.isChecked())
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or
isinstance(self.param, ParameterTableField)):
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()
self.param = ParameterTableField(name, description, parent, datatype, multiple=self.multipleCheck.isChecked())
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_RASTER or
isinstance(self.param, ParameterRaster)):
self.param = ParameterRaster(
name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE or
isinstance(self.param, ParameterTable)):
self.param = ParameterTable(
name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_VECTOR or
isinstance(self.param, ParameterVector)):
self.param = ParameterVector(
name, description,
[self.shapetypeCombo.currentIndex() - 1])
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or
isinstance(self.param, ParameterMultipleInput)):
self.param = ParameterMultipleInput(
name, description,
self.datatypeCombo.currentIndex() - 1)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or
isinstance(self.param, ParameterNumber)):
try:
vmin = self.minTextBox.text().strip()
if vmin == '':
vmin = None
else:
vmin = float(vmin)
vmax = self.maxTextBox.text().strip()
if vmax == '':
vmax = None
else:
vmax = float(vmax)
self.param = ParameterNumber(name, description, vmin, vmax,
str(self.defaultTextBox.text()))
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, ParameterExpression)):
parent = self.parentCombo.currentData()
self.param = ParameterExpression(name, description,
default=str(self.defaultEdit.expression()),
parent_layer=parent)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or
isinstance(self.param, ParameterString)):
self.param = ParameterString(name, description,
str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXTENT or
isinstance(self.param, ParameterExtent)):
self.param = ParameterExtent(name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE or
isinstance(self.param, ParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = ParameterFile(name, description, isFolder=isFolder)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or
isinstance(self.param, ParameterPoint)):
self.param = ParameterPoint(name, description,
str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS or
isinstance(self.param, ParameterCrs)):
self.param = ParameterCrs(name, description, default=self.selector.crs().authid())
self.param.optional = not self.requiredCheck.isChecked()
self.close()
def __init__(self):
super().__init__()
self.addParameter(ParameterVector(self.INPUT,
self.tr('Input layer'),
[dataobjects.TYPE_VECTOR_LINE]))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Polygons from lines'), datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def __init__(self):
super().__init__()
self.addParameter(
ParameterString(
self.DATABASE,
self.tr('Database (connection name)'),
metadata={
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
}))
self.addParameter(
ParameterVector(self.INPUT_LAYER, self.tr('Input layer')))
self.addParameter(
ParameterString(self.SHAPE_ENCODING,
self.tr('Shape encoding'),
"",
optional=True))
self.addParameter(
ParameterSelection(self.GTYPE, self.tr('Output geometry type'),
self.GEOMTYPE, 0))
self.addParameter(
ParameterCrs(self.A_SRS,
self.tr('Assign an output CRS'),
'',
optional=False))
self.addParameter(
ParameterCrs(self.T_SRS,
self.tr('Reproject to this CRS on output '),
'',
optional=True))
self.addParameter(
ParameterCrs(self.S_SRS,
self.tr('Override source CRS'),
'',
optional=True))
self.addParameter(
ParameterString(
self.SCHEMA,
self.tr('Schema name'),
'public',
optional=True,
metadata={
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
'connection_param': self.DATABASE
}
}))
self.addParameter(
ParameterString(
self.TABLE,
self.tr('Table name, leave blank to use input name'),
'',
optional=True,
metadata={
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.TableWidgetWrapper',
'schema_param': self.SCHEMA
}
}))
self.addParameter(
ParameterString(self.PK,
self.tr('Primary key (new field)'),
'id',
optional=True))
self.addParameter(
ParameterTableField(
self.PRIMARY_KEY,
self.
tr('Primary key (existing field, used if the above option is left empty)'
),
self.INPUT_LAYER,
optional=True))
self.addParameter(
ParameterString(self.GEOCOLUMN,
self.tr('Geometry column name'),
'geom',
optional=True))
self.addParameter(
ParameterSelection(self.DIM, self.tr('Vector dimensions'),
self.DIMLIST, 0))
self.addParameter(
ParameterString(self.SIMPLIFY,
self.tr('Distance tolerance for simplification'),
'',
optional=True))
self.addParameter(
ParameterString(
self.SEGMENTIZE,
self.tr('Maximum distance between 2 nodes (densification)'),
'',
optional=True))
self.addParameter(
ParameterExtent(
self.SPAT,
self.tr(
'Select features by extent (defined in input layer CRS)')))
self.addParameter(
ParameterBoolean(
self.CLIP,
self.tr(
'Clip the input layer using the above (rectangle) extent'),
False))
self.addParameter(
ParameterString(
self.WHERE,
self.
tr('Select features using a SQL "WHERE" statement (Ex: column=\'value\')'
),
'',
optional=True))
self.addParameter(
ParameterString(
self.GT,
self.tr('Group N features per transaction (Default: 20000)'),
'',
optional=True))
self.addParameter(
ParameterBoolean(self.OVERWRITE,
self.tr('Overwrite existing table'), True))
self.addParameter(
ParameterBoolean(self.APPEND, self.tr('Append to existing table'),
False))
self.addParameter(
ParameterBoolean(
self.ADDFIELDS,
self.tr('Append and add new fields to existing table'), False))
self.addParameter(
ParameterBoolean(self.LAUNDER,
self.tr('Do not launder columns/table names'),
False))
self.addParameter(
ParameterBoolean(self.INDEX,
self.tr('Do not create spatial index'), False))
self.addParameter(
ParameterBoolean(
self.SKIPFAILURES,
self.tr(
'Continue after a failure, skipping the failed feature'),
False))
self.addParameter(
ParameterBoolean(self.PROMOTETOMULTI,
self.tr('Promote to Multipart'), True))
self.addParameter(
ParameterBoolean(
self.PRECISION,
self.tr('Keep width and precision of input attributes'), True))
self.addParameter(
ParameterString(self.OPTIONS,
self.tr('Additional creation options'),
'',
optional=True))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Spatialite execute SQL')
self.group, self.i18n_group = self.trAlgorithm('Database')
self.addParameter(ParameterVector(self.DATABASE, self.tr('File Database'), False, False))
self.addParameter(ParameterString(self.SQL, self.tr('SQL query'), '', True))
def defineCharacteristics(self):
self.addParameter(ParameterVector(self.INPUT, self.tr('Input Layer')))
self.addParameter(ParameterCrs(self.CRS, 'Output CRS'))
self.addOutput(
OutputVector(self.OUTPUT, self.tr('Layer with projection'), True))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm(
'Rasterize (vector to raster)')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Conversion')
self.addParameter(ParameterVector(self.INPUT, self.tr('Input layer')))
self.addParameter(
ParameterTableField(self.FIELD, self.tr('Attribute field'),
self.INPUT))
self.addParameter(
ParameterSelection(
self.DIMENSIONS,
self.
tr('Set output raster size (ignored if above option is checked)'
), [
'Output size in pixels',
'Output resolution in map units per pixel'
], 1))
self.addParameter(
ParameterNumber(self.WIDTH, self.tr('Horizontal'), 0.0,
99999999.999999, 100.0))
self.addParameter(
ParameterNumber(self.HEIGHT, self.tr('Vertical'), 0.0,
99999999.999999, 100.0))
self.addParameter(
ParameterExtent(self.RAST_EXT, self.tr('Raster extent')))
params = []
params.append(
ParameterSelection(self.RTYPE, self.tr('Raster type'), self.TYPE,
5))
params.append(
ParameterString(self.NO_DATA,
self.tr("Nodata value"),
'',
optional=True))
params.append(
ParameterSelection(self.COMPRESS,
self.tr('GeoTIFF options. Compression type:'),
self.COMPRESSTYPE, 4))
params.append(
ParameterNumber(self.JPEGCOMPRESSION,
self.tr('Set the JPEG compression level'), 1, 100,
75))
params.append(
ParameterNumber(self.ZLEVEL,
self.tr('Set the DEFLATE compression level'), 1, 9,
6))
params.append(
ParameterNumber(
self.PREDICTOR,
self.tr('Set the predictor for LZW or DEFLATE compression'), 1,
3, 1))
params.append(
ParameterBoolean(
self.TILED,
self.tr(
'Create tiled output (only used for the GTiff format)'),
False))
params.append(
ParameterSelection(
self.BIGTIFF,
self.
tr('Control whether the created file is a BigTIFF or a classic TIFF'
), self.BIGTIFFTYPE, 0))
self.addParameter(
ParameterBoolean(
self.TFW,
self.
tr('Force the generation of an associated ESRI world file (.tfw)'
), False))
params.append(
ParameterString(self.EXTRA,
self.tr('Additional creation parameters'),
'',
optional=True))
for param in params:
param.isAdvanced = True
self.addParameter(param)
self.addOutput(OutputRaster(self.OUTPUT, self.tr('Rasterized')))
def defineCharacteristics(self):
self.addParameter(ParameterVector(self.INPUT, self.tr('Input layer')))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Cleaned')))
def defineCharacteristics(self):
self.addParameter(
ParameterVector(self.INPUT_LAYER, self.tr('Input layer'),
[dataobjects.TYPE_VECTOR_ANY]))
self.addOutput(
OutputVector(self.OUTPUT_LAYER, self.tr('Removed null geometry')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm(
'Add autoincremental field')
self.group, self.i18n_group = self.trAlgorithm('Vector table tools')
self.addParameter(ParameterVector(self.INPUT, self.tr('Input layer')))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Incremented')))
def defineCharacteristics(self):
self.addParameter(ParameterVector(self.INPUT_LAYER,
self.tr('Input layer')))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Bounds'), datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def __init__(self):
super().__init__()
self.addParameter(ParameterVector(self.INPUT_LAYER,
self.tr('Input layer')))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Point'), datatype=[dataobjects.TYPE_VECTOR_POINT]))
def initAlgorithm(self, config=None):
self.addParameter(ParameterVector(self.INPUT, self.tr('Input layer')))
self.addParameter(ParameterTableField(self.FIELD,
self.tr('Attribute field'), self.INPUT))
self.addParameter(ParameterRaster(self.INPUT_RASTER,
self.tr('Existing raster layer'), False))
def processParameterLine(self, line):
param = None
out = None
line = line.replace('#', '')
# If the line is in the format of the text description files for
# normal algorithms, then process it using parameter and output
# factories
if '|' in line:
self.processDescriptionParameterLine(line)
return
if line == "nomodeler":
self.showInModeler = False
return
tokens = line.split('=', 1)
desc = self.createDescriptiveName(tokens[0])
if tokens[1].lower().strip() == 'group':
self.group = tokens[0]
return
if tokens[1].lower().strip() == 'name':
self.name = tokens[0]
return
if tokens[1].lower().strip() == 'raster':
param = ParameterRaster(tokens[0], desc, False)
elif tokens[1].lower().strip() == 'vector':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_ANY])
elif tokens[1].lower().strip() == 'vector point':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_POINT])
elif tokens[1].lower().strip() == 'vector line':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_LINE])
elif tokens[1].lower().strip() == 'vector polygon':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_POLYGON])
elif tokens[1].lower().strip() == 'table':
param = ParameterTable(tokens[0], desc, False)
elif tokens[1].lower().strip() == 'multiple raster':
param = ParameterMultipleInput(tokens[0], desc,
ParameterMultipleInput.TYPE_RASTER)
param.optional = False
elif tokens[1].lower().strip() == 'multiple vector':
param = ParameterMultipleInput(
tokens[0], desc, ParameterMultipleInput.TYPE_VECTOR_ANY)
param.optional = False
elif tokens[1].lower().strip().startswith('selection'):
options = tokens[1].strip()[len('selection '):].split(';')
param = ParameterSelection(tokens[0], desc, options)
elif tokens[1].lower().strip().startswith('boolean'):
default = tokens[1].strip()[len('boolean') + 1:]
param = ParameterBoolean(tokens[0], desc, default)
elif tokens[1].lower().strip() == 'extent':
param = ParameterExtent(tokens[0], desc)
elif tokens[1].lower().strip() == 'file':
param = ParameterFile(tokens[0], desc, False)
elif tokens[1].lower().strip() == 'folder':
param = ParameterFile(tokens[0], desc, True)
elif tokens[1].lower().strip().startswith('number'):
default = tokens[1].strip()[len('number') + 1:]
param = ParameterNumber(tokens[0], desc, default=default)
elif tokens[1].lower().strip().startswith('field'):
field = tokens[1].strip()[len('field') + 1:]
found = False
for p in self.parameters:
if p.name == field:
found = True
break
if found:
param = ParameterTableField(tokens[0], desc, field)
elif tokens[1].lower().strip().startswith('string'):
default = tokens[1].strip()[len('string') + 1:]
param = ParameterString(tokens[0], desc, default)
elif tokens[1].lower().strip().startswith('longstring'):
default = tokens[1].strip()[len('longstring') + 1:]
param = ParameterString(tokens[0], desc, default, multiline=True)
elif tokens[1].lower().strip().startswith('crs'):
default = tokens[1].strip()[len('crs') + 1:]
if not default:
default = 'EPSG:4326'
param = ParameterCrs(tokens[0], desc, default)
elif tokens[1].lower().strip().startswith('output raster'):
out = OutputRaster()
elif tokens[1].lower().strip().startswith('output vector'):
out = OutputVector()
elif tokens[1].lower().strip().startswith('output table'):
out = OutputTable()
elif tokens[1].lower().strip().startswith('output html'):
out = OutputHTML()
elif tokens[1].lower().strip().startswith('output file'):
out = OutputFile()
subtokens = tokens[1].split(' ')
if len(subtokens > 2):
out.ext = subtokens[2]
elif tokens[1].lower().strip().startswith('output directory'):
out = OutputDirectory()
elif tokens[1].lower().strip().startswith('output number'):
out = OutputNumber()
elif tokens[1].lower().strip().startswith('output string'):
out = OutputString()
if param is not None:
self.addParameter(param)
elif out is not None:
out.name = tokens[0]
out.description = desc
self.addOutput(out)
else:
raise WrongScriptException(
self.tr('Could not load script: %s.\n'
'Problem with line %d', 'ScriptAlgorithm') %
(self.descriptionFile or '', line))
def defineCharacteristics(self):
self.addParameter(
ParameterVector(self.DATABASE, self.tr('File Database'), False,
False))
self.addParameter(
ParameterString(self.SQL, self.tr('SQL query'), '', True))
def __init__(self):
super().__init__()
self.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'),
QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'),
QgsVectorLayerDirector.DirectionForward),
(self.tr('Both directions'),
QgsVectorLayerDirector.DirectionForward)
])
self.STRATEGIES = [self.tr('Shortest'), self.tr('Fastest')]
self.addParameter(
ParameterVector(self.INPUT_VECTOR,
self.tr('Vector layer representing network'),
[dataobjects.TYPE_VECTOR_LINE]))
self.addParameter(
ParameterPoint(self.START_POINT, self.tr('Start point')))
self.addParameter(
ParameterSelection(self.STRATEGY,
self.tr('Path type to calculate'),
self.STRATEGIES,
default=0))
self.addParameter(
ParameterNumber(
self.TRAVEL_COST,
self.tr(
'Travel cost (distance for "Shortest", time for "Fastest")'
), 0.0, 99999999.999999, 0.0))
params = []
params.append(
ParameterTableField(self.DIRECTION_FIELD,
self.tr('Direction field'),
self.INPUT_VECTOR,
optional=True))
params.append(
ParameterString(self.VALUE_FORWARD,
self.tr('Value for forward direction'),
'',
optional=True))
params.append(
ParameterString(self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
'',
optional=True))
params.append(
ParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
'',
optional=True))
params.append(
ParameterSelection(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
default=2))
params.append(
ParameterTableField(self.SPEED_FIELD,
self.tr('Speed field'),
self.INPUT_VECTOR,
optional=True))
params.append(
ParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'), 0.0,
99999999.999999, 5.0))
params.append(
ParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), 0.0,
99999999.999999, 0.0))
for p in params:
p.setFlags(p.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
self.addOutput(
OutputVector(self.OUTPUT_POINTS,
self.tr('Service area (boundary nodes)'),
datatype=[dataobjects.TYPE_VECTOR_POINT]))
self.addOutput(
OutputVector(self.OUTPUT_POLYGON,
self.tr('Service area (convex hull)'),
datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def initAlgorithm(self, config=None):
self.addParameter(ParameterVector(self.INPUT, self.tr('Input Layer')))
self.addOutput(
OutputVector(self.OUTPUT, self.tr('Indexed layer'), True))
def defineCharacteristics(self):
self.addParameter(ParameterVector(self.INPUT_A,
self.tr('Input layer'), [dataobjects.TYPE_VECTOR_LINE]))
self.addParameter(ParameterVector(self.INPUT_B,
self.tr('Split layer'), [dataobjects.TYPE_VECTOR_LINE]))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Split'), datatype=[dataobjects.TYPE_VECTOR_LINE]))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Import into PostGIS')
self.group, self.i18n_group = self.trAlgorithm('Database')
self.addParameter(
ParameterVector(self.INPUT, self.tr('Layer to import')))
self.addParameter(
ParameterString(
self.DATABASE,
self.tr('Database (connection name)'),
metadata={
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
}))
self.addParameter(
ParameterString(
self.SCHEMA,
self.tr('Schema (schema name)'),
'public',
optional=True,
metadata={
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.SchemaWidgetWrapper',
'connection_param': self.DATABASE
}
}))
self.addParameter(
ParameterString(
self.TABLENAME,
self.tr('Table to import to (leave blank to use layer name)'),
'',
optional=True,
metadata={
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.TableWidgetWrapper',
'schema_param': self.SCHEMA
}
}))
self.addParameter(
ParameterTableField(self.PRIMARY_KEY,
self.tr('Primary key field'),
self.INPUT,
optional=True))
self.addParameter(
ParameterString(self.GEOMETRY_COLUMN, self.tr('Geometry column'),
'geom'))
self.addParameter(
ParameterString(self.ENCODING,
self.tr('Encoding'),
'UTF-8',
optional=True))
self.addParameter(
ParameterBoolean(self.OVERWRITE, self.tr('Overwrite'), True))
self.addParameter(
ParameterBoolean(self.CREATEINDEX, self.tr('Create spatial index'),
True))
self.addParameter(
ParameterBoolean(self.LOWERCASE_NAMES,
self.tr('Convert field names to lowercase'),
True))
self.addParameter(
ParameterBoolean(
self.DROP_STRING_LENGTH,
self.tr('Drop length constraints on character fields'), False))
self.addParameter(
ParameterBoolean(
self.FORCE_SINGLEPART,
self.tr('Create single-part geometries instead of multi-part'),
False))
def defineCharacteristics(self):
self.addParameter(ParameterVector(self.INPUT_LAYER,
self.tr('Input layer')))
self.addOutput(OutputVector(self.OUTPUT_LAYER,
self.tr('Selection')))
def __init__(self):
super().__init__()
self.addParameter(ParameterVector(self.INPUT, self.tr('Input Layer')))
self.addParameter(ParameterCrs(self.CRS, 'Output CRS'))
self.addOutput(
OutputVector(self.OUTPUT, self.tr('Layer with projection'), True))
def defineCharacteristics(self):
self.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'),
QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'),
QgsVectorLayerDirector.DirectionForward),
(self.tr('Both directions'),
QgsVectorLayerDirector.DirectionForward)
])
self.STRATEGIES = [self.tr('Shortest'), self.tr('Fastest')]
self.name, self.i18n_name = self.trAlgorithm(
'Shortest path (point to point)')
self.group, self.i18n_group = self.trAlgorithm('Network analysis')
self.addParameter(
ParameterVector(self.INPUT_VECTOR,
self.tr('Vector layer representing network'),
[dataobjects.TYPE_VECTOR_LINE]))
self.addParameter(
ParameterPoint(self.START_POINT, self.tr('Start point')))
self.addParameter(ParameterPoint(self.END_POINT, self.tr('End point')))
self.addParameter(
ParameterSelection(self.STRATEGY,
self.tr('Path type to calculate'),
self.STRATEGIES,
default=0))
params = []
params.append(
ParameterTableField(self.DIRECTION_FIELD,
self.tr('Direction field'),
self.INPUT_VECTOR,
optional=True))
params.append(
ParameterString(self.VALUE_FORWARD,
self.tr('Value for forward direction'),
'',
optional=True))
params.append(
ParameterString(self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
'',
optional=True))
params.append(
ParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
'',
optional=True))
params.append(
ParameterSelection(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
default=2))
params.append(
ParameterTableField(self.SPEED_FIELD,
self.tr('Speed field'),
self.INPUT_VECTOR,
optional=True))
params.append(
ParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'), 0.0,
99999999.999999, 5.0))
params.append(
ParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), 0.0,
99999999.999999, 0.0))
for p in params:
p.isAdvanced = True
self.addParameter(p)
self.addOutput(OutputNumber(self.TRAVEL_COST, self.tr('Travel cost')))
self.addOutput(
OutputVector(self.OUTPUT_LAYER,
self.tr('Shortest path'),
datatype=[dataobjects.TYPE_VECTOR_LINE]))
def defineCharacteristics(self):
self.addParameter(ParameterVector(self.INPUT,
self.tr('Input layer')))
self.addParameter(ParameterTableField(self.FIELD,
self.tr('Class field'), self.INPUT))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Layer with index field')))
def defineCharacteristics(self):
self.addParameter(ParameterVector(Clip.INPUT,
self.tr('Input layer')))
self.addParameter(ParameterVector(Clip.OVERLAY,
self.tr('Clip layer'), [dataobjects.TYPE_VECTOR_POLYGON]))
self.addOutput(OutputVector(Clip.OUTPUT, self.tr('Clipped')))
def __init__(self):
super().__init__()
self.addParameter(ParameterVector(self.INPUT, self.tr('Input layer')))
self.addParameter(
ParameterVector(self.INPUT2, self.tr('Intersect layer')))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Intersection')))
def __init__(self):
super().__init__()
self.addParameter(ParameterVector(self.INPUT, self.tr('Input Layer')))
self.addOutput(
OutputVector(self.OUTPUT, self.tr('Indexed layer'), True))
def setUp(self):
self.parent_name = 'test_parent_layer'
test_data = points2()
test_layer = QgsVectorLayer(test_data, self.parent_name, 'ogr')
self.parent = ParameterVector(self.parent_name, self.parent_name)
self.parent.setValue(test_layer)
