Beispiel #1
0
 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])
Beispiel #2
0
 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)
Beispiel #4
0
    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')))
Beispiel #5
0
    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)
Beispiel #6
0
    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')))
Beispiel #7
0
    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)
Beispiel #8
0
 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)
Beispiel #9
0
 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)
Beispiel #10
0
    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"])
Beispiel #11
0
    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'])
Beispiel #12
0
    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')))
Beispiel #13
0
    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]))
Beispiel #14
0
    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')))
Beispiel #15
0
    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
Beispiel #16
0
    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')))
Beispiel #17
0
    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]))
Beispiel #18
0
    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))
Beispiel #20
0
 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()
Beispiel #21
0
 def addParametersIgnoreClass2GUI(self):
     self.addParameter(
         ParameterSelection(
             LAStoolsAlgorithm.IGNORE_CLASS2,
             self.tr("also ignore points with this classification"),
             LAStoolsAlgorithm.IGNORE_CLASSES, 0))
Beispiel #22
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')))
Beispiel #23
0
 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))
Beispiel #24
0
 def addParametersVectorOutputFormatGUI(self):
     self.addParameter(
         ParameterSelection(LAStoolsAlgorithm.OUTPUT_VECTOR_FORMAT,
                            self.tr("output format"),
                            LAStoolsAlgorithm.OUTPUT_VECTOR_FORMATS, 0))
Beispiel #25
0
 def addParametersPointOutputFormatGUI(self):
     self.addParameter(
         ParameterSelection(LAStoolsAlgorithm.OUTPUT_POINT_FORMAT,
                            self.tr("output format"),
                            LAStoolsAlgorithm.OUTPUT_POINT_FORMATS, 0))
Beispiel #26
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, ...)")))
Beispiel #28
0
 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')))
Beispiel #29
0
    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, ...)")))
Beispiel #32
0
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))
Beispiel #34
0
    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')))
Beispiel #35
0
    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')))
Beispiel #36
0
    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)'),
Beispiel #37
0
 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))
Beispiel #38
0
    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))
Beispiel #39
0
    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)')))
Beispiel #40
0
    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)
Beispiel #41
0
    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))