def testMultiple(self): parameter = ParameterSelection('myName', 'myDesc', ['option1', 'option2', 'option3'], multiple=True) self.assertEqual(parameter.setValue(1), True) self.assertEqual(parameter.value, 1) self.assertEqual(parameter.setValue([0, 1]), True) self.assertEqual(parameter.value, [0, 1]) self.assertEqual(parameter.setValue(['0', '1']), True) self.assertEqual(parameter.value, [0, 1])
def testMultiple(self): parameter = ParameterSelection("myName", "myDesc", ["option1", "option2", "option3"], multiple=True) self.assertEqual(parameter.setValue(1), True) self.assertEqual(parameter.value, 1) self.assertEqual(parameter.setValue([0, 1]), True) self.assertEqual(parameter.value, [0, 1]) self.assertEqual(parameter.setValue(["0", "1"]), True) self.assertEqual(parameter.value, [0, 1])
def defineCharacteristicsFromFile(self): with open(self.descriptionFile) as lines: line = lines.readline().strip('\n').strip() self.name = line if '|' in self.name: tokens = self.name.split('|') self.name = tokens[0] #cmdname is the name of the algorithm in SAGA, that is, the name to use to call it in the console self.cmdname = tokens[1] else: self.cmdname = self.name self.i18n_name = QCoreApplication.translate("SAGAAlgorithm", str(self.name)) #_commandLineName is the name used in processing to call the algorithm #Most of the time will be equal to the cmdname, but in same cases, several processing algorithms #call the same SAGA one self._commandLineName = self.createCommandLineName(self.name) self.name = decoratedAlgorithmName(self.name) self.i18n_name = QCoreApplication.translate("SAGAAlgorithm", str(self.name)) line = lines.readline().strip('\n').strip() self.undecoratedGroup = line self.group = decoratedGroupName(self.undecoratedGroup) self.i18n_group = QCoreApplication.translate("SAGAAlgorithm", self.group) line = lines.readline().strip('\n').strip() while line != '': if line.startswith('Hardcoded'): self.hardcodedStrings.append(line[len('Hardcoded|'):]) elif line.startswith('Parameter'): self.addParameter(getParameterFromString(line)) elif line.startswith('AllowUnmatching'): self.allowUnmatchingGridExtents = True elif line.startswith('NoResamplingChoice'): self.noResamplingChoice = True elif line.startswith('Extent'): # An extent parameter that wraps 4 SAGA numerical parameters self.extentParamNames = line[6:].strip().split(' ') self.addParameter(ParameterExtent(self.OUTPUT_EXTENT, 'Output extent')) else: self.addOutput(getOutputFromString(line)) line = lines.readline().strip('\n').strip() hasRaster = False for param in self.parameters: if (isinstance(param, ParameterRaster) or (isinstance(param, ParameterMultipleInput) and param.datatype == ParameterMultipleInput.TYPE_RASTER)): hasRaster = True break if (not self.noResamplingChoice and hasRaster): param = ParameterSelection(self.RESAMPLING, "Resampling method", ["Nearest Neighbour", "Bilinear Interpolation", "Bicubic Spline Interpolation", "B-Spline Interpolation"], 3) param.isAdvanced = True self.addParameter(param)
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm('Heatmap (Kernel Density Estimation)') self.group, self.i18n_group = self.trAlgorithm('Interpolation') self.tags = self.tr('heatmap,kde,hotspot') self.addParameter(ParameterVector(self.INPUT_LAYER, self.tr('Point layer'), [dataobjects.TYPE_VECTOR_POINT])) self.addParameter(ParameterNumber(self.RADIUS, self.tr('Radius (layer units)'), 0.0, 9999999999, 100.0)) radius_field_param = ParameterTableField(self.RADIUS_FIELD, self.tr('Radius from field'), self.INPUT_LAYER, optional=True, datatype=ParameterTableField.DATA_TYPE_NUMBER) radius_field_param.isAdvanced = True self.addParameter(radius_field_param) class ParameterHeatmapPixelSize(ParameterNumber): def __init__(self, name='', description='', parent_layer=None, radius_param=None, radius_field_param=None, minValue=None, maxValue=None, default=None, optional=False, metadata={}): ParameterNumber.__init__(self, name, description, minValue, maxValue, default, optional, metadata) self.parent_layer = parent_layer self.radius_param = radius_param self.radius_field_param = radius_field_param self.addParameter(ParameterHeatmapPixelSize(self.PIXEL_SIZE, self.tr('Output raster size'), parent_layer=self.INPUT_LAYER, radius_param=self.RADIUS, radius_field_param=self.RADIUS_FIELD, minValue=0.0, maxValue=9999999999, default=0.1, metadata={'widget_wrapper': HeatmapPixelSizeWidgetWrapper})) weight_field_param = ParameterTableField(self.WEIGHT_FIELD, self.tr('Weight from field'), self.INPUT_LAYER, optional=True, datatype=ParameterTableField.DATA_TYPE_NUMBER) weight_field_param.isAdvanced = True self.addParameter(weight_field_param) kernel_shape_param = ParameterSelection(self.KERNEL, self.tr('Kernel shape'), self.KERNELS) kernel_shape_param.isAdvanced = True self.addParameter(kernel_shape_param) decay_ratio = ParameterNumber(self.DECAY, self.tr('Decay ratio (Triangular kernels only)'), -100.0, 100.0, 0.0) decay_ratio.isAdvanced = True self.addParameter(decay_ratio) output_scaling = ParameterSelection(self.OUTPUT_VALUE, self.tr('Output value scaling'), self.OUTPUT_VALUES) output_scaling.isAdvanced = True self.addParameter(output_scaling) self.addOutput(OutputRaster(self.OUTPUT_LAYER, self.tr('Heatmap')))
def testOptional(self): optionalParameter = ParameterSelection('myName', 'myDesc', ['option1', 'option2', 'option3'], default=0, optional=True) self.assertEqual(optionalParameter.value, 0) optionalParameter.setValue(1) self.assertEqual(optionalParameter.value, 1) self.assertTrue(optionalParameter.setValue(None)) self.assertEqual(optionalParameter.value, None) requiredParameter = ParameterSelection('myName', 'myDesc', ['option1', 'option2', 'option3'], default=0, optional=False) self.assertEqual(requiredParameter.value, 0) requiredParameter.setValue(1) self.assertEqual(requiredParameter.value, 1) self.assertFalse(requiredParameter.setValue(None)) self.assertEqual(requiredParameter.value, 1)
def __init__(self): super().__init__() self.addParameter(ParameterVector(self.INPUT_LAYER, self.tr('Point layer'), [dataobjects.TYPE_VECTOR_POINT])) self.addParameter(ParameterNumber(self.RADIUS, self.tr('Radius (layer units)'), 0.0, 9999999999, 100.0)) radius_field_param = ParameterTableField(self.RADIUS_FIELD, self.tr('Radius from field'), self.INPUT_LAYER, optional=True, datatype=ParameterTableField.DATA_TYPE_NUMBER) radius_field_param.setFlags(radius_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(radius_field_param) class ParameterHeatmapPixelSize(ParameterNumber): def __init__(self, name='', description='', parent_layer=None, radius_param=None, radius_field_param=None, minValue=None, maxValue=None, default=None, optional=False, metadata={}): ParameterNumber.__init__(self, name, description, minValue, maxValue, default, optional, metadata) self.parent_layer = parent_layer self.radius_param = radius_param self.radius_field_param = radius_field_param self.addParameter(ParameterHeatmapPixelSize(self.PIXEL_SIZE, self.tr('Output raster size'), parent_layer=self.INPUT_LAYER, radius_param=self.RADIUS, radius_field_param=self.RADIUS_FIELD, minValue=0.0, maxValue=9999999999, default=0.1, metadata={'widget_wrapper': HeatmapPixelSizeWidgetWrapper})) weight_field_param = ParameterTableField(self.WEIGHT_FIELD, self.tr('Weight from field'), self.INPUT_LAYER, optional=True, datatype=ParameterTableField.DATA_TYPE_NUMBER) weight_field_param.setFlags(weight_field_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(weight_field_param) kernel_shape_param = ParameterSelection(self.KERNEL, self.tr('Kernel shape'), self.KERNELS) kernel_shape_param.setFlags(kernel_shape_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(kernel_shape_param) decay_ratio = ParameterNumber(self.DECAY, self.tr('Decay ratio (Triangular kernels only)'), -100.0, 100.0, 0.0) decay_ratio.setFlags(decay_ratio.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(decay_ratio) output_scaling = ParameterSelection(self.OUTPUT_VALUE, self.tr('Output value scaling'), self.OUTPUT_VALUES) output_scaling.setFlags(output_scaling.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(output_scaling) self.addOutput(OutputRaster(self.OUTPUT_LAYER, self.tr('Heatmap')))
def testOptional(self): optionalParameter = ParameterSelection( "myName", "myDesc", ["option1", "option2", "option3"], default=0, optional=True ) self.assertEqual(optionalParameter.value, 0) optionalParameter.setValue(1) self.assertEqual(optionalParameter.value, 1) self.assertTrue(optionalParameter.setValue(None)) self.assertEqual(optionalParameter.value, None) requiredParameter = ParameterSelection( "myName", "myDesc", ["option1", "option2", "option3"], default=0, optional=False ) self.assertEqual(requiredParameter.value, 0) requiredParameter.setValue(1) self.assertEqual(requiredParameter.value, 1) self.assertFalse(requiredParameter.setValue(None)) self.assertEqual(requiredParameter.value, 1)
def testSetValue(self): parameter = ParameterSelection('myName', 'myDesc', ['option1', 'option2', 'option3']) self.assertIsNone(parameter.value) self.assertEqual(parameter.setValue(1), True) self.assertEqual(parameter.value, 1) self.assertEqual(parameter.setValue('1'), True) self.assertEqual(parameter.value, 1) self.assertEqual(parameter.setValue(1.0), True) self.assertEqual(parameter.value, 1) self.assertEqual(parameter.setValue('1a'), False) self.assertEqual(parameter.setValue([1]), False)
def testSetValue(self): parameter = ParameterSelection("myName", "myDesc", ["option1", "option2", "option3"]) self.assertIsNone(parameter.value) self.assertEqual(parameter.setValue(1), True) self.assertEqual(parameter.value, 1) self.assertEqual(parameter.setValue("1"), True) self.assertEqual(parameter.value, 1) self.assertEqual(parameter.setValue(1.0), True) self.assertEqual(parameter.value, 1) self.assertEqual(parameter.setValue("1a"), False) self.assertEqual(parameter.setValue([1]), False)
def testTupleOptions(self): options = (("o1", "option1"), ("o2", "option2"), ("o3", "option3")) optionalParameter = ParameterSelection("myName", "myDesc", options, default="o1") self.assertEqual(optionalParameter.value, "o1") optionalParameter.setValue("o2") self.assertEqual(optionalParameter.value, "o2") optionalParameter = ParameterSelection("myName", "myDesc", options, default=["o1", "o2"], multiple=True) self.assertEqual(optionalParameter.value, ["o1", "o2"]) optionalParameter.setValue(["o2"]) self.assertEqual(optionalParameter.value, ["o2"])
def testTupleOptions(self): options = ( ('o1', 'option1'), ('o2', 'option2'), ('o3', 'option3')) optionalParameter = ParameterSelection('myName', 'myDesc', options, default='o1') self.assertEqual(optionalParameter.value, 'o1') optionalParameter.setValue('o2') self.assertEqual(optionalParameter.value, 'o2') optionalParameter = ParameterSelection('myName', 'myDesc', options, default=['o1', 'o2'], multiple=True) self.assertEqual(optionalParameter.value, ['o1', 'o2']) optionalParameter.setValue(['o2']) self.assertEqual(optionalParameter.value, ['o2'])
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm('Warp (reproject)') self.group, self.i18n_group = self.trAlgorithm('[GDAL] Projections') self.tags = self.tr('transform,reproject,crs,srs') self.addParameter( ParameterRaster(self.INPUT, self.tr('Input layer'), False)) self.addParameter( ParameterCrs(self.SOURCE_SRS, self.tr('Source SRS'), '', optional=True)) self.addParameter( ParameterCrs(self.DEST_SRS, self.tr('Destination SRS'), 'EPSG:4326')) self.addParameter( ParameterString( self.NO_DATA, self. tr("Nodata value, leave blank to take the nodata value from input" ), '', optional=True)) self.addParameter( ParameterNumber( self.TR, self. tr('Output file resolution in target georeferenced units (leave 0 for no change)' ), 0.0, None, 0.0)) self.addParameter( ParameterSelection(self.METHOD, self.tr('Resampling method'), self.METHOD_OPTIONS)) self.addParameter( ParameterExtent(self.RAST_EXT, self.tr('Raster extent'), optional=True)) if GdalUtils.version() >= 2000000: self.addParameter( ParameterCrs( self.EXT_CRS, self. tr('CRS of the raster extent, leave blank for using Destination SRS' ), optional=True)) params = [] params.append( ParameterSelection(self.RTYPE, self.tr('Output raster type'), self.TYPE, 5)) params.append( ParameterSelection(self.COMPRESS, self.tr('GeoTIFF options. Compression type:'), self.COMPRESSTYPE, 4)) params.append( ParameterNumber(self.JPEGCOMPRESSION, self.tr('Set the JPEG compression level'), 1, 100, 75)) params.append( ParameterNumber(self.ZLEVEL, self.tr('Set the DEFLATE compression level'), 1, 9, 6)) params.append( ParameterNumber( self.PREDICTOR, self.tr('Set the predictor for LZW or DEFLATE compression'), 1, 3, 1)) params.append( ParameterBoolean( self.TILED, self.tr( 'Create tiled output (only used for the GTiff format)'), False)) params.append( ParameterSelection( self.BIGTIFF, self. tr('Control whether the created file is a BigTIFF or a classic TIFF' ), self.BIGTIFFTYPE, 0)) params.append( ParameterBoolean( self.TFW, self. tr('Force the generation of an associated ESRI world file (.tfw))' ), False)) params.append( ParameterString(self.EXTRA, self.tr('Additional creation parameters'), '', optional=True)) for param in params: param.isAdvanced = True self.addParameter(param) self.addOutput(OutputRaster(self.OUTPUT, self.tr('Reprojected')))
def initAlgorithm(self, config=None): self.DIRECTIONS = OrderedDict([ (self.tr('Forward direction'), QgsVectorLayerDirector.DirectionForward), (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionForward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionForward)]) self.STRATEGIES = [self.tr('Shortest'), self.tr('Fastest') ] self.addParameter(ParameterVector(self.INPUT_VECTOR, self.tr('Vector layer representing network'), [dataobjects.TYPE_VECTOR_LINE])) self.addParameter(ParameterPoint(self.START_POINT, self.tr('Start point'))) self.addParameter(ParameterSelection(self.STRATEGY, self.tr('Path type to calculate'), self.STRATEGIES, default=0)) self.addParameter(ParameterNumber(self.TRAVEL_COST, self.tr('Travel cost (distance for "Shortest", time for "Fastest")'), 0.0, 99999999.999999, 0.0)) params = [] params.append(ParameterTableField(self.DIRECTION_FIELD, self.tr('Direction field'), self.INPUT_VECTOR, optional=True)) params.append(ParameterString(self.VALUE_FORWARD, self.tr('Value for forward direction'), '', optional=True)) params.append(ParameterString(self.VALUE_BACKWARD, self.tr('Value for backward direction'), '', optional=True)) params.append(ParameterString(self.VALUE_BOTH, self.tr('Value for both directions'), '', optional=True)) params.append(ParameterSelection(self.DEFAULT_DIRECTION, self.tr('Default direction'), list(self.DIRECTIONS.keys()), default=2)) params.append(ParameterTableField(self.SPEED_FIELD, self.tr('Speed field'), self.INPUT_VECTOR, optional=True)) params.append(ParameterNumber(self.DEFAULT_SPEED, self.tr('Default speed (km/h)'), 0.0, 99999999.999999, 5.0)) params.append(ParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), 0.0, 99999999.999999, 0.0)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(p) self.addOutput(OutputVector(self.OUTPUT_POINTS, self.tr('Service area (boundary nodes)'), datatype=[dataobjects.TYPE_VECTOR_POINT])) self.addOutput(OutputVector(self.OUTPUT_POLYGON, self.tr('Service area (convex hull)'), datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def defineCharacteristics(self): # Required parameters self.addParameter(ParameterRaster(self.INPUT, self.tr('Input layer'))) # Advanced parameters params = [] params.append( ParameterSelection(self.PROFILE, self.tr('Tile cutting profile'), self.PROFILES, 0, False, optional=True)) params.append( ParameterSelection(self.RESAMPLING, self.tr('Resampling method'), self.RESAMPLINGS, 0, False, optional=True)) params.append( ParameterCrs( self.S_SRS, self. tr('The spatial reference system used for the source input data' ), None, True)) params.append( ParameterString(self.ZOOM, self.tr('Zoom levels to render'), None, False, True)) params.append( ParameterBoolean( self.RESUME, self.tr('Resume mode, generate only missing files'), False, True)) params.append( ParameterString( self.NODATA, self.tr( 'NODATA transparency value to assign to the input data'), None, False, True)) params.append( ParameterBoolean( self.FORCEKML, self. tr('Generate KML for Google Earth - default for "geodetic" profile and "raster" in EPSG:4326' ), False, True)) params.append( ParameterBoolean( self.NOKML, self.tr( 'Avoid automatic generation of KML files for EPSG:4326'), False, True)) params.append( ParameterString( self.URL, self. tr('URL address where the generated tiles are going to be published' ), None, False, True)) params.append( ParameterSelection(self.WEBVIEWER, self.tr('Web viewer to generate'), self.WEBVIEWERS, 0, False, optional=True)) params.append( ParameterString(self.TITLE, self.tr('Title of the map'), None, False, True)) params.append( ParameterString(self.COPYRIGHT, self.tr('Copyright for the map'), None, False, True)) params.append( ParameterString( self.GOOGLEKEY, self. tr('Google Maps API key from http://code.google.com/apis/maps/signup.html' ), None, False, True)) params.append( ParameterString( self.BINGKEY, self.tr( 'Bing Maps API key from https://www.bingmapsportal.com/'), None, False, True)) for param in params: param.isAdvanced = True self.addParameter(param) self.addOutput( OutputDirectory( self.OUTPUTDIR, self.tr('The directory where the tile result is created')))
def processInputParameterToken(self, token, name): param = None descName = self.createDescriptiveName(name) if token.lower().strip() == 'raster': param = ParameterRaster(name, descName, False) elif token.lower().strip() == 'vector': param = ParameterVector(name, descName, [dataobjects.TYPE_VECTOR_ANY]) elif token.lower().strip() == 'vector point': param = ParameterVector(name, descName, [dataobjects.TYPE_VECTOR_POINT]) elif token.lower().strip() == 'vector line': param = ParameterVector(name, descName, [dataobjects.TYPE_VECTOR_LINE]) elif token.lower().strip() == 'vector polygon': param = ParameterVector(name, descName, [dataobjects.TYPE_VECTOR_POLYGON]) elif token.lower().strip() == 'table': param = ParameterTable(name, descName, False) elif token.lower().strip() == 'multiple raster': param = ParameterMultipleInput(name, descName, dataobjects.TYPE_RASTER) param.optional = False elif token.lower().strip() == 'multiple vector': param = ParameterMultipleInput(name, descName, dataobjects.TYPE_VECTOR_ANY) param.optional = False elif token.lower().strip().startswith('selectionfromfile'): options = token.strip()[len('selectionfromfile '):].split(';') param = ParameterSelection(name, descName, options, isSource=True) elif token.lower().strip().startswith('selection'): options = token.strip()[len('selection '):].split(';') param = ParameterSelection(name, descName, options) elif token.lower().strip().startswith('boolean'): default = token.strip()[len('boolean') + 1:] if default: param = ParameterBoolean(name, descName, default) else: param = ParameterBoolean(name, descName) elif token.lower().strip() == 'extent': param = ParameterExtent(name, descName) elif token.lower().strip() == 'point': param = ParameterPoint(name, descName) elif token.lower().strip() == 'file': param = ParameterFile(name, descName, False) elif token.lower().strip() == 'folder': param = ParameterFile(name, descName, True) elif token.lower().strip().startswith('number'): default = token.strip()[len('number') + 1:] if default: param = ParameterNumber(name, descName, default=default) else: param = ParameterNumber(name, descName) elif token.lower().strip().startswith('field'): if token.lower().strip().startswith('field number'): field = token.strip()[len('field number') + 1:] datatype = ParameterTableField.DATA_TYPE_NUMBER elif token.lower().strip().startswith('field string'): field = token.strip()[len('field string') + 1:] datatype = ParameterTableField.DATA_TYPE_STRING else: field = token.strip()[len('field') + 1:] datatype = ParameterTableField.DATA_TYPE_ANY found = False for p in self.parameters: if p.name == field: found = True break if found: param = ParameterTableField(name=name, description=descName, parent=field, datatype=datatype) elif token.lower().strip().startswith('multiple field'): if token.lower().strip().startswith('multiple field number'): field = token.strip()[len('multiple field number') + 1:] datatype = ParameterTableMultipleField.DATA_TYPE_NUMBER elif token.lower().strip().startswith('multiple field string'): field = token.strip()[len('multiple field string') + 1:] datatype = ParameterTableMultipleField.DATA_TYPE_STRING else: field = token.strip()[len('multiple field') + 1:] datatype = ParameterTableMultipleField.DATA_TYPE_ANY found = False for p in self.parameters: if p.name == field: found = True break if found: param = ParameterTableMultipleField(name=name, description=descName, parent=field, datatype=datatype) elif token.lower().strip().startswith('string'): default = token.strip()[len('string') + 1:] if default: param = ParameterString(name, descName, default) else: param = ParameterString(name, descName) elif token.lower().strip().startswith('longstring'): default = token.strip()[len('longstring') + 1:] if default: param = ParameterString(name, descName, default, multiline=True) else: param = ParameterString(name, descName, multiline=True) elif token.lower().strip().startswith('crs'): default = token.strip()[len('crs') + 1:] if default: param = ParameterCrs(name, descName, default) else: param = ParameterCrs(name, descName) return param
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm( 'Rasterize (vector to raster)') self.group, self.i18n_group = self.trAlgorithm('[GDAL] Conversion') self.addParameter(ParameterVector(self.INPUT, self.tr('Input layer'))) self.addParameter( ParameterTableField(self.FIELD, self.tr('Attribute field'), self.INPUT)) self.addParameter( ParameterSelection( self.DIMENSIONS, self. tr('Set output raster size (ignored if above option is checked)' ), [ 'Output size in pixels', 'Output resolution in map units per pixel' ], 1)) self.addParameter( ParameterNumber(self.WIDTH, self.tr('Horizontal'), 0.0, 99999999.999999, 100.0)) self.addParameter( ParameterNumber(self.HEIGHT, self.tr('Vertical'), 0.0, 99999999.999999, 100.0)) self.addParameter( ParameterExtent(self.RAST_EXT, self.tr('Raster extent'))) params = [] params.append( ParameterSelection(self.RTYPE, self.tr('Raster type'), self.TYPE, 5)) params.append( ParameterString(self.NO_DATA, self.tr("Nodata value"), '', optional=True)) params.append( ParameterSelection(self.COMPRESS, self.tr('GeoTIFF options. Compression type:'), self.COMPRESSTYPE, 4)) params.append( ParameterNumber(self.JPEGCOMPRESSION, self.tr('Set the JPEG compression level'), 1, 100, 75)) params.append( ParameterNumber(self.ZLEVEL, self.tr('Set the DEFLATE compression level'), 1, 9, 6)) params.append( ParameterNumber( self.PREDICTOR, self.tr('Set the predictor for LZW or DEFLATE compression'), 1, 3, 1)) params.append( ParameterBoolean( self.TILED, self.tr( 'Create tiled output (only used for the GTiff format)'), False)) params.append( ParameterSelection( self.BIGTIFF, self. tr('Control whether the created file is a BigTIFF or a classic TIFF' ), self.BIGTIFFTYPE, 0)) self.addParameter( ParameterBoolean( self.TFW, self. tr('Force the generation of an associated ESRI world file (.tfw)' ), False)) params.append( ParameterString(self.EXTRA, self.tr('Additional creation parameters'), '', optional=True)) for param in params: param.isAdvanced = True self.addParameter(param) self.addOutput(OutputRaster(self.OUTPUT, self.tr('Rasterized')))
def defineCharacteristics(self): self.DIRECTIONS = OrderedDict([ (self.tr('Forward direction'), QgsVectorLayerDirector.DirectionForward), (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionForward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionForward) ]) self.STRATEGIES = [self.tr('Shortest'), self.tr('Fastest')] self.name, self.i18n_name = self.trAlgorithm( 'Shortest path (layer to point)') self.group, self.i18n_group = self.trAlgorithm('Network analysis') self.addParameter( ParameterVector(self.INPUT_VECTOR, self.tr('Vector layer representing network'), [dataobjects.TYPE_VECTOR_LINE])) self.addParameter( ParameterVector(self.START_POINTS, self.tr('Vector layer with start points'), [dataobjects.TYPE_VECTOR_POINT])) self.addParameter(ParameterPoint(self.END_POINT, self.tr('End point'))) self.addParameter( ParameterSelection(self.STRATEGY, self.tr('Path type to calculate'), self.STRATEGIES, default=0)) params = [] params.append( ParameterTableField(self.DIRECTION_FIELD, self.tr('Direction field'), self.INPUT_VECTOR, optional=True)) params.append( ParameterString(self.VALUE_FORWARD, self.tr('Value for forward direction'), '', optional=True)) params.append( ParameterString(self.VALUE_BACKWARD, self.tr('Value for backward direction'), '', optional=True)) params.append( ParameterString(self.VALUE_BOTH, self.tr('Value for both directions'), '', optional=True)) params.append( ParameterSelection(self.DEFAULT_DIRECTION, self.tr('Default direction'), list(self.DIRECTIONS.keys()), default=2)) params.append( ParameterTableField(self.SPEED_FIELD, self.tr('Speed field'), self.INPUT_VECTOR, optional=True)) params.append( ParameterNumber(self.DEFAULT_SPEED, self.tr('Default speed (km/h)'), 0.0, 99999999.999999, 5.0)) params.append( ParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), 0.0, 99999999.999999, 0.0)) for p in params: p.isAdvanced = True self.addParameter(p) self.addOutput( OutputVector(self.OUTPUT_LAYER, self.tr('Shortest path'), datatype=[dataobjects.TYPE_VECTOR_LINE]))
def defineCharacteristicsFromFile(self): lines = open(self.descriptionFile) line = lines.readline().strip('\n').strip() self.grass7Name = line line = lines.readline().strip('\n').strip() self.name = line self.i18n_name = QCoreApplication.translate("GrassAlgorithm", line) if " - " not in self.name: self.name = self.grass7Name + " - " + self.name self.i18n_name = self.grass7Name + " - " + self.i18n_name line = lines.readline().strip('\n').strip() self.group = line self.i18n_group = QCoreApplication.translate("GrassAlgorithm", line) hasRasterOutput = False hasVectorInput = False vectorOutputs = 0 line = lines.readline().strip('\n').strip() while line != '': try: line = line.strip('\n').strip() if line.startswith('Hardcoded'): self.hardcodedStrings.append(line[len('Hardcoded|'):]) elif line.startswith('Parameter'): parameter = getParameterFromString(line) self.addParameter(parameter) if isinstance(parameter, ParameterVector): hasVectorInput = True if isinstance(parameter, ParameterMultipleInput) \ and parameter.datatype < 3: hasVectorInput = True elif line.startswith('*Parameter'): param = getParameterFromString(line[1:]) param.isAdvanced = True self.addParameter(param) else: output = getOutputFromString(line) self.addOutput(output) if isinstance(output, OutputRaster): hasRasterOutput = True elif isinstance(output, OutputVector): vectorOutputs += 1 if isinstance(output, OutputHTML): self.addOutput( OutputFile("rawoutput", output.description + " (raw output)", "txt")) line = lines.readline().strip('\n').strip() except Exception as e: ProcessingLog.addToLog( ProcessingLog.LOG_ERROR, self.tr('Could not open GRASS GIS 7 algorithm: %s\n%s' % (self.descriptionFile, line))) raise e lines.close() self.addParameter( ParameterExtent(self.GRASS_REGION_EXTENT_PARAMETER, self.tr('GRASS GIS 7 region extent'))) if hasRasterOutput: self.addParameter( ParameterNumber( self.GRASS_REGION_CELLSIZE_PARAMETER, self.tr( 'GRASS GIS 7 region cellsize (leave 0 for default)'), 0, None, 0.0)) if hasVectorInput: param = ParameterNumber(self.GRASS_SNAP_TOLERANCE_PARAMETER, 'v.in.ogr snap tolerance (-1 = no snap)', -1, None, -1.0) param.isAdvanced = True self.addParameter(param) param = ParameterNumber(self.GRASS_MIN_AREA_PARAMETER, 'v.in.ogr min area', 0, None, 0.0001) param.isAdvanced = True self.addParameter(param) if vectorOutputs == 1: param = ParameterSelection(self.GRASS_OUTPUT_TYPE_PARAMETER, 'v.out.ogr output type', self.OUTPUT_TYPES) param.isAdvanced = True self.addParameter(param)
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm( '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.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.name, self.i18n_name = self.trAlgorithm('lascanopyPro') self.group, self.i18n_group = self.trAlgorithm('LAStools Production') self.addParametersPointInputFolderGUI() self.addParametersPointInputMergedGUI() self.addParameter( ParameterNumber(lascanopyPro.PLOT_SIZE, self.tr("square plot size"), 0, None, 20)) self.addParameter( ParameterNumber(lascanopyPro.HEIGHT_CUTOFF, self.tr("height cutoff / breast height"), 0, None, 1.37)) self.addParameter( ParameterSelection(lascanopyPro.PRODUCT1, self.tr("create"), lascanopyPro.PRODUCTS, 0)) self.addParameter( ParameterSelection(lascanopyPro.PRODUCT2, self.tr("create"), lascanopyPro.PRODUCTS, 0)) self.addParameter( ParameterSelection(lascanopyPro.PRODUCT3, self.tr("create"), lascanopyPro.PRODUCTS, 0)) self.addParameter( ParameterSelection(lascanopyPro.PRODUCT4, self.tr("create"), lascanopyPro.PRODUCTS, 0)) self.addParameter( ParameterSelection(lascanopyPro.PRODUCT5, self.tr("create"), lascanopyPro.PRODUCTS, 0)) self.addParameter( ParameterSelection(lascanopyPro.PRODUCT6, self.tr("create"), lascanopyPro.PRODUCTS, 0)) self.addParameter( ParameterSelection(lascanopyPro.PRODUCT7, self.tr("create"), lascanopyPro.PRODUCTS, 0)) self.addParameter( ParameterSelection(lascanopyPro.PRODUCT8, self.tr("create"), lascanopyPro.PRODUCTS, 0)) self.addParameter( ParameterSelection(lascanopyPro.PRODUCT9, self.tr("create"), lascanopyPro.PRODUCTS, 0)) self.addParameter( ParameterString(lascanopyPro.COUNTS, self.tr("count rasters (e.g. 2.0 5.0 10.0 20.0)"), "")) self.addParameter( ParameterString( lascanopyPro.DENSITIES, self.tr("density rasters (e.g. 2.0 5.0 10.0 20.0)"), "")) self.addParameter( ParameterBoolean( lascanopyPro.USE_TILE_BB, self.tr("use tile bounding box (after tiling with buffer)"), False)) self.addParameter( ParameterBoolean(lascanopyPro.FILES_ARE_PLOTS, self.tr("input file is single plot"), False)) self.addParametersOutputDirectoryGUI() self.addParametersOutputAppendixGUI() self.addParametersRasterOutputFormatGUI() self.addParametersRasterOutputGUI() self.addParametersAdditionalGUI() self.addParametersCoresGUI() self.addParametersVerboseGUI()
def addParametersIgnoreClass2GUI(self): self.addParameter( ParameterSelection( LAStoolsAlgorithm.IGNORE_CLASS2, self.tr("also ignore points with this classification"), LAStoolsAlgorithm.IGNORE_CLASSES, 0))
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm('Retile') self.group, self.i18n_group = self.trAlgorithm('[GDAL] Miscellaneous') # Required parameters self.addParameter( ParameterMultipleInput(self.INPUT, self.tr('Input layers'), dataobjects.TYPE_RASTER)) # Advanced parameters params = [] params.append( ParameterString( self.PIXELSIZE, self. tr('Pixel size to be used for the output file (XSIZE YSIZE like 512 512)' ), None, False, True)) params.append( ParameterSelection(self.ALGORITHM, self.tr('Resampling algorithm'), self.ALGO, 0, False, optional=True)) params.append( ParameterCrs(self.S_SRS, self.tr('Override source CRS'), None, True)) params.append( ParameterNumber(self.PYRAMIDLEVELS, self.tr('Number of pyramids levels to build'), None, None, None, True)) params.append( ParameterBoolean(self.ONLYPYRAMIDS, self.tr('Build only the pyramids'), False, True)) params.append( ParameterSelection(self.RTYPE, self.tr('Output raster type'), self.TYPE, 5, False, optional=True)) params.append( ParameterSelection(self.FORMAT, self.tr('Output raster format'), list(GdalUtils.getSupportedRasters().keys()), 0, False, optional=True)) params.append( ParameterBoolean(self.USEDIRFOREACHROW, self.tr('Use a directory for each row'), False, True)) params.append( ParameterString( self.CSVFILE, self. tr('Name of the csv file containing the tile(s) georeferencing information' ), None, False, True)) params.append( ParameterString(self.CSVDELIM, self.tr('Column delimiter used in the CSV file'), None, False, True)) params.append( ParameterString( self.TILEINDEX, self.tr( 'name of shape file containing the result tile(s) index'), None, False, True)) params.append( ParameterString( self.TILEINDEXFIELD, self. tr('name of the attribute containing the tile name in the result shape file' ), None, False, True)) for param in params: param.isAdvanced = True self.addParameter(param) self.addOutput( OutputDirectory( self.TARGETDIR, self.tr('The directory where the tile result is created')))
def addParametersFilter3ReturnClassFlagsGUI(self): self.addParameter( ParameterSelection( LAStoolsAlgorithm.FILTER_RETURN_CLASS_FLAGS3, self.tr("third filter (by return, classification, flags)"), LAStoolsAlgorithm.FILTERS_RETURN_CLASS_FLAGS, 0))
def addParametersVectorOutputFormatGUI(self): self.addParameter( ParameterSelection(LAStoolsAlgorithm.OUTPUT_VECTOR_FORMAT, self.tr("output format"), LAStoolsAlgorithm.OUTPUT_VECTOR_FORMATS, 0))
def addParametersPointOutputFormatGUI(self): self.addParameter( ParameterSelection(LAStoolsAlgorithm.OUTPUT_POINT_FORMAT, self.tr("output format"), LAStoolsAlgorithm.OUTPUT_POINT_FORMATS, 0))
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm('Clip raster by extent') self.group, self.i18n_group = self.trAlgorithm('[GDAL] Extraction') self.addParameter( ParameterRaster(self.INPUT, self.tr('Input layer'), False)) self.addParameter( ParameterString( self.NO_DATA, self. tr("Nodata value, leave blank to take the nodata value from input" ), '', optional=True)) self.addParameter( ParameterExtent(self.PROJWIN, self.tr('Clipping extent'))) params = [] params.append( ParameterSelection(self.RTYPE, self.tr('Output raster type'), self.TYPE, 5)) params.append( ParameterSelection(self.COMPRESS, self.tr('GeoTIFF options. Compression type:'), self.COMPRESSTYPE, 4)) params.append( ParameterNumber(self.JPEGCOMPRESSION, self.tr('Set the JPEG compression level'), 1, 100, 75)) params.append( ParameterNumber(self.ZLEVEL, self.tr('Set the DEFLATE compression level'), 1, 9, 6)) params.append( ParameterNumber( self.PREDICTOR, self.tr('Set the predictor for LZW or DEFLATE compression'), 1, 3, 1)) params.append( ParameterBoolean( self.TILED, self.tr( 'Create tiled output (only used for the GTiff format)'), False)) params.append( ParameterSelection( self.BIGTIFF, self. tr('Control whether the created file is a BigTIFF or a classic TIFF' ), self.BIGTIFFTYPE, 0)) params.append( ParameterBoolean( self.TFW, self. tr('Force the generation of an associated ESRI world file (.tfw))' ), False)) params.append( ParameterString(self.EXTRA, self.tr('Additional creation parameters'), '', optional=True)) for param in params: param.isAdvanced = True self.addParameter(param) self.addOutput(OutputRaster(self.OUTPUT, self.tr('Clipped (extent)')))
def addParametersTransform2OtherGUI(self): self.addParameter(ParameterSelection(LAStoolsAlgorithm.TRANSFORM_OTHER2, self.tr("second transform (intensities, scan angles, GPS times, ...)"), LAStoolsAlgorithm.TRANSFORM_OTHERS, 0)) self.addParameter(ParameterString(LAStoolsAlgorithm.TRANSFORM_OTHER2_ARG, self.tr("value for second transform (intensities, scan angles, GPS times, ...)")))
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm('Raster calculator') self.group, self.i18n_group = self.trAlgorithm('[GDAL] Miscellaneous') self.addParameter( ParameterRaster(self.INPUT_A, self.tr('Input layer A'), False)) self.addParameter( ParameterString(self.BAND_A, self.tr('Number of raster band for raster A'), '1', optional=True)) self.addParameter( ParameterRaster(self.INPUT_B, self.tr('Input layer B'), True)) self.addParameter( ParameterString(self.BAND_B, self.tr('Number of raster band for raster B'), '1', optional=True)) self.addParameter( ParameterRaster(self.INPUT_C, self.tr('Input layer C'), True)) self.addParameter( ParameterString(self.BAND_C, self.tr('Number of raster band for raster C'), '1', optional=True)) self.addParameter( ParameterRaster(self.INPUT_D, self.tr('Input layer D'), True)) self.addParameter( ParameterString(self.BAND_D, self.tr('Number of raster band for raster D'), '1', optional=True)) self.addParameter( ParameterRaster(self.INPUT_E, self.tr('Input layer E'), True)) self.addParameter( ParameterString(self.BAND_E, self.tr('Number of raster band for raster E'), '1', optional=True)) self.addParameter( ParameterRaster(self.INPUT_F, self.tr('Input layer F'), True)) self.addParameter( ParameterString(self.BAND_F, self.tr('Number of raster band for raster F'), '1', optional=True)) self.addParameter( ParameterString( self.FORMULA, self. tr('Calculation in gdalnumeric syntax using +-/* or any numpy array functions (i.e. logical_and())' ), 'A*2', optional=False)) self.addParameter( ParameterString(self.NO_DATA, self.tr('Set output nodata value'), '', optional=True)) self.addParameter( ParameterSelection(self.RTYPE, self.tr('Output raster type'), self.TYPE, 5)) #self.addParameter(ParameterBoolean( # self.DEBUG, self.tr('Print debugging information'), False)) self.addParameter( ParameterString(self.EXTRA, self.tr('Additional creation parameters'), '', optional=True)) self.addOutput(OutputRaster(self.OUTPUT, self.tr('Calculated')))
def processInputParameterToken(self, token, name): param = None desc = self.createDescriptiveName(name) if token.lower().strip().startswith('raster'): param = ParameterRaster(name, desc, False) elif token.lower().strip() == 'vector': param = ParameterVector(name, desc, [ParameterVector.VECTOR_TYPE_ANY]) elif token.lower().strip() == 'vector point': param = ParameterVector(name, desc, [ParameterVector.VECTOR_TYPE_POINT]) elif token.lower().strip() == 'vector line': param = ParameterVector(name, desc, [ParameterVector.VECTOR_TYPE_LINE]) elif token.lower().strip() == 'vector polygon': param = ParameterVector(name, desc, [ParameterVector.VECTOR_TYPE_POLYGON]) elif token.lower().strip() == 'table': param = ParameterTable(name, desc, False) elif token.lower().strip().startswith('multiple raster'): param = ParameterMultipleInput(name, desc, ParameterMultipleInput.TYPE_RASTER) param.optional = False elif token.lower().strip() == 'multiple vector': param = ParameterMultipleInput( name, desc, ParameterMultipleInput.TYPE_VECTOR_ANY) param.optional = False elif token.lower().strip().startswith('selection'): options = token.strip()[len('selection'):].split(';') param = ParameterSelection(name, desc, options) elif token.lower().strip().startswith('boolean'): default = token.strip()[len('boolean') + 1:] if default: param = ParameterBoolean(name, desc, default) else: param = ParameterBoolean(name, desc) elif token.lower().strip().startswith('number'): default = token.strip()[len('number') + 1:] if default: param = ParameterNumber(name, desc, default=default) else: param = ParameterNumber(name, desc) elif token.lower().strip().startswith('field'): field = token.strip()[len('field') + 1:] found = False for p in self.parameters: if p.name == field: found = True break if found: param = ParameterTableField(name, desc, field) elif token.lower().strip().startswith('multiple field'): field = token.strip()[len('multiple field') + 1:] found = False for p in self.parameters: if p.name == field: found = True break if found: param = ParameterTableMultipleField(name, desc, field) elif token.lower().strip() == 'extent': param = ParameterExtent(name, desc) elif token.lower().strip() == 'point': param = ParameterPoint(name, desc) elif token.lower().strip() == 'file': param = ParameterFile(name, desc, False) elif token.lower().strip() == 'folder': param = ParameterFile(name, desc, True) elif token.lower().strip().startswith('string'): default = token.strip()[len('string') + 1:] if default: param = ParameterString(name, desc, default) else: param = ParameterString(name, desc) elif token.lower().strip().startswith('longstring'): default = token.strip()[len('longstring') + 1:] if default: param = ParameterString(name, desc, default, multiline=True) else: param = ParameterString(name, desc, multiline=True) elif token.lower().strip() == 'crs': default = token.strip()[len('crs') + 1:] if default: param = ParameterCrs(name, desc, default) else: param = ParameterCrs(name, desc) return param
def addParametersTransform2CoordinateGUI(self): self.addParameter(ParameterSelection(LAStoolsAlgorithm.TRANSFORM_COORDINATE2, self.tr("second transform (coordinates)"), LAStoolsAlgorithm.TRANSFORM_COORDINATES, 0)) self.addParameter(ParameterString(LAStoolsAlgorithm.TRANSFORM_COORDINATE2_ARG, self.tr("value for second transform (coordinates)")))
def addParametersFilter2CoordsIntensityGUI(self): self.addParameter(ParameterSelection(LAStoolsAlgorithm.FILTER_COORDS_INTENSITY2, self.tr("second filter (by coordinate, intensity, GPS time, ...)"), LAStoolsAlgorithm.FILTERS_COORDS_INTENSITY, 0)) self.addParameter(ParameterString(LAStoolsAlgorithm.FILTER_COORDS_INTENSITY2_ARG, self.tr("value for second filter (by coordinate, intensity, GPS time, ...)")))
class Grass7Algorithm(GeoAlgorithm): GRASS_OUTPUT_TYPE_PARAMETER = 'GRASS_OUTPUT_TYPE_PARAMETER' GRASS_MIN_AREA_PARAMETER = 'GRASS_MIN_AREA_PARAMETER' GRASS_SNAP_TOLERANCE_PARAMETER = 'GRASS_SNAP_TOLERANCE_PARAMETER' GRASS_REGION_EXTENT_PARAMETER = 'GRASS_REGION_PARAMETER' GRASS_REGION_CELLSIZE_PARAMETER = 'GRASS_REGION_CELLSIZE_PARAMETER' GRASS_REGION_ALIGN_TO_RESOLUTION = '-a_r.region' OUTPUT_TYPES = ['auto', 'point', 'line', 'area'] def __init__(self, descriptionfile): GeoAlgorithm.__init__(self) self.descriptionFile = descriptionfile self.defineCharacteristicsFromFile() self.numExportedLayers = 0 # GRASS GIS 7 console output, needed to do postprocessing in case GRASS # dumps results to the console self.consoleOutput = [] def getCopy(self): newone = Grass7Algorithm(self.descriptionFile) newone.provider = self.provider return newone def getIcon(self): return QIcon(os.path.dirname(__file__) + '/../../images/grass.png') def help(self): return False, 'http://grass.osgeo.org/grass70/manuals/' + self.grassName \ + '.html' def getParameterDescriptions(self): descs = {} _, helpfile = self.help() try: infile = open(helpfile) lines = infile.readlines() for i in range(len(lines)): if lines[i].startswith('<DT><b>'): for param in self.parameters: searchLine = '<b>' + param.name + '</b>' if searchLine in lines[i]: i += 1 descs[param.name] = (lines[i])[4:-6] break infile.close() except Exception: pass return descs def defineCharacteristicsFromFile(self): lines = open(self.descriptionFile) line = lines.readline().strip('\n').strip() self.grassName = line line = lines.readline().strip('\n').strip() self.name = line line = lines.readline().strip('\n').strip() self.group = line hasRasterOutput = False hasVectorInput = False vectorOutputs = 0 line = lines.readline().strip('\n').strip() while line != '': try: line = line.strip('\n').strip() if line.startswith('Parameter'): parameter = getParameterFromString(line) self.addParameter(parameter) if isinstance(parameter, ParameterVector): hasVectorInput = True if isinstance(parameter, ParameterMultipleInput) \ and parameter.datatype < 3: hasVectorInput = True elif line.startswith('*Parameter'): param = getParameterFromString(line[1:]) param.isAdvanced = True self.addParameter(param) else: output = getOutputFromString(line) self.addOutput(output) if isinstance(output, OutputRaster): hasRasterOutput = True elif isinstance(output, OutputVector): vectorOutputs += 1 line = lines.readline().strip('\n').strip() except Exception, e: ProcessingLog.addToLog( ProcessingLog.LOG_ERROR, self.tr('Could not open GRASS GIS 7 algorithm: %s\n%s' % (self.descriptionFile, line))) raise e lines.close() self.addParameter( ParameterExtent(self.GRASS_REGION_EXTENT_PARAMETER, self.tr('GRASS GIS 7 region extent'))) if hasRasterOutput: self.addParameter( ParameterNumber( self.GRASS_REGION_CELLSIZE_PARAMETER, self.tr( 'GRASS GIS 7 region cellsize (leave 0 for default)'), 0, None, 0.0)) if hasVectorInput: param = ParameterNumber(self.GRASS_SNAP_TOLERANCE_PARAMETER, 'v.in.ogr snap tolerance (-1 = no snap)', -1, None, -1.0) param.isAdvanced = True self.addParameter(param) param = ParameterNumber(self.GRASS_MIN_AREA_PARAMETER, 'v.in.ogr min area', 0, None, 0.0001) param.isAdvanced = True self.addParameter(param) if vectorOutputs == 1: param = ParameterSelection(self.GRASS_OUTPUT_TYPE_PARAMETER, 'v.out.ogr output type', self.OUTPUT_TYPES) param.isAdvanced = True self.addParameter(param)
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm( 'Import Vector into PostGIS database (available connections)') 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( ParameterVector(self.INPUT_LAYER, self.tr('Input layer'), [ParameterVector.VECTOR_TYPE_ANY], False)) self.addParameter( ParameterSelection(self.GTYPE, self.tr('Output geometry type'), self.GEOMTYPE, 0)) self.addParameter( ParameterCrs(self.A_SRS, self.tr('Assign an output CRS'), '', optional=True)) self.addParameter( ParameterCrs(self.T_SRS, self.tr('Reproject to this CRS on output '), '', optional=True)) self.addParameter( ParameterCrs(self.S_SRS, self.tr('Override source CRS'), '', optional=True)) self.addParameter( ParameterString(self.SCHEMA, self.tr('Schema name'), 'public', optional=True)) self.addParameter( ParameterString( self.TABLE, self.tr('Table name, leave blank to use input name'), '', optional=True)) self.addParameter( ParameterString(self.PK, self.tr('Primary key (new field)'), 'id', optional=True)) self.addParameter( ParameterTableField( self.PRIMARY_KEY, self. tr('Primary key (existing field, used if the above option is left empty)' ), self.INPUT_LAYER, optional=True)) self.addParameter( ParameterString(self.GEOCOLUMN, self.tr('Geometry column name'), 'geom', optional=True)) self.addParameter( ParameterSelection(self.DIM, self.tr('Vector dimensions'), self.DIMLIST, 0)) self.addParameter( ParameterString(self.SIMPLIFY, self.tr('Distance tolerance for simplification'), '', optional=True)) self.addParameter( ParameterString( self.SEGMENTIZE, self.tr('Maximum distance between 2 nodes (densification)'), '', optional=True)) self.addParameter( ParameterExtent( self.SPAT, self.tr( 'Select features by extent (defined in input layer CRS)'))) self.addParameter( ParameterBoolean( self.CLIP, self.tr( 'Clip the input layer using the above (rectangle) extent'), False)) self.addParameter( ParameterString( self.WHERE, self. tr('Select features using a SQL "WHERE" statement (Ex: column=\'value\')' ), '', optional=True)) self.addParameter( ParameterString( self.GT, self.tr('Group N features per transaction (Default: 20000)'), '', optional=True)) self.addParameter( ParameterBoolean(self.OVERWRITE, self.tr('Overwrite existing table'), True)) self.addParameter( ParameterBoolean(self.APPEND, self.tr('Append to existing table'), False)) self.addParameter( ParameterBoolean( self.ADDFIELDS, self.tr('Append and add new fields to existing table'), False)) self.addParameter( ParameterBoolean(self.LAUNDER, self.tr('Do not launder columns/table names'), False)) self.addParameter( ParameterBoolean(self.INDEX, self.tr('Do not create spatial index'), False)) self.addParameter( ParameterBoolean( self.SKIPFAILURES, self.tr( 'Continue after a failure, skipping the failed feature'), False)) self.addParameter( ParameterBoolean(self.PROMOTETOMULTI, self.tr('Promote to Multipart'), True)) self.addParameter( ParameterBoolean( self.PRECISION, self.tr('Keep width and precision of input attributes'), True)) self.addParameter( ParameterString(self.OPTIONS, self.tr('Additional creation options'), '', optional=True))
def defineCharacteristics(self): self.addParameter( ParameterVector(self.INPUT_LAYER, self.tr('Point layer'), [dataobjects.TYPE_VECTOR_POINT])) self.addParameter( ParameterNumber(self.RADIUS, self.tr('Radius (layer units)'), 0.0, 9999999999, 100.0)) radius_field_param = ParameterTableField( self.RADIUS_FIELD, self.tr('Radius from field'), self.INPUT_LAYER, optional=True, datatype=ParameterTableField.DATA_TYPE_NUMBER) radius_field_param.isAdvanced = True self.addParameter(radius_field_param) class ParameterHeatmapPixelSize(ParameterNumber): def __init__(self, name='', description='', parent_layer=None, radius_param=None, radius_field_param=None, minValue=None, maxValue=None, default=None, optional=False, metadata={}): ParameterNumber.__init__(self, name, description, minValue, maxValue, default, optional, metadata) self.parent_layer = parent_layer self.radius_param = radius_param self.radius_field_param = radius_field_param self.addParameter( ParameterHeatmapPixelSize( self.PIXEL_SIZE, self.tr('Output raster size'), parent_layer=self.INPUT_LAYER, radius_param=self.RADIUS, radius_field_param=self.RADIUS_FIELD, minValue=0.0, maxValue=9999999999, default=0.1, metadata={'widget_wrapper': HeatmapPixelSizeWidgetWrapper})) weight_field_param = ParameterTableField( self.WEIGHT_FIELD, self.tr('Weight from field'), self.INPUT_LAYER, optional=True, datatype=ParameterTableField.DATA_TYPE_NUMBER) weight_field_param.isAdvanced = True self.addParameter(weight_field_param) kernel_shape_param = ParameterSelection(self.KERNEL, self.tr('Kernel shape'), self.KERNELS) kernel_shape_param.isAdvanced = True self.addParameter(kernel_shape_param) decay_ratio = ParameterNumber( self.DECAY, self.tr('Decay ratio (Triangular kernels only)'), -100.0, 100.0, 0.0) decay_ratio.isAdvanced = True self.addParameter(decay_ratio) output_scaling = ParameterSelection(self.OUTPUT_VALUE, self.tr('Output value scaling'), self.OUTPUT_VALUES) output_scaling.isAdvanced = True self.addParameter(output_scaling) self.addOutput(OutputRaster(self.OUTPUT_LAYER, self.tr('Heatmap')))
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm( 'SLMS - GeoTIFF retiling and compression') self.group, self.i18n_group = self.trAlgorithm('[GDAL] Conversion') self.addParameter( ParameterRaster(self.INPUT, self.tr('Input layer'), False)) #self.addParameter(ParameterNumber(self.OUTSIZE, # self.tr('Set the size of the output file (In pixels or %)'), # 1, None, 100)) #self.addParameter(ParameterBoolean(self.OUTSIZE_PERC, # self.tr('Output size is a percentage of input size'), True)) self.addParameter( ParameterString( self.NO_DATA, self. tr("Nodata value, leave blank to take the nodata value from input" ), '', optional=True)) #self.addParameter(ParameterSelection(self.EXPAND, # self.tr('Expand'), ['none', 'gray', 'rgb', 'rgba'])) #self.addParameter(ParameterCrs(self.SRS, # self.tr('Output projection for output file [leave blank to use input projection]'), None, optional=True)) #self.addParameter(ParameterExtent(self.PROJWIN, # self.tr('Subset based on georeferenced coordinates'))) #self.addParameter(ParameterBoolean(self.SDS, # self.tr('Copy all subdatasets of this file to individual output files'), # False)) self.addParameter( ParameterSelection(self.RTYPE, self.tr('Output raster type'), self.TYPE, 5)) self.addParameter( ParameterSelection(self.COMPRESS, self.tr('GeoTIFF options. Compression type:'), self.COMPRESSTYPE, 0)) #params = [] #params.append(ParameterSelection(self.RTYPE, # self.tr('Output raster type'), self.TYPE, 5)) #params.append(ParameterSelection(self.COMPRESS, # self.tr('GeoTIFF options. Compression type:'), self.COMPRESSTYPE, 4)) #params.append(ParameterNumber(self.JPEGCOMPRESSION, # self.tr('Set the JPEG compression level'), # 1, 100, 75)) #params.append(ParameterNumber(self.ZLEVEL, # self.tr('Set the DEFLATE compression level'), # 1, 9, 6)) #params.append(ParameterNumber(self.PREDICTOR, # self.tr('Set the predictor for LZW or DEFLATE compression'), # 1, 3, 1)) #params.append(ParameterBoolean(self.TILED, # self.tr('Create tiled output (only used for the GTiff format)'), False)) #params.append(ParameterSelection(self.BIGTIFF, # self.tr('Control whether the created file is a BigTIFF or a classic TIFF'), self.BIGTIFFTYPE, 0)) #params.append(ParameterBoolean(self.TFW, # self.tr('Force the generation of an associated ESRI world file (.tfw))'), False)) #params.append(ParameterString(self.EXTRA, # self.tr('Additional creation parameters'), '', optional=True)) #for param in params: # param.isAdvanced = True # self.addParameter(param) self.addOutput(OutputRaster(self.OUTPUT, self.tr('Converted')))
LEFTRIGHT = 'LEFTRIGHT' LEFTRIGHTLIST = ['Right', 'Left'] >>>>>>> upstream/master DISSOLVEALL = 'DISSOLVEALL' FIELD = 'FIELD' MULTI = 'MULTI' OPTIONS = 'OPTIONS' def defineCharacteristics(self): <<<<<<< HEAD self.name = 'Single sided buffers (and offset lines) for lines' self.group = '[OGR] Geoprocessing' self.addParameter(ParameterVector(self.INPUT_LAYER, self.tr('Input layer'), [ParameterVector.VECTOR_TYPE_LINE], False)) self.addParameter(ParameterSelection(self.OPERATION, self.tr('Operation'),self.OPERATIONLIST, 0)) self.addParameter(ParameterString(self.GEOMETRY, self.tr('Geometry column name ("geometry" for Shapefiles, may be different for other formats)'), 'geometry', optional=False)) self.addParameter(ParameterString(self.RADIUS, self.tr('Buffer distance'), '1000', 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)'),
def defineCharacteristics(self): self.addParameter(ParameterString( self.DATABASE, self.tr('Database (connection name)'), metadata={ 'widget_wrapper': { 'class': 'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'}})) self.addParameter(ParameterVector(self.INPUT_LAYER, self.tr('Input layer'))) self.addParameter(ParameterString(self.SHAPE_ENCODING, self.tr('Shape encoding'), "", optional=True)) self.addParameter(ParameterSelection(self.GTYPE, self.tr('Output geometry type'), self.GEOMTYPE, 0)) self.addParameter(ParameterCrs(self.A_SRS, self.tr('Assign an output CRS'), '', optional=False)) self.addParameter(ParameterCrs(self.T_SRS, self.tr('Reproject to this CRS on output '), '', optional=True)) self.addParameter(ParameterCrs(self.S_SRS, self.tr('Override source CRS'), '', optional=True)) self.addParameter(ParameterString( self.SCHEMA, self.tr('Schema name'), 'public', optional=True, metadata={ 'widget_wrapper': { 'class': 'processing.gui.wrappers_postgis.SchemaWidgetWrapper', 'connection_param': self.DATABASE}})) self.addParameter(ParameterString( self.TABLE, self.tr('Table name, leave blank to use input name'), '', optional=True, metadata={ 'widget_wrapper': { 'class': 'processing.gui.wrappers_postgis.TableWidgetWrapper', 'schema_param': self.SCHEMA}})) self.addParameter(ParameterString(self.PK, self.tr('Primary key (new field)'), 'id', optional=True)) self.addParameter(ParameterTableField(self.PRIMARY_KEY, self.tr('Primary key (existing field, used if the above option is left empty)'), self.INPUT_LAYER, optional=True)) self.addParameter(ParameterString(self.GEOCOLUMN, self.tr('Geometry column name'), 'geom', optional=True)) self.addParameter(ParameterSelection(self.DIM, self.tr('Vector dimensions'), self.DIMLIST, 0)) self.addParameter(ParameterString(self.SIMPLIFY, self.tr('Distance tolerance for simplification'), '', optional=True)) self.addParameter(ParameterString(self.SEGMENTIZE, self.tr('Maximum distance between 2 nodes (densification)'), '', optional=True)) self.addParameter(ParameterExtent(self.SPAT, self.tr('Select features by extent (defined in input layer CRS)'))) self.addParameter(ParameterBoolean(self.CLIP, self.tr('Clip the input layer using the above (rectangle) extent'), False)) self.addParameter(ParameterString(self.WHERE, self.tr('Select features using a SQL "WHERE" statement (Ex: column=\'value\')'), '', optional=True)) self.addParameter(ParameterString(self.GT, self.tr('Group N features per transaction (Default: 20000)'), '', optional=True)) self.addParameter(ParameterBoolean(self.OVERWRITE, self.tr('Overwrite existing table'), True)) self.addParameter(ParameterBoolean(self.APPEND, self.tr('Append to existing table'), False)) self.addParameter(ParameterBoolean(self.ADDFIELDS, self.tr('Append and add new fields to existing table'), False)) self.addParameter(ParameterBoolean(self.LAUNDER, self.tr('Do not launder columns/table names'), False)) self.addParameter(ParameterBoolean(self.INDEX, self.tr('Do not create spatial index'), False)) self.addParameter(ParameterBoolean(self.SKIPFAILURES, self.tr('Continue after a failure, skipping the failed feature'), False)) self.addParameter(ParameterBoolean(self.PROMOTETOMULTI, self.tr('Promote to Multipart'), True)) self.addParameter(ParameterBoolean(self.PRECISION, self.tr('Keep width and precision of input attributes'), True)) self.addParameter(ParameterString(self.OPTIONS, self.tr('Additional creation options'), '', optional=True))
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm('TIN interpolation') self.group, self.i18n_group = self.trAlgorithm('Interpolation') 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 defineCharacteristics(self): """Algorithme variable and parameters parameters""" CholeAlgorithm.defineCharacteristics(self) # The name/group that the user will see in the toolbox self.group = 'landscape metrics' self.i18n_group = self.tr('landscape metrics') self.name = 'selected' self.i18n_name = self.tr('selected') # === INPUT PARAMETERS === self.addParameter( ParameterRaster(name=self.INPUT_LAYER_ASC, description=self.tr('Input layer asc'))) self.addParameter( ParameterSelection(name=self.WINDOW_SHAPE, description=self.tr('Window shape'), options=';'.join(self.types_of_shape))) self.addParameter( ParameterFile(name=self.FRICTION_FILE, description=self.tr('Friction file'))) self.addParameter( ParameterNumber(name=self.WINDOW_SIZES, description=self.tr('Windows sizes (pixels)'), default=3)) self.addParameter( ParameterSelection(name=self.PIXELS_POINTS_SELECT, description=self.tr('Pixels/points selection'), options=';'.join( self.types_of_pixel_point_select))) self.addParameter( ParameterFile(name=self.PIXELS_FILE, description=self.tr('Pixels file'))) self.addParameter( ParameterFile(name=self.POINTS_FILE, description=self.tr('Points file'))) self.addParameter( ParameterNumber( name=self.MAXIMUM_RATE_MISSING_VALUES, description=self.tr('Maximum rate of mising values'), minValue=0, maxValue=100, default=100)) self.addParameter( ParameterString(name=self.METRICS, description=self.tr('Select metrics'))) # === OUTPUT PARAMETERS === self.addOutput( OutputFile(name=self.SAVE_PROPERTIES, description=self.tr('Properties file'), ext='properties')) self.addOutput( OutputTable(name=self.OUTPUT_CSV, description=self.tr('Output csv (*.csv)'))) self.addOutput( ASCOutputRaster(name=self.OUTPUT_ASC, description=self.tr('Output ascii (*.asc)')))
def defineCharacteristicsFromFile(self): with open(self.descriptionFile) as lines: line = lines.readline().strip('\n').strip() self.grass7Name = line line = lines.readline().strip('\n').strip() self._name = line self._display_name = QCoreApplication.translate( "GrassAlgorithm", line) if " - " not in self._name: self._name = self.grass7Name + " - " + self._name self._display_name = self.grass7Name + " - " + self._display_name self._name = self._name[:self._name.find(' ')].lower() line = lines.readline().strip('\n').strip() self._group = QCoreApplication.translate("GrassAlgorithm", line) hasRasterOutput = False hasVectorInput = False vectorOutputs = 0 line = lines.readline().strip('\n').strip() while line != '': try: line = line.strip('\n').strip() if line.startswith('Hardcoded'): self.hardcodedStrings.append(line[len('Hardcoded|'):]) parameter = getParameterFromString(line) if parameter is not None: self.addParameter(parameter) if isinstance(parameter, ParameterVector): hasVectorInput = True if isinstance(parameter, ParameterMultipleInput) \ and parameter.datatype < 3: hasVectorInput = True else: output = getOutputFromString(line) self.addOutput(output) if isinstance(output, OutputRaster): hasRasterOutput = True elif isinstance(output, OutputVector): vectorOutputs += 1 if isinstance(output, OutputHTML): self.addOutput( OutputFile( "rawoutput", self.tr("{0} (raw output)").format( output.description()), "txt")) line = lines.readline().strip('\n').strip() except Exception as e: QgsMessageLog.logMessage( self.tr( 'Could not open GRASS GIS 7 algorithm: {0}\n{1}'). format(self.descriptionFile, line), self.tr('Processing'), QgsMessageLog.CRITICAL) raise e self.addParameter( ParameterExtent(self.GRASS_REGION_EXTENT_PARAMETER, self.tr('GRASS GIS 7 region extent'))) if hasRasterOutput: self.addParameter( ParameterNumber( self.GRASS_REGION_CELLSIZE_PARAMETER, self.tr( 'GRASS GIS 7 region cellsize (leave 0 for default)'), 0, None, 0.0)) if hasVectorInput: param = ParameterNumber(self.GRASS_SNAP_TOLERANCE_PARAMETER, 'v.in.ogr snap tolerance (-1 = no snap)', -1, None, -1.0) param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(param) param = ParameterNumber(self.GRASS_MIN_AREA_PARAMETER, 'v.in.ogr min area', 0, None, 0.0001) param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(param) if vectorOutputs == 1: param = ParameterSelection(self.GRASS_OUTPUT_TYPE_PARAMETER, 'v.out.ogr output type', self.OUTPUT_TYPES) param.setFlags(param.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(param)
def processParameterLine(self, line): param = None out = None line = line.replace('#', '') # If the line is in the format of the text description files for # normal algorithms, then process it using parameter and output # factories if '|' in line: self.processDescriptionParameterLine(line) return if line == "nomodeler": self.showInModeler = False return tokens = line.split('=', 1) desc = self.createDescriptiveName(tokens[0]) if tokens[1].lower().strip() == 'group': self.group = tokens[0] return if tokens[1].lower().strip() == 'name': self.name = tokens[0] return if tokens[1].lower().strip() == 'raster': param = ParameterRaster(tokens[0], desc, False) elif tokens[1].lower().strip() == 'vector': param = ParameterVector(tokens[0], desc, [ParameterVector.VECTOR_TYPE_ANY]) elif tokens[1].lower().strip() == 'vector point': param = ParameterVector(tokens[0], desc, [ParameterVector.VECTOR_TYPE_POINT]) elif tokens[1].lower().strip() == 'vector line': param = ParameterVector(tokens[0], desc, [ParameterVector.VECTOR_TYPE_LINE]) elif tokens[1].lower().strip() == 'vector polygon': param = ParameterVector(tokens[0], desc, [ParameterVector.VECTOR_TYPE_POLYGON]) elif tokens[1].lower().strip() == 'table': param = ParameterTable(tokens[0], desc, False) elif tokens[1].lower().strip() == 'multiple raster': param = ParameterMultipleInput(tokens[0], desc, ParameterMultipleInput.TYPE_RASTER) param.optional = False elif tokens[1].lower().strip() == 'multiple vector': param = ParameterMultipleInput( tokens[0], desc, ParameterMultipleInput.TYPE_VECTOR_ANY) param.optional = False elif tokens[1].lower().strip().startswith('selectionfromfile'): options = tokens[1].strip()[len('selectionfromfile '):].split(';') param = ParameterSelection(tokens[0], desc, options, isSource=True) elif tokens[1].lower().strip().startswith('selection'): options = tokens[1].strip()[len('selection '):].split(';') param = ParameterSelection(tokens[0], desc, options) elif tokens[1].lower().strip().startswith('boolean'): default = tokens[1].strip()[len('boolean') + 1:] param = ParameterBoolean(tokens[0], desc, default) elif tokens[1].lower().strip() == 'extent': param = ParameterExtent(tokens[0], desc) elif tokens[1].lower().strip() == 'file': param = ParameterFile(tokens[0], desc, False) elif tokens[1].lower().strip() == 'folder': param = ParameterFile(tokens[0], desc, True) elif tokens[1].lower().strip().startswith('number'): default = tokens[1].strip()[len('number') + 1:] param = ParameterNumber(tokens[0], desc, default=default) elif tokens[1].lower().strip().startswith('field'): field = tokens[1].strip()[len('field') + 1:] found = False for p in self.parameters: if p.name == field: found = True break if found: param = ParameterTableField(tokens[0], desc, field) elif tokens[1].lower().strip().startswith('string'): default = tokens[1].strip()[len('string') + 1:] param = ParameterString(tokens[0], desc, default) elif tokens[1].lower().strip().startswith('longstring'): default = tokens[1].strip()[len('longstring') + 1:] param = ParameterString(tokens[0], desc, default, multiline=True) elif tokens[1].lower().strip().startswith('crs'): default = tokens[1].strip()[len('crs') + 1:] if not default: default = 'EPSG:4326' param = ParameterCrs(tokens[0], desc, default) elif tokens[1].lower().strip().startswith('output raster'): out = OutputRaster() elif tokens[1].lower().strip().startswith('output vector'): out = OutputVector() elif tokens[1].lower().strip().startswith('output table'): out = OutputTable() elif tokens[1].lower().strip().startswith('output html'): out = OutputHTML() elif tokens[1].lower().strip().startswith('output file'): out = OutputFile() subtokens = tokens[1].split(' ') if len(subtokens) > 2: out.ext = subtokens[2] elif tokens[1].lower().strip().startswith('output directory'): out = OutputDirectory() elif tokens[1].lower().strip().startswith('output number'): out = OutputNumber() elif tokens[1].lower().strip().startswith('output string'): out = OutputString() if param is not None: self.addParameter(param) elif out is not None: out.name = tokens[0] out.description = desc self.addOutput(out) else: raise WrongScriptException( self.tr( 'Could not load script: %s.\n' 'Problem with line "%s"', 'ScriptAlgorithm') % (self.descriptionFile or '', line))