def testMinValue(self): parameter = ParameterNumber("myName", "myDescription", minValue=3) self.assertFalse(parameter.setValue(1)) self.assertEqual(parameter.value, None) self.assertFalse(parameter.setValue(-2)) self.assertEqual(parameter.value, None) self.assertTrue(parameter.setValue(3)) self.assertEqual(parameter.value, 3)
def testScriptCode(self): parameter = ParameterNumber('myName', 'myDescription') code = parameter.getAsScriptCode() result = getParameterFromString(code) self.assertIsInstance(result, ParameterNumber) parameter.optional = True code = parameter.getAsScriptCode() result = getParameterFromString(code) self.assertIsInstance(result, ParameterNumber) self.assertTrue(result.optional)
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 defineCharacteristics(self): self.addParameter(ParameterVector(self.INPUT_LAYER, self.tr('Input layer'), [dataobjects.TYPE_VECTOR_LINE, dataobjects.TYPE_VECTOR_POLYGON])) self.addParameter(ParameterNumber(self.ANGLE_TOLERANCE, self.tr('Maximum angle tolerance (degrees)'), 0.0, 45.0, 15.0)) max_iterations = ParameterNumber(self.MAX_ITERATIONS, self.tr('Maximum algorithm iterations'), 1, 10000, 1000) max_iterations.isAdvanced = True self.addParameter(max_iterations) self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Orthogonalized')))
def __init__(self): super().__init__() self.addParameter(ParameterVector(self.INPUT_LAYER, self.tr('Input layer'), [dataobjects.TYPE_VECTOR_LINE, dataobjects.TYPE_VECTOR_POLYGON])) self.addParameter(ParameterNumber(self.ANGLE_TOLERANCE, self.tr('Maximum angle tolerance (degrees)'), 0.0, 45.0, 15.0)) max_iterations = ParameterNumber(self.MAX_ITERATIONS, self.tr('Maximum algorithm iterations'), 1, 10000, 1000) max_iterations.setFlags(max_iterations.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(max_iterations) self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Orthogonalized')))
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 __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
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm('Orthogonalize') self.group, self.i18n_group = self.trAlgorithm('Vector geometry tools') self.tags = self.tr('rectangle,perpendicular,right,angles,square,quadrilateralise') self.addParameter(ParameterVector(self.INPUT_LAYER, self.tr('Input layer'), [dataobjects.TYPE_VECTOR_LINE, dataobjects.TYPE_VECTOR_POLYGON])) self.addParameter(ParameterNumber(self.ANGLE_TOLERANCE, self.tr('Maximum angle tolerance (degrees)'), 0.0, 45.0, 15.0)) max_iterations = ParameterNumber(self.MAX_ITERATIONS, self.tr('Maximum algorithm iterations'), 1, 10000, 1000) max_iterations.isAdvanced = True self.addParameter(max_iterations) self.addOutput(OutputVector(self.OUTPUT_LAYER, self.tr('Orthogonalized')))
def testOptional(self): optionalParameter = ParameterNumber("myName", "myDescription", default=1.0, optional=True) self.assertEqual(optionalParameter.value, 1.0) optionalParameter.setValue(5) self.assertEqual(optionalParameter.value, 5) self.assertTrue(optionalParameter.setValue(None)) self.assertEqual(optionalParameter.value, None) requiredParameter = ParameterNumber("myName", "myDescription", default=1.0, optional=False) self.assertEqual(requiredParameter.value, 1.0) requiredParameter.setValue(5) self.assertEqual(requiredParameter.value, 5) self.assertFalse(requiredParameter.setValue(None)) self.assertEqual(requiredParameter.value, 5)
def testParameterNumber(self): param = ParameterNumber('name', 'desc', 0, 10) assert not param.setValue('wrongvalue') assert param.value is None assert not param.setValue(25) assert param.value is None assert param.setValue(5) assert param.value == 5 assert param.setValue(None) assert param.value == param.default s = param.serialize() param2 = ParameterNumber() param2.deserialize(s) assert param.default == param2.default assert param.max == param2.max assert param.min == param2.min assert param.description == param2.description assert param.name == param2.name
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 testSetValue(self): parameter = ParameterNumber('myName', 'myDescription') self.assertTrue(parameter.setValue(5)) self.assertEqual(parameter.value, 5)
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 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('selection'): options = tokens[1].strip()[len('selection '):].split(';') param = ParameterSelection(tokens[0], desc, options) elif tokens[1].lower().strip().startswith('boolean'): default = tokens[1].strip()[len('boolean') + 1:] param = ParameterBoolean(tokens[0], desc, default) elif tokens[1].lower().strip() == 'extent': param = ParameterExtent(tokens[0], desc) elif tokens[1].lower().strip() == 'file': param = ParameterFile(tokens[0], desc, False) elif tokens[1].lower().strip() == 'folder': param = ParameterFile(tokens[0], desc, True) elif tokens[1].lower().strip().startswith('number'): default = tokens[1].strip()[len('number') + 1:] param = ParameterNumber(tokens[0], desc, default=default) elif tokens[1].lower().strip().startswith('field'): field = tokens[1].strip()[len('field') + 1:] found = False for p in self.parameters: if p.name == field: found = True break if found: param = ParameterTableField(tokens[0], desc, field) elif tokens[1].lower().strip().startswith('string'): default = tokens[1].strip()[len('string') + 1:] param = ParameterString(tokens[0], desc, default) elif tokens[1].lower().strip().startswith('longstring'): default = tokens[1].strip()[len('longstring') + 1:] param = ParameterString(tokens[0], desc, default, multiline=True) elif tokens[1].lower().strip().startswith('crs'): default = tokens[1].strip()[len('crs') + 1:] if not default: default = 'EPSG:4326' param = ParameterCrs(tokens[0], desc, default) elif tokens[1].lower().strip().startswith('output raster'): out = OutputRaster() elif tokens[1].lower().strip().startswith('output vector'): out = OutputVector() elif tokens[1].lower().strip().startswith('output table'): out = OutputTable() elif tokens[1].lower().strip().startswith('output html'): out = OutputHTML() elif tokens[1].lower().strip().startswith('output file'): out = OutputFile() subtokens = tokens[1].split(' ') if len(subtokens) > 2: out.ext = subtokens[2] elif tokens[1].lower().strip().startswith('output directory'): out = OutputDirectory() elif tokens[1].lower().strip().startswith('output number'): out = OutputNumber() elif tokens[1].lower().strip().startswith('output string'): out = OutputString() if param is not None: self.addParameter(param) elif out is not None: out.name = tokens[0] out.description = desc self.addOutput(out) else: raise WrongScriptException( self.tr('Could not load script: %s.\n' 'Problem with line %d', 'ScriptAlgorithm') % (self.descriptionFile or '', line))
def 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.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|'):]) 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: ProcessingLog.addToLog( ProcessingLog.LOG_ERROR, self.tr( 'Could not open GRASS GIS 7 algorithm: {0}\n{1}'). format(self.descriptionFile, line)) raise e self.addParameter( ParameterExtent(self.GRASS_REGION_EXTENT_PARAMETER, self.tr('GRASS GIS 7 region extent'))) if hasRasterOutput: self.addParameter( ParameterNumber( self.GRASS_REGION_CELLSIZE_PARAMETER, self.tr( 'GRASS GIS 7 region cellsize (leave 0 for default)'), 0, None, 0.0)) if hasVectorInput: param = ParameterNumber(self.GRASS_SNAP_TOLERANCE_PARAMETER, 'v.in.ogr snap tolerance (-1 = no snap)', -1, None, -1.0) param.isAdvanced = True self.addParameter(param) param = ParameterNumber(self.GRASS_MIN_AREA_PARAMETER, 'v.in.ogr min area', 0, None, 0.0001) param.isAdvanced = True self.addParameter(param) if vectorOutputs == 1: param = ParameterSelection(self.GRASS_OUTPUT_TYPE_PARAMETER, 'v.out.ogr output type', self.OUTPUT_TYPES) param.isAdvanced = True self.addParameter(param)
def testSetValue(self): parameter = ParameterNumber('myName', 'myDescription') self.assertTrue(parameter.setValue(5)) self.assertEquals(parameter.value, 5)
def defineCharacteristics(self): # 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 defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm( 'Clip raster by mask layer') self.group, self.i18n_group = self.trAlgorithm('[GDAL] Extraction') self.addParameter( ParameterRaster(self.INPUT, self.tr('Input layer'), False)) self.addParameter( ParameterVector(self.MASK, self.tr('Mask layer'), [dataobjects.TYPE_VECTOR_POLYGON])) self.addParameter( ParameterString( self.NO_DATA, self. tr("Nodata value, leave blank to take the nodata value from input" ), '', optional=True)) self.addParameter( ParameterBoolean(self.ALPHA_BAND, self.tr('Create and output alpha band'), False)) self.addParameter( ParameterBoolean( self.CROP_TO_CUTLINE, self. tr('Crop the extent of the target dataset to the extent of the cutline' ), True)) self.addParameter( ParameterBoolean(self.KEEP_RESOLUTION, self.tr('Keep resolution of output raster'), False)) params = [] params.append( ParameterSelection(self.RTYPE, self.tr('Output raster type'), self.TYPE, 5)) params.append( ParameterSelection(self.COMPRESS, self.tr('GeoTIFF options. Compression type:'), self.COMPRESSTYPE, 4)) params.append( ParameterNumber(self.JPEGCOMPRESSION, self.tr('Set the JPEG compression level'), 1, 100, 75)) params.append( ParameterNumber(self.ZLEVEL, self.tr('Set the DEFLATE compression level'), 1, 9, 6)) params.append( ParameterNumber( self.PREDICTOR, self.tr('Set the predictor for LZW or DEFLATE compression'), 1, 3, 1)) params.append( ParameterBoolean( self.TILED, self.tr( 'Create tiled output (only used for the GTiff format)'), False)) params.append( ParameterSelection( self.BIGTIFF, self. tr('Control whether the created file is a BigTIFF or a classic TIFF' ), self.BIGTIFFTYPE, 0)) params.append( ParameterBoolean( self.TFW, self. tr('Force the generation of an associated ESRI world file (.tfw))' ), False)) params.append( ParameterString(self.EXTRA, self.tr('Additional creation parameters'), '', optional=True)) for param in params: param.isAdvanced = True self.addParameter(param) self.addOutput(OutputRaster(self.OUTPUT, self.tr('Clipped (mask)')))
def 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( 'Service area (from layer)') 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( ParameterSelection(self.STRATEGY, self.tr('Path type to calculate'), self.STRATEGIES, default=0)) self.addParameter( ParameterNumber( self.TRAVEL_COST, self.tr( 'Travel cost (distance for "Shortest", time for "Fastest")' ), 0.0, 99999999.999999, 0.0)) params = [] params.append( ParameterTableField(self.DIRECTION_FIELD, self.tr('Direction field'), self.INPUT_VECTOR, optional=True)) params.append( ParameterString(self.VALUE_FORWARD, self.tr('Value for forward direction'), '', optional=True)) params.append( ParameterString(self.VALUE_BACKWARD, self.tr('Value for backward direction'), '', optional=True)) params.append( ParameterString(self.VALUE_BOTH, self.tr('Value for both directions'), '', optional=True)) params.append( ParameterSelection(self.DEFAULT_DIRECTION, self.tr('Default direction'), list(self.DIRECTIONS.keys()), default=2)) params.append( ParameterTableField(self.SPEED_FIELD, self.tr('Speed field'), self.INPUT_VECTOR, optional=True)) params.append( ParameterNumber(self.DEFAULT_SPEED, self.tr('Default speed (km/h)'), 0.0, 99999999.999999, 5.0)) params.append( ParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), 0.0, 99999999.999999, 0.0)) for p in params: p.isAdvanced = True self.addParameter(p) self.addOutput( OutputVector(self.OUTPUT_POINTS, self.tr('Service area (boundary nodes)'), datatype=[dataobjects.TYPE_VECTOR_POINT])) self.addOutput( OutputVector(self.OUTPUT_POLYGON, self.tr('Service area (convex hull)'), datatype=[dataobjects.TYPE_VECTOR_POLYGON]))
def testMaxValue(self): parameter = ParameterNumber('myName', 'myDescription', maxValue=10) self.assertFalse(parameter.setValue(11)) self.assertEqual(parameter.value, None) self.assertTrue(parameter.setValue(10)) self.assertEqual(parameter.value, 10)
def testSetValueOnlyValidNumbers(self): parameter = ParameterNumber('myName', 'myDescription') self.assertFalse(parameter.setValue('not a number')) self.assertEqual(parameter.value, None)
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm('Relief') self.group, self.i18n_group = self.trAlgorithm( 'Raster terrain analysis') class ParameterReliefColors(Parameter): default_metadata = { 'widget_wrapper': 'processing.algs.qgis.ui.ReliefColorsWidget.ReliefColorsWidgetWrapper' } def __init__(self, name='', description='', parent=None, optional=True): Parameter.__init__(self, name, description, None, optional) self.parent = parent def setValue(self, value): if value is None: if not self.optional: return False self.value = None return True if value == '': if not self.optional: return False if isinstance(value, str): self.value = value if value != '' else None else: self.value = ParameterReliefColors.colorsToString(value) return True def getValueAsCommandLineParameter(self): return '"{}"'.format(self.value) def getAsScriptCode(self): param_type = '' param_type += 'relief colors ' return '##' + self.name + '=' + param_type @classmethod def fromScriptCode(self, line): isOptional, name, definition = _splitParameterOptions(line) descName = _createDescriptiveName(name) parent = definition.lower().strip()[len('relief colors') + 1:] return ParameterReliefColors(name, descName, parent) @staticmethod def colorsToString(colors): s = '' for c in colors: s += '{:f}, {:f}, {:d}, {:d}, {:d};'.format( c[0], c[1], c[2], c[3], c[4]) return s[:-1] self.addParameter( ParameterRaster(self.INPUT_LAYER, self.tr('Elevation layer'))) self.addParameter( ParameterNumber(self.Z_FACTOR, self.tr('Z factor'), 1.0, 999999.99, 1.0)) self.addParameter( ParameterBoolean(self.AUTO_COLORS, self.tr('Generate relief classes automatically'), False)) self.addParameter( ParameterReliefColors(self.COLORS, self.tr('Relief colors'), self.INPUT_LAYER, True)) self.addOutput(OutputRaster(self.OUTPUT_LAYER, self.tr('Relief'))) self.addOutput( OutputTable(self.FREQUENCY_DISTRIBUTION, self.tr('Frequency distribution')))
def testSetValue(self): parameter = ParameterNumber("myName", "myDescription") self.assertTrue(parameter.setValue(5)) self.assertEqual(parameter.value, 5)
class GrassAlgorithm(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 console output, needed to do postprocessing in case GRASS # dumps results to the console self.consoleOutput = [] def getCopy(self): newone = GrassAlgorithm(self.descriptionFile) newone.provider = self.provider return newone def getIcon(self): return QIcon(os.path.join(pluginPath, 'images', 'grass.png')) def help(self): return False, 'http://grass.osgeo.org/grass64/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 algorithm: %s.\n%s' % (self.descriptionFile, line))) raise e lines.close() self.addParameter( ParameterExtent(self.GRASS_REGION_EXTENT_PARAMETER, self.tr('GRASS region extent'))) if hasRasterOutput: self.addParameter( ParameterNumber( self.GRASS_REGION_CELLSIZE_PARAMETER, self.tr('GRASS 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 testMaxValue(self): parameter = ParameterNumber("myName", "myDescription", maxValue=10) self.assertFalse(parameter.setValue(11)) self.assertEqual(parameter.value, None) self.assertTrue(parameter.setValue(10)) self.assertEqual(parameter.value, 10)
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm('IDW interpolation') self.group, self.i18n_group = self.trAlgorithm('Interpolation') 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, description, parent) @staticmethod def dataToString(data): s = '' for d in data: s += '{}, {}, {:d}, {:d};'.format(c[0], c[1], c[2], c[3]) return s[:-1] self.addParameter( ParameterInterpolationData(self.INTERPOLATION_DATA, self.tr('Input layer(s)'))) self.addParameter( ParameterNumber(self.DISTANCE_COEFFICIENT, self.tr('Distance coefficient P'), 0.0, 99.99, 2.0)) self.addParameter( ParameterNumber(self.COLUMNS, self.tr('Number of columns'), 0, 10000000, 300)) self.addParameter( ParameterNumber(self.ROWS, self.tr('Number of rows'), 0, 10000000, 300)) self.addParameter( ParameterNumber(self.CELLSIZE_X, self.tr('Cell Size X'), 0.0, 999999.000000, 0.0)) self.addParameter( ParameterNumber(self.CELLSIZE_Y, self.tr('Cell Size Y'), 0.0, 999999.000000, 0.0)) self.addParameter( ParameterExtent(self.EXTENT, self.tr('Extent'), optional=False)) self.addOutput(OutputRaster(self.OUTPUT_LAYER, self.tr('Interpolated')))
def defineCharacteristics(self): self.name, self.i18n_name = self.trAlgorithm( 'Translate (convert format)') 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)) 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')))
def __init__(self): super().__init__() self.DIRECTIONS = OrderedDict([ (self.tr('Forward direction'), QgsVectorLayerDirector.DirectionForward), (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionForward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionForward) ]) self.STRATEGIES = [self.tr('Shortest'), self.tr('Fastest')] self.addParameter( ParameterVector(self.INPUT_VECTOR, self.tr('Vector layer representing network'), [dataobjects.TYPE_VECTOR_LINE])) self.addParameter( ParameterPoint(self.START_POINT, self.tr('Start point'))) self.addParameter( ParameterVector(self.END_POINTS, self.tr('Vector layer with end points'), [dataobjects.TYPE_VECTOR_POINT])) self.addParameter( ParameterSelection(self.STRATEGY, self.tr('Path type to calculate'), self.STRATEGIES, default=0)) params = [] params.append( ParameterTableField(self.DIRECTION_FIELD, self.tr('Direction field'), self.INPUT_VECTOR, optional=True)) params.append( ParameterString(self.VALUE_FORWARD, self.tr('Value for forward direction'), '', optional=True)) params.append( ParameterString(self.VALUE_BACKWARD, self.tr('Value for backward direction'), '', optional=True)) params.append( ParameterString(self.VALUE_BOTH, self.tr('Value for both directions'), '', optional=True)) params.append( ParameterSelection(self.DEFAULT_DIRECTION, self.tr('Default direction'), list(self.DIRECTIONS.keys()), default=2)) params.append( ParameterTableField(self.SPEED_FIELD, self.tr('Speed field'), self.INPUT_VECTOR, optional=True)) params.append( ParameterNumber(self.DEFAULT_SPEED, self.tr('Default speed (km/h)'), 0.0, 99999999.999999, 5.0)) params.append( ParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), 0.0, 99999999.999999, 0.0)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(p) self.addOutput( OutputVector(self.OUTPUT_LAYER, self.tr('Shortest path'), datatype=[dataobjects.TYPE_VECTOR_LINE]))
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 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('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 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 testSetValueOnlyValidNumbers(self): parameter = ParameterNumber("myName", "myDescription") self.assertFalse(parameter.setValue("not a number")) self.assertEqual(parameter.value, None)
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 addParametersCoresGUI(self): self.addParameter( ParameterNumber(LAStoolsAlgorithm.CORES, "number of cores", 1, 32, 4))
def initAlgorithm(self, config=None): self.addParameter(ParameterRaster(self.INPUT, self.tr('Input layer'))) self.addParameter( ParameterNumber(self.BINS, self.tr('Number of bins'), 2, None, 10)) self.addOutput(OutputHTML(self.PLOT, self.tr('Histogram')))
def 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.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|") :]) 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", 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 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 addParametersStepGUI(self): self.addParameter( ParameterNumber(LAStoolsAlgorithm.STEP, "step size / pixel size", 0, None, 1.0))
def __init__(self): super().__init__() self.addParameter( ParameterRaster(self.INPUT, self.tr('Input layer'), False)) self.addParameter( ParameterCrs(self.SOURCE_SRS, self.tr('Source SRS'), '', optional=True)) self.addParameter( ParameterCrs(self.DEST_SRS, self.tr('Destination SRS'), 'EPSG:4326')) self.addParameter( ParameterString( self.NO_DATA, self. tr("Nodata value, leave blank to take the nodata value from input" ), '', optional=True)) self.addParameter( ParameterNumber( self.TR, self. tr('Output file resolution in target georeferenced units (leave 0 for no change)' ), 0.0, None, 0.0)) self.addParameter( ParameterSelection(self.METHOD, self.tr('Resampling method'), self.METHOD_OPTIONS)) self.addParameter( ParameterBoolean( self.USE_RASTER_EXTENT, self.tr('Set georeferenced extents of output file'), False)) self.addParameter( ParameterExtent(self.RASTER_EXTENT, self.tr('Raster extent'), optional=True)) self.addParameter( ParameterCrs( self.EXTENT_CRS, self. tr('CRS of the raster extent, leave blank for using Destination SRS' ), optional=True)) self.addParameter( ParameterString( self.OPTIONS, self.tr('Additional creation options'), optional=True, metadata={ 'widget_wrapper': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper' })) self.addParameter( ParameterBoolean( self.MULTITHREADING, self.tr('Use multithreaded warping implementation'), False)) self.addParameter( ParameterSelection(self.RTYPE, self.tr('Output raster type'), self.TYPE, 5)) self.addOutput(OutputRaster(self.OUTPUT, self.tr('Reprojected')))
def defineCharacteristics(self): """ Algorithme variable and parameters parameters """ CholeAlgorithm.defineCharacteristics(self) # The name/group that the user will see in the toolbox self.group = 'generate ascii grid' self.i18n_group = self.tr('generate ascii grid') self.name = 'from csv' self.i18n_name = self.tr('from csv') # === INPUT PARAMETERS === self.addParameter( ParameterTable(name=self.INPUT_FILE_CSV, description=self.tr('Input file csv'))) self.addParameter( ParameterString(name=self.FIELDS, description=self.tr('Fields selection'), default='')) self.addParameter( ParameterNumber(name=self.N_COLS, description=self.tr('Columns count'), minValue=0, default=100)) self.addParameter( ParameterNumber(name=self.N_ROWS, description=self.tr('Rows count'), minValue=0, default=100)) self.addParameter( ParameterNumber( name=self.XLL_CORNER, description=self.tr('X bottom left corner coordinate'), default=0.0)) self.addParameter( ParameterNumber( name=self.YLL_CORNER, description=self.tr('Y bottom left corner coordinate'), default=0.0)) self.addParameter( ParameterNumber(name=self.CELL_SIZE, description=self.tr('Cell size'), default=1.0)) self.addParameter( ParameterNumber(name=self.NODATA_VALUE, description=self.tr('Value if no-data'), default=-1)) self.addOutput( OutputFile(name=self.SAVE_PROPERTIES, description=self.tr('Properties file'), ext='properties')) # === OUTPUT PARAMETERS === self.addOutput( ASCOutputRaster(name=self.OUTPUT_ASC, description=self.tr('Ouput Raster ascii')))