示例#1
0
    def runGdal(commands, progress=None):
        if progress is None:
            progress = SilentProgress()
        envval = os.getenv('PATH')
        # We need to give some extra hints to get things picked up on OS X
        isDarwin = False
        try:
            isDarwin = platform.system() == 'Darwin'
        except IOError:  # https://travis-ci.org/m-kuhn/QGIS#L1493-L1526
            pass
        if isDarwin and os.path.isfile(
                os.path.join(QgsApplication.prefixPath(), "bin", "gdalinfo")):
            # Looks like there's a bundled gdal. Let's use it.
            os.environ['PATH'] = "{}{}{}".format(
                os.path.join(QgsApplication.prefixPath(), "bin"), os.pathsep,
                envval)
            os.environ['DYLD_LIBRARY_PATH'] = os.path.join(
                QgsApplication.prefixPath(), "lib")
        else:
            # Other platforms should use default gdal finder codepath
            settings = QSettings()
            path = settings.value('/GdalTools/gdalPath', '')
            if not path.lower() in envval.lower().split(os.pathsep):
                envval += '{}{}'.format(os.pathsep, path)
                os.putenv('PATH', envval)

        fused_command = ' '.join([str(c) for c in commands])
        ProcessingLog.addToLog(ProcessingLog.LOG_INFO, fused_command)
        progress.setInfo('GDAL command:')
        progress.setCommand(fused_command)
        progress.setInfo('GDAL command output:')
        success = False
        retry_count = 0
        while success == False:
            loglines = []
            loglines.append('GDAL execution console output')
            try:
                proc = subprocess.Popen(
                    fused_command,
                    shell=True,
                    stdout=subprocess.PIPE,
                    stdin=subprocess.DEVNULL,
                    stderr=subprocess.STDOUT,
                    universal_newlines=True,
                ).stdout
                for line in proc:
                    progress.setConsoleInfo(line)
                    loglines.append(line)
                success = True
            except IOError as e:
                if retry_count < 5:
                    retry_count += 1
                else:
                    raise IOError(
                        e.message +
                        u'\nTried 5 times without success. Last iteration stopped after reading {} line(s).\nLast line(s):\n{}'
                        .format(len(loglines), u'\n'.join(loglines[-10:])))

        ProcessingLog.addToLog(ProcessingLog.LOG_INFO, loglines)
        GdalUtils.consoleOutput = loglines
示例#2
0
文件: GdalUtils.py 项目: spono/QGIS
    def runGdal(commands, progress=None):
        if progress is None:
            progress = SilentProgress()
        envval = os.getenv("PATH")
        # We need to give some extra hints to get things picked up on OS X
        isDarwin = False
        try:
            isDarwin = platform.system() == "Darwin"
        except IOError:  # https://travis-ci.org/m-kuhn/QGIS#L1493-L1526
            pass
        if isDarwin and os.path.isfile(os.path.join(QgsApplication.prefixPath(), "bin", "gdalinfo")):
            # Looks like there's a bundled gdal. Let's use it.
            os.environ["PATH"] = "{}{}{}".format(os.path.join(QgsApplication.prefixPath(), "bin"), os.pathsep, envval)
            os.environ["DYLD_LIBRARY_PATH"] = os.path.join(QgsApplication.prefixPath(), "lib")
        else:
            # Other platforms should use default gdal finder codepath
            settings = QSettings()
            path = settings.value("/GdalTools/gdalPath", "")
            if not path.lower() in envval.lower().split(os.pathsep):
                envval += "{}{}".format(os.pathsep, path)
                os.putenv("PATH", envval)

        fused_command = " ".join([str(c) for c in commands])
        ProcessingLog.addToLog(ProcessingLog.LOG_INFO, fused_command)
        progress.setInfo("GDAL command:")
        progress.setCommand(fused_command)
        progress.setInfo("GDAL command output:")
        success = False
        retry_count = 0
        while success == False:
            loglines = []
            loglines.append("GDAL execution console output")
            try:
                with subprocess.Popen(
                    fused_command,
                    shell=True,
                    stdout=subprocess.PIPE,
                    stdin=subprocess.DEVNULL,
                    stderr=subprocess.STDOUT,
                    universal_newlines=True,
                ) as proc:
                    for line in proc.stdout:
                        progress.setConsoleInfo(line)
                        loglines.append(line)
                    success = True
            except IOError as e:
                if retry_count < 5:
                    retry_count += 1
                else:
                    raise IOError(
                        e.message
                        + u"\nTried 5 times without success. Last iteration stopped after reading {} line(s).\nLast line(s):\n{}".format(
                            len(loglines), u"\n".join(loglines[-10:])
                        )
                    )

        ProcessingLog.addToLog(ProcessingLog.LOG_INFO, loglines)
        GdalUtils.consoleOutput = loglines
