def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Clip raster by extent')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Extraction')
self.addParameter(
ParameterRaster(self.INPUT, self.tr('Input layer'), False))
self.addParameter(
ParameterString(
self.NO_DATA,
self.
tr("Nodata value, leave blank to take the nodata value from input"
), ''))
self.addParameter(
ParameterExtent(self.PROJWIN, self.tr('Clipping extent')))
params = []
params.append(
ParameterSelection(self.RTYPE, self.tr('Output raster type'),
self.TYPE, 5))
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))
params.append(
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('Clipped (extent)')))
def defineCharacteristics(self):
self.name = 'Import Vector into PostGIS database (available connections)'
self.group = '[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(
ParameterSelection(self.GTYPE, self.tr('Output geometry type'),
self.GEOMTYPE, 5))
self.addParameter(
ParameterCrs(self.S_SRS, self.tr('Input CRS'), 'EPSG:4326'))
self.addParameter(
ParameterCrs(self.T_SRS, self.tr('Output CRS'), 'EPSG:4326'))
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'),
'id',
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(
ParameterString(self.OPTIONS,
self.tr('Additional creation options'),
'',
optional=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 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 = 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.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 = unicode(self.minTextBox.text()).strip()
if vmin == '':
vmin = None
else:
vmin = float(vmin)
vmax = unicode(self.maxTextBox.text()).strip()
if vmax == '':
vmax = None
else:
vmax = float(vmax)
self.param = ParameterNumber(
name, description, vmin, vmax,
unicode(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)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or \
isinstance(self.param, ParameterPoint):
self.param = ParameterPoint(name, description,
unicode(self.defaultTextBox.text()))
self.param.optional = self.yesNoCombo.currentIndex() == 1
self.close()
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm(
'Translate (convert format)')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Conversion')
self.addParameter(
ParameterRaster(self.INPUT, self.tr('Input layer'), False))
self.addParameter(
ParameterNumber(
self.OUTSIZE,
self.tr('Set the size of the output file (In pixels or %)'), 1,
None, 100))
self.addParameter(
ParameterBoolean(
self.OUTSIZE_PERC,
self.tr('Output size is a percentage of input size'), True))
self.addParameter(
ParameterString(
self.NO_DATA,
self.
tr("Nodata value, leave blank to take the nodata value from input"
), ''))
self.addParameter(
ParameterSelection(self.EXPAND, self.tr('Expand'),
['none', 'gray', 'rgb', 'rgba']))
self.addParameter(
ParameterCrs(
self.SRS,
self.
tr('Output projection for output file [leave blank to use input projection]'
), None))
self.addParameter(
ParameterExtent(
self.PROJWIN,
self.tr('Subset based on georeferenced coordinates')))
self.addParameter(
ParameterBoolean(
self.SDS,
self.
tr('Copy all subdatasets of this file to individual output files'
), False))
params = []
params.append(
ParameterSelection(self.RTYPE, self.tr('Output raster type'),
self.TYPE, 5))
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))
params.append(
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('Converted')))
def testSetValue(self):
parameter = ParameterExtent('myName', 'myDesc')
self.assertTrue(parameter.setValue('0,2,2,4'))
self.assertEqual(parameter.value, '0,2,2,4')
def __init__(self):
super().__init__()
self.addParameter(
ParameterRaster(self.INPUT, self.tr('Input layer'), False))
self.addParameter(
ParameterCrs(self.SOURCE_SRS,
self.tr('Source SRS'),
'',
optional=True))
self.addParameter(
ParameterCrs(self.DEST_SRS, self.tr('Destination SRS'),
'EPSG:4326'))
self.addParameter(
ParameterString(
self.NO_DATA,
self.
tr("Nodata value, leave blank to take the nodata value from input"
),
'',
optional=True))
self.addParameter(
ParameterNumber(
self.TR,
self.
tr('Output file resolution in target georeferenced units (leave 0 for no change)'
), 0.0, None, 0.0))
self.addParameter(
ParameterSelection(self.METHOD, self.tr('Resampling method'),
self.METHOD_OPTIONS))
self.addParameter(
ParameterBoolean(
self.USE_RASTER_EXTENT,
self.tr('Set georeferenced extents of output file'), False))
self.addParameter(
ParameterExtent(self.RASTER_EXTENT,
self.tr('Raster extent'),
optional=True))
self.addParameter(
ParameterCrs(
self.EXTENT_CRS,
self.
tr('CRS of the raster extent, leave blank for using Destination SRS'
),
optional=True))
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.MULTITHREADING,
self.tr('Use multithreaded warping implementation'), False))
self.addParameter(
ParameterSelection(self.RTYPE, self.tr('Output raster type'),
self.TYPE, 5))
self.addOutput(OutputRaster(self.OUTPUT, self.tr('Reprojected')))
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,
[dataobjects.TYPE_VECTOR_ANY])
elif token.lower().strip() == 'vector point':
param = ParameterVector(name, descName,
[dataobjects.TYPE_VECTOR_POINT])
elif token.lower().strip() == 'vector line':
param = ParameterVector(name, descName,
[dataobjects.TYPE_VECTOR_LINE])
elif token.lower().strip() == 'vector polygon':
param = ParameterVector(name, descName,
[dataobjects.TYPE_VECTOR_POLYGON])
elif token.lower().strip() == 'table':
param = ParameterTable(name, descName, False)
elif token.lower().strip() == 'multiple raster':
param = ParameterMultipleInput(name, descName,
dataobjects.TYPE_RASTER)
param.optional = False
elif token.lower().strip() == 'multiple vector':
param = ParameterMultipleInput(name, descName,
dataobjects.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'):
if token.lower().strip().startswith('field number'):
field = token.strip()[len('field number') + 1:]
datatype = ParameterTableField.DATA_TYPE_NUMBER
elif token.lower().strip().startswith('field string'):
field = token.strip()[len('field string') + 1:]
datatype = ParameterTableField.DATA_TYPE_STRING
else:
field = token.strip()[len('field') + 1:]
datatype = ParameterTableField.DATA_TYPE_ANY
found = False
for p in self.parameters:
if p.name == field:
found = True
break
if found:
param = ParameterTableField(name=name,
description=descName,
parent=field,
datatype=datatype)
elif token.lower().strip().startswith('multiple field'):
if token.lower().strip().startswith('multiple field number'):
field = token.strip()[len('multiple field number') + 1:]
datatype = ParameterTableMultipleField.DATA_TYPE_NUMBER
elif token.lower().strip().startswith('multiple field string'):
field = token.strip()[len('multiple field string') + 1:]
datatype = ParameterTableMultipleField.DATA_TYPE_STRING
else:
field = token.strip()[len('multiple field') + 1:]
datatype = ParameterTableMultipleField.DATA_TYPE_ANY
found = False
for p in self.parameters:
if p.name == field:
found = True
break
if found:
param = ParameterTableMultipleField(name=name,
description=descName,
parent=field,
datatype=datatype)
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
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Warp (reproject)')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Projections')
self.tags = self.tr('transform,reproject,crs,srs')
self.addParameter(
ParameterRaster(self.INPUT, self.tr('Input layer'), False))
self.addParameter(
ParameterCrs(self.SOURCE_SRS,
self.tr('Source SRS'),
'',
optional=True))
self.addParameter(
ParameterCrs(self.DEST_SRS, self.tr('Destination SRS'),
'EPSG:4326'))
self.addParameter(
ParameterString(
self.NO_DATA,
self.
tr("Nodata value, leave blank to take the nodata value from input"
),
'',
optional=True))
self.addParameter(
ParameterNumber(
self.TR,
self.
tr('Output file resolution in target georeferenced units (leave 0 for no change)'
), 0.0, None, 0.0))
self.addParameter(
ParameterSelection(self.METHOD, self.tr('Resampling method'),
self.METHOD_OPTIONS))
self.addParameter(
ParameterExtent(self.RAST_EXT,
self.tr('Raster extent'),
optional=True))
if GdalUtils.version() >= 2000000:
self.addParameter(
ParameterCrs(
self.EXT_CRS,
self.
tr('CRS of the raster extent, leave blank for using Destination SRS'
),
optional=True))
params = []
params.append(
ParameterSelection(self.RTYPE, self.tr('Output raster type'),
self.TYPE, 5))
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))
params.append(
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('Reprojected')))
class Grass7Algorithm(GeoAlgorithm):
GRASS_OUTPUT_TYPE_PARAMETER = 'GRASS_OUTPUT_TYPE_PARAMETER'
GRASS_MIN_AREA_PARAMETER = 'GRASS_MIN_AREA_PARAMETER'
GRASS_SNAP_TOLERANCE_PARAMETER = 'GRASS_SNAP_TOLERANCE_PARAMETER'
GRASS_REGION_EXTENT_PARAMETER = 'GRASS_REGION_PARAMETER'
GRASS_REGION_CELLSIZE_PARAMETER = 'GRASS_REGION_CELLSIZE_PARAMETER'
GRASS_REGION_ALIGN_TO_RESOLUTION = '-a_r.region'
OUTPUT_TYPES = ['auto', 'point', 'line', 'area']
def __init__(self, descriptionfile):
GeoAlgorithm.__init__(self)
self.descriptionFile = descriptionfile
self.defineCharacteristicsFromFile()
self.numExportedLayers = 0
# GRASS GIS 7 console output, needed to do postprocessing in case GRASS
# dumps results to the console
self.consoleOutput = []
def getCopy(self):
newone = Grass7Algorithm(self.descriptionFile)
newone.provider = self.provider
return newone
def getIcon(self):
return QIcon(os.path.dirname(__file__) + '/../../images/grass.png')
def help(self):
return False, 'http://grass.osgeo.org/grass70/manuals/' + self.grassName \
+ '.html'
def getParameterDescriptions(self):
descs = {}
_, helpfile = self.help()
try:
infile = open(helpfile)
lines = infile.readlines()
for i in range(len(lines)):
if lines[i].startswith('<DT><b>'):
for param in self.parameters:
searchLine = '<b>' + param.name + '</b>'
if searchLine in lines[i]:
i += 1
descs[param.name] = (lines[i])[4:-6]
break
infile.close()
except Exception:
pass
return descs
def defineCharacteristicsFromFile(self):
lines = open(self.descriptionFile)
line = lines.readline().strip('\n').strip()
self.grassName = line
line = lines.readline().strip('\n').strip()
self.name = line
line = lines.readline().strip('\n').strip()
self.group = line
hasRasterOutput = False
hasVectorInput = False
vectorOutputs = 0
line = lines.readline().strip('\n').strip()
while line != '':
try:
line = line.strip('\n').strip()
if line.startswith('Parameter'):
parameter = getParameterFromString(line)
self.addParameter(parameter)
if isinstance(parameter, ParameterVector):
hasVectorInput = True
if isinstance(parameter, ParameterMultipleInput) \
and parameter.datatype < 3:
hasVectorInput = True
elif line.startswith('*Parameter'):
param = getParameterFromString(line[1:])
param.isAdvanced = True
self.addParameter(param)
else:
output = getOutputFromString(line)
self.addOutput(output)
if isinstance(output, OutputRaster):
hasRasterOutput = True
elif isinstance(output, OutputVector):
vectorOutputs += 1
line = lines.readline().strip('\n').strip()
except Exception, e:
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
self.tr('Could not open GRASS GIS 7 algorithm: %s\n%s' %
(self.descriptionFile, line)))
raise e
lines.close()
self.addParameter(
ParameterExtent(self.GRASS_REGION_EXTENT_PARAMETER,
self.tr('GRASS GIS 7 region extent')))
if hasRasterOutput:
self.addParameter(
ParameterNumber(
self.GRASS_REGION_CELLSIZE_PARAMETER,
self.tr(
'GRASS GIS 7 region cellsize (leave 0 for default)'),
0, None, 0.0))
if hasVectorInput:
param = ParameterNumber(self.GRASS_SNAP_TOLERANCE_PARAMETER,
'v.in.ogr snap tolerance (-1 = no snap)',
-1, None, -1.0)
param.isAdvanced = True
self.addParameter(param)
param = ParameterNumber(self.GRASS_MIN_AREA_PARAMETER,
'v.in.ogr min area', 0, None, 0.0001)
param.isAdvanced = True
self.addParameter(param)
if vectorOutputs == 1:
param = ParameterSelection(self.GRASS_OUTPUT_TYPE_PARAMETER,
'v.out.ogr output type',
self.OUTPUT_TYPES)
param.isAdvanced = True
self.addParameter(param)
def processInputParameterToken(self, token, name):
param = None
desc = self.createDescriptiveName(name)
if token.lower().strip().startswith('raster'):
param = ParameterRaster(name, desc, False)
elif token.lower().strip() == 'vector':
param = ParameterVector(name, desc,
[ParameterVector.VECTOR_TYPE_ANY])
elif token.lower().strip() == 'vector point':
param = ParameterVector(name, desc,
[ParameterVector.VECTOR_TYPE_POINT])
elif token.lower().strip() == 'vector line':
param = ParameterVector(name, desc,
[ParameterVector.VECTOR_TYPE_LINE])
elif token.lower().strip() == 'vector polygon':
param = ParameterVector(name, desc,
[ParameterVector.VECTOR_TYPE_POLYGON])
elif token.lower().strip() == 'table':
param = ParameterTable(name, desc, False)
elif token.lower().strip().startswith('multiple raster'):
param = ParameterMultipleInput(name, desc,
ParameterMultipleInput.TYPE_RASTER)
param.optional = False
elif token.lower().strip() == 'multiple vector':
param = ParameterMultipleInput(
name, desc, ParameterMultipleInput.TYPE_VECTOR_ANY)
param.optional = False
elif token.lower().strip().startswith('selection'):
options = token.strip()[len('selection'):].split(';')
param = ParameterSelection(name, desc, options)
elif token.lower().strip().startswith('boolean'):
default = token.strip()[len('boolean') + 1:]
if default:
param = ParameterBoolean(name, desc, default)
else:
param = ParameterBoolean(name, desc)
elif token.lower().strip().startswith('number'):
default = token.strip()[len('number') + 1:]
if default:
param = ParameterNumber(name, desc, default=default)
else:
param = ParameterNumber(name, desc)
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, desc, field)
elif token.lower().strip().startswith('multiple field'):
field = token.strip()[len('multiple field') + 1:]
found = False
for p in self.parameters:
if p.name == field:
found = True
break
if found:
param = ParameterTableMultipleField(name, desc, field)
elif token.lower().strip() == 'extent':
param = ParameterExtent(name, desc)
elif token.lower().strip() == 'point':
param = ParameterPoint(name, desc)
elif token.lower().strip() == 'file':
param = ParameterFile(name, desc, False)
elif token.lower().strip() == 'folder':
param = ParameterFile(name, desc, True)
elif token.lower().strip().startswith('string'):
default = token.strip()[len('string') + 1:]
if default:
param = ParameterString(name, desc, default)
else:
param = ParameterString(name, desc)
elif token.lower().strip().startswith('longstring'):
default = token.strip()[len('longstring') + 1:]
if default:
param = ParameterString(name, desc, default, multiline=True)
else:
param = ParameterString(name, desc, multiline=True)
elif token.lower().strip() == 'crs':
default = token.strip()[len('crs') + 1:]
if default:
param = ParameterCrs(name, desc, default)
else:
param = ParameterCrs(name, desc)
return param
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('selectionfromfile'):
options = tokens[1].strip()[len('selectionfromfile '):].split(';')
param = ParameterSelection(tokens[0], desc, options, isSource=True)
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 "%s"', 'ScriptAlgorithm') %
(self.descriptionFile or '', line))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('lasquery')
self.group, self.i18n_group = self.trAlgorithm('LAStools')
self.addParametersVerboseGUI()
self.addParameter(ParameterExtent(self.AOI, self.tr('area of interest'), optional=False))
self.addParametersAdditionalGUI()
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 = self.tablename
# The branch of the toolbox under which the algorithm will appear
self.group = self.groupname
# 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(
ParameterExtent(
self.EXTENT,
self.tr(
u'Definer afgrænsningen af forespørgsel for "{}".').format(
self.tablename),
default="0,0,0,0"))
self.addParameter(
ParameterVector(
self.VECTOR_SELECTION,
self.
tr(u'- eller brug en valgt polygongeometri som afgrænsning for "{}" fra tabel'
).format(self.tablename),
[ParameterVector.VECTOR_TYPE_POLYGON], False))
self.addParameter(
ParameterString(self.COMPOUNDNAME, self.tr(u'Stofnavn'), ''))
self.addParameter(
ParameterNumber(
self.COMPOUNDLIMIT,
self.tr(
u'Udtræk kun analyseværdier over (0 = alle analyser):'),
0,
None,
'0',
optional=True))
self.addParameter(
ParameterString(
self.DATE_FROM,
self.tr(u'Angiv prøve-startdato i formatet YYYY-MM-DD'),
'1900-01-01',
optional=True))
self.addParameter(
ParameterString(
self.DATE_TO,
self.tr(u'Angiv prøve-slutdato i formatet YYYY-MM-DD'),
date.today(),
optional=True))
self.addParameter(
ParameterBoolean(
self.LOAD_ONLY_LATEST,
self.tr(u'-eller hent kun seneste data fra hver boring'),
optional=True))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Stoftabel')))
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())
if not self.requiredCheck.isChecked():
self.param.setFlags(self.param.flags() | QgsProcessingParameterDefinition.FlagOptional)
self.close()
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm(
'Import Vector into PostGIS database (available connections)')
self.group, self.i18n_group = self.trAlgorithm('Vector miscellaneous')
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 = "composite/mosaic raster datasets"
self.group = "[pktools] raster"
self.addParameter(
ParameterMultipleInput(self.INPUT, 'Input layer raster data set',
ParameterMultipleInput.TYPE_RASTER))
self.addParameter(
ParameterString(
self.BAND,
"band index(es) to crop (leave empty if all bands must be retained"
))
self.addParameter(
ParameterSelection(self.CRULE, "composite rule",
self.CRULE_OPTIONS, 0))
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.CB,
"band index(es) used for the composite rule (0 based), e.g., 0;1 in case of maxndvi",
"0"))
self.addParameter(
ParameterString(
self.SRCNODATA,
"invalid value(s) for input raster dataset (e.g., 0;255)",
"none"))
self.addParameter(
ParameterString(
self.BNDNODATA,
"Band(s) in input image to check if pixel is valid (e.g., 0;1)",
"0"))
self.addParameter(
ParameterString(
self.DSTNODATA,
"nodata value to put in output raster dataset if not valid or out of bounds",
"0"))
self.addParameter(
ParameterString(
self.MINGUI,
"flag values smaller or equal to this value as invalid",
"none"))
self.addParameter(
ParameterString(
self.MAXGUI,
"flag values larger or equal to this value as invalid",
"none"))
self.addParameter(
ParameterSelection(self.RESAMPLE, "resampling method",
self.RESAMPLE_OPTIONS, 0))
self.addParameter(
ParameterString(self.EXTRA,
'Additional parameters',
'-of GTiff',
optional=True))
def __init__(self):
super().__init__()
self.METHODS = [self.tr('Linear'), self.tr('Clough-Toucher (cubic)')]
class ParameterInterpolationData(Parameter):
default_metadata = {
'widget_wrapper':
'processing.algs.qgis.ui.InterpolationDataWidget.InterpolationDataWidgetWrapper'
}
def __init__(self, name='', description=''):
Parameter.__init__(self, name, description)
def setValue(self, value):
if value is None:
if not self.flags(
) & QgsProcessingParameterDefinition.FlagOptional:
return False
self.value = None
return True
if value == '':
if not self.flags(
) & QgsProcessingParameterDefinition.FlagOptional:
return False
if isinstance(value, str):
self.value = value if value != '' else None
else:
self.value = ParameterInterpolationData.dataToString(value)
return True
def getValueAsCommandLineParameter(self):
return '"{}"'.format(self.value)
def getAsScriptCode(self):
param_type = ''
param_type += 'interpolation data '
return '##' + self.name + '=' + param_type
@classmethod
def fromScriptCode(self, line):
isOptional, name, definition = _splitParameterOptions(line)
descName = QgsProcessingParameters.descriptionFromName(name)
parent = definition.lower().strip()[len('interpolation data') +
1:]
return ParameterInterpolationData(name, descName, parent)
@staticmethod
def dataToString(data):
s = ''
for c in data:
s += '{}, {}, {:d}, {:d};'.format(c[0], c[1], c[2], c[3])
return s[:-1]
self.addParameter(
ParameterInterpolationData(self.INTERPOLATION_DATA,
self.tr('Input layer(s)')))
self.addParameter(
ParameterSelection(self.METHOD, self.tr('Interpolation method'),
self.METHODS, 0))
self.addParameter(
ParameterNumber(self.COLUMNS, self.tr('Number of columns'), 0,
10000000, 300))
self.addParameter(
ParameterNumber(self.ROWS, self.tr('Number of rows'), 0, 10000000,
300))
self.addParameter(
ParameterNumber(self.CELLSIZE_X, self.tr('Cell size X'), 0.0,
999999.000000, 0.0))
self.addParameter(
ParameterNumber(self.CELLSIZE_Y, self.tr('Cell size Y'), 0.0,
999999.000000, 0.0))
self.addParameter(
ParameterExtent(self.EXTENT, self.tr('Extent'), optional=False))
self.addOutput(OutputRaster(self.OUTPUT_LAYER,
self.tr('Interpolated')))
self.addOutput(
OutputVector(
self.TRIANULATION_FILE,
self.tr('Triangulation'),
)) # datatype=dataobjects.TYPE_VECTOR_LINE))
def testSetInvalidValue(self):
parameter = ParameterExtent('myName', 'myDesc')
self.assertFalse(parameter.setValue('0,2,0'))
self.assertFalse(parameter.setValue('0,2,0,a'))
class OTBAlgorithm(GeoAlgorithm):
REGION_OF_INTEREST = "ROI"
def __init__(self, descriptionfile):
GeoAlgorithm.__init__(self)
self.roiFile = None
self.descriptionFile = descriptionfile
self.defineCharacteristicsFromFile()
self.numExportedLayers = 0
self.hasROI = None
def __str__(self):
return ("Algo : " + self.name + " from app : " + self.cliName +
" in : " + self.group)
def getCopy(self):
newone = OTBAlgorithm(self.descriptionFile)
newone.provider = self.provider
return newone
def getIcon(self):
return PyQt4.QtGui.QIcon(
os.path.dirname(__file__) + "/../../images/otb.png")
def help(self):
folder = os.path.join(OTBUtils.otbDescriptionPath(), 'doc')
helpfile = os.path.join(str(folder), self.appkey + ".html")
if os.path.exists(helpfile):
return False, helpfile
else:
raise False, None
def adapt_list_to_string(self, c_list):
a_list = c_list[1:]
if a_list[0] in ["ParameterVector", "ParameterMultipleInput"]:
if c_list[0] == "ParameterType_InputImageList":
a_list[3] = 3
elif c_list[0] == "ParameterType_InputFilenameList":
a_list[3] = 4
else:
a_list[3] = -1
a_list[1] = "-%s" % a_list[1]
def mystr(par):
if type(par) == type([]):
return ";".join(par)
return str(par)
b_list = map(mystr, a_list)
res = "|".join(b_list)
return res
def get_list_from_node(self, myet):
all_params = []
for parameter in myet.iter('parameter'):
rebuild = []
par_type = parameter.find('parameter_type').text
key = parameter.find('key').text
name = parameter.find('name').text
source_par_type = parameter.find(
'parameter_type').attrib['source_parameter_type']
rebuild.append(source_par_type)
rebuild.append(par_type)
rebuild.append(key)
rebuild.append(name)
for each in parameter[4:]:
if not each.tag in ["hidden"]:
if len(list(each)) == 0:
rebuild.append(each.text)
else:
rebuild.append(
[item.text for item in each.iter('choice')])
all_params.append(rebuild)
return all_params
def defineCharacteristicsFromFile(self):
content = open(self.descriptionFile).read()
dom_model = ET.fromstring(content)
self.appkey = dom_model.find('key').text
self.cliName = dom_model.find('exec').text
self.name = dom_model.find('longname').text
self.group = dom_model.find('group').text
#ProcessingLog.addToLog(ProcessingLog.LOG_INFO, "Reading parameters for %s" % self.appkey)
rebu = None
the_result = None
try:
rebu = self.get_list_from_node(dom_model)
the_result = map(self.adapt_list_to_string, rebu)
except Exception, e:
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR, "Could not open OTB algorithm: " +
self.descriptionFile + "\n" + traceback.format_exc())
raise e
for line in the_result:
try:
if line.startswith("Parameter") or line.startswith(
"*Parameter"):
if line.startswith("*Parameter"):
param = ParameterFactory.getFromString(line[1:])
param.isAdvanced = True
else:
param = getParameterFromString(line)
# Hack for initializing the elevation parameters from Processing configuration
if param.name == "-elev.dem.path" or param.name == "-elev.dem" or "elev.dem" in param.name:
param.default = OTBUtils.otbSRTMPath()
elif param.name == "-elev.dem.geoid" or param.name == "-elev.geoid" or "elev.geoid" in param.name:
param.default = OTBUtils.otbGeoidPath()
self.addParameter(param)
elif line.startswith("Extent"):
self.addParameter(
ParameterExtent(self.REGION_OF_INTEREST,
"Region of interest", "0,1,0,1"))
self.hasROI = True
else:
self.addOutput(getOutputFromString(line))
except Exception, e:
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR, "Could not open OTB algorithm: " +
self.descriptionFile + "\n" + line)
raise e
def defineCharacteristicsFromFile(self):
with open(self.descriptionFile) as lines:
line = lines.readline().strip('\n').strip()
self.grass7Name = line
line = lines.readline().strip('\n').strip()
self._name = line
self._display_name = QCoreApplication.translate("GrassAlgorithm", line)
if " - " not in self._name:
self._name = self.grass7Name + " - " + self._name
self._display_name = self.grass7Name + " - " + self._display_name
self._name = self._name[:self._name.find(' ')].lower()
line = lines.readline().strip('\n').strip()
self._group = QCoreApplication.translate("GrassAlgorithm", line)
hasRasterOutput = False
hasVectorInput = False
vectorOutputs = 0
line = lines.readline().strip('\n').strip()
while line != '':
try:
line = line.strip('\n').strip()
if line.startswith('Hardcoded'):
self.hardcodedStrings.append(line[len('Hardcoded|'):])
parameter = getParameterFromString(line)
if parameter is not None:
self.addParameter(parameter)
if isinstance(parameter, ParameterVector):
hasVectorInput = True
if isinstance(parameter, ParameterMultipleInput) \
and parameter.datatype < 3:
hasVectorInput = True
else:
output = getOutputFromString(line)
self.addOutput(output)
if isinstance(output, OutputRaster):
hasRasterOutput = True
elif isinstance(output, OutputVector):
vectorOutputs += 1
if isinstance(output, OutputHTML):
self.addOutput(OutputFile("rawoutput",
self.tr("{0} (raw output)").format(output.description()),
"txt"))
line = lines.readline().strip('\n').strip()
except Exception as e:
QgsMessageLog.logMessage(self.tr('Could not open GRASS GIS 7 algorithm: {0}\n{1}').format(self.descriptionFile, line), self.tr('Processing'), QgsMessageLog.CRITICAL)
raise e
self.addParameter(ParameterExtent(
self.GRASS_REGION_EXTENT_PARAMETER,
self.tr('GRASS GIS 7 region extent'))
)
if hasRasterOutput:
self.addParameter(ParameterNumber(
self.GRASS_REGION_CELLSIZE_PARAMETER,
self.tr('GRASS GIS 7 region cellsize (leave 0 for default)'),
0, None, 0.0))
if hasVectorInput:
param = ParameterNumber(self.GRASS_SNAP_TOLERANCE_PARAMETER,
'v.in.ogr snap tolerance (-1 = no snap)',
-1, None, -1.0)
param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
param = ParameterNumber(self.GRASS_MIN_AREA_PARAMETER,
'v.in.ogr min area', 0, None, 0.0001)
param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
if vectorOutputs == 1:
param = ParameterSelection(self.GRASS_OUTPUT_TYPE_PARAMETER,
'v.out.ogr output type',
self.OUTPUT_TYPES)
param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(param)
def defineCharacteristics(self):
class ParameterInterpolationData(Parameter):
default_metadata = {
'widget_wrapper':
'processing.algs.qgis.ui.InterpolationDataWidget.InterpolationDataWidgetWrapper'
}
def __init__(self, name='', description=''):
Parameter.__init__(self, name, description)
def setValue(self, value):
if value is None:
if not self.optional:
return False
self.value = None
return True
if value == '':
if not self.optional:
return False
if isinstance(value, str):
self.value = value if value != '' else None
else:
self.value = ParameterInterpolationData.dataToString(value)
return True
def getValueAsCommandLineParameter(self):
return '"{}"'.format(self.value)
def getAsScriptCode(self):
param_type = ''
param_type += 'interpolation data '
return '##' + self.name + '=' + param_type
@classmethod
def fromScriptCode(self, line):
isOptional, name, definition = _splitParameterOptions(line)
descName = _createDescriptiveName(name)
parent = definition.lower().strip()[len('interpolation data') +
1:]
return ParameterInterpolationData(name, descName, parent)
@staticmethod
def dataToString(data):
s = ''
for c in data:
s += '{}, {}, {:d}, {:d};'.format(c[0], c[1], c[2], c[3])
return s[:-1]
self.addParameter(
ParameterInterpolationData(self.INTERPOLATION_DATA,
self.tr('Input layer(s)')))
self.addParameter(
ParameterNumber(self.DISTANCE_COEFFICIENT,
self.tr('Distance coefficient P'), 0.0, 99.99,
2.0))
self.addParameter(
ParameterNumber(self.COLUMNS, self.tr('Number of columns'), 0,
10000000, 300))
self.addParameter(
ParameterNumber(self.ROWS, self.tr('Number of rows'), 0, 10000000,
300))
self.addParameter(
ParameterNumber(self.CELLSIZE_X, self.tr('Cell Size X'), 0.0,
999999.000000, 0.0))
self.addParameter(
ParameterNumber(self.CELLSIZE_Y, self.tr('Cell Size Y'), 0.0,
999999.000000, 0.0))
self.addParameter(
ParameterExtent(self.EXTENT, self.tr('Extent'), optional=False))
self.addOutput(OutputRaster(self.OUTPUT_LAYER,
self.tr('Interpolated')))
def __init__(self):
super().__init__()
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.HOST,
self.tr('Host'),
'localhost',
optional=True))
self.addParameter(
ParameterString(self.PORT, self.tr('Port'), '5432', optional=True))
self.addParameter(
ParameterString(self.USER, self.tr('Username'), '', optional=True))
self.addParameter(
ParameterString(self.DBNAME,
self.tr('Database name'),
'',
optional=True))
self.addParameter(
ParameterString(self.PASSWORD,
self.tr('Password'),
'',
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 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() == '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() == '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('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 defineCharacteristicsFromFile(self):
lines = open(self.descriptionFile)
line = lines.readline().strip('\n').strip()
self.grass7Name = line
line = lines.readline().strip('\n').strip()
self.name = line
self.i18n_name = QCoreApplication.translate("GrassAlgorithm", line)
if " - " not in self.name:
self.name = self.grass7Name + " - " + self.name
self.i18n_name = self.grass7Name + " - " + self.i18n_name
line = lines.readline().strip('\n').strip()
self.group = line
self.i18n_group = QCoreApplication.translate("GrassAlgorithm", line)
hasRasterOutput = False
hasVectorInput = False
vectorOutputs = 0
line = lines.readline().strip('\n').strip()
while line != '':
try:
line = line.strip('\n').strip()
if line.startswith('Hardcoded'):
self.hardcodedStrings.append(line[len('Hardcoded|'):])
elif line.startswith('Parameter'):
parameter = getParameterFromString(line)
self.addParameter(parameter)
if isinstance(parameter, ParameterVector):
hasVectorInput = True
if isinstance(parameter, ParameterMultipleInput) \
and parameter.datatype < 3:
hasVectorInput = True
elif line.startswith('*Parameter'):
param = getParameterFromString(line[1:])
param.isAdvanced = True
self.addParameter(param)
else:
output = getOutputFromString(line)
self.addOutput(output)
if isinstance(output, OutputRaster):
hasRasterOutput = True
elif isinstance(output, OutputVector):
vectorOutputs += 1
if isinstance(output, OutputHTML):
self.addOutput(OutputFile("rawoutput", output.description +
" (raw output)", "txt"))
line = lines.readline().strip('\n').strip()
except Exception as e:
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
self.tr('Could not open GRASS GIS 7 algorithm: %s\n%s' % (self.descriptionFile, line)))
raise e
lines.close()
self.addParameter(ParameterExtent(
self.GRASS_REGION_EXTENT_PARAMETER,
self.tr('GRASS GIS 7 region extent'))
)
if hasRasterOutput:
self.addParameter(ParameterNumber(
self.GRASS_REGION_CELLSIZE_PARAMETER,
self.tr('GRASS GIS 7 region cellsize (leave 0 for default)'),
0, None, 0.0))
if hasVectorInput:
param = ParameterNumber(self.GRASS_SNAP_TOLERANCE_PARAMETER,
'v.in.ogr snap tolerance (-1 = no snap)',
- 1, None, -1.0)
param.isAdvanced = True
self.addParameter(param)
param = ParameterNumber(self.GRASS_MIN_AREA_PARAMETER,
'v.in.ogr min area', 0, None, 0.0001)
param.isAdvanced = True
self.addParameter(param)
if vectorOutputs == 1:
param = ParameterSelection(self.GRASS_OUTPUT_TYPE_PARAMETER,
'v.out.ogr output type',
self.OUTPUT_TYPES)
param.isAdvanced = True
self.addParameter(param)
def defineCharacteristics(self):
self.name = 'Import Vector into PostGIS database (new connection)'
self.group = '[OGR] Miscellaneous'
self.addParameter(
ParameterVector(self.INPUT_LAYER, 'Input layer',
[ParameterVector.VECTOR_TYPE_ANY], False))
self.addParameter(
ParameterSelection(self.GTYPE, 'Output geometry type',
self.GEOMTYPE, 5))
self.addParameter(
ParameterCrs(self.S_SRS, 'Input CRS (EPSG Code)', 'EPSG:4326'))
self.addParameter(
ParameterCrs(self.T_SRS, 'Output CRS (EPSG Code)', 'EPSG:4326'))
self.addParameter(
ParameterString(self.HOST, 'Host', 'localhost', optional=False))
self.addParameter(
ParameterString(self.PORT, 'Port', '5432', optional=False))
self.addParameter(
ParameterString(self.USER, 'Username', '', optional=False))
self.addParameter(
ParameterString(self.DBNAME, 'Database Name', '', optional=False))
self.addParameter(
ParameterString(self.PASSWORD, 'Password', '', optional=False))
self.addParameter(
ParameterString(self.SCHEMA,
'Schema name',
'public',
optional=True))
self.addParameter(
ParameterString(self.TABLE,
'Table name, leave blank to use input name',
'',
optional=True))
self.addParameter(
ParameterString(self.PK, 'Primary Key', 'id', optional=True))
self.addParameter(
ParameterString(self.GEOCOLUMN,
'Geometry column name',
'geom',
optional=True))
self.addParameter(
ParameterSelection(self.DIM, 'Vector dimensions', self.DIMLIST, 0))
self.addParameter(
ParameterString(self.SIMPLIFY,
'Distance tolerance for simplification',
'',
optional=True))
self.addParameter(
ParameterString(self.SEGMENTIZE,
'Maximum distance between 2 nodes (densification)',
'',
optional=True))
self.addParameter(
ParameterExtent(
self.SPAT,
'Select features by extent (defined in input layer CRS)'))
self.addParameter(
ParameterBoolean(
self.CLIP,
'Clip the input layer using the above (rectangle) extent',
False))
self.addParameter(
ParameterString(
self.WHERE,
'Select features using a SQL "WHERE" statement (Ex: column="value")',
'',
optional=True))
self.addParameter(
ParameterString(
self.GT,
'Group "n" features per transaction (Default: 20000)',
'',
optional=True))
self.addParameter(
ParameterBoolean(self.OVERWRITE, 'Overwrite existing table?',
True))
self.addParameter(
ParameterBoolean(self.APPEND, 'Append to existing table?', False))
self.addParameter(
ParameterBoolean(self.ADDFIELDS,
'Append and add new fields to existing table?',
False))
self.addParameter(
ParameterBoolean(self.LAUNDER,
'Do not launder columns/table name/s?', False))
self.addParameter(
ParameterBoolean(self.INDEX, 'Do not create Spatial Index?',
False))
self.addParameter(
ParameterBoolean(
self.SKIPFAILURES,
'Continue after a failure, skipping the failed feature',
False))
self.addParameter(
ParameterString(self.OPTIONS,
'Additional creation options',
'',
optional=True))
