Python GrassUtils.GrassUtils类代码示例

 def initializeSettings(self):
     AlgorithmProvider.initializeSettings(self)
     if isWindows() or isMac():
         ProcessingConfig.addSetting(Setting(self.getDescription(),
                 GrassUtils.GRASS_FOLDER, 'GRASS folder',
                 GrassUtils.grassPath()))
         ProcessingConfig.addSetting(Setting(self.getDescription(),
                 GrassUtils.GRASS_WIN_SHELL, 'Msys folder',
                 GrassUtils.grassWinShell()))
     ProcessingConfig.addSetting(Setting(self.getDescription(),
                                 GrassUtils.GRASS_LOG_COMMANDS,
                                 'Log execution commands', False))
     ProcessingConfig.addSetting(Setting(self.getDescription(),
                                 GrassUtils.GRASS_LOG_CONSOLE,
                                 'Log console output', False))

    def processAlgorithm(self, progress):
        commands = []
        vector = self.getParameterValue(self.VECTOR)
        elevation = self.getParameterValue(self.ELEVATION)
        color = self.getParameterValue(self.COLOR)

        region = \
            unicode(self.getParameterValue(self.GRASS_REGION_EXTENT_PARAMETER))
        regionCoords = region.split(',')
        command = 'g.region '
        command += 'n=' + unicode(regionCoords[3])
        command += ' s=' + unicode(regionCoords[2])
        command += ' e=' + unicode(regionCoords[1])
        command += ' w=' + unicode(regionCoords[0])
        cellsize = self.getParameterValue(self.GRASS_REGION_CELLSIZE_PARAMETER)
        if cellsize:
            command += ' res=' + unicode(cellsize)
        else:
            command += ' res=' + unicode(self.getDefaultCellsize())
        commands.append(command)

        command = 'nviz'
        if vector:
            layers = vector.split(';')
            for layer in layers:
                (cmd, newfilename) = self.exportVectorLayer(layer)
                commands.append(cmd)
                vector = vector.replace(layer, newfilename)
            command += ' vector=' + vector.replace(';', ',')
        if color:
            layers = color.split(';')
            for layer in layers:
                (cmd, newfilename) = self.exportRasterLayer(layer)
                commands.append(cmd)
                color = color.replace(layer, newfilename)
            command += ' color=' + color.replace(';', ',')
        if elevation:
            layers = elevation.split(';')
            for layer in layers:
                (cmd, newfilename) = self.exportRasterLayer(layer)
                commands.append(cmd)
                elevation = elevation.replace(layer, newfilename)
            command += ' elevation=' + elevation.replace(';', ',')
        if elevation is None and vector is None:
            command += ' -q'
        commands.append(command)
        GrassUtils.createTempMapset()
        GrassUtils.executeGrass(commands, progress)

 def checkBeforeOpeningParametersDialog(self):
     msg = GrassUtils.checkGrassIsInstalled()
     if msg is not None:
         html = '<p>This algorithm requires GRASS to be run. \
             Unfortunately, it seems that GRASS is not installed in \
             your system, or it is not correctly configured to be used \
             from QGIS</p>'
         html += '<p><a href="http://docs.qgis.org/2.0/en/docs/user_manual/processing/3rdParty.html">Click here</a> to know more about how to install and configure GRASS to be used with QGIS</p>'
         return html

    def getPostProcessingErrorMessage(self, wrongLayers):
        html = GeoAlgorithm.getPostProcessingErrorMessage(self, wrongLayers)
        msg = GrassUtils.checkGrassIsInstalled(True)
        html += '<p>This algorithm requires GRASS to be run. A test \
            to check if GRASS is correctly installed and configured in \
            your system has been performed, with the following \
            result:</p><ul><i>'
        if msg is None:
            html += 'GRASS seems to be correctly installed and \
                configured</i></li></ul>'
        else:
            html += msg + '</i></li></ul>'
            html += '<p><a href= "http://docs.qgis.org/2.0/en/docs/user_manual/processing/3rdParty.html">Click here</a> to know more about how to install and configure GRASS to be used with QGIS</p>'

        return html

 def createAlgsList(self):
     self.preloadedAlgs = []
     folder = GrassUtils.grassDescriptionPath()
     for descriptionFile in os.listdir(folder):
         if descriptionFile.endswith('txt'):
             try:
                 alg = GrassAlgorithm(os.path.join(folder, descriptionFile))
                 if alg.name.strip() != '':
                     self.preloadedAlgs.append(alg)
                 else:
                     ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                         self.tr('Could not open GRASS algorithm: %s' % descriptionFile))
             except Exception, e:
                 ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                     self.tr('Could not open GRASS algorithm: %s' % descriptionFile))

    def processAlgorithm(self, progress):
        if system.isWindows():
            path = GrassUtils.grassPath()
            if path == '':
                raise GeoAlgorithmExecutionException(
                    self.tr('GRASS folder is not configured.\nPlease '
                            'configure it before running GRASS algorithms.'))

        commands = []
        self.exportedLayers = {}
        outputCommands = []

        # If GRASS session has been created outside of this algorithm then
        # get the list of layers loaded in GRASS otherwise start a new
        # session
        existingSession = GrassUtils.sessionRunning
        if existingSession:
            self.exportedLayers = GrassUtils.getSessionLayers()
        else:
            GrassUtils.startGrassSession()

        # 1: Export layer to grass mapset

        for param in self.parameters:
            if isinstance(param, ParameterRaster):
                if param.value is None:
                    continue
                value = param.value

                # Check if the layer hasn't already been exported in, for
                # example, previous GRASS calls in this session
                if value in self.exportedLayers.keys():
                    continue
                else:
                    self.setSessionProjectionFromLayer(value, commands)
                    commands.append(self.exportRasterLayer(value))
            if isinstance(param, ParameterVector):
                if param.value is None:
                    continue
                value = param.value
                if value in self.exportedLayers.keys():
                    continue
                else:
                    self.setSessionProjectionFromLayer(value, commands)
                    commands.append(self.exportVectorLayer(value))
            if isinstance(param, ParameterTable):
                pass
            if isinstance(param, ParameterMultipleInput):
                if param.value is None:
                    continue
                layers = param.value.split(';')
                if layers is None or len(layers) == 0:
                    continue
                if param.datatype == ParameterMultipleInput.TYPE_RASTER:
                    for layer in layers:
                        if layer in self.exportedLayers.keys():
                            continue
                        else:
                            self.setSessionProjectionFromLayer(layer, commands)
                            commands.append(self.exportRasterLayer(layer))
                elif param.datatype == ParameterMultipleInput.TYPE_VECTOR_ANY:
                    for layer in layers:
                        if layer in self.exportedLayers.keys():
                            continue
                        else:
                            self.setSessionProjectionFromLayer(layer, commands)
                            commands.append(self.exportVectorLayer(layer))

        self.setSessionProjectionFromProject(commands)

        region = \
            unicode(self.getParameterValue(self.GRASS_REGION_EXTENT_PARAMETER))
        regionCoords = region.split(',')
        command = 'g.region'
        command += ' n=' + unicode(regionCoords[3])
        command += ' s=' + unicode(regionCoords[2])
        command += ' e=' + unicode(regionCoords[1])
        command += ' w=' + unicode(regionCoords[0])
        cellsize = self.getParameterValue(self.GRASS_REGION_CELLSIZE_PARAMETER)
        if cellsize:
            command += ' res=' + unicode(cellsize)
        else:
            command += ' res=' + unicode(self.getDefaultCellsize())
        alignToResolution = \
            self.getParameterValue(self.GRASS_REGION_ALIGN_TO_RESOLUTION)
        if alignToResolution:
            command += ' -a'
        commands.append(command)

        # 2: Set parameters and outputs

        command = self.grassName
        for param in self.parameters:
            if param.value is None or param.value == '':
                continue
            if param.name in [ self.GRASS_REGION_CELLSIZE_PARAMETER, self.GRASS_REGION_EXTENT_PARAMETER, self.GRASS_MIN_AREA_PARAMETER, self.GRASS_SNAP_TOLERANCE_PARAMETER, self.GRASS_OUTPUT_TYPE_PARAMETER, self.GRASS_REGION_ALIGN_TO_RESOLUTION ]:
                continue
            if isinstance(param, (ParameterRaster, ParameterVector)):
                value = param.value
                if value in self.exportedLayers.keys():
#.........这里部分代码省略.........

 def checkBeforeOpeningParametersDialog(self):
     return GrassUtils.checkGrassIsInstalled()

 def checkBeforeOpeningParametersDialog(self):
     msg = GrassUtils.checkGrassIsInstalled()
     if msg is not None:
         return msg

 def canBeActivated(self):
     return not bool(GrassUtils.checkGrassIsInstalled())