示例#3
0
    def handle(self, **kwargs):
        self.logger.debug('>>> Handler: 4...')

        vector_layer = kwargs['vector_layer']
        plugin_name = kwargs['plugin_name']

        if vector_layer:
            destination = 'memory:' if 'buffer_source' not in kwargs else kwargs[
                'buffer_source']
            open_output_layer = True if 'open_output_layer' not in kwargs else kwargs[
                'open_output_layer']

            buffer_layer = sp_buffering(plugin_name,
                                        SilentProgress(),
                                        vector_layer,
                                        destination=destination,
                                        open_output_layer=open_output_layer)
            if buffer_layer and buffer_layer.isValid():
                kwargs['buffer_layer'] = buffer_layer
                self.next(**kwargs)
            else:
                self.error = 'Fail to create buffer, buffer is null or feature count is zero.'
                self.logger.fatal(self.error)
                raise RuntimeError(self.error)
        else:
            self.error = 'Failt to get grid layer.'
            self.logger.fatal(self.error)
            raise RuntimeError(self.error)
示例#4
0
    def execute(self, progress=SilentProgress(), model=None):
        """The method to use to call a processing algorithm.

        Although the body of the algorithm is in processAlgorithm(),
        it should be called using this method, since it performs
        some additional operations.

        Raises a GeoAlgorithmExecutionException in case anything goes
        wrong.
        """
        self.model = model
        try:
            self.setOutputCRS()
            self.resolveOutputs()
            self.evaluateParameterValues()
            self.runPreExecutionScript(progress)
            self.processAlgorithm(progress)
            progress.setPercentage(100)
            self.convertUnsupportedFormats(progress)
            self.runPostExecutionScript(progress)
        except GeoAlgorithmExecutionException as gaee:
            lines = [self.tr('Error while executing algorithm')]
            lines.append(traceback.format_exc())
            ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, gaee.msg)
            raise GeoAlgorithmExecutionException(gaee.msg, lines, gaee)
        except Exception as e:
            # If something goes wrong and is not caught in the
            # algorithm, we catch it here and wrap it
            lines = [self.tr('Uncaught error while executing algorithm')]
            lines.append(traceback.format_exc())
            ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, lines)
            raise GeoAlgorithmExecutionException(str(e) + self.tr('\nSee log for more details'), lines, e)
示例#5
0
def runalg(alg, progress=None):
    """Executes a given algorithm, showing its progress in the
    progress object passed along.

    Return true if everything went OK, false if the algorithm
    could not be completed.
    """
    if progress is None:
        progress = SilentProgress()
    try:
        alg.execute(progress)
        return True
    except GeoAlgorithmExecutionException as e:
        ProcessingLog.addToLog(sys.exc_info()[0], ProcessingLog.LOG_ERROR)
        progress.error(e.msg)
        return False
