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.DATE_FROM,
self.tr(u'Angiv prøve-startdato i formatet YYYY-MM-DD'),
'1900-01-01',
optional=True))
self.addParameter(ParameterString(
self.DATE_TO,
self.tr(u'Angiv prøve-slutdato i formatet YYYY-MM-DD'),
date.today(),
optional=True))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Alle_stoffer')))
def defineCharacteristics(self):
self.name = "extract regular grid"
self.group = "[pktools] raster/vector"
self.addParameter(ParameterRaster(self.INPUT, 'Input raster data set'))
self.addParameter(
ParameterSelection(self.RULE, "extraction rule", self.RULE_OPTIONS,
0))
self.addOutput(OutputVector(self.OUTPUT, 'Output vector data set'))
self.addParameter(
ParameterSelection(self.FORMAT, 'Destination Format', FORMATS))
self.addParameter(
ParameterNumber(
self.BUFFER,
"Buffer for calculating statistics for point features", 1, 25,
1))
self.addParameter(
ParameterNumber(self.GRID,
"Cell grid size (in projected units, e.g,. m)", 0,
1000000, 100))
self.addParameter(
ParameterString(
self.SRCNODATA,
"invalid value(s) for input raster dataset (e.g., 0;255)",
"none"))
self.addParameter(
ParameterString(
self.BNDNODATA,
"Band(s) in input image to check if pixel is valid (e.g., 0;1)",
"0"))
self.addParameter(
ParameterString(self.EXTRA,
'Additional parameters',
'',
optional=True))
def __init__(self):
super().__init__()
self.i18n_operators = ['=',
'!=',
'>',
'>=',
'<',
'<=',
self.tr('begins with'),
self.tr('contains'),
self.tr('is null'),
self.tr('is not null'),
self.tr('does not contain')
]
self.addParameter(ParameterVector(self.INPUT,
self.tr('Input Layer')))
self.addParameter(ParameterTableField(self.FIELD,
self.tr('Selection attribute'), self.INPUT))
self.addParameter(ParameterSelection(self.OPERATOR,
self.tr('Operator'), self.i18n_operators))
self.addParameter(ParameterString(self.VALUE, self.tr('Value'), optional=True))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Extracted (attribute)')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm(
'Eliminate selected polygons')
self.group, self.i18n_group = self.trAlgorithm('Vector geometry tools')
self.modes = [
self.tr('Largest area'),
self.tr('Smallest Area'),
self.tr('Largest common boundary')
]
self.addParameter(
ParameterVector(self.INPUT, self.tr('Input layer'),
[dataobjects.TYPE_VECTOR_POLYGON]))
self.addParameter(
ParameterSelection(
self.MODE,
self.tr(
'Merge selection with the neighbouring polygon with the'),
self.modes))
self.addOutput(
OutputVector(self.OUTPUT,
self.tr('Eliminated'),
datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Buffer vectors')
self.group, self.i18n_group = self.trAlgorithm('[OGR] Geoprocessing')
self.addParameter(ParameterVector(self.INPUT_LAYER,
self.tr('Input layer')))
self.addParameter(ParameterString(self.GEOMETRY,
self.tr('Geometry column name ("geometry" for Shapefiles, may be different for other formats)'),
'geometry', optional=False))
self.addParameter(ParameterNumber(self.DISTANCE,
self.tr('Buffer distance'),
0.0, 99999999.999999, 1000.0,
optional=False))
self.addParameter(ParameterBoolean(self.DISSOLVEALL,
self.tr('Dissolve all results'), False))
self.addParameter(ParameterTableField(self.FIELD,
self.tr('Dissolve by attribute'), self.INPUT_LAYER, optional=True))
self.addParameter(ParameterBoolean(self.MULTI,
self.tr('Output as singlepart geometries (only used when dissolving by attribute)'), False))
self.addParameter(ParameterString(self.OPTIONS,
self.tr('Additional creation options (see ogr2ogr manual)'),
'', optional=True))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Buffer'), datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Concave hull')
self.group, self.i18n_group = self.trAlgorithm('Vector geometry tools')
self.addParameter(
ParameterVector(ConcaveHull.INPUT, self.tr('Input point layer'),
[dataobjects.TYPE_VECTOR_POINT]))
self.addParameter(
ParameterNumber(
self.ALPHA,
self.tr(
'Threshold (0-1, where 1 is equivalent with Convex Hull)'),
0, 1, 0.3))
self.addParameter(
ParameterBoolean(self.HOLES, self.tr('Allow holes'), True))
self.addParameter(
ParameterBoolean(
self.NO_MULTIGEOMETRY,
self.tr(
'Split multipart geometry into singleparts geometries'),
False))
self.addOutput(
OutputVector(ConcaveHull.OUTPUT,
self.tr('Concave hull'),
datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Create grid (polygon)')
self.group, self.i18n_group = self.trAlgorithm('Vector creation tools')
self.tags = self.tr('grid,polygons,vector,create,fishnet')
self.types = [self.tr('Rectangle (polygon)'),
self.tr('Diamond (polygon)'),
self.tr('Hexagon (polygon)')]
self.addParameter(ParameterSelection(self.TYPE,
self.tr('Grid type'), self.types))
self.addParameter(ParameterExtent(self.EXTENT,
self.tr('Grid extent'), optional=False))
self.addParameter(ParameterNumber(self.HSPACING,
self.tr('Horizontal spacing'), 0.0, 1000000000.0, 0.0001))
self.addParameter(ParameterNumber(self.VSPACING,
self.tr('Vertical spacing'), 0.0, 1000000000.0, 0.0001))
self.addParameter(ParameterNumber(self.HOVERLAY,
self.tr('Horizontal overlay'), 0.0, 1000000000.0, 0.0))
self.addParameter(ParameterNumber(self.VOVERLAY,
self.tr('Vertical overlay'), 0.0, 1000000000.0, 0.0))
self.addParameter(ParameterCrs(self.CRS, 'Grid CRS', 'EPSG:4326'))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Grid'), datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Join attributes by location')
self.group, self.i18n_group = self.trAlgorithm('Vector general tools')
self.addParameter(ParameterVector(self.TARGET,
self.tr('Target vector layer'),
[ParameterVector.VECTOR_TYPE_ANY]))
self.addParameter(ParameterVector(self.JOIN,
self.tr('Join vector layer'),
[ParameterVector.VECTOR_TYPE_ANY]))
predicates = list(ParameterGeometryPredicate.predicates)
predicates.remove('disjoint')
self.addParameter(ParameterGeometryPredicate(self.PREDICATE,
self.tr('Geometric predicate'),
left=self.TARGET, right=self.JOIN,
enabledPredicates=predicates))
self.addParameter(ParameterSelection(self.SUMMARY,
self.tr('Attribute summary'), self.SUMMARYS))
self.addParameter(ParameterString(self.STATS,
self.tr('Statistics for summary (comma separated)'),
'sum,mean,min,max,median', optional=True))
self.addParameter(ParameterSelection(self.KEEP,
self.tr('Joined table'), self.KEEPS))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Joined layer')))
def __init__(self):
super().__init__()
self.predicates = (
('intersects', self.tr('intersects')),
('contains', self.tr('contains')),
('disjoint', self.tr('disjoint')),
('equals', self.tr('equals')),
('touches', self.tr('touches')),
('overlaps', self.tr('overlaps')),
('within', self.tr('within')),
('crosses', self.tr('crosses')))
self.addParameter(ParameterVector(self.INPUT,
self.tr('Layer to select from')))
self.addParameter(ParameterVector(self.INTERSECT,
self.tr('Additional layer (intersection layer)')))
self.addParameter(ParameterSelection(self.PREDICATE,
self.tr('Geometric predicate'),
self.predicates,
multiple=True))
self.addParameter(ParameterNumber(self.PRECISION,
self.tr('Precision'),
0.0, None, 0.0))
self.addOutput(OutputVector(self.OUTPUT, self.tr('Extracted (location)')))
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 = 'Differential Privacy - independent points'
# The branch of the toolbox under which the algorithm will appear
self.group = 'Vector'
# 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(
ParameterVector(self.INPUT_LAYER, self.tr('Input layer'),
[ParameterVector.VECTOR_TYPE_POINT], False))
self.addParameter(
ParameterNumber(self.PROTECTION_DISTANCE,
self.tr('Protection distance (projected units)'),
minValue=0.,
default=500))
self.addParameter(
ParameterBoolean(
self.LIMIT_NINETY_FIVE,
"Limit the distance moved to the 95% confidence interval",
default=False))
# We add a vector layer as output
self.addOutput(
OutputVector(self.OUTPUT_LAYER, self.tr('Anonymized features')))
self.addOutput(
OutputNumber(self.NINETY_FIVE_DISTANCE,
"95% confidence distance for offset"))
def __init__(self):
super().__init__()
self.addParameter(ParameterVector(self.INPUT_LAYER,
self.tr('Input layer'), [dataobjects.TYPE_VECTOR_LINE], False))
self.addParameter(ParameterString(self.GEOMETRY,
self.tr('Geometry column name ("geometry" for Shapefiles, may be different for other formats)'),
'geometry', optional=False))
self.addParameter(ParameterNumber(self.RADIUS,
self.tr('Buffer distance'),
0.0, 99999999.999999, 1000.0,
optional=False))
self.addParameter(ParameterSelection(self.LEFTRIGHT,
self.tr('Buffer side'), self.LEFTRIGHTLIST, 0))
self.addParameter(ParameterBoolean(self.DISSOLVEALL,
self.tr('Dissolve all results'), False))
self.addParameter(ParameterTableField(self.FIELD,
self.tr('Dissolve by attribute'), self.INPUT_LAYER, optional=True))
self.addParameter(ParameterBoolean(self.MULTI,
self.tr('Output as singlepart geometries (only used when dissolving by attribute)'), False))
self.addParameter(ParameterString(self.OPTIONS,
self.tr('Additional creation options (see ogr2ogr manual)'),
'', optional=True))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Single sided buffer')))
def defineCharacteristics(self):
self.STATS = {self.tr('Count'): QgsZonalStatistics.Count,
self.tr('Sum'): QgsZonalStatistics.Count,
self.tr('Mean'): QgsZonalStatistics.Count,
self.tr('Median'): QgsZonalStatistics.Count,
self.tr('Std. dev.'): QgsZonalStatistics.Count,
self.tr('Min'): QgsZonalStatistics.Count,
self.tr('Max'): QgsZonalStatistics.Count,
self.tr('Range'): QgsZonalStatistics.Count,
self.tr('Minority'): QgsZonalStatistics.Count,
self.tr('Majority'): QgsZonalStatistics.Count,
self.tr('Variety'): QgsZonalStatistics.Count,
self.tr('All'): QgsZonalStatistics.All
}
self.name, self.i18n_name = self.trAlgorithm('Zonal Statistics (QGIS)')
self.group, self.i18n_group = self.trAlgorithm('Raster tools')
self.addParameter(ParameterRaster(self.INPUT_RASTER,
self.tr('Raster layer')))
self.addParameter(ParameterNumber(self.RASTER_BAND,
self.tr('Raster band'),
1, 999, 1))
self.addParameter(ParameterVector(self.INPUT_VECTOR,
self.tr('Vector layer containing zones'),
[dataobjects.TYPE_VECTOR_POLYGON]))
self.addParameter(ParameterString(self.COLUMN_PREFIX,
self.tr('Output column prefix'), '_'))
self.addParameter(ParameterSelection(self.STATISTICS,
self.tr('Statistics to calculate'),
list(self.STATS.keys()),
multiple=True))
self.addOutput(OutputVector(self.OUTPUT_LAYER,
self.tr('Zonal statistics'),
True,
datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Select by attribute')
self.group, self.i18n_group = self.trAlgorithm(
'Vector selection tools')
self.i18n_operators = [
'=', '!=', '>', '>=', '<', '<=',
self.tr('begins with '),
self.tr('contains')
]
self.addParameter(
ParameterVector(self.INPUT, self.tr('Input Layer'),
[ParameterVector.VECTOR_TYPE_ANY]))
self.addParameter(
ParameterTableField(self.FIELD, self.tr('Selection attribute'),
self.INPUT))
self.addParameter(
ParameterSelection(self.OPERATOR, self.tr('Operator'),
self.i18n_operators))
self.addParameter(ParameterString(self.VALUE, self.tr('Value')))
self.addOutput(
OutputVector(self.OUTPUT, self.tr('Selected (attribute)'), True))
def defineCharacteristics(self):
self.addParameter(
ParameterVector(self.INPUT_LAYER, self.tr('Input layer'), [
dataobjects.TYPE_VECTOR_POLYGON, dataobjects.TYPE_VECTOR_LINE
]))
self.addParameter(
ParameterNumber(self.ITERATIONS,
self.tr('Iterations'),
default=1,
minValue=1,
maxValue=10))
self.addParameter(
ParameterNumber(self.OFFSET,
self.tr('Offset'),
default=0.25,
minValue=0.0,
maxValue=0.5))
self.addParameter(
ParameterNumber(self.MAX_ANGLE,
self.tr('Maximum node angle to smooth'),
default=180.0,
minValue=0.0,
maxValue=180.0))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Smoothed')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm(
'Random points inside polygons (variable)')
self.group, self.i18n_group = self.trAlgorithm('Vector creation tools')
self.strategies = [self.tr('Points count'), self.tr('Points density')]
self.addParameter(
ParameterVector(self.VECTOR, self.tr('Input layer'),
[dataobjects.TYPE_VECTOR_POLYGON]))
self.addParameter(
ParameterSelection(self.STRATEGY, self.tr('Sampling strategy'),
self.strategies, 0))
self.addParameter(
ParameterTableField(self.FIELD, self.tr('Number field'),
self.VECTOR,
ParameterTableField.DATA_TYPE_NUMBER))
self.addParameter(
ParameterNumber(self.MIN_DISTANCE, self.tr('Minimum distance'),
0.0, None, 0.0))
self.addOutput(
OutputVector(self.OUTPUT,
self.tr('Random points'),
datatype=[dataobjects.TYPE_VECTOR_POINT]))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Offset lines for lines')
self.group, self.i18n_group = self.trAlgorithm('[OGR] Geoprocessing')
self.addParameter(ParameterVector(self.INPUT_LAYER,
self.tr('Input layer'), [dataobjects.TYPE_VECTOR_LINE], False))
self.addParameter(ParameterString(self.GEOMETRY,
self.tr('Geometry column name ("geometry" for Shapefiles, may be different for other formats)'),
'geometry', optional=False))
self.addParameter(ParameterNumber(self.RADIUS,
self.tr('Offset distance (positive value for left-sided and negative - for right-sided)'),
-99999999.999999, 99999999.999999, 1000.0,
optional=False))
self.addParameter(ParameterBoolean(self.DISSOLVEALL,
self.tr('Dissolve all results'), False))
self.addParameter(ParameterTableField(self.FIELD,
self.tr('Dissolve by attribute'), self.INPUT_LAYER, optional=True))
self.addParameter(ParameterBoolean(self.MULTI,
self.tr('Output as singlepart geometries (only used when dissolving by attribute)'), False))
self.addParameter(ParameterString(self.OPTIONS,
self.tr('Additional creation options (see ogr2ogr manual)'),
'', optional=True))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Offset line')))
def initAlgorithm(self, config=None):
self.predicates = (('intersects', self.tr('intersects')),
('contains',
self.tr('contains')), ('disjoint',
self.tr('disjoint')),
('equals', self.tr('equals')), ('touches',
self.tr('touches')),
('overlaps', self.tr('overlaps')),
('within', self.tr('within')), ('crosses',
self.tr('crosses')))
self.methods = [
self.tr('creating new selection'),
self.tr('adding to current selection'),
self.tr('removing from current selection')
]
self.addParameter(
ParameterVector(self.INPUT, self.tr('Layer to select from')))
self.addParameter(
ParameterVector(self.INTERSECT,
self.tr('Additional layer (intersection layer)')))
self.addParameter(
ParameterSelection(self.PREDICATE,
self.tr('Geometric predicate'),
self.predicates,
multiple=True))
self.addParameter(
ParameterNumber(self.PRECISION, self.tr('Precision'), 0.0, None,
0.0))
self.addParameter(
ParameterSelection(self.METHOD,
self.tr('Modify current selection by'),
self.methods, 0))
self.addOutput(
OutputVector(self.OUTPUT, self.tr('Selected (location)'), True))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm(
'Random selection within subsets')
self.group, self.i18n_group = self.trAlgorithm(
'Vector selection tools')
self.methods = [
self.tr('Number of selected features'),
self.tr('Percentage of selected features')
]
self.addParameter(ParameterVector(self.INPUT, self.tr('Input layer')))
self.addParameter(
ParameterTableField(self.FIELD, self.tr('ID Field'), self.INPUT))
self.addParameter(
ParameterSelection(self.METHOD, self.tr('Method'), self.methods,
0))
self.addParameter(
ParameterNumber(self.NUMBER,
self.tr('Number/percentage of selected features'),
1, None, 10))
self.addOutput(
OutputVector(self.OUTPUT, self.tr('Selection stratified'), True))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Select by expression')
self.group, self.i18n_group = self.trAlgorithm(
'Vector selection tools')
self.methods = [
self.tr('creating new selection'),
self.tr('adding to current selection'),
self.tr('removing from current selection'),
self.tr('selecting within current selection')
]
self.addParameter(
ParameterVector(self.LAYERNAME, self.tr('Input Layer')))
self.addParameter(
ParameterExpression(self.EXPRESSION,
self.tr("Expression"),
parent_layer=self.LAYERNAME))
self.addParameter(
ParameterSelection(self.METHOD,
self.tr('Modify current selection by'),
self.methods, 0))
self.addOutput(
OutputVector(self.RESULT, self.tr('Selected (expression)'), True))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Contour')
self.group, self.i18n_group = self.trAlgorithm('Raster extraction')
self.addParameter(
ParameterRaster(self.INPUT_RASTER, self.tr('Input layer'), False))
self.addParameter(
ParameterNumber(self.INTERVAL,
self.tr('Interval between contour lines'), 0.0,
99999999.999999, 10.0))
self.addParameter(
ParameterString(
self.FIELD_NAME,
self.
tr('Attribute name (if not set, no elevation attribute is attached)'
),
'ELEV',
optional=True))
self.addParameter(
ParameterString(self.EXTRA,
self.tr('Additional creation parameters'),
'',
optional=True))
self.addOutput(OutputVector(self.OUTPUT_VECTOR, self.tr('Contours')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Convex hull')
self.group, self.i18n_group = self.trAlgorithm('Vector geometry tools')
self.methods = [
self.tr('Create single minimum convex hull'),
self.tr('Create convex hulls based on field')
]
self.addParameter(ParameterVector(self.INPUT, self.tr('Input layer')))
self.addParameter(
ParameterTableField(
self.FIELD,
self.
tr('Field (optional, only used if creating convex hulls by classes)'
),
self.INPUT,
optional=True))
self.addParameter(
ParameterSelection(self.METHOD, self.tr('Method'), self.methods))
self.addOutput(
OutputVector(self.OUTPUT,
self.tr('Convex hull'),
datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm(
'Advanced Python field calculator')
self.group, self.i18n_group = self.trAlgorithm('Vector table tools')
self.type_names = [
self.tr('Integer'),
self.tr('Float'),
self.tr('String')
]
self.addParameter(
ParameterVector(self.INPUT_LAYER, self.tr('Input layer')))
self.addParameter(
ParameterString(self.FIELD_NAME, self.tr('Result field name'),
'NewField'))
self.addParameter(
ParameterSelection(self.FIELD_TYPE, self.tr('Field type'),
self.type_names))
self.addParameter(
ParameterNumber(self.FIELD_LENGTH, self.tr('Field length'), 1, 255,
10))
self.addParameter(
ParameterNumber(self.FIELD_PRECISION, self.tr('Field precision'),
0, 10, 0))
self.addParameter(
ParameterString(self.GLOBAL,
self.tr('Global expression'),
multiline=True,
optional=True))
self.addParameter(
ParameterString(self.FORMULA,
self.tr('Formula'),
'value = ',
multiline=True))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Calculated')))
def defineCharacteristics(self):
self.addParameter(
ParameterVector(self.VECTOR, self.tr('Input point layer'),
[dataobjects.TYPE_VECTOR_POINT]))
self.addParameter(
ParameterTableField(self.GROUP_FIELD, self.tr('Group field'),
self.VECTOR))
self.addParameter(
ParameterTableField(self.ORDER_FIELD, self.tr('Order field'),
self.VECTOR))
self.addParameter(
ParameterString(
self.DATE_FORMAT,
self.tr('Date format (if order field is DateTime)'),
'',
optional=True))
#self.addParameter(ParameterNumber(
# self.GAP_PERIOD,
# 'Gap period (if order field is DateTime)', 0, 60, 0))
self.addOutput(
OutputVector(self.OUTPUT_LINES,
self.tr('Paths'),
datatype=[dataobjects.TYPE_VECTOR_LINE]))
self.addOutput(OutputDirectory(self.OUTPUT_TEXT, self.tr('Directory')))
def __init__(self):
super().__init__()
self.addParameter(
ParameterExtent(self.EXTENT,
self.tr('Grid extent'),
optional=False))
self.addParameter(
ParameterNumber(self.HSPACING,
self.tr('Horizontal spacing'),
0.0,
1000000000.0,
default=0.0001))
self.addParameter(
ParameterNumber(self.VSPACING,
self.tr('Vertical spacing'),
0.0,
1000000000.0,
default=0.0001))
self.addParameter(
ParameterNumber(self.HOVERLAY,
self.tr('Horizontal overlay'),
0.0,
1000000000.0,
default=0.0))
self.addParameter(
ParameterNumber(self.VOVERLAY,
self.tr('Vertical overlay'),
0.0,
1000000000.0,
default=0.0))
self.addParameter(ParameterCrs(self.CRS, 'Grid CRS', 'EPSG:4326'))
self.addOutput(
OutputVector(self.OUTPUT,
self.tr('Grid'),
datatype=[dataobjects.TYPE_VECTOR_LINE]))
def processOutputParameterToken(self, token):
out = None
if token.lower().strip().startswith('raster'):
out = OutputRaster()
elif token.lower().strip().startswith('vector'):
out = OutputVector()
elif token.lower().strip().startswith('table'):
out = OutputTable()
elif token.lower().strip().startswith('html'):
out = OutputHTML()
elif token.lower().strip().startswith('file'):
out = OutputFile()
subtokens = token.split(' ')
if len(subtokens) > 2:
out.ext = subtokens[2]
elif token.lower().strip().startswith('directory'):
out = OutputDirectory()
elif token.lower().strip().startswith('number'):
out = OutputNumber()
elif token.lower().strip().startswith('string'):
out = OutputString()
return out
def defineCharacteristics(self):
self.addParameter(ParameterVector(self.INPUT_LAYER,
self.tr('Input layer'), [dataobjects.TYPE_VECTOR_ANY]))
self.addParameter(ParameterString(self.NODES,
self.tr('Node indices'), default='0'))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Nodes'), datatype=[dataobjects.TYPE_VECTOR_POINT]))
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 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_LAYER, self.tr('Input layer'),
[dataobjects.TYPE_VECTOR_POLYGON]))
self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Centroids')))
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 __init__(self,name='', description='', hidden=False):
OutputVector.__init__(self, name, description,hidden)
self.hidden = True
