def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('lasdiff')
self.group, self.i18n_group = self.trAlgorithm('LAStools')
self.addParametersVerboseGUI()
self.addParametersPointInputGUI()
self.addParameter(
ParameterFile(lasdiff.OTHER_POINT_FILE,
self.tr("other input LAS/LAZ file"), False, False))
self.addParameter(
ParameterSelection(
lasdiff.SHUTUP,
self.tr("stop reporting difference after this many points"),
lasdiff.SHUTUP_AFTER, 0))
self.addParameter(
ParameterBoolean(
lasdiff.CREATE_DIFFERENCE_FILE,
self.
tr("create elevation difference file (if points are in the same order)"
), False))
self.addParametersPointOutputGUI()
self.addParametersAdditionalGUI()
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('ASCII to DTM')
self.group, self.i18n_group = self.trAlgorithm('Conversion')
self.addParameter(
ParameterFile(self.INPUT, self.tr('Input ESRI ASCII layer')))
self.addParameter(
ParameterSelection(self.XYUNITS, self.tr('XY Units'), self.UNITS))
self.addParameter(
ParameterSelection(self.ZUNITS, self.tr('Z Units'), self.UNITS))
self.addParameter(
ParameterSelection(self.COORDSYS, self.tr('Coordinate system'),
['unknown', 'UTM', 'state plane']))
self.addParameter(
ParameterNumber(
self.ZONE, self.tr("Coordinate system zone ('0' for unknown)"),
0, None, 0))
self.addOutput(
OutputFile(self.OUTPUT, self.tr('Output surface'), 'dtm'))
self.addAdvancedModifiers()
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Tin Surface Create')
self.group, self.i18n_group = self.trAlgorithm('Surface')
self.addParameter(ParameterFile(
self.INPUT, self.tr('Input LAS layer')))
self.addParameter(ParameterNumber(self.CELLSIZE,
self.tr('Cellsize'), 0, None, 10.0))
self.addParameter(ParameterSelection(self.XYUNITS,
self.tr('XY Units'), self.UNITS))
self.addParameter(ParameterSelection(self.ZUNITS,
self.tr('Z Units'), self.UNITS))
self.addOutput(OutputFile(self.OUTPUT,
self.tr('.dtm output surface'), 'dtm'))
class_var = ParameterString(self.CLASS,
self.tr('Class'), '', False, True)
class_var.isAdvanced = True
self.addParameter(class_var)
return_sel = ParameterString(self.RETURN,
self.tr('Select specific return'), '', False, True)
return_sel.isAdvanced = True
self.addParameter(return_sel)
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('laspublishPro')
self.group, self.i18n_group = self.trAlgorithm('LAStools Production')
self.addParametersVerboseGUI()
self.addParametersPointInputFolderGUI()
self.addParameter(
ParameterSelection(laspublishPro.MODE, self.tr("type of portal"),
laspublishPro.MODES, 1))
self.addParameter(
ParameterBoolean(laspublishPro.USE_EDL,
self.tr("use Eye Dome Lighting (EDL)"), True))
self.addParameter(
ParameterBoolean(laspublishPro.SHOW_SKYBOX, self.tr("show Skybox"),
True))
self.addParameter(
ParameterSelection(laspublishPro.MATERIAL,
self.tr("default material colors on start-up"),
laspublishPro.MATERIALS, 0))
self.addParameter(
ParameterFile(laspublishPro.PORTAL_DIRECTORY,
self.tr("portal output directory"), True, False))
self.addParameter(
ParameterSelection(
laspublishPro.COPY_OR_MOVE,
self.
tr("copy or move source LiDAR files into portal (only for download portals)"
), laspublishPro.COPY_OR_MOVE_OPTIONS, 2))
self.addParameter(
ParameterBoolean(laspublishPro.OVERWRITE_EXISTING,
self.tr("overwrite existing files"), True))
self.addParameter(
ParameterString(laspublishPro.PORTAL_HTML_PAGE,
self.tr("portal HTML page"), "portal.html", False))
self.addParameter(
ParameterString(laspublishPro.PORTAL_TITLE,
self.tr("portal title"), "My LiDAR Portal"))
self.addParameter(
ParameterString(laspublishPro.PORTAL_DESCRIPTION,
self.tr("portal description")))
self.addParametersAdditionalGUI()
def defineCharacteristics(self):
self.name = "Create raster dataset from LAS(Z) data point cloud(s)"
self.group = "[pktools] LiDAR"
self.addParameter(
ParameterFile(self.INPUT, "Input LAS(Z) data set(s)", False,
False))
self.addParameter(
ParameterSelection(self.ATTRIBUTE,
"name of the point attribute to select",
self.ATTRIBUTE_OPTIONS, 0))
self.addParameter(
ParameterSelection(self.COMPOSITE,
"composite for multiple points in cell",
self.COMPOSITE_OPTIONS, 0))
self.addParameter(
ParameterSelection(self.FILTER, "filter las points",
self.FILTER_OPTIONS, 0))
self.addOutput(OutputRaster(self.OUTPUT, "Output raster data set"))
self.addParameter(
ParameterSelection(self.RTYPE, 'Output raster type', self.TYPE, 0))
self.addParameter(
ParameterNumber(self.PERCENTILE,
"Percentile value used for rule percentile", 0.0,
100.0, 95))
self.addParameter(
ParameterNumber(self.DX, "Output resolution in x", 0.0, None, 1.0))
self.addParameter(
ParameterNumber(self.DY, "Output resolution in y", 0.0, None, 1.0))
# self.addParameter(ParameterExtent(self.PROJWIN,
# 'Georeferenced boundingbox'))
self.addParameter(
ParameterNumber(self.NODATA, "nodata value to put in image", 0,
None, 0))
self.addParameter(
ParameterString(self.EXTRA,
'Additional parameters',
'-of GTiff',
optional=True))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Catalog')
self.group, self.i18n_group = self.trAlgorithm('Points')
self.addParameter(ParameterFile(
self.INPUT, self.tr('Input LAS layer'),
optional=False))
self.addOutput(OutputFile(self.OUTPUT, self.tr('Output files')))
density = ParameterString(
self.DENSITY,
self.tr('Density - area, min, max (set blank if not used)'),
'', False, True)
density.isAdvanced = True
self.addParameter(density)
firest_density = ParameterString(
self.FIRSTDENSITY,
self.tr('First Density - area, min, max (set blank if not used)'),
'', False, True)
firest_density.isAdvanced = True
self.addParameter(firest_density)
intensity = ParameterString(
self.INTENSITY,
self.tr('Intensity - area, min, max (set blank if not used)'),
'', False, True)
intensity.isAdvanced = True
self.addParameter(intensity)
self.addParameter(ParameterBoolean(self.INDEX,
self.tr('Create LIDAR data file indexes'), False))
self.addParameter(ParameterBoolean(self.IMAGE,
self.tr('Create image files showing the coverage area for each LIDAR file'), False))
self.addParameter(ParameterBoolean(self.DRAWTILES,
self.tr('Draw data file extents and names on the intensity image'), False))
self.addParameter(ParameterBoolean(self.COVERAGE,
self.tr('Create one image that shows the nominal coverage area'), False))
self.addParameter(ParameterBoolean(self.CRETURNS,
self.tr('Adds count return columns in the CSV and HTML output'), False))
advanced_modifiers = ParameterString(
self.ADVANCED_MODIFIERS,
self.tr('Additional modifiers'), '', False, True)
advanced_modifiers.isAdvanced = True
self.addParameter(advanced_modifiers)
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('txt2las')
self.group, self.i18n_group = self.trAlgorithm('LAStools')
self.addParametersVerboseGUI()
self.addParameter(ParameterFile(txt2las.INPUT,
self.tr("Input ASCII file")))
self.addParameter(ParameterString(txt2las.PARSE,
self.tr("parse lines as", "xyz")))
self.addParameter(ParameterNumber(txt2las.SKIP,
self.tr("skip the first n lines"), 0, None, 0))
self.addParameter(ParameterNumber(txt2las.SCALE_FACTOR_XY,
self.tr("resolution of x and y coordinate"), 0, None, 0.01))
self.addParameter(ParameterNumber(txt2las.SCALE_FACTOR_Z,
self.tr("resolution of z coordinate"), 0, None, 0.01))
self.addParameter(ParameterSelection(txt2las.PROJECTION,
self.tr("projection"), txt2las.PROJECTIONS, 0))
self.addParameter(ParameterSelection(txt2las.UTM,
self.tr("utm zone"), txt2las.UTM_ZONES, 0))
self.addParameter(ParameterSelection(txt2las.SP,
self.tr("state plane code"), txt2las.STATE_PLANES, 0))
self.addParametersPointOutputGUI()
self.addParametersAdditionalGUI()
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Merge ASCII files')
self.group, self.i18n_group = self.trAlgorithm('Points')
self.addParameter(
ParameterFile(self.INPUT,
self.tr('Input ASCII files'),
optional=False))
self.addOutput(OutputFile(self.OUTPUT, self.tr('Output file'), 'asc'))
overl = ParameterString(
self.OVERL, self.tr('Specify how overlap areas should be treated'),
'', False, True)
overl.isAdvanced = True
self.addParameter(overl)
comp = ParameterBoolean(
self.COMP,
self.tr(
'Compare values in cells common to two or more input files'),
False)
comp.isAdvanced = True
self.addParameter(comp)
self.addAdvancedModifiers()
def defineCharacteristics(self):
self.name = 'Peuker Douglas (multifile)'
self.cmdName = 'peukerdouglas'
self.group = 'Stream Network Analysis tools'
self.addParameter(
ParameterFile(self.ELEVATION_GRID, self.tr('Elevation Grid'), True,
False))
self.addParameter(
ParameterNumber(self.CENTER_WEIGHT,
self.tr('Center Smoothing Weight'), 0, None, 0.4))
self.addParameter(
ParameterNumber(self.SIDE_WEIGHT, self.tr('Side Smoothing Weight'),
0, None, 0.1))
self.addParameter(
ParameterNumber(self.DIAGONAL_WEIGHT,
self.tr('Diagonal Smoothing Weight'), 0, None,
0.05))
self.addOutput(
OutputDirectory(self.STREAM_SOURCE_GRID,
self.tr('Stream Source Grid')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Topographic Metrics')
self.group, self.i18n_group = self.trAlgorithm('Points')
self.addParameter(
ParameterFile(self.INPUT,
self.tr('Input PLANS DTM surface files'),
optional=False))
self.addOutput(OutputFile(self.OUTPUT, self.tr('Output file')))
self.addParameter(
ParameterNumber(
self.CELLSIZE,
self.tr('Size of the cell used to report topographic metrics'),
0, None, 5.0))
self.addParameter(
ParameterNumber(
self.POINTSP,
self.
tr('Spacing for the 3 by 3 array of points used to compute the metrics'
), 0, None, 0.0))
self.addParameter(
ParameterNumber(self.LATITUDE, self.tr('Latitude'), 2, None, 45.0))
self.addParameter(
ParameterNumber(self.TPI, self.tr('TPI window size'), 0, None,
5.0))
square = ParameterBoolean(self.SQUARE,
self.tr('Use a square window for TPI'),
False)
square.isAdvanced = True
self.addParameter(square)
disk = ParameterBoolean(
self.DISK,
self.tr('Do not load ground surface models into memory'), False)
disk.isAdvanced = True
self.addParameter(disk)
self.addAdvancedModifiers()
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 = 'Classify model'
# The branch of the toolbox under which the algorithm will appear
self.group = 'Learning and classification'
self.addParameter(
ParameterRaster(self.INPUT_RASTER, self.tr('Input raster'), False))
self.addParameter(
ParameterRaster(self.INPUT_MASK, self.tr('Input mask'), True))
self.addParameter(
ParameterFile(self.INPUT_MODEL, self.tr('Input model'), False))
self.addOutput(
OutputRaster(self.OUTPUT_RASTER,
self.tr('Output raster (classification)')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Cloud Metrics')
self.group, self.i18n_group = self.trAlgorithm('Points')
self.addParameter(ParameterFile(self.INPUT,
self.tr('Input LAS layer')))
self.addOutput(
OutputFile(self.OUTPUT,
self.tr('Output file with tabular metric information'),
'csv'))
above = ParameterString(self.ABOVE, self.tr('Above'), '', False)
above.isAdvanced = True
self.addParameter(above)
firstImpulse = ParameterBoolean(self.FIRSTIMPULSE,
self.tr('First Impulse'), False)
firstImpulse.isAdvanced = True
self.addParameter(firstImpulse)
firstReturn = ParameterBoolean(self.FIRSTRETURN,
self.tr('First Return'), False)
firstReturn.isAdvanced = True
self.addParameter(firstReturn)
htmin = ParameterString(self.HTMIN, self.tr('Htmin'), '', False, True)
htmin.isAdvanced = True
self.addParameter(htmin)
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Return Density')
self.group, self.i18n_group = self.trAlgorithm('Surface')
self.addParameter(ParameterFile(
self.INPUT, self.tr('Input LAS layer'), optional=False))
self.addParameter(ParameterNumber(
self.CELLSIZE, self.tr('Cellsize'), 0, None, 10.0))
self.addOutput(OutputFile(
self.OUTPUT, self.tr('Output file')))
first = ParameterBoolean(
self.FIRST, self.tr('Use only first returns when computing return counts'), False)
first.isAdvanced = True
self.addParameter(first)
ascii = ParameterBoolean(
self.ASCII, self.tr('Output raster data in ASCII raster format instead of PLANS DTM format'), False)
ascii.isAdvanced = True
self.addParameter(ascii)
class_var = ParameterString(
self.CLASS, self.tr('LAS class'), '', False, True)
class_var.isAdvanced = True
self.addParameter(class_var)
self.addAdvancedModifiers()
def testModelerParametersDialogAvailableValuesOfType(self):
# test getAvailableValuesOfType from ModelerParametersDialog
m = ModelerAlgorithm()
string_param_1 = ModelerParameter(ParameterString('string', 'string desc'))
m.addParameter(string_param_1)
string_param_2 = ModelerParameter(ParameterString('string2', 'string desc'))
m.addParameter(string_param_2)
num_param = ModelerParameter(ParameterNumber('number', 'number desc'))
m.addParameter(num_param)
table_field_param = ModelerParameter(ParameterTableField('field', 'field desc'))
m.addParameter(table_field_param)
file_param = ModelerParameter(ParameterFile('file', 'file desc'))
m.addParameter(file_param)
dlg = ModelerParametersDialog(m, m)
# test single types
self.assertEqual(set(p.name for p in dlg.getAvailableValuesOfType(ParameterNumber)),
set(['number']))
self.assertEqual(set(p.name for p in dlg.getAvailableValuesOfType(ParameterTableField)),
set(['field']))
self.assertEqual(set(p.name for p in dlg.getAvailableValuesOfType(ParameterFile)),
set(['file']))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('lasduplicate')
self.group, self.i18n_group = self.trAlgorithm('LAStools')
self.addParametersVerboseGUI()
self.addParametersPointInputGUI()
self.addParameter(
ParameterBoolean(
lasduplicate.LOWEST_Z,
self.tr("keep duplicate with lowest z coordinate"), False))
self.addParameter(
ParameterBoolean(lasduplicate.UNIQUE_XYZ,
self.tr("only remove duplicates in x y and z"),
False))
self.addParameter(
ParameterBoolean(
lasduplicate.SINGLE_RETURNS,
self.tr("mark surviving duplicate as single return"), False))
self.addParameter(
ParameterFile(
lasduplicate.RECORD_REMOVED,
self.tr("record removed duplicates to LAS/LAZ file")))
self.addParametersPointOutputGUI()
self.addParametersAdditionalGUI()
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Merge PLANS DTM files')
self.group, self.i18n_group = self.trAlgorithm('Points')
self.addParameter(ParameterFile(
self.INPUT, self.tr('Input PLANS DTM files'), optional=False))
self.addOutput(OutputFile(
self.OUTPUT, self.tr('Output merged file')))
cellsize = ParameterNumber(
self.CELLSIZE, self.tr('Resample the input DTM data to the following cellsize'), 0, None, 0.0)
cellsize.isAdvanced = True
self.addParameter(cellsize)
extent = ParameterBoolean(
self.EXTENT, self.tr('Preserve the exact extent of the input models'), False)
extent.isAdvanced = True
self.addParameter(extent)
disk = ParameterBoolean(
self.DISK, self.tr('Merge the files to a disk file. USE ONLY IF DEFAULT METHOD FAILS'), False)
disk.isAdvanced = True
self.addParameter(disk)
self.addAdvancedModifiers()
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 multi'
self.i18n_name = self.tr('sliding multi')
# === 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(
ParameterString(name=self.WINDOW_SIZES,
description=self.tr('Windows sizes (pixels)')))
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(
OutputDirectory(name=self.OUTPUT_DIR,
description=self.tr('Output directory')))
self.addParameter(
ParameterBoolean(name=self.OPEN_ALL_ASC,
description=self.tr('Open all ascii'),
default=True,
optional=True))
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 processParameterLine(self, line):
param = None
out = None
line = line.replace('#', '')
if line.lower().strip().startswith('showplots'):
self.showPlots = True
self.addOutput(OutputHTML(RAlgorithm.RPLOTS, 'R Plots'))
return
if line.lower().strip().startswith('dontuserasterpackage'):
self.useRasterPackage = False
return
if line.lower().strip().startswith('passfilenames'):
self.passFileNames = True
return
tokens = line.split('=')
desc = self.createDescriptiveName(tokens[0])
if tokens[1].lower().strip() == 'group':
self.group = tokens[0]
return
if tokens[1].lower().strip().startswith('raster'):
param = ParameterRaster(tokens[0], desc, False)
elif tokens[1].lower().strip() == 'vector':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_ANY])
elif tokens[1].lower().strip() == 'vector point':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_POINT])
elif tokens[1].lower().strip() == 'vector line':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_LINE])
elif tokens[1].lower().strip() == 'vector polygon':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_POLYGON])
elif tokens[1].lower().strip() == 'table':
param = ParameterTable(tokens[0], desc, False)
elif tokens[1].lower().strip().startswith('multiple raster'):
param = ParameterMultipleInput(tokens[0], desc,
ParameterMultipleInput.TYPE_RASTER)
param.optional = False
elif tokens[1].lower().strip() == 'multiple vector':
param = ParameterMultipleInput(
tokens[0], desc, ParameterMultipleInput.TYPE_VECTOR_ANY)
param.optional = False
elif tokens[1].lower().strip().startswith('selection'):
options = tokens[1].strip()[len('selection'):].split(';')
param = ParameterSelection(tokens[0], desc, options)
elif tokens[1].lower().strip().startswith('boolean'):
default = tokens[1].strip()[len('boolean') + 1:]
param = ParameterBoolean(tokens[0], desc, default)
elif tokens[1].lower().strip().startswith('number'):
try:
default = float(tokens[1].strip()[len('number') + 1:])
param = ParameterNumber(tokens[0], desc, default=default)
except:
raise WrongScriptException(
self.tr(
'Could not load R script: %s.\n Problem with line %s' %
(self.descriptionFile, line)))
elif tokens[1].lower().strip().startswith('field'):
field = tokens[1].strip()[len('field') + 1:]
found = False
for p in self.parameters:
if p.name == field:
found = True
break
if found:
param = ParameterTableField(tokens[0], tokens[0], field)
elif tokens[1].lower().strip() == 'extent':
param = ParameterExtent(tokens[0], desc)
elif tokens[1].lower().strip() == 'point':
param = ParameterPoint(tokens[0], desc)
elif tokens[1].lower().strip() == 'file':
param = ParameterFile(tokens[0], desc, False)
elif tokens[1].lower().strip() == 'folder':
param = ParameterFile(tokens[0], desc, True)
elif tokens[1].lower().strip().startswith('string'):
default = tokens[1].strip()[len('string') + 1:]
param = ParameterString(tokens[0], desc, default)
elif tokens[1].lower().strip().startswith('longstring'):
default = tokens[1].strip()[len('longstring') + 1:]
param = ParameterString(tokens[0], desc, default, multiline=True)
elif tokens[1].lower().strip().startswith('output raster'):
out = OutputRaster()
elif tokens[1].lower().strip().startswith('output vector'):
out = OutputVector()
elif tokens[1].lower().strip().startswith('output table'):
out = OutputTable()
elif tokens[1].lower().strip().startswith('output file'):
out = OutputFile()
if param is not None:
self.addParameter(param)
elif out is not None:
out.name = tokens[0]
out.description = tokens[0]
self.addOutput(out)
else:
raise WrongScriptException(
self.tr('Could not load R script: %s.\n Problem with line %s' %
(self.descriptionFile, line)))
def defineCharacteristics(self):
self.addParameter(ParameterVector(self.INPUT, self.tr('Vector layer')))
self.addParameter(
ParameterFile(self.STYLE, self.tr('Style file'), False, False,
'qml'))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Styled'), True))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Csv2Grid')
self.group, self.i18n_group = self.trAlgorithm('Points')
self.addParameter(ParameterFile(self.INPUT, self.tr('CSV Files')))
self.addParameter(ParameterString(self.COLUMN, self.tr('Column')))
self.addOutput(OutputFile(self.OUTPUT, self.tr('Raster Output file'), 'asc'))
def testGetValueAsCommandLineParameter(self):
parameter = ParameterFile('myName', 'myDesc')
parameter.setValue('myFile.png')
self.assertEqual(parameter.getValueAsCommandLineParameter(),
'"myFile.png"')
def testSetValue(self):
parameter = ParameterFile('myName', 'myDesc')
self.assertTrue(parameter.setValue('myFile.png'))
self.assertEqual(parameter.value, 'myFile.png')
def initAlgorithm(self, config=None):
self.addParameter(ParameterVector(self.INPUT, self.tr('Vector layer')))
self.addParameter(
ParameterFile(self.STYLE, self.tr('Style file'), False, False,
'qml'))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Styled'), True))
def processInputParameterToken(self, token, name):
param = None
descName = self.createDescriptiveName(name)
if token.lower().strip() == 'raster':
param = ParameterRaster(name, descName, False)
elif token.lower().strip() == 'vector':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_ANY])
elif token.lower().strip() == 'vector point':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_POINT])
elif token.lower().strip() == 'vector line':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_LINE])
elif token.lower().strip() == 'vector polygon':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_POLYGON])
elif token.lower().strip() == 'table':
param = ParameterTable(name, descName, False)
elif token.lower().strip() == 'multiple raster':
param = ParameterMultipleInput(name, descName,
ParameterMultipleInput.TYPE_RASTER)
param.optional = False
elif token.lower().strip() == 'multiple vector':
param = ParameterMultipleInput(
name, descName, ParameterMultipleInput.TYPE_VECTOR_ANY)
param.optional = False
elif token.lower().strip().startswith('selectionfromfile'):
options = token.strip()[len('selectionfromfile '):].split(';')
param = ParameterSelection(name, descName, options, isSource=True)
elif token.lower().strip().startswith('selection'):
options = token.strip()[len('selection '):].split(';')
param = ParameterSelection(name, descName, options)
elif token.lower().strip().startswith('boolean'):
default = token.strip()[len('boolean') + 1:]
if default:
param = ParameterBoolean(name, descName, default)
else:
param = ParameterBoolean(name, descName)
elif token.lower().strip() == 'extent':
param = ParameterExtent(name, descName)
elif token.lower().strip() == 'point':
param = ParameterPoint(name, descName)
elif token.lower().strip() == 'file':
param = ParameterFile(name, descName, False)
elif token.lower().strip() == 'folder':
param = ParameterFile(name, descName, True)
elif token.lower().strip().startswith('number'):
default = token.strip()[len('number') + 1:]
if default:
param = ParameterNumber(name, descName, default=default)
else:
param = ParameterNumber(name, descName)
elif token.lower().strip().startswith('field'):
field = token.strip()[len('field') + 1:]
found = False
for p in self.parameters:
if p.name == field:
found = True
break
if found:
param = ParameterTableField(name, descName, field)
elif token.lower().strip().startswith('string'):
default = token.strip()[len('string') + 1:]
if default:
param = ParameterString(name, descName, default)
else:
param = ParameterString(name, descName)
elif token.lower().strip().startswith('longstring'):
default = token.strip()[len('longstring') + 1:]
if default:
param = ParameterString(name,
descName,
default,
multiline=True)
else:
param = ParameterString(name, descName, multiline=True)
elif token.lower().strip().startswith('crs'):
default = token.strip()[len('crs') + 1:]
if default:
param = ParameterCrs(name, descName, default)
else:
param = ParameterCrs(name, descName)
return param
def defineCharacteristics(self):
# The name that the user will see in the toolbox
self.name = 'Dynamic Time Warping (DTW)'
# The branch of the toolbox under which the algorithm will appear
self.group = 'Image manipulation'
self.addParameter(
ParameterRaster(self.REF_RASTER, self.tr('Reference image'),
False))
self.addParameter(
ParameterFile(
self.REF_CSV,
self.
tr('Reference variable (1 csv with 1 value per date). Delimiter is comma : \',\'.'
),
ext='csv',
optional=False))
##
self.addParameter(
ParameterMultipleInput(self.SYNC_RASTER,
self.tr('Image(s) to sync'),
ParameterMultipleInput.TYPE_RASTER, True))
#
self.addParameter(
ParameterFile(
self.SYNC_CSV,
self.
tr('Sync variable (1 csv with 1 value per date). Respect the same order as the sync raster list. Delimiter is comma : \',\'.'
),
ext='csv',
optional=False))
# add num
self.addParameter(
ParameterNumber(
self.N_SAMPLES,
self.
tr('Number of dates to resample (minimum is the number of dates of your largest dataset). -1 to use the minimum.'
),
minValue=-1,
default=-1))
# add num
self.addParameter(
ParameterNumber(
self.N_SPECTRAL_BANDS,
self.tr('Number of spectral bands used for each date'),
minValue=1,
default=4))
#MASK
self.addParameter(
ParameterRaster(
self.MASK_RASTER,
self.tr('Mask image. Each pixel > 0 is classed as nodata.'),
True))
self.addParameter(
ParameterNumber(self.NO_DATA,
self.tr('No data value'),
minValue=-10000,
default=-10000))
# We add a vector layer as output
self.addOutput(
OutputDirectory(self.OUTPUT_FOLDER, self.tr('Output folder')))
def addParametersTemporaryDirectoryGUI(self):
self.addParameter(
ParameterFile(LAStoolsAlgorithm.TEMPORARY_DIRECTORY,
self.tr("empty temporary directory"), True, False))
def addParametersOutputDirectoryGUI(self):
self.addParameter(
ParameterFile(LAStoolsAlgorithm.OUTPUT_DIRECTORY,
self.tr("output directory"), True))
def addParametersPointInputGUI(self):
self.addParameter(
ParameterFile(LAStoolsAlgorithm.INPUT_LASLAZ,
self.tr("input LAS/LAZ file"), False, False))
0: 'p',
1: 'h',
2: 'v',
3: 's',
}
def getIcon(self):
return QIcon(os.path.dirname(__file__) + '/../../images/taudem.png')
def defineCharacteristics(self):
<<<<<<< HEAD
self.name = 'D-Infinity Distance Up (multifile)'
self.cmdName = 'dinfdistup'
self.group = 'Specialized Grid Analysis tools'
self.addParameter(ParameterFile(self.DINF_FLOW_DIR_GRID,
self.tr('D-Infinity Flow Direction Grid'), True, False))
self.addParameter(ParameterFile(self.PIT_FILLED_GRID,
self.tr('Pit Filled Elevation Grid'), True, False))
self.addParameter(ParameterFile(self.SLOPE_GRID,
self.tr('Slope Grid'), True, False))
self.addParameter(ParameterSelection(self.STAT_METHOD,
self.tr('Statistical Method'), self.STATISTICS, 2))
self.addParameter(ParameterSelection(self.DIST_METHOD,
self.tr('Distance Method'), self.DISTANCE, 1))
self.addParameter(ParameterNumber(self.THRESHOLD,
self.tr('Proportion Threshold'), 0, None, 0.5))
self.addParameter(ParameterBoolean(self.EDGE_CONTAM,
self.tr('Check for edge contamination'), True))
self.addOutput(OutputDirectory(self.DIST_UP_GRID,
self.tr('D-Infinity Distance Up')))