示例#6
0
def handleAlgorithmResults(alg, progress=None, showResults=True):
    wrongLayers = []
    htmlResults = False
    if progress is None:
        progress = SilentProgress()
    progress.setText(QCoreApplication.translate('Postprocessing', 'Loading resulting layers'))
    i = 0
    for out in alg.outputs:
        progress.setPercentage(100 * i / float(len(alg.outputs)))
        if out.hidden or not out.open:
            continue
        if isinstance(out, (OutputRaster, OutputVector, OutputTable)):
            try:
                if hasattr(out, "layer") and out.layer is not None:
                    out.layer.setLayerName(out.description)
                    QgsMapLayerRegistry.instance().addMapLayers([out.layer])
                else:
                    if ProcessingConfig.getSetting(
                            ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                        name = os.path.basename(out.value)
                    else:
                        name = out.description

                    isRaster = True if isinstance(out, OutputRaster) else False
                    dataobjects.load(out.value, name, alg.crs,
                                     RenderingStyles.getStyle(alg.commandLineName(), out.name),
                                     isRaster)
            except Exception:
                ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                                       "Error loading result layer:\n" + traceback.format_exc())
                wrongLayers.append(out.description)
        elif isinstance(out, OutputFile) and out.ext == 'csv':
            try:
                dataobjects.load(out.value, name, alg.crs,
                                 RenderingStyles.getStyle(alg.commandLineName(),
                                                          out.name))
            except Exception:
                ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                                       "Error loading result layer:\n" + traceback.format_exc())
                wrongLayers.append(out.description)
        elif isinstance(out, OutputHTML):
            ProcessingResults.addResult(out.description, out.value)
            htmlResults = True
        i += 1

    QApplication.restoreOverrideCursor()
    if wrongLayers:
        msg = "The following layers were not correctly generated.<ul>"
        msg += "".join(["<li>%s</li>" % lay for lay in wrongLayers]) + "</ul>"
        msg += "You can check the log messages to find more information about the execution of the algorithm"
        progress.error(msg)

    if showResults and htmlResults and not wrongLayers:
        dlg = ResultsDialog()
        dlg.exec_()

    return len(wrongLayers) == 0
    def runalgIterating(alg, paramToIter, progress):
        # Generate all single-feature layers
        settings = QSettings()
        systemEncoding = settings.value('/UI/encoding', 'System')
        layerfile = alg.getParameterValue(paramToIter)
        layer = dataobjects.getObjectFromUri(layerfile, False)
        feat = QgsFeature()
        filelist = []
        outputs = {}
        provider = layer.dataProvider()
        features = vector.features(layer)
        for feat in features:
            output = getTempFilename('shp')
            filelist.append(output)
            writer = QgsVectorFileWriter(output, systemEncoding,
                                         provider.fields(),
                                         provider.geometryType(), layer.crs())
            writer.addFeature(feat)
            del writer

        # store output values to use them later as basenames for all outputs
        for out in alg.outputs:
            outputs[out.name] = out.value

        # now run all the algorithms
        i = 1
        for f in filelist:
            alg.setParameterValue(paramToIter, f)
            for out in alg.outputs:
                filename = outputs[out.name]
                if filename:
                    filename = filename[:filename.rfind('.')] + '_' + str(i) \
                        + filename[filename.rfind('.'):]
                out.value = filename
            progress.setText('Executing iteration ' + str(i) + '/' +
                             str(len(filelist)) + '...')
            progress.setPercentage(i * 100 / len(filelist))
            if UnthreadedAlgorithmExecutor.runalg(alg, SilentProgress()):
                Postprocessing.handleAlgorithmResults(alg, SilentProgress(),
                                                      False)
                i += 1
            else:
                return False

        return True
示例#8
0
    def handle(self, **kwargs):
        self.logger.debug('>>> Handler: 5...')

        torre_layer = kwargs['torre_layer']

        if torre_layer:
            buffer_layer = sp_buffering(PLUGIN_VULNERABILIDADE,
                                        SilentProgress(), torre_layer)
            kwargs['buffer_layer_teste'] = buffer_layer
            self.next(**kwargs)
示例#9
0
    def handle(self, **kwargs):
        self.logger.error('>>> Handler: 5...')

        pc_layer = kwargs['pc_layer']

        if pc_layer:
            buffer_pc_layer = sp_buffering(PLUGIN_VULNERABILIDADE,
                                           SilentProgress(), pc_layer)
            kwargs['buffer_pc_layer'] = buffer_pc_layer
            self.next(**kwargs)
