def defineCharacteristics(self):
self.addParameter(ParameterRaster(self.INPUT, self.tr('Input layer')))
self.addParameter(
ParameterNumber(self.BINS, self.tr('Number of bins'), 2, None, 10))
self.addOutput(OutputHTML(self.PLOT, self.tr('Histogram')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Retile')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Miscellaneous')
# 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.isAdvanced = True
self.addParameter(param)
self.addOutput(
OutputDirectory(
self.TARGETDIR,
self.tr('The directory where the tile result is created')))
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, self.i18n_name = self.trAlgorithm(
'Clip raster by mask layer')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Extraction')
self.addParameter(
ParameterRaster(self.INPUT, self.tr('Input layer'), False))
self.addParameter(
ParameterVector(self.MASK, self.tr('Mask layer'),
[ParameterVector.VECTOR_TYPE_POLYGON]))
self.addParameter(
ParameterString(
self.NO_DATA,
self.
tr("Nodata value, leave blank to take the nodata value from input"
),
'',
optional=True))
self.addParameter(
ParameterBoolean(self.ALPHA_BAND,
self.tr('Create and output alpha band'), False))
self.addParameter(
ParameterBoolean(
self.CROP_TO_CUTLINE,
self.
tr('Crop the extent of the target dataset to the extent of the cutline'
), False))
self.addParameter(
ParameterBoolean(self.KEEP_RESOLUTION,
self.tr('Keep resolution of output raster'),
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('Clipped (mask)')))
def testSetValueOnlyValidNumbers(self):
parameter = ParameterNumber('myName', 'myDescription')
self.assertFalse(parameter.setValue('not a number'))
self.assertEqual(parameter.value, None)
def addParametersCoresGUI(self):
self.addParameter(ParameterNumber(LAStoolsAlgorithm.CORES, self.tr("number of cores"), 1, 32, 4))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('lascanopyPro')
self.group, self.i18n_group = self.trAlgorithm('LAStools Production')
self.addParametersPointInputFolderGUI()
self.addParametersPointInputMergedGUI()
self.addParameter(
ParameterNumber(lascanopyPro.PLOT_SIZE,
self.tr("square plot size"), 0, None, 20))
self.addParameter(
ParameterNumber(lascanopyPro.HEIGHT_CUTOFF,
self.tr("height cutoff / breast height"), 0, None,
1.37))
self.addParameter(
ParameterSelection(lascanopyPro.PRODUCT1, self.tr("create"),
lascanopyPro.PRODUCTS, 0))
self.addParameter(
ParameterSelection(lascanopyPro.PRODUCT2, self.tr("create"),
lascanopyPro.PRODUCTS, 0))
self.addParameter(
ParameterSelection(lascanopyPro.PRODUCT3, self.tr("create"),
lascanopyPro.PRODUCTS, 0))
self.addParameter(
ParameterSelection(lascanopyPro.PRODUCT4, self.tr("create"),
lascanopyPro.PRODUCTS, 0))
self.addParameter(
ParameterSelection(lascanopyPro.PRODUCT5, self.tr("create"),
lascanopyPro.PRODUCTS, 0))
self.addParameter(
ParameterSelection(lascanopyPro.PRODUCT6, self.tr("create"),
lascanopyPro.PRODUCTS, 0))
self.addParameter(
ParameterSelection(lascanopyPro.PRODUCT7, self.tr("create"),
lascanopyPro.PRODUCTS, 0))
self.addParameter(
ParameterSelection(lascanopyPro.PRODUCT8, self.tr("create"),
lascanopyPro.PRODUCTS, 0))
self.addParameter(
ParameterSelection(lascanopyPro.PRODUCT9, self.tr("create"),
lascanopyPro.PRODUCTS, 0))
self.addParameter(
ParameterString(lascanopyPro.COUNTS,
self.tr("count rasters (e.g. 2.0 5.0 10.0 20.0)"),
""))
self.addParameter(
ParameterString(
lascanopyPro.DENSITIES,
self.tr("density rasters (e.g. 2.0 5.0 10.0 20.0)"), ""))
self.addParameter(
ParameterBoolean(
lascanopyPro.USE_TILE_BB,
self.tr("use tile bounding box (after tiling with buffer)"),
False))
self.addParameter(
ParameterBoolean(lascanopyPro.FILES_ARE_PLOTS,
self.tr("input file is single plot"), False))
self.addParametersOutputDirectoryGUI()
self.addParametersOutputAppendixGUI()
self.addParametersRasterOutputFormatGUI()
self.addParametersRasterOutputGUI()
self.addParametersAdditionalGUI()
self.addParametersCoresGUI()
self.addParametersVerboseGUI()
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().startswith('file'):
param = ParameterFile(name, desc, False)
ext = token.strip()[len('file') + 1:]
if ext:
param.ext = ext
elif token.lower().strip().startswith('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().startswith('crs'):
default = token.strip()[len('crs') + 1:]
if default:
param = ParameterCrs(name, desc, default)
else:
param = ParameterCrs(name, desc)
return param
def __init__(self):
super().__init__()
self.addParameter(
ParameterVector(self.INPUT_LAYER, self.tr('Point layer'),
[dataobjects.TYPE_VECTOR_POINT]))
self.addParameter(
ParameterNumber(self.RADIUS, self.tr('Radius (layer units)'), 0.0,
9999999999, 100.0))
radius_field_param = ParameterTableField(
self.RADIUS_FIELD,
self.tr('Radius from field'),
self.INPUT_LAYER,
optional=True,
datatype=ParameterTableField.DATA_TYPE_NUMBER)
radius_field_param.setFlags(
radius_field_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(radius_field_param)
class ParameterHeatmapPixelSize(ParameterNumber):
def __init__(self,
name='',
description='',
parent_layer=None,
radius_param=None,
radius_field_param=None,
minValue=None,
maxValue=None,
default=None,
optional=False,
metadata={}):
ParameterNumber.__init__(self, name, description, minValue,
maxValue, default, optional, metadata)
self.parent_layer = parent_layer
self.radius_param = radius_param
self.radius_field_param = radius_field_param
self.addParameter(
ParameterHeatmapPixelSize(
self.PIXEL_SIZE,
self.tr('Output raster size'),
parent_layer=self.INPUT_LAYER,
radius_param=self.RADIUS,
radius_field_param=self.RADIUS_FIELD,
minValue=0.0,
maxValue=9999999999,
default=0.1,
metadata={'widget_wrapper': HeatmapPixelSizeWidgetWrapper}))
weight_field_param = ParameterTableField(
self.WEIGHT_FIELD,
self.tr('Weight from field'),
self.INPUT_LAYER,
optional=True,
datatype=ParameterTableField.DATA_TYPE_NUMBER)
weight_field_param.setFlags(
weight_field_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(weight_field_param)
kernel_shape_param = ParameterSelection(self.KERNEL,
self.tr('Kernel shape'),
self.KERNELS)
kernel_shape_param.setFlags(
kernel_shape_param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(kernel_shape_param)
decay_ratio = ParameterNumber(
self.DECAY, self.tr('Decay ratio (Triangular kernels only)'),
-100.0, 100.0, 0.0)
decay_ratio.setFlags(decay_ratio.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(decay_ratio)
output_scaling = ParameterSelection(self.OUTPUT_VALUE,
self.tr('Output value scaling'),
self.OUTPUT_VALUES)
output_scaling.setFlags(
output_scaling.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(output_scaling)
self.addOutput(OutputRaster(self.OUTPUT_LAYER, self.tr('Heatmap')))
def initAlgorithm(self, config=None):
self.addParameter(ParameterRaster(self.INPUT, self.tr('Input layer')))
self.addParameter(
ParameterNumber(self.BINS, self.tr('Number of bins'), 2, None, 10))
self.addOutput(OutputHTML(self.PLOT, self.tr('Histogram')))
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 defineCharacteristics(self):
# WPS Data Inputs
for key, value in self.process.getDataInputs().iteritems():
optionalBoolean = value.getMinOccurs() != 1
required = u' (※)' if value.getMinOccurs() == 1 else u''
paramIdentifier = value.getIdentifier()
paramTitle = value.getTitle() + required
if isinstance(value, WPSLiteralData):
# string, double, int, boolean
defaultValue = value.getDefaultValue()
param = None
if value.getType() == LiteralType.BOOLEAN:
param = ParameterBoolean(paramIdentifier, paramTitle)
elif value.getType() == LiteralType.FLOAT:
param = ParameterNumber(paramIdentifier, paramTitle)
param.isInteger = False
elif value.getType() == LiteralType.INT:
param = ParameterNumber(paramIdentifier, paramTitle)
param.isInteger = True
else:
if value.getAllowedValues():
param = ParameterSelection2(paramIdentifier,
paramTitle,
value.getAllowedValues())
else:
param = ParameterString(paramIdentifier,
paramTitle,
optional=optionalBoolean)
if defaultValue:
param.setValue(defaultValue)
self.addParameter(param)
elif isinstance(value, WPSComplexData):
# geometry, featurecollection, gridcoverage, xml
param = None
if value.getType() == ComplexType.VECTOR:
# select vector layer
param = ParameterVector(paramIdentifier,
paramTitle,
optional=optionalBoolean)
elif value.getType() == ComplexType.RASTER:
# select raster layer
param = ParameterRaster(paramIdentifier,
paramTitle,
optional=optionalBoolean)
elif value.getType() == ComplexType.GEOMETRY:
# use WKT format
param = ParameterString(paramIdentifier,
paramTitle,
multiline=True,
optional=optionalBoolean)
elif value.getType() == ComplexType.FILTER:
# use ECQL expression
param = ParameterString(paramIdentifier,
paramTitle,
multiline=True,
optional=optionalBoolean)
elif value.getType() == ComplexType.XML:
# use XML Expression
param = ParameterString(paramIdentifier,
paramTitle,
multiline=True,
optional=optionalBoolean)
self.addParameter(param)
elif isinstance(value, WPSBoundingBoxData):
# default = current map layer's minimum extent & crs
param = ParameterExtent(paramIdentifier, paramTitle)
# The value is a string in the form "xmin, xmax, ymin, ymax"
extent = iface.mapCanvas().extent()
default_extent = str(extent.xMinimum()) + ',' + str(extent.xMaximum()) + ',' \
+ str(extent.yMinimum()) + ',' + str(extent.yMaximum())
param.setValue(default_extent)
self.addParameter(param)
# WPS Process Outputs
# OutputString --> OutputHTML
for key, value in self.process.getProcessOutputs().iteritems():
if isinstance(value, WPSLiteralOutput):
# string, float, int, boolean
self.addOutput(
OutputHTML(value.getIdentifier(), value.getTitle()))
elif isinstance(value, WPSComplexOutput):
# geometry, featurecollection, gridcoverage, xml
if value.getType() == ComplexType.VECTOR:
self.addOutput(
OutputVector(value.getIdentifier(), value.getTitle()))
elif value.getType() == ComplexType.RASTER:
self.addOutput(
OutputRaster(value.getIdentifier(), value.getTitle()))
elif value.getType() == ComplexType.XML:
self.addOutput(
OutputHTML(value.getIdentifier(), value.getTitle()))
elif value.getType() == ComplexType.FILTER:
self.addOutput(
OutputHTML(value.getIdentifier(), value.getTitle()))
elif value.getType() == ComplexType.GEOMETRY:
# return WKT and save shapefile
self.addOutput(
OutputVector(value.getIdentifier(), value.getTitle()))
def defineCharacteristics(self):
"""Algorithme variable and parameters parameters"""
CholeAlgorithm.defineCharacteristics(self)
# The name/group that the user will see in the toolbox
self.group = 'landscape metrics'
self.i18n_group = self.tr('landscape metrics')
self.name = 'selected'
self.i18n_name = self.tr('selected')
# === INPUT PARAMETERS ===
self.addParameter(ParameterRaster(
name=self.INPUT_LAYER_ASC,
description=self.tr('Input layer asc')))
self.addParameter(ParameterSelection(
name=self.WINDOW_SHAPE,
description=self.tr('Window shape'),
options = ';'.join(self.types_of_shape)))
self.addParameter(ParameterFile(
name=self.FRICTION_FILE,
description=self.tr('Friction file')))
self.addParameter(ParameterNumber(
name=self.WINDOW_SIZES,
description=self.tr('Windows sizes (pixels)'),
default=3))
self.addParameter(ParameterSelection(
name=self.PIXELS_POINTS_SELECT,
description=self.tr('Pixels/points selection'),
options = ';'.join(self.types_of_pixel_point_select)))
self.addParameter(ParameterFile(
name=self.PIXELS_FILE,
description=self.tr('Pixels file')))
self.addParameter(ParameterFile(
name=self.POINTS_FILE,
description=self.tr('Points file')))
self.addParameter(ParameterNumber(
name=self.MAXIMUM_RATE_MISSING_VALUES,
description=self.tr('Maximum rate of mising values'),
minValue=0,
maxValue=100,
default=100))
self.addParameter(ParameterString(
name=self.METRICS,
description=self.tr('Select metrics')))
# === OUTPUT PARAMETERS ===
self.addOutput(OutputFile(
name=self.SAVE_PROPERTIES,
description=self.tr('Properties file'),
ext='properties'))
self.addOutput(OutputTable(
name=self.OUTPUT_CSV,
description=self.tr('Output csv (*.csv)')))
self.addOutput(ASCOutputRaster(
name=self.OUTPUT_ASC,
description=self.tr('Output ascii (*.asc)')))
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 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 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.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.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'), QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'), QgsVectorLayerDirector.DirectionForward),
(self.tr('Both directions'), QgsVectorLayerDirector.DirectionForward)])
self.STRATEGIES = [self.tr('Shortest'),
self.tr('Fastest')
]
self.addParameter(ParameterVector(self.INPUT_VECTOR,
self.tr('Vector layer representing network'),
[dataobjects.TYPE_VECTOR_LINE]))
self.addParameter(ParameterVector(self.START_POINTS,
self.tr('Vector layer with start points'),
[dataobjects.TYPE_VECTOR_POINT]))
self.addParameter(ParameterSelection(self.STRATEGY,
self.tr('Path type to calculate'),
self.STRATEGIES,
default=0))
self.addParameter(ParameterNumber(self.TRAVEL_COST,
self.tr('Travel cost (distance for "Shortest", time for "Fastest")'),
0.0, 99999999.999999, 0.0))
params = []
params.append(ParameterTableField(self.DIRECTION_FIELD,
self.tr('Direction field'),
self.INPUT_VECTOR,
optional=True))
params.append(ParameterString(self.VALUE_FORWARD,
self.tr('Value for forward direction'),
'',
optional=True))
params.append(ParameterString(self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
'',
optional=True))
params.append(ParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
'',
optional=True))
params.append(ParameterSelection(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
default=2))
params.append(ParameterTableField(self.SPEED_FIELD,
self.tr('Speed field'),
self.INPUT_VECTOR,
optional=True))
params.append(ParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'),
0.0, 99999999.999999, 5.0))
params.append(ParameterNumber(self.TOLERANCE,
self.tr('Topology tolerance'),
0.0, 99999999.999999, 0.0))
for p in params:
p.isAdvanced = True
self.addParameter(p)
self.addOutput(OutputVector(self.OUTPUT_POINTS,
self.tr('Service area (boundary nodes)'),
datatype=[dataobjects.TYPE_VECTOR_POINT]))
self.addOutput(OutputVector(self.OUTPUT_POLYGON,
self.tr('Service area (convex hull)'),
datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def __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 addParametersStepGUI(self):
self.addParameter(ParameterNumber(LAStoolsAlgorithm.STEP, self.tr("step size / pixel size"), 0, None, 1.0))
def __init__(self):
super().__init__()
self.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'), QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'), QgsVectorLayerDirector.DirectionForward),
(self.tr('Both directions'), QgsVectorLayerDirector.DirectionForward)])
self.STRATEGIES = [self.tr('Shortest'),
self.tr('Fastest')
]
self.addParameter(ParameterVector(self.INPUT_VECTOR,
self.tr('Vector layer representing network'),
[dataobjects.TYPE_VECTOR_LINE]))
self.addParameter(ParameterPoint(self.START_POINT,
self.tr('Start point')))
self.addParameter(ParameterPoint(self.END_POINT,
self.tr('End point')))
self.addParameter(ParameterSelection(self.STRATEGY,
self.tr('Path type to calculate'),
self.STRATEGIES,
default=0))
params = []
params.append(ParameterTableField(self.DIRECTION_FIELD,
self.tr('Direction field'),
self.INPUT_VECTOR,
optional=True))
params.append(ParameterString(self.VALUE_FORWARD,
self.tr('Value for forward direction'),
'',
optional=True))
params.append(ParameterString(self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
'',
optional=True))
params.append(ParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
'',
optional=True))
params.append(ParameterSelection(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
default=2))
params.append(ParameterTableField(self.SPEED_FIELD,
self.tr('Speed field'),
self.INPUT_VECTOR,
optional=True))
params.append(ParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'),
0.0, 99999999.999999, 5.0))
params.append(ParameterNumber(self.TOLERANCE,
self.tr('Topology tolerance'),
0.0, 99999999.999999, 0.0))
for p in params:
p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(p)
self.addOutput(OutputNumber(self.TRAVEL_COST,
self.tr('Travel cost')))
self.addOutput(OutputVector(self.OUTPUT_LAYER,
self.tr('Shortest path'),
datatype=[dataobjects.TYPE_VECTOR_LINE]))
def defineCharacteristics(self):
class ParameterReliefColors(Parameter):
default_metadata = {
'widget_wrapper':
'processing.algs.qgis.ui.ReliefColorsWidget.ReliefColorsWidgetWrapper'
}
def __init__(self,
name='',
description='',
parent=None,
optional=True):
Parameter.__init__(self, name, description, None, optional)
self.parent = parent
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 = ParameterReliefColors.colorsToString(value)
return True
def getValueAsCommandLineParameter(self):
return '"{}"'.format(self.value)
def getAsScriptCode(self):
param_type = ''
param_type += 'relief colors '
return '##' + self.name + '=' + param_type
@classmethod
def fromScriptCode(self, line):
isOptional, name, definition = _splitParameterOptions(line)
descName = _createDescriptiveName(name)
parent = definition.lower().strip()[len('relief colors') + 1:]
return ParameterReliefColors(name, descName, parent)
@staticmethod
def colorsToString(colors):
s = ''
for c in colors:
s += '{:f}, {:f}, {:d}, {:d}, {:d};'.format(
c[0], c[1], c[2], c[3], c[4])
return s[:-1]
self.addParameter(
ParameterRaster(self.INPUT_LAYER, self.tr('Elevation layer')))
self.addParameter(
ParameterNumber(self.Z_FACTOR, self.tr('Z factor'), 1.0, 999999.99,
1.0))
self.addParameter(
ParameterBoolean(self.AUTO_COLORS,
self.tr('Generate relief classes automatically'),
False))
self.addParameter(
ParameterReliefColors(self.COLORS, self.tr('Relief colors'),
self.INPUT_LAYER, True))
self.addOutput(OutputRaster(self.OUTPUT_LAYER, self.tr('Relief')))
self.addOutput(
OutputTable(self.FREQUENCY_DISTRIBUTION,
self.tr('Frequency distribution')))
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 testSetValue(self):
parameter = ParameterNumber('myName', 'myDescription')
self.assertTrue(parameter.setValue(5))
self.assertEqual(parameter.value, 5)
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.COMPOUNDNAME1, self.tr(u'Stof til x-aksen'),
u'Sulfat'))
self.addParameter(
ParameterString(self.COMPOUNDNAME2, self.tr(u'Stof til y-aksen'),
u'Nitrat'))
self.addParameter(
ParameterNumber(
self.XAXELINE,
self.tr(u'Marker værdi til x-aksen (vertikal linje)'),
0,
None,
'31',
optional=True))
self.addParameter(
ParameterNumber(
self.YAXELINE,
self.tr(u'Marker værdi til y-aksen (horisontal linje)'),
0,
None,
'1',
optional=True))
self.addParameter(
ParameterBoolean(self.SHOWANNOTATIONS,
self.tr(u'Label scatter-punkter med boreholeno'),
False,
optional=False))
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))
def testMaxValue(self):
parameter = ParameterNumber('myName', 'myDescription', maxValue=10)
self.assertFalse(parameter.setValue(11))
self.assertEqual(parameter.value, None)
self.assertTrue(parameter.setValue(10))
self.assertEqual(parameter.value, 10)
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')))
def defineCharacteristics(self):
self.DIRECTIONS = OrderedDict([
(self.tr('Forward direction'),
QgsVectorLayerDirector.DirectionForward),
(self.tr('Backward direction'),
QgsVectorLayerDirector.DirectionForward),
(self.tr('Both directions'),
QgsVectorLayerDirector.DirectionForward)
])
self.STRATEGIES = [self.tr('Shortest'), self.tr('Fastest')]
self.name, self.i18n_name = self.trAlgorithm(
'Shortest path (layer to point)')
self.group, self.i18n_group = self.trAlgorithm('Network analysis')
self.addParameter(
ParameterVector(self.INPUT_VECTOR,
self.tr('Vector layer representing network'),
[dataobjects.TYPE_VECTOR_LINE]))
self.addParameter(
ParameterVector(self.START_POINTS,
self.tr('Vector layer with start points'),
[dataobjects.TYPE_VECTOR_POINT]))
self.addParameter(ParameterPoint(self.END_POINT, self.tr('End point')))
self.addParameter(
ParameterSelection(self.STRATEGY,
self.tr('Path type to calculate'),
self.STRATEGIES,
default=0))
params = []
params.append(
ParameterTableField(self.DIRECTION_FIELD,
self.tr('Direction field'),
self.INPUT_VECTOR,
optional=True))
params.append(
ParameterString(self.VALUE_FORWARD,
self.tr('Value for forward direction'),
'',
optional=True))
params.append(
ParameterString(self.VALUE_BACKWARD,
self.tr('Value for backward direction'),
'',
optional=True))
params.append(
ParameterString(self.VALUE_BOTH,
self.tr('Value for both directions'),
'',
optional=True))
params.append(
ParameterSelection(self.DEFAULT_DIRECTION,
self.tr('Default direction'),
list(self.DIRECTIONS.keys()),
default=2))
params.append(
ParameterTableField(self.SPEED_FIELD,
self.tr('Speed field'),
self.INPUT_VECTOR,
optional=True))
params.append(
ParameterNumber(self.DEFAULT_SPEED,
self.tr('Default speed (km/h)'), 0.0,
99999999.999999, 5.0))
params.append(
ParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), 0.0,
99999999.999999, 0.0))
for p in params:
p.isAdvanced = True
self.addParameter(p)
self.addOutput(
OutputVector(self.OUTPUT_LAYER,
self.tr('Shortest path'),
datatype=[dataobjects.TYPE_VECTOR_LINE]))
def defineCharacteristics(self):
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.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(
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 initAlgorithm(self, config=None):
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(
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 defineCharacteristics(self):
"""Algorithme variable and parameters parameters"""
CholeAlgorithm.defineCharacteristics(self)
# The name/group that the user will see in the toolbox
self.group = 'landscape metrics'
self.i18n_group = self.tr('landscape metrics')
self.name = 'sliding'
self.i18n_name = self.tr('sliding')
# === INPUT PARAMETERS ===
self.addParameter(ParameterRaster(
name=self.INPUT_LAYER_ASC,
description=self.tr('Input layer asc')))
self.addParameter(ParameterSelection(
name=self.WINDOW_SHAPE,
description=self.tr('Window shape'),
options = ';'.join(self.types_of_shape)))
self.addParameter(ParameterFile(
name=self.FRICTION_FILE,
description=self.tr('Friction file')))
self.addParameter(ParameterNumber(
name=self.WINDOW_SIZES,
description=self.tr('Window size (pixels)'),
default=3))
self.addParameter(ParameterNumber(
name=self.DELTA_DISPLACEMENT,
description=self.tr('Delta od displacement (pixels)'),
default=1))
self.addParameter(ParameterBoolean(
name=self.INTERPOLATE_VALUES_BOOL,
description=self.tr('Interpolate Values'),
default=False))
self.addParameter(ParameterString(
name=self.FILTER,
description=self.tr('Filters - Analyse only (optional)'),
default='',
optional=True))
self.addParameter(ParameterString(
name=self.UNFILTER,
default='',
description=self.tr('Filters - Do not analyse (optional)'),
optional=True))
self.addParameter(ParameterNumber(
name=self.MAXIMUM_RATE_MISSING_VALUES,
description=self.tr('Maximum rate of mising values'),
minValue=0,
maxValue=100,
default=100))
self.addParameter(ParameterString(
name=self.METRICS,
description=self.tr('Select metrics')))
# === OUTPUT PARAMETERS ===
self.addOutput(OutputFile(
name=self.SAVE_PROPERTIES,
description=self.tr('Properties file'),
ext='properties'))
self.addOutput(OutputTable(
name=self.OUTPUT_CSV,
description=self.tr('Output csv (*.csv)')))
self.addOutput(ASCOutputRaster(
name=self.OUTPUT_ASC,
description=self.tr('Output ascii (*.asc)')))
