Пример #1
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(QtCore.QSettings().value("/GeoServer/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 runalg(alg, SilentProgress()):
                        return load(alg.outputs[0].value)
                    return layer
            except:
                return layer
        elif layer.type() == layer.VectorLayer:
            try:
                hookFile = str(QtCore.QSettings().value("/GeoServer/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 runalg(alg, SilentProgress()):
                        return load(alg.outputs[0].value)
                    return layer
            except:
                QgsMessageLog.logMessage("Could not apply hook to layer upload. Wrong Hook", QgsMessageLog.WARNING)
                return layer
Пример #2
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 out.value.startswith('memory:'):
                    layer = out.memoryLayer
                    QgsMapLayerRegistry.instance().addMapLayers([layer])
                else:
                    if ProcessingConfig.getSetting(
                            ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                        name = os.path.basename(out.value)
                    else:
                        name = out.description
                    dataobjects.load(
                        out.value, name, alg.crs,
                        RenderingStyles.getStyle(alg.commandLineName(),
                                                 out.name))
            except Exception, e:
                wrongLayers.append(out.description)
        elif isinstance(out, OutputHTML):
            ProcessingResults.addResult(out.description, out.value)
            htmlResults = True
Пример #3
0
 def handleAlgorithmResults(alg, progress, showResults = True):
     wrongLayers = []
     htmlResults = False;
     progress.setText("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 out.value.startswith("memory:"):
                     layer = out.memoryLayer
                     QgsMapLayerRegistry.instance().addMapLayers([layer])
                 else:
                     if ProcessingConfig.getSetting(ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                         name = os.path.basename(out.value)
                     else:
                         name = out.description
                     dataobjects.load(out.value, name, alg.crs, RenderingStyles.getStyle(alg.commandLineName(),out.name))
             except Exception, e:
                 wrongLayers.append(out)
         elif isinstance(out, OutputHTML):
             ProcessingResults.addResult(out.description, out.value)
             htmlResults = True
Пример #4
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
Пример #5
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
Пример #6
0
    def processAlgorithm(self, parameters, context, feedback):
        filename = self.getParameterValue(self.INPUT)

        style = self.getParameterValue(self.STYLE)
        layer = QgsProcessingUtils.mapLayerFromString(filename, context, False)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
        else:
            layer.loadNamedStyle(style)
            context.addLayerToLoadOnCompletion(layer.id())
            layer.triggerRepaint()
Пример #7
0
    def processAlgorithm(self, parameters, context, feedback):
        filename = self.getParameterValue(self.INPUT)

        style = self.getParameterValue(self.STYLE)
        layer = QgsProcessingUtils.mapLayerFromString(filename, context, False)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
        else:
            layer.loadNamedStyle(style)
            context.addLayerToLoadOnCompletion(layer.id())
            layer.triggerRepaint()
Пример #8
0
    def processAlgorithm(self, progress):
        filename = self.getParameterValue(self.INPUT)

        style = self.getParameterValue(self.STYLE)
        layer = dataobjects.getObjectFromUri(filename, False)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
            self.getOutputFromName(self.OUTPUT).open = False
        else:
            layer.loadNamedStyle(style)
            iface.mapCanvas().refresh()
            layer.triggerRepaint()
Пример #9
0
    def processAlgorithm(self, feedback):
        filename = self.getParameterValue(self.INPUT)

        style = self.getParameterValue(self.STYLE)
        layer = dataobjects.getObjectFromUri(filename, False)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
            self.getOutputFromName(self.OUTPUT).open = False
        else:
            layer.loadNamedStyle(style)
            iface.mapCanvas().refresh()
            layer.triggerRepaint()
Пример #10
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 out.value.startswith('memory:'):
                    layer = out.memoryLayer
                    QgsMapLayerRegistry.instance().addMapLayers([layer])
                else:
                    if ProcessingConfig.getSetting(
                            ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                        name = os.path.basename(out.value)
                    else:
                        name = out.description
                    dataobjects.load(
                        out.value, name, alg.crs,
                        RenderingStyles.getStyle(alg.commandLineName(),
                                                 out.name))
            except Exception as e:
                wrongLayers.append(out.description)
        elif isinstance(out, OutputHTML):
            ProcessingResults.addResult(out.description, out.value)
            htmlResults = True
        i += 1
    if wrongLayers:
        QApplication.restoreOverrideCursor()
        dlg = MessageDialog()
        dlg.setTitle(
            QCoreApplication.translate('Postprocessing',
                                       'Problem loading output layers'))
        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 <a href='log'>log messages</a> to find more information about the execution of the algorithm"
        dlg.setMessage(msg)
        dlg.exec_()

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

    return len(wrongLayers) == 0
Пример #11
0
    def processAlgorithm(self, progress):
        filename = self.getParameterValue(self.INPUT)
        style = self.getParameterValue(self.STYLE)

        dataobjects.resetLoadedLayers()
        layer = dataobjects.getObjectFromUri(filename, False)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
        else:
            layer.loadNamedStyle(style)
            layer.triggerRepaint()
            iface.legendInterface().refreshLayerSymbology(layer)
        self.setOutputValue(self.OUTPUT, filename)
Пример #12
0
    def processAlgorithm(self, progress):
        filename = self.getParameterValue(self.INPUT)
        style = self.getParameterValue(self.STYLE)

        dataobjects.resetLoadedLayers()
        layer = dataobjects.getObjectFromUri(filename, False)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
        else:
            layer.loadNamedStyle(style)
            layer.triggerRepaint()
            iface.legendInterface().refreshLayerSymbology(layer)
        self.setOutputValue(self.OUTPUT, filename)
Пример #13
0
    def processAlgorithm(self, progress):
        filename = self.getParameterValue(self.INPUT)
        layer = dataobjects.getObjectFromUri(filename)

        style = self.getParameterValue(self.STYLE)
        layer = dataobjects.getObjectFromUri(filename, False)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
            self.getOutputFromName(self.OUTPUT).open = False
        else:
            layer.loadNamedStyle(style)
            iface.mapCanvas().refresh()
            iface.legendInterface().refreshLayerSymbology(layer)
Пример #14
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(QtCore.QSettings().value(
                    "/GeoServer/Settings/GeoServer/PreuploadRasterHook", ""))
                if hookFile:
                    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 runalg(alg, SilentProgress()):
                            return load(alg.outputs[0].value)
                        return layer
                else:
                    return layer
            except:
                QgsMessageLog.logMessage(
                    "Could not apply hook to layer upload. Wrong Hook",
                    level=QgsMessageLog.WARNING)
                return layer
        elif layer.type() == layer.VectorLayer:
            try:
                hookFile = str(QtCore.QSettings().value(
                    "/GeoServer/Settings/GeoServer/PreuploadVectorHook", ""))
                if hookFile:
                    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 runalg(alg, SilentProgress()):
                            return load(alg.outputs[0].value)
                        return layer
                else:
                    return layer
            except:
                QgsMessageLog.logMessage(
                    "Could not apply hook to layer upload. Wrong Hook",
                    level=QgsMessageLog.WARNING)
                return layer
Пример #15
0
def handleAlgorithmResults(alg, context, feedback=None, showResults=True):
    wrongLayers = []
    if feedback is None:
        feedback = QgsProcessingFeedback()
    feedback.setProgressText(
        QCoreApplication.translate('Postprocessing',
                                   'Loading resulting layers'))
    i = 0
    for out in alg.outputs:
        feedback.setProgress(100 * i / float(len(alg.outputs)))
        if out.hidden or not out.open:
            continue
        if isinstance(out, (OutputRaster, OutputVector, OutputTable)):
            try:
                layer = QgsProcessingUtils.mapLayerFromString(
                    out.value, context)
                if layer:
                    layer.setName(out.description)
                    QgsProject.instance().addMapLayer(
                        context.temporaryLayerStore().takeMapLayer(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.id(), out.name), isRaster)
            except Exception:
                QgsMessageLog.logMessage(
                    "Error loading result layer:\n" + traceback.format_exc(),
                    'Processing', QgsMessageLog.CRITICAL)
                wrongLayers.append(out.description)
        elif isinstance(out, OutputHTML):
            resultsList.addResult(alg.icon(), out.description, out.value)
        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"
        feedback.reportError(msg)

    return len(wrongLayers) == 0
Пример #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
def openProjectFromMapboxFile(mapboxFile):
    iface.newProject()
    layers = {}
    labels = []
    with open(mapboxFile) as f:
        project = json.load(f)
    if "sprite" in project:
        sprites = os.path.join(os.path.dirname(mapboxFile), project["sprite"])
    else:
        sprites = None
    for layer in project["layers"]:
        layerType = project["sources"][layer["source"]]["type"]
        if layerType.lower() == "geojson":
            source = project["sources"][layer["source"]]["data"]
            path = os.path.join(os.path.dirname(mapboxFile), source)
            if layer["id"].startswith("txt"):
                labels.append(layer)
            else:
                add = True
                if layer["source"] not in layers:
                    add = False
                    layers[layer["source"]] = dataobjects.load(
                        path, layer["id"])
                setLayerSymbologyFromMapboxStyle(layers[layer["source"]],
                                                 layer, sprites, add)
        elif layerType.lower() == "raster":
            url = project["sources"][layer["source"]]["tiles"][0]
            url = url.replace("bbox={bbox-epsg-3857}", "")
            url = url.replace("&&", "&")
            wmsLayer = QgsRasterLayer(url, layer["id"], "wms")
            QgsMapLayerRegistry.instance().addMapLayer(wmsLayer)
    for labelLayer in labels:
        setLayerLabelingFromMapboxStyle(layers[labelLayer["source"]],
                                        labelLayer)
Пример #18
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 out.value.startswith('memory:'):
                    layer = out.memoryLayer
                    QgsMapLayerRegistry.instance().addMapLayers([layer])
                else:
                    if ProcessingConfig.getSetting(
                            ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                        name = os.path.basename(out.value)
                    else:
                        name = out.description
                    dataobjects.load(out.value, name, alg.crs,
                                     RenderingStyles.getStyle(alg.commandLineName(),
                                                              out.name))
            except Exception as e:
                wrongLayers.append(out.description)
        elif isinstance(out, OutputHTML):
            ProcessingResults.addResult(out.description, out.value)
            htmlResults = True
        i += 1
    if wrongLayers:
        QApplication.restoreOverrideCursor()
        dlg = MessageDialog()
        dlg.setTitle(QCoreApplication.translate('Postprocessing', 'Problem loading output layers'))
        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 <a href='log'>log messages</a> to find more information about the execution of the algorithm"
        dlg.setMessage(msg)
        dlg.exec_()

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

    return len(wrongLayers) == 0
Пример #19
0
    def processAlgorithm(self, parameters, context, feedback):
        filename = self.getParameterValue(self.INPUT)
        layer = QgsProcessingUtils.mapLayerFromString(filename, context)

        style = self.getParameterValue(self.STYLE)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
        else:
            with open(style) as f:
                xml = "".join(f.readlines())
            d = QDomDocument()
            d.setContent(xml)
            n = d.firstChild()
            layer.readSymbology(n, '')
            context.addLayerToLoadOnCompletion(self.getOutputFromName(self.OUTPUT).value)
            self.setOutputValue(self.OUTPUT, filename)
            layer.triggerRepaint()
Пример #20
0
    def processAlgorithm(self, parameters, context, feedback):
        filename = self.getParameterValue(self.INPUT)
        layer = QgsProcessingUtils.mapLayerFromString(filename, context)

        style = self.getParameterValue(self.STYLE)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
        else:
            with open(style) as f:
                xml = "".join(f.readlines())
            d = QDomDocument()
            d.setContent(xml)
            n = d.firstChild()
            layer.readSymbology(n, '')
            context.addLayerToLoadOnCompletion(self.getOutputFromName(self.OUTPUT).value)
            self.setOutputValue(self.OUTPUT, filename)
            layer.triggerRepaint()
Пример #21
0
    def processAlgorithm(self, progress):
        filename = self.getParameterValue(self.INPUT)
        layer = dataobjects.getObjectFromUri(filename)

        style = self.getParameterValue(self.STYLE)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
            self.getOutputFromName(self.OUTPUT).open = False
        else:
            with open(style) as f:
                xml = "".join(f.readlines())
            d = QDomDocument()
            d.setContent(xml)
            n = d.firstChild()
            layer.readSymbology(n, '')
            self.setOutputValue(self.OUTPUT, filename)
            iface.mapCanvas().refresh()
Пример #22
0
    def processAlgorithm(self, progress):
        filename = self.getParameterValue(self.INPUT)
        layer = dataobjects.getObjectFromUri(filename)

        style = self.getParameterValue(self.STYLE)
        if layer is None:
            dataobjects.load(filename, os.path.basename(filename), style=style)
            self.getOutputFromName(self.OUTPUT).open = False
        else:
            with open(style) as f:
                xml = "".join(f.readlines())
            d = QDomDocument()
            d.setContent(xml)
            n = d.firstChild()
            layer.readSymbology(n, '')
            self.setOutputValue(self.OUTPUT, filename)
            iface.mapCanvas().refresh()
Пример #23
0
def handleAlgorithmResults(alg, feedback=None, showResults=True):
    wrongLayers = []
    if feedback is None:
        feedback = QgsProcessingFeedback()
    feedback.setProgressText(
        QCoreApplication.translate('Postprocessing',
                                   'Loading resulting layers'))
    i = 0
    for out in alg.outputs:
        feedback.setProgress(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.setName(out.description)
                    QgsProject.instance().addMapLayers([out.layer])
                else:
                    if ProcessingConfig.getSetting(
                            ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                        name = os.path.basename(out.value)
                    else:
                        name = out.description
                    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):
            resultsList.addResult(alg.getIcon(), out.description, out.value)
        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"
        feedback.reportError(msg)

    return len(wrongLayers) == 0
Пример #24
0
def handleAlgorithmResults(alg, feedback=None, showResults=True):
    wrongLayers = []
    if feedback is None:
        feedback = QgsProcessingFeedback()
    feedback.setProgressText(QCoreApplication.translate('Postprocessing', 'Loading resulting layers'))
    i = 0
    for out in alg.outputs:
        feedback.setProgress(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.setName(out.description)
                    QgsProject.instance().addMapLayers([out.layer])
                else:
                    if ProcessingConfig.getSetting(
                            ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                        name = os.path.basename(out.value)
                    else:
                        name = out.description
                    dataobjects.load(out.value, name, alg.crs,
                                     RenderingStyles.getStyle(alg.id(),
                                                              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):
            resultsList.addResult(alg.icon(), out.description, out.value)
        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"
        feedback.reportError(msg)

    return len(wrongLayers) == 0
Пример #25
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
def handleAlgorithmResults(alg, progress=None, showResults=True):
    wrongLayers = []
    reslayers = []
    if progress is None:
        progress = SilentProgress()
    progress.setText(QCoreApplication.translate('ArpaGeoprocessing', 'Loading resulting layer'))
    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, (OutputVector)):
            try:
                if alg.outputType == 'Postgis':
                    outUri = QgsDataSourceURI()
                    psql = out.value['PSQL']
                    outUri.setConnection(psql.PSQLHost, psql.PSQLPort, psql.PSQLDatabase, psql.PSQLUsername, psql.PSQLPassword)
                    outUri.setDataSource(out.value['schema'],out.value['table'],out.value['geoColumn'])
                    layer = QgsVectorLayer(outUri.uri(), out.value['table'], "postgres")
                    QgsMapLayerRegistry.instance().addMapLayers([layer])
                    
                else:
                    if ProcessingConfig.getSetting(
                            ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                        name = os.path.basename(out.value)
                        name = name.split('.')[0]
                    else:
                        name = out.description
                        # removing .ext from name if exixst
                    layer = dataobjects.load(out.value, name, alg.crs,
                            RenderingStyles.getStyle(alg.commandLineName(),
                            out.name))
                        
                reslayers.append(layer)
            except Exception, e:
                wrongLayers.append(out)
            i += 1
Пример #27
0
#Definition of inputs and outputs
#==================================
##Landsat Indices=name
##Landsat Tools=group
##ParameterRaster|input|Input Reflectance Stack|False
##OutputDirectory|outputDirectory|Folder to save the stack of Indices
#OutputRaster|output|Name for Index Stack

# Call the function for Landsat index calculation
#==================================
import os
import sys

here = os.path.dirname(scriptDescriptionFile)
if here not in sys.path:
    sys.path.append(here)
import landsat_indices
from processing.tools import dataobjects

print 'Starting index calculation...'
out_file = landsat_indices.landsat_indices(input, outputDirectory)
dataobjects.load(out_file, isRaster=True)
print 'Finished writing to disk...'

Пример #28
0
    # Read watermask as nparray
    watermask_opt, geotrans, proj = rsu.raster2array(os.path.join(
        path_watermasks_opt, wm_file),
                                                     AOI_extent=extent_AOI)

    # Perform fusion
    fused_watermask = fuse_watermasks(watermask_opt, watermask_opt_max,
                                      watermask_sar)

    # Write to file
    path_output_file = os.path.join(path_output_watermasks,
                                    wm_file[:-4] + "_sar.tif")
    res = rsu.array2raster(fused_watermask, geotrans, proj, path_output_file,
                           gdal.GDT_Float32, 255)
    if res != True:
        if not DEBUG:
            raise GeoAlgorithmExecutionException(res)
        else:
            print(res)
            sys.exit(1)
    else:
        if not DEBUG:
            try:
                dataobjects.load(path_output_file,
                                 os.path.basename(path_output_file),
                                 isRaster=True)
            except:
                dataobjects.load(path_output_file,
                                 os.path.basename(path_output_file))
Пример #29
0
def fmasklandsat(instance, parameters, context, feedback, inputs):
    """ landsat indicies """
    def standard_index(band1, band2):
        """Function for standard index calculation"""
        with np.errstate(divide='warn'):
            idx = (band1 - band2) / (band1 + band2) * 10000
        return idx

    def extract_band(stack, bnd_num):
        """Function to extract single bands from stack; stack = input stack, bnd_num = the band number to extract"""
        b = stack.GetRasterBand(bnd_num)
        band = b.ReadAsArray().astype(np.float32)
        return band

    def calc_index(stack, bnd_num1, bnd_num2):
        """ Function to calculate an index; stack = input stack, bnd_numx = the band number in the stack"""
        band1 = extract_band(stack, bnd_num1)
        band2 = extract_band(stack, bnd_num2)
        any_index = standard_index(band1, band2)
        return any_index

    def landsat_indices(inRst, outDir):
        """
        Main function for calculating a selction of Sentinel 2 Spectral indices
        """
        stk = gdal.Open(inRst)

        # get raster specs
        xsize = stk.RasterXSize
        ysize = stk.RasterYSize
        proj = stk.GetProjection()
        geotransform = stk.GetGeoTransform()

        # calculate indices: these indices were chosen based on variable importance ranking from Random Forest classification
        # calc ndvi
        ndvi = calc_index(stk, 4, 3)

        # calc ndvi using 8a
        ndmi = calc_index(stk, 4, 5)

        # calc red edge ndi b8a_b5
        nbr = calc_index(stk, 4, 6)

        # calc red edge ndi b8a_b6
        nbr2 = calc_index(stk, 5, 6)

        # Stack and write to disk
        # get base filename and combine with outpath
        sName = os.path.splitext(os.path.basename(inRst))[-2]
        stkPath = os.path.join(outDir, sName + "_indices.tif")
        drv = gdal.GetDriverByName("GTiff")
        outTif = drv.Create(stkPath, xsize, ysize, 4, gdal.GDT_Int16)
        outTif.SetProjection(proj)
        outTif.SetGeoTransform(geotransform)
        outTif.GetRasterBand(1).WriteArray(ndvi)
        outTif.GetRasterBand(2).WriteArray(ndmi)
        outTif.GetRasterBand(3).WriteArray(nbr)
        outTif.GetRasterBand(4).WriteArray(nbr2)
        outTif = None
        return stkPath

    feedback.pushConsoleInfo("Starting index calculation...")
    out_file = landsat_indices(
        instance.parameterAsString(parameters, "input", context),
        instance.parameterAsString(parameters, "outputDirectory", context),
    )
    dataobjects.load(out_file, isRaster=True)
    feedback.pushConsoleInfo("Finished writing to disk...")
Пример #30
0
import os
import sys
from processing.tools import dataobjects
here = os.path.dirname(scriptDescriptionFile)
if here not in sys.path:
    sys.path.append(here)

import download_swi
from logs import set_qgis_logger

set_qgis_logger(progress)

product = ['SWI', 'SWI10'][product_param]

outfiles = download_swi.download(outdir=outdir,
                                 progress=progress,
                                 product=product,
                                 username=username,
                                 password=password,
                                 startdate=startdate,
                                 enddate=enddate,
                                 extent=extent,
                                 delete_downloaded=delete_downloaded)

if load_to_canvas:
    for outfile in outfiles:
        dataobjects.load(outfile, os.path.basename(outfile), style=None)

# Release file pointers held by QGIS Processing
dataobjects.resetLoadedLayers()
Пример #31
0
def handleAlgorithmResults(alg, context, feedback=None, showResults=True):
    wrongLayers = []
    if feedback is None:
        feedback = QgsProcessingFeedback()
    feedback.setProgressText(QCoreApplication.translate('Postprocessing', 'Loading resulting layers'))
    i = 0
    for l, details in context.layersToLoadOnCompletion().items():
        if feedback.isCanceled():
            return False

        if len(context.layersToLoadOnCompletion()) > 2:
            # only show progress feedback if we're loading a bunch of layers
            feedback.setProgress(100 * i / float(len(context.layersToLoadOnCompletion())))

        try:
            layer = QgsProcessingUtils.mapLayerFromString(l, context)
            if layer is not None:
                layer.setName(details.name)
                details.project.addMapLayer(context.temporaryLayerStore().takeMapLayer(layer))
            else:
                name = details.name
                if ProcessingConfig.getSetting(
                        ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                    name = os.path.basename(l)
                dataobjects.load(l, name, alg.crs,
                                 RenderingStyles.getStyle(alg.id(), l))
        except Exception:
            QgsMessageLog.logMessage("Error loading result layer:\n" + traceback.format_exc(), 'Processing', QgsMessageLog.CRITICAL)
            #wrongLayers.append(out.description())
            wrongLayers.append(l)
    # for out in alg.outputs:
    #     feedback.setProgress(100 * i / float(len(alg.outputs)))
    #     if out.flags() & QgsProcessingParameterDefinition.FlagHidden or not out.open:
    #         continue
    #     if isinstance(out, (OutputRaster, OutputVector, OutputTable)):
    #         try:
    #             layer = QgsProcessingUtils.mapLayerFromString(out.value, context)
    #             if layer:
    #                 layer.setName(out.description)
    #                 QgsProject.instance().addMapLayer(context.temporaryLayerStore().takeMapLayer(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.id(), out.name),
    #                                  isRaster)
    #         except Exception:
    #             QgsMessageLog.logMessage("Error loading result layer:\n" + traceback.format_exc(), 'Processing', QgsMessageLog.CRITICAL)
    #             wrongLayers.append(out.description)
    #     elif isinstance(out, OutputHTML):
    #         resultsList.addResult(alg.icon(), out.description, out.value)
        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"
        feedback.reportError(msg)

    return len(wrongLayers) == 0
Пример #32
0
                       -9999)
if res != True:
    if not DEBUG:
        raise GeoAlgorithmExecutionException(res)
    else:
        print(res)
        sys.exit(1)

# Legend file
outfile_name = os.path.join(path_output_classification, file_name + ".qml")
copyfile(os.path.join(qmlDir, "water_wet_frequency.qml"), outfile_name)

# Load water frequency to canvas
if not DEBUG:
    try:
        dataobjects.load(dest, os.path.basename(dest), isRaster=True)
    except:
        dataobjects.load(dest, os.path.basename(dest))

# Maximum water extent
file_name = title + "_maximum_water_extent"
dest = os.path.join(path_output_classification, file_name + ".tif")
res = rsu.array2raster(max_water_extent, geotrans, proj, dest, gdal.GDT_Byte,
                       255)
if res != True:
    if not DEBUG:
        raise GeoAlgorithmExecutionException(res)
    else:
        print(res)
        sys.exit(1)
    if not os.path.exists(path_output_extents):
        os.mkdir(path_output_extents)
    extent_name = "userDefinedExtent_" + dt.datetime.today().strftime("%Y%m%d-h%Hm%M")
    # Write to shapefile
    res = extent_AOI.save_as_shp(path_output_extents, extent_name)
    if res != True:
        if not DEBUG:
            raise GeoAlgorithmExecutionException(res)
        else:
            print(res)
            sys.exit(1)

    # Load shapefile with user defined extent to canvas
    if not DEBUG:
        print(os.path.join(path_output_extents, extent_name + ".shp"))
        dataobjects.load(os.path.join(path_output_extents, extent_name+".shp"), extent_name)

else: # 3. minimum joint extent of all scenes
    exBands = [sce.files[-1] for sce in scenes] # use swir2 bands as reference for geotransformation
    extent_AOI = rsu.getJointExtent(exBands)

    if extent_AOI is None:
        if not DEBUG:
            progress.setText("Invalid input data: Extent of AOI is invalid. "
                             "Check if all scenes overlap each other.")
        else:
            print("Invalid input data: Extent of AOI is invalid. Check if all scenes overlap each other.")
        sys.exit(1)

# Check AOI size -------------------------------------------------------------------------------------------------
AOI_size = extent_AOI.ncol * extent_AOI.nrow
def untarimagery(instance, parameters, context, feedback, inputs):
    """ untarimagery """

    processing_path = instance.parameterAsString(parameters, "processing_path", context)
    infile = instance.parameterAsString(parameters, "infile", context)

    def untar(infile, processing_path):
        tar = tarfile.open(infile)
        tarfiles = tar.getnames()
        feedback.pushConsoleInfo("Unpacking data:")
        feedback.pushConsoleInfo(str(tarfiles))
        tar.extractall(processing_path)
        tar.close()
        return tarfiles

    feedback.pushConsoleInfo("Starting untar")
    tarfiles = untar(infile, processing_path)
    feedback.pushConsoleInfo("Untar finished...")

    lbase = os.path.basename(infile)
    ltype = lbase[:4]

    if ltype in "LC08":
        bandlist = [
            "band2",
            "band3",
            "band4",
            "band5",
            "band6",
            "band7",
            "B2",
            "B3",
            "B4",
            "B5",
            "B6",
            "B7",
        ]
    elif ltype in ["LE07", "LT05"]:
        bandlist = [
            "band1",
            "band2",
            "band3",
            "band4",
            "band5",
            "band7",
            "B1",
            "B2",
            "B3",
            "B4",
            "B5",
            "B7",
        ]
    else:
        feedback.pushConsoleInfo("Cannot detect if it is Landsat 5, 7, or 8. Stopping")
        exit()

    # paths to the .tif files
    fls = [os.path.join(processing_path, f) for f in tarfiles]
    feedback.pushConsoleInfo(str(fls))

    bandfile_list = []
    type(bandfile_list)
    for item in bandlist:
        for cont in fls:
            extension = os.path.splitext(cont)[1]
            if extension == ".tif":
                if (
                    cont.replace(extension, "").split("_")[
                        (len(cont.replace(extension, "").split("_")) - 1)
                    ]
                    == item
                ):
                    bandfile_list.append(cont)

    for layer in bandfile_list:
        dataobjects.load(layer, isRaster=True)

    return {
        "outfolder": instance.parameterAsString(parameters, "processing_path", context)
    }
Пример #35
0
def loadTestData():
    dataobjects.load(points(), "points");
    dataobjects.load(points2(), "points2");
    dataobjects.load(polygons(), "polygons");
    dataobjects.load(polygons2(), "polygons2");
    dataobjects.load(polygonsGeoJson(), "polygonsGeoJson");
    dataobjects.load(lines(), "lines");
    dataobjects.load(raster(), "raster");
    dataobjects.load(table(), "table");
    dataobjects.load(union(), "union");
Пример #36
0
        bands.sort(key=_sortfunc)
        return bands


set_progress_logger(name='s2_export', progress=progress)

kwargs = {}

bands_param = bands_param.replace(' ', '')
if bands_param:
    kwargs['bands'] = bands_param.split(',')
else:
    kwargs['bands'] = flags_to_bandlist(
            B1=B1, B2=B2, B3=B3, B4=B4, B5=B5,
            B6=B6, B7=B7, B8=B8, B8A=B8A, B9=B9,
            B10=B10, B11=B11, B12=B12, allVISNIR=allVISNIR)

kwargs['tgt_res'] = ["10m", "20m", "60m"][out_res]

if granules.strip():
    kwargs['granules'] = granules.split(',')

kwargs['infile'] = infile
kwargs['outdir'] = outdir


outfiles = s2_export.export(**kwargs)

for outfile in outfiles:
    dataobjects.load(outfile)
Пример #37
0
def loadTestData():
    dataobjects.load(points(), 'points')
    dataobjects.load(points2(), 'points2')
    dataobjects.load(polygons(), 'polygons')
    dataobjects.load(polygons2(), 'polygons2')
    dataobjects.load(polygonsGeoJson(), 'polygonsGeoJson')
    dataobjects.load(lines(), 'lines')
    dataobjects.load(raster(), 'raster')
    dataobjects.load(table(), 'table')
    dataobjects.load(union(), 'union')
        print("%s not within AOI." % sce.ID)
        if not debug:
            progress.setText("%s not within AOI." % sce.ID)
        continue

    # Check whether scene has enough valid pixels within AOI
    #sce.calcCloudCoverage()
    if sce.cloudy > maxCloudCover:
        print "Cloud coverage too high. Scene is skipped."
        if not debug:
            progress.setText("Cloud coverage too high. Scene is skipped.")
            continue

    scenesWithinExtent.append(sce)
    sce.createVRT(path_vrt)
    dataobjects.load(sce.VRTfile, os.path.basename(sce.VRTfile))

scenes = scenesWithinExtent
if len(scenes) == 0:
    if not debug:
        raise GeoAlgorithmExecutionException(
            "Invalid input data: No %s scenes found that match the selection criteria."
            % sensor)
        sys.exit(1)
    else:
        print "Invalid input data: No %s scenes found that match the selection criteria." % sensor

if not debug:
    progress.setPercentage(10)
    progress.setText("\n%s %s scenes selected." % (len(scenes), sensor))
Пример #39
0
TWI_binary = np.where(TWI > 0.4, 0, 1)

#Sieve mask
TWI_binary = rsu.removeNoise(TWI_binary, 2)
TWI_binary = rsu.binaryBuffer_negative(TWI_binary, 3)

#Export to file
x = rsu.array2raster(TWI_binary, geotrans, proj, outfile_binary, gdal.GDT_Byte,
                     255)
if x == False:
    raise RuntimeError("Exporting TWI mask failed.")

del TWI_binary, TWI

try:
    dataobjects.load(outfile_binary,
                     os.path.basename(outfile_binary),
                     isRaster=True)
except:
    dataobjects.load(outfile_binary, os.path.basename(outfile_binary))

try:
    dataobjects.load(path_TWI_filtered,
                     os.path.basename(path_TWI_filtered),
                     isRaster=True)
except:
    dataobjects.load(path_TWI_filtered, os.path.basename(path_TWI_filtered))

if not DEBUG:
    progress.setText("TWI binary mask done.")
Пример #40
0
        with np.errstate(invalid="ignore"):
            mainRoutine_angles(cmdargs_angles)
        progress.setConsoleInfo("Done.")

    cmdargs = Namespace(
        toa=tempvrt,
        anglesfile=anglesfile,
        output=output,
        verbose=verbose,
        tempdir=tempdir,
        keepintermediates=False,
        mincloudsize=mincloudsize,
        cloudbufferdistance=cloudbufferdistance,
        shadowbufferdistance=shadowbufferdistance,
        cloudprobthreshold=cloudprobthreshold,
        nirsnowthreshold=nirsnowthreshold,
        greensnowthreshold=greensnowthreshold,
    )

    progress.setConsoleInfo("Running FMask (this may take a while) ...")
    with redirect_print(progress):
        mainRoutine(cmdargs)
finally:
    try:
        shutil.rmtree(tempdir)
    except OSError:
        pass

progress.setConsoleInfo("Done.")
dataobjects.load(output, os.path.basename(output))
Пример #41
0
def loadTestData():
    dataobjects.load(points(), 'points')
    dataobjects.load(points2(), 'points2')
    dataobjects.load(polygons(), 'polygons')
    dataobjects.load(polygons2(), 'polygons2')
    dataobjects.load(polygonsGeoJson(), 'polygonsGeoJson')
    dataobjects.load(lines(), 'lines')
    dataobjects.load(raster(), 'raster')
    dataobjects.load(table(), 'table')
    dataobjects.load(union(), 'union')
Пример #42
0
def handleAlgorithmResults(alg, context, feedback=None, showResults=True):
    wrongLayers = []
    if feedback is None:
        feedback = QgsProcessingFeedback()
    feedback.setProgressText(
        QCoreApplication.translate('Postprocessing',
                                   'Loading resulting layers'))
    i = 0
    for l, details in context.layersToLoadOnCompletion().items():
        if feedback.isCanceled():
            return False

        if len(context.layersToLoadOnCompletion()) > 2:
            # only show progress feedback if we're loading a bunch of layers
            feedback.setProgress(
                100 * i / float(len(context.layersToLoadOnCompletion())))

        try:
            layer = QgsProcessingUtils.mapLayerFromString(l, context)
            if layer is not None:
                layer.setName(details.name)
                details.project.addMapLayer(
                    context.temporaryLayerStore().takeMapLayer(layer))
            else:
                name = details.name
                if ProcessingConfig.getSetting(
                        ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
                    name = os.path.basename(l)
                dataobjects.load(l, name, alg.crs,
                                 RenderingStyles.getStyle(alg.id(), l))
        except Exception:
            QgsMessageLog.logMessage(
                "Error loading result layer:\n" + traceback.format_exc(),
                'Processing', QgsMessageLog.CRITICAL)
            #wrongLayers.append(out.description())
            wrongLayers.append(l)
    # for out in alg.outputs:
    #     feedback.setProgress(100 * i / float(len(alg.outputs)))
    #     if out.flags() & QgsProcessingParameterDefinition.FlagHidden or not out.open:
    #         continue
    #     if isinstance(out, (OutputRaster, OutputVector, OutputTable)):
    #         try:
    #             layer = QgsProcessingUtils.mapLayerFromString(out.value, context)
    #             if layer:
    #                 layer.setName(out.description)
    #                 QgsProject.instance().addMapLayer(context.temporaryLayerStore().takeMapLayer(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.id(), out.name),
    #                                  isRaster)
    #         except Exception:
    #             QgsMessageLog.logMessage("Error loading result layer:\n" + traceback.format_exc(), 'Processing', QgsMessageLog.CRITICAL)
    #             wrongLayers.append(out.description)
    #     elif isinstance(out, OutputHTML):
    #         resultsList.addResult(alg.icon(), out.description, out.value)
        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"
        feedback.reportError(msg)

    return len(wrongLayers) == 0
Пример #43
0
# Export maps to file ===============================================================================

# WATER FREQUENCY

file_name = "WI_total_NUMOB"
dest = os.path.join(pathOUT_class, file_name + '.tif')
rsu.array2raster(validObs, geotrans, proj, dest, gdal.GDT_Byte, 255)

file_name = "WI_water_frequency"
dest = os.path.join(pathOUT_class, file_name + '.tif')
rsu.array2raster(waterFreq_all, geotrans, proj, dest, gdal.GDT_Float32, -9999)

# qml file
outfile_name = os.path.join(pathOUT_class, file_name + '.qml')
copyfile(os.path.join(qmlDir, "water_wet_frequency.qml"), outfile_name)
dataobjects.load(dest, os.path.basename(dest))

file_name = "WI_dry_frequency"
dest = os.path.join(pathOUT_class, file_name + '.tif')
rsu.array2raster(dryFreq_all, geotrans, proj, dest, gdal.GDT_Float32, -9999)

# qml file
outfile_name = os.path.join(pathOUT_class, file_name + '.qml')
copyfile(os.path.join(qmlDir, "water_wet_frequency.qml"), outfile_name)

# Wet frequency
file_name = "WI_wetness_frequency"
dest = os.path.join(pathOUT_class, file_name + '.tif')
rsu.array2raster(wetFreq_all, geotrans, proj, dest, gdal.GDT_Float32, -9999)

# qml file
Пример #44
0
                         outfile=refimg,
                         imagename='ref',
                         landsatkey=landsatkey)
    progress.setConsoleInfo('Done.')

    # create angles file
    anglesfile = anglesfile or os.path.join(tempdir, 'angles.img')
    if not os.path.isfile(anglesfile):
        progress.setConsoleInfo('Creating angles file ...')
        with np.errstate(invalid='ignore'):
            mainRoutine_angles(
                Namespace(mtl=mtl, templateimg=refimg, outfile=anglesfile))
        progress.setConsoleInfo('Done.')

    progress.setConsoleInfo('Creating TOA image ...')
    cmdargs = Namespace(infile=refimg,
                        mtl=mtl,
                        anglesfile=anglesfile,
                        output=outfile)
    with np.errstate(invalid='ignore'):
        mainRoutine(cmdargs)
    progress.setConsoleInfo('Done.')

finally:
    try:
        shutil.rmtree(tempdir)
    except OSError:
        pass

dataobjects.load(outfile, os.path.basename(outfile))
Пример #45
0
                                      water_mask_sar)

    # Write to file
    path_output_file = os.path.join(path_output_masks,
                                    wm_file[:-4] + "_sar.tif")
    res = rsu.array2raster(fused_watermask, geotrans, proj, path_output_file,
                           gdal.GDT_Float32, 255)
    if res != True:
        if not DEBUG:
            raise GeoAlgorithmExecutionException(res)
        else:
            print(res)
            sys.exit(1)
    else:
        if not DEBUG:
            dataobjects.load(path_output_file,
                             os.path.basename(path_output_file))

    if wetness_fusion:

        # Dense vegetation wetness mask
        wet_files_soil = [
            os.path.join(path_masks_opt, f) for f in fnmatch.filter(
                os.listdir(path_masks_opt),
                "*_d" + wm_file[idx_date:idx_date + 8] + "*_soil_mask.tif",
            )
        ]

        # Dense vegetation wetness mask
        wet_files_sveg = [
            os.path.join(path_masks_opt, f) for f in fnmatch.filter(
                os.listdir(path_masks_opt),