示例#10
0
    def handle(self, **kwargs):
        self.logger.debug('>>> Handler: 4...')

        self.logger.debug(kwargs)

        vao_layer = kwargs['vao_layer']

        if vao_layer:
            buffer_layer = calc(PLUGIN_VULNERABILIDADE, SilentProgress(),
                                vao_layer)
            kwargs['buffer_layer'] = buffer_layer
            self.next(**kwargs)
示例#11
0
    def handle(self, **kwargs):
        self.logger.debug('>>> Handler: 4...')

        self.logger.debug(kwargs['line_layer'])

        line_layer = kwargs['clip_line_layers']

        if line_layer:
            buffer_layer = sp_buffering(PLUGIN_VULNERABILIDADE,
                                        SilentProgress(), line_layer)
            kwargs['buffer_clip_layer'] = buffer_layer
            self.next(**kwargs)
示例#12
0
    def preprocess(self, layer):
        '''
        Preprocesses the layer with the corresponding preprocess hook and returns the path to the 
        resulting layer. If no preprocessing is performed, it returns the input layer itself
        '''
        if not processingOk:
            return layer

        if layer.type() == layer.RasterLayer:
            try:
                hookFile = str(QSettings().value(
                    "/OpenGeo/Settings/GeoServer/PreuploadRasterHook", ""))
                alg = self.getAlgorithmFromHookFile(hookFile)
                if (len(alg.parameters) == 1
                        and isinstance(alg.parameters[0], ParameterRaster)
                        and len(alg.outputs) == 1
                        and isinstance(alg.outputs[0], OutputRaster)):
                    alg.parameters[0].setValue(layer)
                    if UnthreadedAlgorithmExecutor.runalg(
                            alg, SilentProgress()):
                        return load(alg.outputs[0].value)
                    return layer
            except:
                return layer
        elif layer.type() == layer.VectorLayer:
            try:
                hookFile = str(QSettings().value(
                    "/OpenGeo/Settings/GeoServer/PreuploadVectorHook", ""))
                alg = self.getAlgorithmFromHookFile(hookFile)
                if (len(alg.parameters) == 1
                        and isinstance(alg.parameters[0], ParameterVector)
                        and len(alg.outputs) == 1
                        and isinstance(alg.outputs[0], OutputVector)):
                    alg.parameters[0].setValue(layer)
                    if UnthreadedAlgorithmExecutor.runalg(
                            alg, SilentProgress()):
                        return load(alg.outputs[0].value)
                    return layer
            except:
                return layer
示例#13
0
    def handle(self, **kwargs):
        self.logger.debug('>>> Handler: 8...')

        self.logger.debug(kwargs['clip_line_layers'])

        line_layer = kwargs['clip_line_layers']
        output_vector = kwargs['output_vector']

        if line_layer:
            buffer_layer = buffer_line(PLUGIN_VULNERABILIDADE,
                                       SilentProgress(), line_layer,
                                       output_vector)
            kwargs['buffer_line_layer'] = buffer_layer
            self.next(**kwargs)
示例#14
0
def runalg(alg, progress=None):
    """Executes a given algorithm, showing its progress in the
    progress object passed along.

    Return true if everything went OK, false if the algorithm
    could not be completed.
    """
    try:
        alg.execute(progress or SilentProgress())
        return True
    except GeoAlgorithmExecutionException as e:
        ProcessingLog.addToLog(sys.exc_info()[0], ProcessingLog.LOG_ERROR)
        progress.error(e.msg)
        return False
