def testScriptCode(self):
parameter = ParameterTable("myName", "myDesc")
code = parameter.getAsScriptCode()
result = getParameterFromString(code)
self.assertIsInstance(result, ParameterTable)
parameter.optional = True
code = parameter.getAsScriptCode()
result = getParameterFromString(code)
self.assertIsInstance(result, ParameterTable)
self.assertTrue(result.optional)
def testScriptCode(self):
parameter = ParameterTable(
'myName', 'myDesc')
code = parameter.getAsScriptCode()
result = getParameterFromString(code)
self.assertTrue(isinstance(result, ParameterTable))
parameter.optional = True
code = parameter.getAsScriptCode()
result = getParameterFromString(code)
self.assertTrue(isinstance(result, ParameterTable))
self.assertTrue(result.optional)
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Points layer from table')
self.group, self.i18n_group = self.trAlgorithm('Vector creation tools')
self.addParameter(ParameterTable(self.INPUT, self.tr('Input layer')))
self.addParameter(
ParameterTableField(self.XFIELD, self.tr('X field'), self.INPUT,
ParameterTableField.DATA_TYPE_ANY))
self.addParameter(
ParameterTableField(self.YFIELD, self.tr('Y field'), self.INPUT,
ParameterTableField.DATA_TYPE_ANY))
self.addParameter(
ParameterCrs(self.TARGET_CRS, self.tr('Target CRS'), 'EPSG:4326'))
self.addOutput(
OutputVector(self.OUTPUT,
self.tr('Points from table'),
datatype=[dataobjects.TYPE_VECTOR_POINT]))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Join attributes table')
self.group, self.i18n_group = self.trAlgorithm('Vector general tools')
self.addParameter(
ParameterVector(self.INPUT_LAYER, self.tr('Input layer')))
self.addParameter(
ParameterTable(self.INPUT_LAYER_2, self.tr('Input layer 2'),
False))
self.addParameter(
ParameterTableField(self.TABLE_FIELD, self.tr('Table field'),
self.INPUT_LAYER))
self.addParameter(
ParameterTableField(self.TABLE_FIELD_2, self.tr('Table field 2'),
self.INPUT_LAYER_2))
self.addOutput(OutputVector(self.OUTPUT_LAYER,
self.tr('Joined layer')))
def __init__(self):
super().__init__()
self.addParameter(
ParameterTable(self.INPUT_LAYER, self.tr('Input table')))
self.addParameter(
ParameterTableField(self.FIELD_NAME,
self.tr('Field to calculate statistics on'),
self.INPUT_LAYER))
self.addOutput(OutputHTML(self.OUTPUT_HTML_FILE,
self.tr('Statistics')))
self.addOutput(OutputNumber(self.COUNT, self.tr('Count')))
self.addOutput(
OutputNumber(self.UNIQUE, self.tr('Number of unique values')))
self.addOutput(
OutputNumber(self.EMPTY, self.tr('Number of empty (null) values')))
self.addOutput(
OutputNumber(self.FILLED, self.tr('Number of non-empty values')))
self.addOutput(OutputNumber(self.MIN, self.tr('Minimum value')))
self.addOutput(OutputNumber(self.MAX, self.tr('Maximum value')))
self.addOutput(OutputNumber(self.MIN_LENGTH,
self.tr('Minimum length')))
self.addOutput(OutputNumber(self.MAX_LENGTH,
self.tr('Maximum length')))
self.addOutput(OutputNumber(self.MEAN_LENGTH, self.tr('Mean length')))
self.addOutput(
OutputNumber(self.CV, self.tr('Coefficient of Variation')))
self.addOutput(OutputNumber(self.SUM, self.tr('Sum')))
self.addOutput(OutputNumber(self.MEAN, self.tr('Mean value')))
self.addOutput(
OutputNumber(self.STD_DEV, self.tr('Standard deviation')))
self.addOutput(OutputNumber(self.RANGE, self.tr('Range')))
self.addOutput(OutputNumber(self.MEDIAN, self.tr('Median')))
self.addOutput(
OutputNumber(self.MINORITY,
self.tr('Minority (rarest occurring value)')))
self.addOutput(
OutputNumber(
self.MAJORITY,
self.tr('Majority (most frequently occurring value)')))
self.addOutput(
OutputNumber(self.FIRSTQUARTILE, self.tr('First quartile')))
self.addOutput(
OutputNumber(self.THIRDQUARTILE, self.tr('Third quartile')))
self.addOutput(
OutputNumber(self.IQR, self.tr('Interquartile Range (IQR)')))
def defineCharacteristics(self):
self.name = 'Mean and standard deviation plot'
self.group = 'Graphics'
self.addParameter(ParameterTable(self.INPUT, self.tr('Input table')))
self.addParameter(
ParameterTableField(self.NAME_FIELD,
self.tr('Category name field'), self.INPUT,
ParameterTableField.DATA_TYPE_ANY))
self.addParameter(
ParameterTableField(self.MEAN_FIELD, self.tr('Mean field'),
self.INPUT))
self.addParameter(
ParameterTableField(self.STDDEV_FIELD, self.tr('StdDev field'),
self.INPUT))
self.addOutput(OutputHTML(self.OUTPUT, self.tr('Output')))
def defineCharacteristics(self):
self.name = 'Join attributes table'
self.group = 'Vector general tools'
self.addParameter(
ParameterVector(self.INPUT_LAYER, self.tr('Input layer'),
[ParameterVector.VECTOR_TYPE_ANY], False))
self.addParameter(
ParameterTable(self.INPUT_LAYER_2, self.tr('Input layer 2'),
False))
self.addParameter(
ParameterTableField(self.TABLE_FIELD, self.tr('Table field'),
self.INPUT_LAYER))
self.addParameter(
ParameterTableField(self.TABLE_FIELD_2, self.tr('Table field 2'),
self.INPUT_LAYER_2))
self.addOutput(OutputVector(self.OUTPUT_LAYER,
self.tr('Joined layer')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Refactor fields')
self.group, self.i18n_group = self.trAlgorithm('Vector table tools')
self.addParameter(
ParameterTable(self.INPUT_LAYER, self.tr('Input layer'), False))
class ParameterFieldsMapping(Parameter):
default_metadata = {
'widget_wrapper':
'processing.algs.qgis.ui.FieldsMappingPanel.FieldsMappingWidgetWrapper'
}
def __init__(self, name='', description='', parent=None):
Parameter.__init__(self, name, description)
self.parent = parent
self.value = []
def getValueAsCommandLineParameter(self):
return '"' + str(self.value) + '"'
def setValue(self, value):
if value is None:
return False
if isinstance(value, list):
self.value = value
return True
if isinstance(value, str):
try:
self.value = eval(value)
return True
except Exception as e:
# fix_print_with_import
print(str(e)) # display error in console
return False
return False
self.addParameter(
ParameterFieldsMapping(self.FIELDS_MAPPING,
self.tr('Fields mapping'),
self.INPUT_LAYER))
self.addOutput(
OutputVector(self.OUTPUT_LAYER,
self.tr('Refactored'),
base_input=self.INPUT_LAYER))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm(
'Basic statistics for numeric fields')
self.group, self.i18n_group = self.trAlgorithm('Vector table tools')
self.tags = self.tr('stats,statistics,number,table,layer')
self.addParameter(
ParameterTable(self.INPUT_LAYER, self.tr('Input vector layer')))
self.addParameter(
ParameterTableField(self.FIELD_NAME,
self.tr('Field to calculate statistics on'),
self.INPUT_LAYER,
ParameterTableField.DATA_TYPE_NUMBER))
self.addOutput(OutputHTML(self.OUTPUT_HTML_FILE,
self.tr('Statistics')))
self.addOutput(
OutputNumber(self.CV, self.tr('Coefficient of Variation')))
self.addOutput(OutputNumber(self.MIN, self.tr('Minimum value')))
self.addOutput(OutputNumber(self.MAX, self.tr('Maximum value')))
self.addOutput(OutputNumber(self.SUM, self.tr('Sum')))
self.addOutput(OutputNumber(self.MEAN, self.tr('Mean value')))
self.addOutput(
OutputNumber(self.STD_DEV, self.tr('Standard deviation')))
self.addOutput(OutputNumber(self.COUNT, self.tr('Count')))
self.addOutput(OutputNumber(self.RANGE, self.tr('Range')))
self.addOutput(OutputNumber(self.MEDIAN, self.tr('Median')))
self.addOutput(
OutputNumber(self.UNIQUE, self.tr('Number of unique values')))
self.addOutput(
OutputNumber(self.MINORITY,
self.tr('Minority (rarest occurring value)')))
self.addOutput(
OutputNumber(
self.MAJORITY,
self.tr('Majority (most frequently occurring value)')))
self.addOutput(
OutputNumber(self.FIRSTQUARTILE, self.tr('First quartile')))
self.addOutput(
OutputNumber(self.THIRDQUARTILE, self.tr('Third quartile')))
self.addOutput(
OutputNumber(self.NULLVALUES, self.tr('NULL (missed) values')))
self.addOutput(
OutputNumber(self.IQR, self.tr('Interquartile Range (IQR)')))
def defineCharacteristics(self):
self.addParameter(ParameterTable(self.INPUT_LAYER,
self.tr('Input vector layer')))
self.addParameter(ParameterTableField(self.FIELD_NAME,
self.tr('Field to calculate statistics on'),
self.INPUT_LAYER, ParameterTableField.DATA_TYPE_STRING))
self.addOutput(OutputHTML(self.OUTPUT_HTML_FILE,
self.tr('Statistics for text')))
self.addOutput(OutputNumber(self.MIN_LEN, self.tr('Minimum length')))
self.addOutput(OutputNumber(self.MAX_LEN, self.tr('Maximum length')))
self.addOutput(OutputNumber(self.MEAN_LEN, self.tr('Mean length')))
self.addOutput(OutputNumber(self.COUNT, self.tr('Count')))
self.addOutput(OutputNumber(self.EMPTY, self.tr('Number of empty values')))
self.addOutput(OutputNumber(self.FILLED, self.tr('Number of non-empty values')))
self.addOutput(OutputNumber(self.UNIQUE, self.tr('Number of unique values')))
self.addOutput(OutputNumber(self.MIN_VALUE, self.tr('Minimum string value')))
self.addOutput(OutputNumber(self.MAX_VALUE, self.tr('Maximum string value')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Import layer/table as geometryless table into PostgreSQL database')
self.group, self.i18n_group = self.trAlgorithm('[OGR] Miscellaneous')
self.DB_CONNECTIONS = self.dbConnectionNames()
self.addParameter(ParameterSelection(self.DATABASE,
self.tr('Database (connection name)'), self.DB_CONNECTIONS))
self.addParameter(ParameterTable(self.INPUT_LAYER,
self.tr('Input layer')))
self.addParameter(ParameterString(self.SHAPE_ENCODING,
self.tr('Shape encoding'), "", 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'), '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.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.SKIPFAILURES,
self.tr('Continue after a failure, skipping the failed record'),
False))
self.addParameter(ParameterBoolean(self.PRECISION,
self.tr('Keep width and precision of input attributes'),
True))
self.addParameter(ParameterString(self.OPTIONS,
self.tr('Additional creation options'), '', optional=True))
def defineCharacteristics(self):
self.addParameter(ParameterTable(self.INPUT, self.tr('Input table')))
self.addParameter(ParameterTableField(self.NAME_FIELD,
self.tr('Category name field'),
self.INPUT,
ParameterTableField.DATA_TYPE_ANY))
self.addParameter(ParameterTableField(self.VALUE_FIELD,
self.tr('Value field'),
self.INPUT,
ParameterTableField.DATA_TYPE_NUMBER))
msd = [self.tr('Show Mean'),
self.tr('Show Standard Deviation'),
self.tr('Don\'t show Mean and Standard Deviation')
]
self.addParameter(ParameterSelection(
self.MSD,
self.tr('Additional Statistic Lines'),
msd, default=0))
self.addOutput(OutputHTML(self.OUTPUT, self.tr('Box plot')))
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.dktablename
# The branch of the toolbox under which the algorithm will appear
self.group = self.groupname
self.addParameter(
ParameterTable(self.INPUT, self.tr(u'Vælg tabel med DGU-nummer')))
self.addParameter(
ParameterTableField(self.DGUNR_FIELD,
self.tr(u'Vælg kolonne med DGU-nummer'),
self.INPUT))
self.addOutput(OutputVector(self.OUTPUT, self.tr(self.dktablename)))
def __init__(self):
super().__init__()
self.addParameter(
ParameterTable(self.INPUT_LAYER, self.tr('Input vector layer')))
self.addParameter(
ParameterTableField(self.FIELD_NAME,
self.tr('Field to calculate statistics on'),
self.INPUT_LAYER,
ParameterTableField.DATA_TYPE_NUMBER))
self.addOutput(OutputHTML(self.OUTPUT_HTML_FILE,
self.tr('Statistics')))
self.addOutput(
OutputNumber(self.CV, self.tr('Coefficient of Variation')))
self.addOutput(OutputNumber(self.MIN, self.tr('Minimum value')))
self.addOutput(OutputNumber(self.MAX, self.tr('Maximum value')))
self.addOutput(OutputNumber(self.SUM, self.tr('Sum')))
self.addOutput(OutputNumber(self.MEAN, self.tr('Mean value')))
self.addOutput(
OutputNumber(self.STD_DEV, self.tr('Standard deviation')))
self.addOutput(OutputNumber(self.COUNT, self.tr('Count')))
self.addOutput(OutputNumber(self.RANGE, self.tr('Range')))
self.addOutput(OutputNumber(self.MEDIAN, self.tr('Median')))
self.addOutput(
OutputNumber(self.UNIQUE, self.tr('Number of unique values')))
self.addOutput(
OutputNumber(self.MINORITY,
self.tr('Minority (rarest occurring value)')))
self.addOutput(
OutputNumber(
self.MAJORITY,
self.tr('Majority (most frequently occurring value)')))
self.addOutput(
OutputNumber(self.FIRSTQUARTILE, self.tr('First quartile')))
self.addOutput(
OutputNumber(self.THIRDQUARTILE, self.tr('Third quartile')))
self.addOutput(
OutputNumber(self.NULLVALUES, self.tr('NULL (missed) values')))
self.addOutput(
OutputNumber(self.IQR, self.tr('Interquartile Range (IQR)')))
def defineCharacteristics(self):
"""Inputs and output description of the algorithm, along
with some other properties.
"""
# The name that the user will see in the toolbox
self.name = 'Coordinate format convertion'
self.i18n_name = self.name
# The branch of the toolbox under which the algorithm will appear
self.group = 'Formatting'
self.i18n_group = self.group
# 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(ParameterTable(self.SOURCE_TABLE, 'Source table', optional=False))
self.addParameter(ParameterTableField(self.SOURCE_X_FIELD, "X (lon) or mgrs field ", parent=self.SOURCE_TABLE, optional=True))
self.addParameter(ParameterTableField(self.SOURCE_Y_FIELD, "Y (lat) or mgrs field", parent=self.SOURCE_TABLE, optional=True))
self.addParameter(ParameterSelection(self.SOURCE_FORMAT, "Source format", options=self.FORMAT_LIST, default=0))
self.addParameter(ParameterSelection(self.DESTINATION_FORMAT, "Destination format", options=self.FORMAT_LIST, default=0, optional=True))
self.addParameter(ParameterString(self.CUSTOM_FORMAT, "Custom coordinate format", default=self.CUSTOM_COORD_FORMAT, optional=True))
self.addParameter(ParameterString(self.OUTPUT_X_FIELD, "Destination X field", optional=True))
self.addParameter(ParameterString(self.OUTPUT_Y_FIELD, "Destination Y field", optional=True))
self.addParameter(ParameterString(self.OUTPUT_XY_FIELD, "Destination single XY field", optional=True))
self.addParameter(ParameterString(self.OUTPUT_COORDINATE_FORMAT, "Single field coord fromat", default=self.SINGLE_FIELD_COORD_FORMAT, optional=True))
# We add a table layer as output
self.addOutput(OutputTable(self.OUTPUT_TABLE, 'Input table modified'))
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.name = 'Simulate flow in storm water conveyance systems'
self.group = 'Simulation'
self.addParameter(
ParameterString(self.TITLE, 'Title', 'Swmm Simulation'))
self.addParameter(
ParameterTable(self.OPTIONS, 'Analysis options', True))
self.addParameter(
ParameterTable(self.REPORT, 'Output reporting instructions', True))
self.addParameter(
ParameterTable(self.FILES, 'Interface file options', True))
self.addParameter(
ParameterTable(self.RAINGAGES, 'Rain gage information', True))
self.addParameter(
ParameterTable(
self.HYDROGRAPHS,
'Unit hydrograph data used to construct RDII inflows', True))
self.addParameter(
ParameterTable(self.EVAPORATION, 'Evaporation data', True))
self.addParameter(
ParameterTable(self.TEMPERATURE,
'Air temperature and snow melt data', True))
self.addParameter(
ParameterVector(self.SUBCATCHMENTS,
'Basic subcatchment information',
[ParameterVector.VECTOR_TYPE_POLYGON], True))
self.addParameter(
ParameterTable(self.SUBAREAS,
'Subcatchment impervious/pervious sub-area data',
True))
self.addParameter(
ParameterTable(self.INFILTRATION,
'Subcatchment infiltration parameters', True))
self.addParameter(
ParameterTable(self.LID_CONTROLS,
'Low impact development control information', True))
self.addParameter(
ParameterTable(self.LID_USAGE,
'Assignment of LID controls to subcatchments',
True))
self.addParameter(
ParameterTable(self.AQUIFERS, 'Groundwater aquifer parameters',
True))
self.addParameter(
ParameterTable(self.GROUNDWATER,
'Subcatchment groundwater parameters', True))
self.addParameter(
ParameterTable(self.SNOWPACKS, 'Subcatchment snow pack parameters',
True))
self.addParameter(
ParameterVector(self.JUNCTIONS, 'Junction node information',
[ParameterVector.VECTOR_TYPE_POINT], True))
self.addParameter(
ParameterTable(self.OUTFALLS, 'Outfall node information', True))
self.addParameter(
ParameterVector(self.DIVIDERS, 'Flow divider node information',
[ParameterVector.VECTOR_TYPE_POINT], True))
self.addParameter(
ParameterVector(self.STORAGE, 'Storage node information',
[ParameterVector.VECTOR_TYPE_POINT], True))
self.addParameter(
ParameterVector(self.CONDUITS, 'Conduit link information',
[ParameterVector.VECTOR_TYPE_LINE], True))
self.addParameter(
ParameterVector(self.PUMPS, 'Pump link information',
[ParameterVector.VECTOR_TYPE_POINT], True))
self.addParameter(
ParameterVector(self.ORIFICES, 'Orifice link information',
[ParameterVector.VECTOR_TYPE_POINT], True))
self.addParameter(
ParameterVector(self.WEIRS, 'Weir link information',
[ParameterVector.VECTOR_TYPE_POINT], True))
self.addParameter(
ParameterVector(self.OUTLETS, 'Outlet link information',
[ParameterVector.VECTOR_TYPE_POINT], True))
self.addParameter(
ParameterTable(
self.XSECTIONS,
'Conduit, orifice, and weir cross-section geometry', True))
self.addParameter(
ParameterTable(
self.TRANSECTS,
'Transect geometry for conduits with irregular cross-sections',
True))
self.addParameter(
ParameterTable(self.LOSSES,
'Conduit entrance/exit losses and flap valves',
True))
self.addParameter(
ParameterTable(self.CONTROLS,
'Rules that control pump and regulator operation',
True))
self.addParameter(
ParameterTable(self.POLLUTANTS, 'Pollutant information', True))
self.addParameter(
ParameterTable(self.LANDUSES, 'Land use categories', True))
self.addParameter(
ParameterTable(self.COVERAGES,
'Assignment of land uses to subcatchments', True))
self.addParameter(
ParameterTable(self.BUILDUP,
'Buildup functions for pollutants and land uses',
True))
self.addParameter(
ParameterTable(self.WASHOFF,
'Washoff functions for pollutants and land uses',
True))
self.addParameter(
ParameterTable(
self.TREATMENT,
'Pollutant removal functions at conveyance system nodes',
True))
self.addParameter(
ParameterTable(self.INFLOWS,
'External hydrograph/pollutograph inflow at nodes',
True))
self.addParameter(
ParameterTable(self.DWF,
'Baseline dry weather sanitary inflow at nodes',
True))
self.addParameter(
ParameterTable(self.PATTERNS,
'Periodic variation in dry weather inflow', True))
self.addParameter(
ParameterTable(self.RDII,
'Rainfall-dependent I/I information at nodes',
True))
self.addParameter(
ParameterTable(self.LOADINGS,
'Initial pollutant loads on subcatchments', True))
self.addParameter(
ParameterTable(self.CURVES,
'x-y tabular data referenced in other sections',
True))
self.addParameter(
ParameterTable(self.TIMESERIES,
'Time series data referenced in other sections',
True))
self.addOutput(OutputVector(self.NODE_OUTPUT, 'Node output layer'))
self.addOutput(OutputTable(self.NODE_TABLE_OUTPUT,
'Node output table'))
self.addOutput(OutputVector(self.LINK_OUTPUT, 'Link output layer'))
pass
def defineCharacteristics(self):
self.addParameter(ParameterTable(self.INPUT, self.tr('Input Layer')))
self.addOutput(
OutputVector(self.OUTPUT, self.tr('Truncated layer'), True))
def __init__(self):
super().__init__()
self.addParameter(ParameterTable(self.INPUT, self.tr('Input Layer')))
self.addOutput(
OutputVector(self.OUTPUT, self.tr('Truncated layer'), True))
def defineCharacteristics(self):
"""
Algorithme variable and parameters parameters
"""
CholeAlgorithm.defineCharacteristics(self)
# The name/group that the user will see in the toolbox
self.group = 'generate ascii grid'
self.i18n_group = self.tr('generate ascii grid')
self.name = 'from csv'
self.i18n_name = self.tr('from csv')
# === INPUT PARAMETERS ===
self.addParameter(ParameterTable(
name=self.INPUT_FILE_CSV,
description=self.tr('Input file csv')))
self.addParameter(ParameterString(
name=self.FIELDS,
description=self.tr('Fields selection'),
default=''))
self.addParameter(ParameterNumber(
name=self.N_COLS,
description=self.tr('Columns count'),
minValue=0,
default=100))
self.addParameter(ParameterNumber(
name=self.N_ROWS,
description=self.tr('Rows count'),
minValue=0,
default=100))
self.addParameter(ParameterNumber(
name=self.XLL_CORNER,
description=self.tr('X bottom left corner coordinate'),
default=0.0))
self.addParameter(ParameterNumber(
name=self.YLL_CORNER,
description=self.tr('Y bottom left corner coordinate'),
default=0.0))
self.addParameter(ParameterNumber(
name=self.CELL_SIZE,
description=self.tr('Cell size'),
default=1.0))
self.addParameter(ParameterNumber(
name=self.NODATA_VALUE,
description=self.tr('Value if no-data'),
default=-1))
self.addOutput(OutputFile(
name=self.SAVE_PROPERTIES,
description=self.tr('Properties file'),
ext='properties'))
# === OUTPUT PARAMETERS ===
self.addOutput(ASCOutputRaster(
name=self.OUTPUT_ASC,
description=self.tr('Ouput Raster ascii')))
def initAlgorithm(self, config=None):
self.addParameter(ParameterTable(self.INPUT, self.tr('Input Layer')))
self.addOutput(
OutputVector(self.OUTPUT, self.tr('Truncated layer'), True))
def processParameterLine(self, line):
param = None
out = None
line = line.replace('#', '')
# If the line is in the format of the text description files for
# normal algorithms, then process it using parameter and output
# factories
if '|' in line:
self.processDescriptionParameterLine(line)
return
if line == "nomodeler":
self.showInModeler = False
return
tokens = line.split('=', 1)
desc = self.createDescriptiveName(tokens[0])
if tokens[1].lower().strip() == 'group':
self.group = tokens[0]
return
if tokens[1].lower().strip() == 'name':
self.name = tokens[0]
return
if tokens[1].lower().strip() == 'raster':
param = ParameterRaster(tokens[0], desc, False)
elif tokens[1].lower().strip() == 'vector':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_ANY])
elif tokens[1].lower().strip() == 'vector point':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_POINT])
elif tokens[1].lower().strip() == 'vector line':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_LINE])
elif tokens[1].lower().strip() == 'vector polygon':
param = ParameterVector(tokens[0], desc,
[ParameterVector.VECTOR_TYPE_POLYGON])
elif tokens[1].lower().strip() == 'table':
param = ParameterTable(tokens[0], desc, False)
elif tokens[1].lower().strip() == 'multiple raster':
param = ParameterMultipleInput(tokens[0], desc,
ParameterMultipleInput.TYPE_RASTER)
param.optional = False
elif tokens[1].lower().strip() == 'multiple vector':
param = ParameterMultipleInput(
tokens[0], desc, ParameterMultipleInput.TYPE_VECTOR_ANY)
param.optional = False
elif tokens[1].lower().strip().startswith('selection'):
options = tokens[1].strip()[len('selection '):].split(';')
param = ParameterSelection(tokens[0], desc, options)
elif tokens[1].lower().strip().startswith('boolean'):
default = tokens[1].strip()[len('boolean') + 1:]
param = ParameterBoolean(tokens[0], desc, default)
elif tokens[1].lower().strip() == 'extent':
param = ParameterExtent(tokens[0], desc)
elif tokens[1].lower().strip() == 'file':
param = ParameterFile(tokens[0], desc, False)
elif tokens[1].lower().strip() == 'folder':
param = ParameterFile(tokens[0], desc, True)
elif tokens[1].lower().strip().startswith('number'):
default = tokens[1].strip()[len('number') + 1:]
param = ParameterNumber(tokens[0], desc, default=default)
elif tokens[1].lower().strip().startswith('field'):
field = tokens[1].strip()[len('field') + 1:]
found = False
for p in self.parameters:
if p.name == field:
found = True
break
if found:
param = ParameterTableField(tokens[0], desc, field)
elif tokens[1].lower().strip().startswith('string'):
default = tokens[1].strip()[len('string') + 1:]
param = ParameterString(tokens[0], desc, default)
elif tokens[1].lower().strip().startswith('longstring'):
default = tokens[1].strip()[len('longstring') + 1:]
param = ParameterString(tokens[0], desc, default, multiline=True)
elif tokens[1].lower().strip().startswith('crs'):
default = tokens[1].strip()[len('crs') + 1:]
if not default:
default = 'EPSG:4326'
param = ParameterCrs(tokens[0], desc, default)
elif tokens[1].lower().strip().startswith('output raster'):
out = OutputRaster()
elif tokens[1].lower().strip().startswith('output vector'):
out = OutputVector()
elif tokens[1].lower().strip().startswith('output table'):
out = OutputTable()
elif tokens[1].lower().strip().startswith('output html'):
out = OutputHTML()
elif tokens[1].lower().strip().startswith('output file'):
out = OutputFile()
subtokens = tokens[1].split(' ')
if len(subtokens) > 2:
out.ext = subtokens[2]
elif tokens[1].lower().strip().startswith('output directory'):
out = OutputDirectory()
elif tokens[1].lower().strip().startswith('output number'):
out = OutputNumber()
elif tokens[1].lower().strip().startswith('output string'):
out = OutputString()
if param is not None:
self.addParameter(param)
elif out is not None:
out.name = tokens[0]
out.description = desc
self.addOutput(out)
else:
raise WrongScriptException(
self.tr('Could not load script: %s.\n'
'Problem with line %d', 'ScriptAlgorithm') %
(self.descriptionFile or '', line))
def processInputParameterToken(self, token, name):
param = None
descName = self.createDescriptiveName(name)
if token.lower().strip() == 'raster':
param = ParameterRaster(name, descName, False)
elif token.lower().strip() == 'vector':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_ANY])
elif token.lower().strip() == 'vector point':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_POINT])
elif token.lower().strip() == 'vector line':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_LINE])
elif token.lower().strip() == 'vector polygon':
param = ParameterVector(name, descName,
[ParameterVector.VECTOR_TYPE_POLYGON])
elif token.lower().strip() == 'table':
param = ParameterTable(name, descName, False)
elif token.lower().strip() == 'multiple raster':
param = ParameterMultipleInput(name, descName,
ParameterMultipleInput.TYPE_RASTER)
param.optional = False
elif token.lower().strip() == 'multiple vector':
param = ParameterMultipleInput(
name, descName, ParameterMultipleInput.TYPE_VECTOR_ANY)
param.optional = False
elif token.lower().strip().startswith('selectionfromfile'):
options = token.strip()[len('selectionfromfile '):].split(';')
param = ParameterSelection(name, descName, options, isSource=True)
elif token.lower().strip().startswith('selection'):
options = token.strip()[len('selection '):].split(';')
param = ParameterSelection(name, descName, options)
elif token.lower().strip().startswith('boolean'):
default = token.strip()[len('boolean') + 1:]
if default:
param = ParameterBoolean(name, descName, default)
else:
param = ParameterBoolean(name, descName)
elif token.lower().strip() == 'extent':
param = ParameterExtent(name, descName)
elif token.lower().strip() == 'point':
param = ParameterPoint(name, descName)
elif token.lower().strip() == 'file':
param = ParameterFile(name, descName, False)
elif token.lower().strip() == 'folder':
param = ParameterFile(name, descName, True)
elif token.lower().strip().startswith('number'):
default = token.strip()[len('number') + 1:]
if default:
param = ParameterNumber(name, descName, default=default)
else:
param = ParameterNumber(name, descName)
elif token.lower().strip().startswith('field'):
field = token.strip()[len('field') + 1:]
found = False
for p in self.parameters:
if p.name == field:
found = True
break
if found:
param = ParameterTableField(name, descName, field)
elif token.lower().strip().startswith('string'):
default = token.strip()[len('string') + 1:]
if default:
param = ParameterString(name, descName, default)
else:
param = ParameterString(name, descName)
elif token.lower().strip().startswith('longstring'):
default = token.strip()[len('longstring') + 1:]
if default:
param = ParameterString(name,
descName,
default,
multiline=True)
else:
param = ParameterString(name, descName, multiline=True)
elif token.lower().strip().startswith('crs'):
default = token.strip()[len('crs') + 1:]
if default:
param = ParameterCrs(name, descName, default)
else:
param = ParameterCrs(name, descName)
return param
PRECISION = 'PRECISION'
OPTIONS = 'OPTIONS'
def dbConnectionNames(self):
settings = QSettings()
settings.beginGroup('/PostgreSQL/connections/')
return settings.childGroups()
def defineCharacteristics(self):
<<<<<<< HEAD
self.name = 'Import layer/table as geometryless table into PostgreSQL database'
self.group = '[OGR] Miscellaneous'
self.DB_CONNECTIONS = self.dbConnectionNames()
self.addParameter(ParameterSelection(self.DATABASE,
self.tr('Database (connection name)'), self.DB_CONNECTIONS))
self.addParameter(ParameterTable(self.INPUT_LAYER,
self.tr('Input layer')))
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(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.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)'),
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):
self.name = 'Simulate flow in drinking water network'
self.group = 'Simulation'
self.addParameter(
ParameterString(self.TITLE, 'Title', 'Epanet Simulation'))
self.addParameter(
ParameterVector(self.JUNCTIONS, 'Junctions layer',
[ParameterVector.VECTOR_TYPE_POINT]))
self.addParameter(
ParameterVector(self.PIPES, 'Pipes layer',
[ParameterVector.VECTOR_TYPE_LINE]))
self.addParameter(
ParameterVector(self.RESERVOIRS, 'Reservoir layer',
[ParameterVector.VECTOR_TYPE_POINT], True))
self.addParameter(
ParameterVector(self.TANKS, 'Tanks layer',
[ParameterVector.VECTOR_TYPE_POINT], True))
self.addParameter(
ParameterVector(self.PUMPS, 'Pumps layer', [
ParameterVector.VECTOR_TYPE_POINT,
ParameterVector.VECTOR_TYPE_LINE
], True))
self.addParameter(
ParameterVector(self.VALVES, 'Valves layer', [
ParameterVector.VECTOR_TYPE_POINT,
ParameterVector.VECTOR_TYPE_LINE
], True))
self.addParameter(
ParameterVector(self.EMITTERS, 'Emiters layer',
[ParameterVector.VECTOR_TYPE_POINT], True))
self.addParameter(ParameterTable(self.DEMANDS, 'Demands table',
True))
self.addParameter(ParameterTable(self.STATUS, 'Status table', True))
self.addParameter(
ParameterTable(self.PATTERNS, 'Patterns table', True))
self.addParameter(ParameterTable(self.CURVES, 'Curves table', True))
self.addParameter(
ParameterTable(self.CONTROLS, 'Controls table', True))
self.addParameter(ParameterTable(self.QUALITY, 'Quality table',
True))
self.addParameter(ParameterTable(self.MIXING, 'Mixing table', True))
#self.addParameter(ParameterFile(self.ADDITIONAL_FILE, 'Epanet config file'))
self.addParameter(ParameterTable(self.TIMES, 'Simulation Time'))
self.addParameter(ParameterTable(self.RULES, 'Control rules', True))
self.addParameter(ParameterTable(self.ENERGY, 'Energy ', True))
self.addParameter(ParameterTable(self.REACTIONS, 'Reaction', True))
self.addParameter(ParameterTable(self.REPORT, 'Report options', True))
self.addParameter(ParameterTable(self.OPTIONS, 'Options', True))
#self.addOutput(OutputVector(self.NODE_OUTPUT, 'Node output layer'))
#self.addOutput(OutputVector(self.LINK_OUTPUT, 'Link output layer'))
self.addOutput(
EpanetOutputTable(self.NODE_TABLE_OUTPUT, 'Node output table'))
self.addOutput(
EpanetOutputTable(self.LINK_TABLE_OUTPUT, 'Link output table'))
self.addOutput(
EpanetOutputTable(self.TIME_AGREGATE_NODE_TABLE_OUTPUT,
'Node output table (time agregates)'))
self.addOutput(
EpanetOutputTable(self.TIME_AGREGATE_LINK_TABLE_OUTPUT,
'Link output table (time agregates)'))
pass
