def testGetAsStringWhenVector(self):
parameter = ParameterMultipleInput("myName", "myDesc", datatype=ParameterMultipleInput.TYPE_VECTOR_ANY)
# With Path
self.assertEqual(parameter.getAsString("/some/path"), "/some/path")
# With Layer
layer = QgsVectorLayer("/path/to/myVector.shp", "myVector", "memory")
self.assertEqual(parameter.getAsString(layer), "/path/to/myVector.shp")
def testGetAsStringWhenRaster(self):
parameter = ParameterMultipleInput("myName", "myDesc", datatype=ParameterMultipleInput.TYPE_RASTER)
# With Path
self.assertEqual(parameter.getAsString("/some/path"), "/some/path")
# With Layer
layer = QgsRasterLayer("/path/to/myRaster.tif", "myRaster")
self.assertEqual(parameter.getAsString(layer), "/path/to/myRaster.tif")
def testGetAsStringWhenRaster(self):
parameter = ParameterMultipleInput('myName', 'myDesc', datatype=dataobjects.TYPE_RASTER)
# With Path
self.assertEqual(parameter.getAsString('/some/path'), '/some/path')
# With Layer
layer = QgsRasterLayer('/path/to/myRaster.tif', 'myRaster')
self.assertEqual(parameter.getAsString(layer), '/path/to/myRaster.tif')
def testGetAsStringWhenVector(self):
parameter = ParameterMultipleInput('myName', 'myDesc', datatype=dataobjects.TYPE_VECTOR_ANY)
# With Path
self.assertEqual(parameter.getAsString('/some/path'), '/some/path')
# With Layer
layer = QgsVectorLayer('/path/to/myVector.shp', 'myVector', 'memory')
self.assertEqual(parameter.getAsString(layer), '/path/to/myVector.shp')
def testScriptCode(self):
parameter = ParameterMultipleInput('myName', 'myDescription')
code = parameter.getAsScriptCode()
result = getParameterFromString(code)
self.assertIsInstance(result, ParameterMultipleInput)
parameter.optional = True
code = parameter.getAsScriptCode()
result = getParameterFromString(code)
self.assertIsInstance(result, ParameterMultipleInput)
self.assertTrue(result.optional)
def testMultipleInput(self):
parameter = ParameterMultipleInput("myName", "myDesc", optional=True)
self.assertTrue(parameter.setMinNumInputs(1))
parameter = ParameterMultipleInput("myName", "myDesc", optional=False)
self.assertFalse(parameter.setMinNumInputs(0))
parameter.setMinNumInputs(2)
self.assertTrue(parameter.setValue(["myLayerFile.shp", "myLayerFile2.shp"]))
parameter.setMinNumInputs(3)
self.assertFalse(parameter.setValue(["myLayerFile.shp", "myLayerFile2.shp"]))
def defineCharacteristics(self):
self.name = 'Merge'
self.group = '[GDAL] Miscellaneous'
self.addParameter(
ParameterMultipleInput(merge.INPUT, 'Input layers',
ParameterMultipleInput.TYPE_RASTER))
self.addParameter(
ParameterBoolean(merge.PCT,
'Grab pseudocolor table from first layer', False))
self.addParameter(
ParameterBoolean(merge.SEPARATE, 'Layer stack', False))
self.addParameter(
ParameterSelection(self.RTYPE, 'Output raster type', self.TYPE, 5))
self.addOutput(OutputRaster(merge.OUTPUT, 'Output layer'))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('nviz7')
self.group, self.i18n_group = self.trAlgorithm('Visualization(NVIZ)')
self.addParameter(
ParameterMultipleInput(nviz7.ELEVATION,
self.tr('Raster file(s) for elevation'),
dataobjects.TYPE_RASTER, True))
self.addParameter(
ParameterMultipleInput(
nviz7.VECTOR, self.tr('Vector lines/areas overlay file(s)'),
dataobjects.TYPE_VECTOR_ANY, True))
self.addParameter(
ParameterMultipleInput(nviz7.COLOR,
self.tr('Raster file(s) for color'),
dataobjects.TYPE_RASTER, True))
self.addParameter(
ParameterExtent(nviz7.GRASS_REGION_EXTENT_PARAMETER,
self.tr('GRASS region extent')))
self.addParameter(
ParameterNumber(
self.GRASS_REGION_CELLSIZE_PARAMETER,
self.tr('GRASS region cellsize (leave 0 for default)'), 0,
None, 0.0))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Build virtual vector')
self.group, self.i18n_group = self.trAlgorithm('Vector general tools')
self.addParameter(ParameterMultipleInput(self.DATASOURCES,
self.tr('Input datasources')))
self.addParameter(ParameterBoolean(self.UNIONED,
self.tr('Create "unioned" VRT'),
default=False))
self.addOutput(OutputFile(self.VRT_FILE,
self.tr('Virtual vector'), ext='vrt'))
self.addOutput(OutputString(self.VRT_STRING,
self.tr('Virtual string')))
def defineCharacteristics(self):
self.addParameter(
ParameterMultipleInput(self.DATASOURCES,
self.tr('Input datasources'),
dataobjects.TYPE_TABLE))
self.addParameter(
ParameterBoolean(self.UNIONED,
self.tr('Create "unioned" VRT'),
default=False))
self.addOutput(
OutputFile(self.VRT_FILE, self.tr('Virtual vector'), ext='vrt'))
self.addOutput(OutputString(self.VRT_STRING,
self.tr('Virtual string')))
def __init__(self):
super().__init__()
self.addParameter(
ParameterMultipleInput(self.INPUT, self.tr('Input layers'),
dataobjects.TYPE_RASTER))
self.addParameter(
ParameterSelection(self.RESOLUTION, self.tr('Resolution'),
self.RESOLUTION_OPTIONS, 0))
self.addParameter(
ParameterBoolean(self.SEPARATE, self.tr('Layer stack'), True))
self.addParameter(
ParameterBoolean(self.PROJ_DIFFERENCE,
self.tr('Allow projection difference'), False))
self.addOutput(OutputRaster(buildvrt.OUTPUT, self.tr('Virtual')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Raster calculator')
self.group, self.i18n_group = self.trAlgorithm('Raster')
self.addParameter(
ParameterMultipleInput(
self.LAYERS,
self.tr('Input layers'),
datatype=dataobjects.TYPE_RASTER,
optional=True,
metadata={'widget_wrapper': LayersListWidgetWrapper}))
class ParameterRasterCalculatorExpression(ParameterString):
def evaluateForModeler(self, value, model):
for i in list(model.inputs.values()):
param = i.param
if isinstance(param, ParameterRaster):
new = "{}@".format(os.path.basename(param.value))
old = "{}@".format(param.name)
value = value.replace(old, new)
for alg in list(model.algs.values()):
for out in alg.algorithm.outputs:
if isinstance(out, OutputRaster):
if out.value:
new = "{}@".format(
os.path.basename(out.value))
old = "{}:{}@".format(alg.name, out.name)
value = value.replace(old, new)
return value
self.addParameter(
ParameterRasterCalculatorExpression(
self.EXPRESSION,
self.tr('Expression'),
multiline=True,
metadata={'widget_wrapper': ExpressionWidgetWrapper}))
self.addParameter(
ParameterNumber(
self.CELLSIZE,
self.tr('Cell size (use 0 or empty to set it automatically)'),
minValue=0.0,
default=0.0,
optional=True))
self.addParameter(
ParameterExtent(self.EXTENT,
self.tr('Output extent'),
optional=True))
self.addOutput(OutputRaster(self.OUTPUT, self.tr('Output')))
def __init__(self):
super().__init__()
# Required parameters
self.addParameter(ParameterMultipleInput(self.INPUT,
self.tr('Input layers'),
dataobjects.TYPE_RASTER))
# Advanced parameters
params = []
params.append(ParameterString(self.PIXELSIZE,
self.tr('Pixel size to be used for the output file (XSIZE YSIZE like 512 512)'),
None, False, True))
params.append(ParameterSelection(self.ALGORITHM,
self.tr('Resampling algorithm'), self.ALGO, 0, False, optional=True))
params.append(ParameterCrs(self.S_SRS,
self.tr('Override source CRS'), None, True))
params.append(ParameterNumber(self.PYRAMIDLEVELS,
self.tr('Number of pyramids levels to build'),
None, None, None, True))
params.append(ParameterBoolean(self.ONLYPYRAMIDS,
self.tr('Build only the pyramids'),
False, True))
params.append(ParameterSelection(self.RTYPE,
self.tr('Output raster type'),
self.TYPE, 5, False, optional=True))
params.append(ParameterSelection(self.FORMAT,
self.tr('Output raster format'),
list(GdalUtils.getSupportedRasters().keys()), 0, False, optional=True))
params.append(ParameterBoolean(self.USEDIRFOREACHROW,
self.tr('Use a directory for each row'),
False, True))
params.append(ParameterString(self.CSVFILE,
self.tr('Name of the csv file containing the tile(s) georeferencing information'),
None, False, True))
params.append(ParameterString(self.CSVDELIM,
self.tr('Column delimiter used in the CSV file'),
None, False, True))
params.append(ParameterString(self.TILEINDEX,
self.tr('name of shape file containing the result tile(s) index'),
None, False, True))
params.append(ParameterString(self.TILEINDEXFIELD,
self.tr('name of the attribute containing the tile name in the result shape file'),
None, False, True))
for param in params:
param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
self.addOutput(OutputDirectory(self.TARGETDIR,
self.tr('The directory where the tile result is created')))
def initAlgorithm(self, config=None):
self.addParameter(
ParameterMultipleInput(self.INPUT, self.tr('Input layers'),
dataobjects.TYPE_RASTER))
self.addParameter(
ParameterString(self.FIELD_NAME,
self.tr('Tile index field'),
'location',
optional=True))
self.addParameter(
ParameterBoolean(
self.PROJ_DIFFERENCE,
self.tr('Skip files with different projection reference'),
False))
self.addOutput(OutputVector(gdaltindex.OUTPUT, self.tr('Tile index')))
def defineCharacteristics(self):
self.name = 'Build Virtual Raster'
self.group = '[GDAL] Miscellaneous'
self.addParameter(
ParameterMultipleInput(buildvrt.INPUT, 'Input layers',
ParameterMultipleInput.TYPE_RASTER))
self.addParameter(
ParameterSelection(buildvrt.RESOLUTION, 'Resolution',
buildvrt.RESOLUTION_OPTIONS, 0))
self.addParameter(
ParameterBoolean(buildvrt.SEPARATE, 'Layer stack', True))
self.addParameter(
ParameterBoolean(buildvrt.PROJ_DIFFERENCE,
'Allow projection difference', False))
self.addOutput(OutputRaster(buildvrt.OUTPUT, 'Output layer'))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Build Virtual Raster')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Miscellaneous')
self.addParameter(
ParameterMultipleInput(self.INPUT, self.tr('Input layers'),
ParameterMultipleInput.TYPE_RASTER))
self.addParameter(
ParameterSelection(self.RESOLUTION, self.tr('Resolution'),
self.RESOLUTION_OPTIONS, 0))
self.addParameter(
ParameterBoolean(self.SEPARATE, self.tr('Layer stack'), True))
self.addParameter(
ParameterBoolean(self.PROJ_DIFFERENCE,
self.tr('Allow projection difference'), False))
self.addOutput(OutputRaster(buildvrt.OUTPUT, self.tr('Virtual')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Merge')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Miscellaneous')
self.addParameter(
ParameterMultipleInput(merge.INPUT, self.tr('Input layers'),
ParameterMultipleInput.TYPE_RASTER))
self.addParameter(
ParameterBoolean(
merge.PCT, self.tr('Grab pseudocolor table from first layer'),
False))
self.addParameter(
ParameterBoolean(merge.SEPARATE, self.tr('Layer stack'), False))
self.addParameter(
ParameterSelection(self.RTYPE, self.tr('Output raster type'),
self.TYPE, 5))
self.addOutput(OutputRaster(merge.OUTPUT, self.tr('Merged')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Tile Index')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Miscellaneous')
self.addParameter(
ParameterMultipleInput(self.INPUT, self.tr('Input layers'),
dataobjects.TYPE_RASTER))
self.addParameter(
ParameterString(self.FIELD_NAME,
self.tr('Tile index field'),
'location',
optional=True))
self.addParameter(
ParameterBoolean(
self.PROJ_DIFFERENCE,
self.tr('Skip files with different projection reference'),
False))
self.addOutput(OutputVector(gdaltindex.OUTPUT, self.tr('Tile index')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Execute SQL')
self.group, self.i18n_group = self.trAlgorithm('Vector general tools')
self.addParameter(
ParameterMultipleInput(
name=self.INPUT_DATASOURCES,
description=self.
tr('Additional input datasources (called input1, .., inputN in the query)'
),
datatype=ParameterMultipleInput.TYPE_VECTOR_ANY,
optional=True))
self.addParameter(
ParameterString(name=self.INPUT_QUERY,
description=self.tr('SQL query'),
multiline=True))
self.addParameter(
ParameterString(name=self.INPUT_UID_FIELD,
description=self.tr('Unique identifier field'),
optional=True))
self.addParameter(
ParameterString(name=self.INPUT_GEOMETRY_FIELD,
description=self.tr('Geometry field'),
optional=True))
self.geometryTypes = [
self.tr('Autodetect'),
self.tr('No geometry'), 'Point', 'LineString', 'Polygon',
'MultiPoint', 'MultiLineString', 'MultiPolygon'
]
self.addParameter(
ParameterSelection(self.INPUT_GEOMETRY_TYPE,
self.tr('Geometry type'),
self.geometryTypes,
optional=True))
self.addParameter(
ParameterCrs(self.INPUT_GEOMETRY_CRS,
self.tr('CRS'),
optional=True))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Output')))
def defineCharacteristics(self):
self.name = "reclass raster datasets"
self.group = "[pktools] raster"
self.addParameter(
ParameterMultipleInput(self.INPUT, 'Input layer raster data set',
ParameterMultipleInput.TYPE_RASTER))
self.addOutput(OutputRaster(self.OUTPUT, "Output raster data set"))
self.addParameter(
ParameterString(
self.BAND,
"Band index(es) to replace, e.g., 0;1;2 (other bands are copied to output)",
'0'))
self.addParameter(
ParameterRaster(self.MASK, "Mask raster dataset", optional=True))
self.addParameter(
ParameterString(
self.MSKNODATA,
"Mask value(s) not to consider for classification (e.g., 0;255)",
"0"))
self.addParameter(
ParameterString(
self.CLASS,
"list of classes to reclass, in combination with reclass option, e.g., 0;1;2;3",
""))
self.addParameter(
ParameterString(
self.RECLASS,
"list of recoded classes, in combination with class option e.g., 10;11;12;13",
""))
self.addParameter(
ParameterNumber(self.NODATA,
"nodata value to put in image if not valid", 0,
None, 0))
self.addParameter(
ParameterSelection(
self.RTYPE,
'Output raster type (leave as none to keep original type)',
self.TYPE, 0))
self.addParameter(
ParameterString(self.EXTRA,
'Additional parameters',
'-of GTiff',
optional=True))
def testOptional(self):
parameter = ParameterMultipleInput("myName", "myDesc", optional=True)
self.assertTrue(parameter.setValue("myLayerFile.shp"))
self.assertEqual(parameter.value, "myLayerFile.shp")
self.assertTrue(parameter.setValue(None))
self.assertEqual(parameter.value, None)
parameter = ParameterMultipleInput("myName", "myDesc", optional=False)
self.assertFalse(parameter.setValue(None))
self.assertEqual(parameter.value, None)
self.assertTrue(parameter.setValue("myLayerFile.shp"))
self.assertEqual(parameter.value, "myLayerFile.shp")
self.assertFalse(parameter.setValue(None))
self.assertEqual(parameter.value, "myLayerFile.shp")
def defineCharacteristics(self):
self.addParameter(ParameterMultipleInput(self.INPUT,
self.tr('Input layers'),
dataobjects.TYPE_RASTER))
self.addParameter(ParameterString(self.OPTIONS,
self.tr('Additional creation options'),
optional=True,
metadata={'widget_wrapper': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}))
self.addParameter(ParameterBoolean(self.PCT,
self.tr('Grab pseudocolor table from first layer'),
False))
self.addParameter(ParameterBoolean(self.SEPARATE,
self.tr('Place each input file into a separate band'),
False))
self.addParameter(ParameterSelection(self.RTYPE,
self.tr('Output raster type'),
self.TYPE, 5))
self.addOutput(OutputRaster(self.OUTPUT, self.tr('Merged')))
def __init__(self):
super().__init__()
self.addParameter(
ParameterMultipleInput(
name=self.INPUT_DATASOURCES,
description=self.
tr('Additional input datasources (called input1, .., inputN in the query)'
),
optional=True))
self.addParameter(
ParameterString(name=self.INPUT_QUERY,
description=self.tr('SQL query'),
multiline=True))
self.addParameter(
ParameterString(name=self.INPUT_UID_FIELD,
description=self.tr('Unique identifier field'),
optional=True))
self.addParameter(
ParameterString(name=self.INPUT_GEOMETRY_FIELD,
description=self.tr('Geometry field'),
optional=True))
self.geometryTypes = [
self.tr('Autodetect'),
self.tr('No geometry'), 'Point', 'LineString', 'Polygon',
'MultiPoint', 'MultiLineString', 'MultiPolygon'
]
self.addParameter(
ParameterSelection(self.INPUT_GEOMETRY_TYPE,
self.tr('Geometry type'),
self.geometryTypes,
optional=True))
self.addParameter(
ParameterCrs(self.INPUT_GEOMETRY_CRS,
self.tr('CRS'),
optional=True))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('SQL Output')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Build virtual vector')
self.group, self.i18n_group = self.trAlgorithm('Vector general tools')
self.addParameter(
ParameterMultipleInput(
name=self.INPUT_DATASOURCES,
description=self.tr('Input datasources'),
datatype=ParameterMultipleInput.TYPE_VECTOR_ANY,
optional=False))
self.addParameter(
ParameterBoolean(name=self.INPUT_OVERWRITE_FLAG,
description=self.tr('Overwrite output vrt'),
default=False))
self.addOutput(
OutputFile(self.OUTPUT_VRT_FILE,
self.tr('Virtual vector'),
ext='vrt'))
self.addOutput(
OutputString(self.OUTPUT_VRT_STRING, self.tr('Virtual string')))
def defineCharacteristics(self):
"""Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# The name that the user will see in the toolbox
self.name = 'vector layers to sqlite'
# The branch of the toolbox under which the algorithm will appear
self.group = 'Export to Geopaparazzi'
# We add the input vector layer. It can have any kind of geometry
# It is a mandatory (not optional) one, hence the False argument
self.addParameter(
ParameterMultipleInput(
self.LAYERS,
self.tr('Layers to export'),
datatype=ParameterMultipleInput.TYPE_VECTOR_ANY))
# We add a vector layer as output
self.addOutput(
OutputFile(self.OUTFILE, self.tr('Output file'), 'sqlite'))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Merge')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Miscellaneous')
self.addParameter(
ParameterMultipleInput(merge.INPUT, self.tr('Input layers'),
ParameterMultipleInput.TYPE_RASTER))
self.addParameter(
ParameterBoolean(
merge.PCT, self.tr('Grab pseudocolor table from first layer'),
False))
self.addParameter(
ParameterBoolean(
merge.SEPARATE,
self.tr('Place each input file into a separate band'), False))
self.addParameter(
ParameterNumber(
self.NODATA,
self.tr('Assign a specified nodata value to output bands'),
None, None, -9999))
self.addParameter(
ParameterSelection(self.RTYPE, self.tr('Output raster type'),
self.TYPE, 5))
self.addOutput(OutputRaster(merge.OUTPUT, self.tr('Merged')))
def testMultipleInput(self):
parameter = ParameterMultipleInput('myName', 'myDesc', optional=True)
self.assertTrue(parameter.setMinNumInputs(1))
parameter = ParameterMultipleInput('myName', 'myDesc', optional=False)
self.assertFalse(parameter.setMinNumInputs(0))
parameter.setMinNumInputs(2)
self.assertTrue(
parameter.setValue(['myLayerFile.shp', 'myLayerFile2.shp']))
parameter.setMinNumInputs(3)
self.assertFalse(
parameter.setValue(['myLayerFile.shp', 'myLayerFile2.shp']))
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 testGetAsStringWhenFile(self):
parameter = ParameterMultipleInput('myName',
'myDesc',
datatype=dataobjects.TYPE_FILE)
self.assertEqual(parameter.getAsString('/some/path'), '/some/path')
def processParameterLine(self, line):
param = None
out = None
line = line.replace('#', '')
if line.lower().strip().startswith('showplots'):
self.showPlots = True
self.addOutput(OutputHTML(RAlgorithm.RPLOTS, 'R Plots'))
return
if line.lower().strip().startswith('dontuserasterpackage'):
self.useRasterPackage = False
return
if line.lower().strip().startswith('passfilenames'):
self.passFileNames = True
return
tokens = line.split('=')
desc = self.createDescriptiveName(tokens[0])
if tokens[1].lower().strip() == 'group':
self.group = tokens[0]
return
if tokens[1].lower().strip().startswith('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().startswith('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().startswith('number'):
try:
default = float(tokens[1].strip()[len('number') + 1:])
param = ParameterNumber(tokens[0], desc, default=default)
except:
raise WrongScriptException(
self.tr(
'Could not load R script: %s.\n Problem with line %s' %
(self.descriptionFile, line)))
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], tokens[0], field)
elif tokens[1].lower().strip() == 'extent':
param = ParameterExtent(tokens[0], desc)
elif tokens[1].lower().strip() == 'point':
param = ParameterPoint(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('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('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 file'):
out = OutputFile()
if param is not None:
self.addParameter(param)
elif out is not None:
out.name = tokens[0]
out.description = tokens[0]
self.addOutput(out)
else:
raise WrongScriptException(
self.tr('Could not load R script: %s.\n Problem with line %s' %
(self.descriptionFile, line)))
def defineCharacteristics(self):
self.addParameter(ParameterMultipleInput(self.LAYERS,
self.tr('Layers to merge'),
datatype=dataobjects.TYPE_VECTOR_ANY))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Merged')))
<<<<<<< HEAD
=======
>>>>>>> upstream/master
class gdaltindex(GdalAlgorithm):
INPUT = 'INPUT'
OUTPUT = 'OUTPUT'
FIELD_NAME = 'FIELD_NAME'
PROJ_DIFFERENCE = 'PROJ_DIFFERENCE'
def defineCharacteristics(self):
<<<<<<< HEAD
self.name = 'Tile Index'
self.group = '[GDAL] Miscellaneous'
self.addParameter(ParameterMultipleInput(self.INPUT,
self.tr('Input layers'), ParameterMultipleInput.TYPE_RASTER))
self.addParameter(ParameterString(self.FIELD_NAME,
self.tr('Tile index field'),
'location', optional=True))
self.addParameter(ParameterBoolean(self.PROJ_DIFFERENCE,
self.tr('Skip files with different projection reference'), False))
self.addOutput(OutputVector(gdaltindex.OUTPUT, self.tr('Output layer')))
def processAlgorithm(self, progress):
fieldName = str(self.getParameterValue(self.FIELD_NAME))
=======
self.name, self.i18n_name = self.trAlgorithm('Tile Index')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Miscellaneous')
self.addParameter(ParameterMultipleInput(self.INPUT,
self.tr('Input layers'), ParameterMultipleInput.TYPE_RASTER))
self.addParameter(ParameterString(self.FIELD_NAME,
def testGetAsStringWhenFile(self):
parameter = ParameterMultipleInput('myName', 'myDesc', datatype=dataobjects.TYPE_FILE)
self.assertEqual(parameter.getAsString('/some/path'), '/some/path')
def defineCharacteristics(self):
# The name that the user will see in the toolbox
self.name = 'Dynamic Time Warping (DTW)'
# The branch of the toolbox under which the algorithm will appear
self.group = 'Image manipulation'
self.addParameter(
ParameterRaster(self.REF_RASTER, self.tr('Reference image'),
False))
self.addParameter(
ParameterFile(
self.REF_CSV,
self.
tr('Reference variable (1 csv with 1 value per date). Delimiter is comma : \',\'.'
),
ext='csv',
optional=False))
##
self.addParameter(
ParameterMultipleInput(self.SYNC_RASTER,
self.tr('Image(s) to sync'),
ParameterMultipleInput.TYPE_RASTER, True))
#
self.addParameter(
ParameterFile(
self.SYNC_CSV,
self.
tr('Sync variable (1 csv with 1 value per date). Respect the same order as the sync raster list. Delimiter is comma : \',\'.'
),
ext='csv',
optional=False))
# add num
self.addParameter(
ParameterNumber(
self.N_SAMPLES,
self.
tr('Number of dates to resample (minimum is the number of dates of your largest dataset). -1 to use the minimum.'
),
minValue=-1,
default=-1))
# add num
self.addParameter(
ParameterNumber(
self.N_SPECTRAL_BANDS,
self.tr('Number of spectral bands used for each date'),
minValue=1,
default=4))
#MASK
self.addParameter(
ParameterRaster(
self.MASK_RASTER,
self.tr('Mask image. Each pixel > 0 is classed as nodata.'),
True))
self.addParameter(
ParameterNumber(self.NO_DATA,
self.tr('No data value'),
minValue=-10000,
default=-10000))
# We add a vector layer as output
self.addOutput(
OutputDirectory(self.OUTPUT_FOLDER, self.tr('Output folder')))
def defineCharacteristics(self):
self.name = "crop raster datasets"
self.group = "[pktools] raster"
self.addParameter(
ParameterMultipleInput(self.INPUT, 'Input layer raster data set',
ParameterMultipleInput.TYPE_RASTER))
self.addOutput(OutputRaster(self.OUTPUT, "Output raster data set"))
self.addParameter(
ParameterSelection(
self.RTYPE,
'Output raster type (leave as none to keep original type)',
self.TYPE, 0))
self.addParameter(
ParameterNumber(self.DX,
"Output resolution in x (leave 0 for no change)",
0.0, None, 0.0))
self.addParameter(
ParameterNumber(self.DY,
"Output resolution in y (leave 0 for no change)",
0.0, None, 0.0))
self.addParameter(
ParameterFile(
self.EXTENT,
"get boundary from extent from polygons in vector file",
False,
optional=True))
self.addParameter(
ParameterBoolean(
self.CUT,
"Crop the extent of the target dataset to the extent of the cutline.",
False))
self.addParameter(
ParameterFile(
self.MASK,
"Use the first band of the specified file as a validity mask (0 is nodata)",
False,
optional=True))
self.addParameter(
ParameterString(self.MSKBAND, "Mask band to read (0 indexed)",
"0"))
self.addParameter(
ParameterString(self.MSKNODATA,
"Mask value not to consider for composite.", "0"))
self.addParameter(
ParameterExtent(self.PROJWIN, 'Georeferenced boundingbox'))
self.addParameter(
ParameterString(
self.NODATA,
"invalid value(s) for input raster dataset (e.g., 0;255)",
"none"))
self.addParameter(
ParameterString(
self.BAND,
"Band(s) in input image to crop, e.g., 0;1;2 (leave empty to retain all bands)",
'',
optional=True))
self.addParameter(
ParameterSelection(self.RESAMPLE, "resampling method",
self.RESAMPLE_OPTIONS, 0))
self.addParameter(
ParameterString(self.EXTRA,
'Additional parameters',
'-of GTiff',
optional=True))
def okPressed(self):
description = unicode(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 = self.paramType.upper().replace(' ', '') + '_' \
+ safeName.upper()
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.itemData(self.parentCombo.currentIndex())
self.param = ParameterTableField(name, description, parent)
elif self.paramType \
== ModelerParameterDefinitionDialog.PARAMETER_RASTER \
or isinstance(self.param, ParameterRaster):
self.param = ParameterRaster(name, description,
self.yesNoCombo.currentIndex() == 1)
elif self.paramType \
== ModelerParameterDefinitionDialog.PARAMETER_TABLE \
or isinstance(self.param, ParameterTable):
self.param = ParameterTable(name, description,
self.yesNoCombo.currentIndex() == 1)
elif self.paramType \
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR \
or isinstance(self.param, ParameterVector):
self.param = ParameterVector(
name, description, [self.shapetypeCombo.currentIndex() - 1],
self.yesNoCombo.currentIndex() == 1)
elif self.paramType \
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE \
or isinstance(self.param, ParameterMultipleInput):
self.param = ParameterMultipleInput(
name, description,
self.datatypeCombo.currentIndex() - 1,
self.yesNoCombo.currentIndex() == 1)
elif self.paramType \
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER \
or isinstance(self.param, ParameterNumber):
try:
vmin = str(self.minTextBox.text()).strip()
if vmin == '':
vmin = None
else:
vmin = float(vmin)
vmax = str(self.maxTextBox.text()).strip()
if vmax == '':
vmax = None
else:
vmax = float(vmax)
self.param = ParameterNumber(
name, description, vmin, vmax,
float(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_STRING \
or isinstance(self.param, ParameterString):
self.param = ParameterString(name, description,
unicode(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)
self.close()
def testGetAsStringWhenFile(self):
parameter = ParameterMultipleInput("myName", "myDesc", datatype=ParameterMultipleInput.TYPE_FILE)
self.assertEqual(parameter.getAsString("/some/path"), "/some/path")
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 processInputParameterToken(self, token, name):
param = None
descName = self.createDescriptiveName(name)
if token.lower().strip() == 'raster':
param = ParameterRaster(name, descName, False)
elif token.lower().strip() == 'vector':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_ANY])
elif token.lower().strip() == 'vector point':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_POINT])
elif token.lower().strip() == 'vector line':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_LINE])
elif token.lower().strip() == 'vector polygon':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_POLYGON])
elif token.lower().strip() == 'table':
param = ParameterTable(name, descName, False)
elif token.lower().strip() == 'multiple raster':
param = ParameterMultipleInput(name, descName,
ParameterMultipleInput.TYPE_RASTER)
param.optional = False
elif token.lower().strip() == 'multiple vector':
param = ParameterMultipleInput(
name, descName, ParameterMultipleInput.TYPE_VECTOR_ANY)
param.optional = False
elif token.lower().strip().startswith('selectionfromfile'):
options = token.strip()[len('selectionfromfile '):].split(';')
param = ParameterSelection(name, descName, options, isSource=True)
elif token.lower().strip().startswith('selection'):
options = token.strip()[len('selection '):].split(';')
param = ParameterSelection(name, descName, options)
elif token.lower().strip().startswith('boolean'):
default = token.strip()[len('boolean') + 1:]
if default:
param = ParameterBoolean(name, descName, default)
else:
param = ParameterBoolean(name, descName)
elif token.lower().strip() == 'extent':
param = ParameterExtent(name, descName)
elif token.lower().strip() == 'point':
param = ParameterPoint(name, descName)
elif token.lower().strip() == 'file':
param = ParameterFile(name, descName, False)
elif token.lower().strip() == 'folder':
param = ParameterFile(name, descName, True)
elif token.lower().strip().startswith('number'):
default = token.strip()[len('number') + 1:]
if default:
param = ParameterNumber(name, descName, default=default)
else:
param = ParameterNumber(name, descName)
elif token.lower().strip().startswith('field'):
field = token.strip()[len('field') + 1:]
found = False
for p in self.parameters:
if p.name == field:
found = True
break
if found:
param = ParameterTableField(name, descName, field)
elif token.lower().strip().startswith('string'):
default = token.strip()[len('string') + 1:]
if default:
param = ParameterString(name, descName, default)
else:
param = ParameterString(name, descName)
elif token.lower().strip().startswith('longstring'):
default = token.strip()[len('longstring') + 1:]
if default:
param = ParameterString(name,
descName,
default,
multiline=True)
else:
param = ParameterString(name, descName, multiline=True)
elif token.lower().strip().startswith('crs'):
default = token.strip()[len('crs') + 1:]
if default:
param = ParameterCrs(name, descName, default)
else:
param = ParameterCrs(name, descName)
return param