示例#15
0
文件: GdalUtils.py 项目: barogi/QGIS
    def runGdal(commands, progress=None):
        if progress is None:
            progress = SilentProgress()
        envval = os.getenv('PATH')
        # We need to give some extra hints to get things picked up on OS X
        isDarwin = False
        try:
            isDarwin = platform.system() == 'Darwin'
        except IOError: # https://travis-ci.org/m-kuhn/QGIS#L1493-L1526
            pass
        if isDarwin and os.path.isfile(os.path.join(QgsApplication.prefixPath(), "bin", "gdalinfo")):
            # Looks like there's a bundled gdal. Let's use it.
            os.environ['PATH'] = "{}{}{}".format(os.path.join(QgsApplication.prefixPath(), "bin"), os.pathsep, envval)
            os.environ['DYLD_LIBRARY_PATH'] = os.path.join(QgsApplication.prefixPath(), "lib")
        else:
            # Other platforms should use default gdal finder codepath
            settings = QSettings()
            path = settings.value('/GdalTools/gdalPath', '')
            if not path.lower() in envval.lower().split(os.pathsep):
                envval += '{}{}'.format(os.pathsep, path)
                os.putenv('PATH', envval)

        loglines = []
        loglines.append('GDAL execution console output')
        fused_command = ''.join(['%s ' % c for c in commands])
        progress.setInfo('GDAL command:')
        progress.setCommand(fused_command)
        proc = subprocess.Popen(
            fused_command,
            shell=True,
            stdout=subprocess.PIPE,
            stdin=open(os.devnull),
            stderr=subprocess.STDOUT,
            universal_newlines=True,
        ).stdout
        progress.setInfo('GDAL command output:')
        for line in iter(proc.readline, ''):
            progress.setConsoleInfo(line)
            loglines.append(line)
        ProcessingLog.addToLog(ProcessingLog.LOG_INFO, loglines)
        GdalUtils.consoleOutput = loglines
示例#16
0
def handleAlgorithmResults(alg, progress=None, showResults=True):
    wrongLayers = []
    htmlResults = False
    if progress is None:
        progress = SilentProgress()
    progress.setText(QCoreApplication.translate('Postprocessing', 'Loading resulting layers'))
    i = 0
    for out in alg.outputs:
        progress.setPercentage(100 * i / float(len(alg.outputs)))
        if out.hidden or not out.open:
            continue
        if isinstance(out, (OutputRaster, OutputVector, OutputTable)):
            try:
                if hasattr(out, "layer") and out.layer is not None:
                    out.layer.setLayerName(out.description)
                    QgsMapLayerRegistry.instance().addMapLayers([out.layer])
                else:
                    if ProcessingConfig.getSetting(
                            ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                        name = os.path.basename(out.value)
                    else:
                        name = out.description

                    isRaster = True if isinstance(out, OutputRaster) else False
                    dataobjects.load(out.value, name, alg.crs,
                                     RenderingStyles.getStyle(alg.commandLineName(), out.name),
                                     isRaster)
            except Exception:
                ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                                       "Error loading result layer:\n" + traceback.format_exc())
                wrongLayers.append(out.description)
        elif isinstance(out, OutputHTML):
            ProcessingResults.addResult(out.description, out.value)
            htmlResults = True
        i += 1

    QApplication.restoreOverrideCursor()
    if wrongLayers:
        msg = "The following layers were not correctly generated.<ul>"
        msg += "".join(["<li>%s</li>" % lay for lay in wrongLayers]) + "</ul>"
        msg += "You can check the log messages to find more information about the execution of the algorithm"
        progress.error(msg)

    if showResults and htmlResults and not wrongLayers:
        dlg = ResultsDialog()
        dlg.exec_()

    return len(wrongLayers) == 0
示例#17
0
文件: OTBUtils.py 项目: AndiJay/QGIS
def getInstalledVersion(runOtb=False):
    global _installedVersion
    global _installedVersionFound

    if _installedVersionFound and not runOtb:
        return _installedVersion

    if otbPath() is None or otbLibPath() is None:
        _installedVersionFound = False
        return None
    commands = [os.path.join(otbPath(), "otbcli_Smoothing")]
    progress = SilentProgress()
    out = executeOtb(commands, progress, False)
    for line in out:
        if "version" in line:
            _installedVersionFound = True
            _installedVersion = line.split("version")[-1].strip()
            break
    return _installedVersion
示例#18
0
    def execute(self, progress=SilentProgress(), model=None):
        """The method to use to call a processing algorithm.

        Although the body of the algorithm is in processAlgorithm(),
        it should be called using this method, since it performs
        some additional operations.

        Raises a GeoAlgorithmExecutionException in case anything goes
        wrong.
        """
        self.model = model
        try:
            self.setOutputCRS()
            self.resolveTemporaryOutputs()
            self.resolveDataObjects()
            self.checkOutputFileExtensions()
            self.runPreExecutionScript(progress)
            self.processAlgorithm(progress)
            progress.setPercentage(100)
            self.convertUnsupportedFormats(progress)
            self.runPostExecutionScript(progress)
        except GeoAlgorithmExecutionException as gaee:
            lines = [self.tr('Uncaught error while executing algorithm')]
            lines.append(traceback.format_exc())
            ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, gaee.msg)
            raise GeoAlgorithmExecutionException(gaee.msg, lines, gaee)
        except Exception as e:
            # If something goes wrong and is not caught in the
            # algorithm, we catch it here and wrap it
            lines = [self.tr('Uncaught error while executing algorithm')]
            lines.append(traceback.format_exc())
            ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, lines)
            try:
                message = unicode(e)
            except UnicodeDecodeError:
                # Try with the 'replace' mode (requires e.message instead of e!)
                message = unicode(e.message, 'utf-8', 'replace')
            raise GeoAlgorithmExecutionException(
                message + self.tr(' \nSee log for more details'), lines, e)
示例#19
0
    def runAlgorithm(algOrName, onFinish, *args):
        if isinstance(algOrName, GeoAlgorithm):
            alg = algOrName
        else:
            alg = Processing.getAlgorithm(algOrName)
        if alg is None:
            print 'Error: Algorithm not found\n'
            return
        if len(args) != alg.getVisibleParametersCount() \
                    + alg.getVisibleOutputsCount():
            print 'Error: Wrong number of parameters'
            processing.alghelp(algOrName)
            return

        alg = alg.getCopy()
        if isinstance(args, dict):
            # Set params by name
            for (name, value) in args.items():
                if alg.getParameterFromName(name).setValue(value):
                    continue
                if alg.getOutputFromName(name).setValue(value):
                    continue
                print 'Error: Wrong parameter value %s for parameter %s.' \
                    % (value, name)
                return
        else:
            i = 0
            for param in alg.parameters:
                if not param.hidden:
                    if not param.setValue(args[i]):
                        print 'Error: Wrong parameter value: ' \
                            + unicode(args[i])
                        return
                    i = i + 1

            for output in alg.outputs:
                if not output.hidden:
                    if not output.setValue(args[i]):
                        print 'Error: Wrong output value: ' + unicode(args[i])
                        return
                    i = i + 1

        msg = alg.checkParameterValuesBeforeExecuting()
        if msg:
            print 'Unable to execute algorithm\n' + msg
            return

        if not alg.checkInputCRS():
            print 'Warning: Not all input layers use the same CRS.\n' \
                + 'This can cause unexpected results.'

        ProcessingLog.addToLog(ProcessingLog.LOG_ALGORITHM, alg.getAsCommand())

        # Don't set the wait cursor twice, because then when you
        # restore it, it will still be a wait cursor.
        cursor = QApplication.overrideCursor()
        if cursor is None or cursor == 0:
            QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        elif cursor.shape() != Qt.WaitCursor:
            QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))

        progress = SilentProgress()
        if interface.iface is not None :
          progress = MessageBarProgress()
        ret = UnthreadedAlgorithmExecutor.runalg(alg, progress)
        if onFinish is not None and ret:
            onFinish(alg, progress)
        QApplication.restoreOverrideCursor()
        progress.close()
        return alg
示例#20
0
    def runAlgorithm(algOrName, onFinish, *args):
        if isinstance(algOrName, GeoAlgorithm):
            alg = algOrName
        else:
            alg = Processing.getAlgorithm(algOrName)
        if alg is None:
            print 'Error: Algorithm not found\n'
            return
        if len(args) != alg.getVisibleParametersCount() \
                    + alg.getVisibleOutputsCount():
            print 'Error: Wrong number of parameters'
            processing.alghelp(algOrName)
            return

        alg = alg.getCopy()
        if isinstance(args, dict):
            # Set params by name
            for (name, value) in args.items():
                if alg.getParameterFromName(name).setValue(value):
                    continue
                if alg.getOutputFromName(name).setValue(value):
                    continue
                print 'Error: Wrong parameter value %s for parameter %s.' \
                    % (value, name)
                return
        else:
            i = 0
            for param in alg.parameters:
                if not param.hidden:
                    if not param.setValue(args[i]):
                        print 'Error: Wrong parameter value: ' \
                            + unicode(args[i])
                        return
                    i = i + 1

            for output in alg.outputs:
                if not output.hidden:
                    if not output.setValue(args[i]):
                        print 'Error: Wrong output value: ' + unicode(args[i])
                        return
                    i = i + 1

        msg = alg.checkParameterValuesBeforeExecuting()
        if msg:
            print 'Unable to execute algorithm\n' + msg
            return

        if not alg.checkInputCRS():
            print 'Warning: Not all input layers use the same CRS.\n' \
                + 'This can cause unexpected results.'

        ProcessingLog.addToLog(ProcessingLog.LOG_ALGORITHM, alg.getAsCommand())

        # Don't set the wait cursor twice, because then when you
        # restore it, it will still be a wait cursor.
        cursor = QApplication.overrideCursor()
        if cursor is None or cursor == 0:
            QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        elif cursor.shape() != Qt.WaitCursor:
            QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))

        progress = SilentProgress()
        if iface is not None :
            progress = MessageBarProgress()
        ret = UnthreadedAlgorithmExecutor.runalg(alg, progress)
        if onFinish is not None and ret:
            onFinish(alg, progress)
        QApplication.restoreOverrideCursor()
        progress.close()
        return alg
示例#21
0
  def runChole(commands, progress=None):
    cwd=os.path.dirname(__file__) + os.sep + 'Chloe2012'
    
    if progress is None:
      progress = SilentProgress()

    fused_command = ' '.join(commands)
    progress.setInfo('Command:')
    progress.setCommand(fused_command)
    progress.setInfo('Output:')

    # Execution Chloe with subprocess command system
    success = False
    retry_count = 0
    while success == False:
      loglines = []
      loglines.append('Execution console output :')
      try:
        process = subprocess.Popen(
          fused_command,
          shell=True,
          stdout=subprocess.PIPE,
          stdin=open(os.devnull),
          stderr=subprocess.STDOUT,
          universal_newlines=True,
          cwd=cwd,
        )

        regex = re.compile(r'^\s*##\s*(?P<percentage>\d+)\s*\/\s*\d+\s*$')
        while True:
          output = process.stdout.readline()
          if output == '' and process.poll() is not None:
              break
          if output:
              line = output.strip()
              res = regex.search(line)
              if res:
                percentage = int(res.group('percentage'))
                progress.setPercentage(percentage)
              else:
                progress.setConsoleInfo(line)
              loglines.append(line)
          rc = process.poll()

        success = True
      except IOError as e:
        if retry_count < 5:
          retry_count += 1
        else:
          raise IOError(e.message + u'\nTried 5 times without success. Last iteration stopped after reading {} line(s).\nLast line(s):\n{}'.format(len(loglines), u'\n'.join(loglines[-10:])))
    
    # Save log
    ProcessingLog.addToLog(ProcessingLog.LOG_INFO, loglines)
    ChloeUtils.consoleOutput = loglines
示例#22
0
 def execute(self, progress=SilentProgress(), model=None):
     self.collectNonTemporaryOutputs()
     GeoAlgorithm.execute(self, progress, model)