[GIS] Getting the output layer reference returned by Processing tool

pyqgisqgisqgis-3qgis-processing

After running Processing algorithm ending up with a layer by runalg or runandload in QGIS2, run or runAndLoadResults in QGIS 3, these methods return a result which is mostly a dictionary like {'OUTPUT': 'file_path'} etc. So, after result = processing.run*(...), I can get the output by result['OUTPUT']. But its value is mostly just a string.

If it would be a method like processing.run*(...) that returns an instance of output instead of file path, we would get the layer reference by writing just layer = processing.run*(...).

Is there any processing.run*() method that returns layer instance/reference directly, e.g. QgsVectorLayer?

Best Answer

Please note that all solutions explained here are related to vector layer used as the input and QGIS native algorithms. The answer doesn't explain the results of other providers' tools. (GRASS, GDAL, SAGA, ...). They may be different from native ones.

QGIS 3:

OPTION 1: run() method with memory output:

  result = processing.run("native:buffer",
                          {'INPUT':'D:/foo/bar.shp', 
                           ... 
                           'OUTPUT':'TEMPORARY_OUTPUT'
                          })

  # OUTPUT
  #`result = {'OUTPUT': <qgis._core.QgsVectorLayer object at 0x00...>}`

Result is a dictionary. result['OUTPUT'] gives an instance of a layer (QgsVectorLayer). No layer is added. Option 1 is one and only solution that returns a reference for QgsVectorLayer in QGIS 3.

It can be used in the following way:

result_layer = processing.run("alg_name", {...,  "OUTPUT":'TEMPORARY_OUTPUT'})["OUTPUT"]

result_layer is now qgis._core.QgsVectorLayer. Since it's a memory layer, it should be added to the project using addMapLayer() method.

Other Processing Options

OPTION 2: run() method with file output:

  result = processing.run("native:buffer",
                          {'INPUT':'D:/foo/bar.shp', 
                           ... 
                           'OUTPUT':'c:/foo/baz.shp'})

  # OUTPUT
  # `result = {'OUTPUT': 'c:/foo/baz.shp'}`

Result is a dictionary, value is a string. No layer is added.

OPTION 3: runAndLoadResults() method with file output

  result = processing.runAndLoadResults("native:buffer",
                                        {'INPUT':'D:/foo/bar.shp', 
                                         ... 
                                         'OUTPUT':'c:/foo/baz.shp'})

  # OUTPUT
  # `result = {'OUTPUT': 'c:/foo/baz.shp'}`

Result is a dictionary, value is a string. A layer is added.

OPTION 4: runAndLoadResults() method with memory output

  result = processing.runAndLoadResults("native:buffer",
                                        {'INPUT':'D:/foo/bar.shp', 
                                         ... 
                                         'OUTPUT':'TEMPORARY_OUTPUT'
                                        })

  # OUTPUT
  # `result = {'OUTPUT': 'buffer_0ae....'}`

Result is a dictionary, value is a string. A layer is added.

QGIS 2:

OPTION 1: runandload() method with file output

  result = processing.runandload("qgis:fixeddistancebuffer",
                                 "c:/foo/bar.shp", 10, 5, False,
                                 "c:/foo/baz.shp")
  # OUTPUT
  # `result = <*****.FixedDistanceBuffer instance at 0x00...>`

Result is an instance of related algorithm class. A layer is added.

OPTION 2: runandload() method with memory output

  result = processing.runandload("qgis:fixeddistancebuffer",
                                 "c:/foo/bar.shp", 10, 5, False,
                                 "memory:mem_layer")
  # OUTPUT
  # `result = <*****.FixedDistanceBuffer instance at 0x00...>`

Result is an instance of related algorithm class. A layer is added.

OPTION 3: runalg() method with file output

  result = processing.runalg("qgis:fixeddistancebuffer",
                             "c:/foo/bar.shp", 10, 5, False,
                             "c:/foo/baz.shp")
  # OUTPUT
  # `result = {'OUTPUT': "c:/foo/baz.shp"}`

Result is a dictionary, value is a string. No layer is added.

OPTION 4: runalg() method with memory output

  result = processing.runalg("qgis:fixeddistancebuffer",
                             "c:/foo/bar.shp", 10, 5, False,
                             "memory:mem_layer") 

  # OUTPUT
  # `result = {'OUTPUT': "memory:mem_layer"}`

Result is a dictionary, value is a string. No layer is added.

Neither runalg nor runandload returns a layer reference/instance for output in QGIS 2.

Related Solutions

[GIS] Using memory layer for processing algorithms in QGIS 3

As Germán noted, you should use "memory:" as the output string. But you'll also need to store the algorithm results, or the memory layer will be garbage collected by python!

results = processing.run('grass7:v.net',
            {"input":inputLayer,
             ...
            "output": 'memory:'})
result_layer = results['output']

But more generally - it's a bit inefficient to use a memory layer here. Because you're calling a grass algorithm (not a native QGIS one), all the outputs and inputs are being converted to disk based formats for use by grass, and all outputs from grass are also disk-based (behind the scenes these are shapefiles in a temporary directory). So when you ask for a memory layer output, QGIS has to read over the shapefile created by grass and convert that to a QGIS memory layer. So in this case, it's actually more efficient to just give the algorithm a path to save the shapefile and then read that directly.

[GIS] pyqgis – post-processing of layer output of QgsProcessingAlgorithm

Just to be more elaborate than the comment.

Basically, the postProcessAlgorithm() does what it says. It also returns a value map, including the OUTPUT. However, you need to look up the layer in the algorithm's context with QgsProcessingUtils.mapLayerFromString(). For that to work, you have to save a reference to the original output layer from processAlgorithm():

class ORSisochronesAlgo(QgsProcessingAlgorithm):
    dest_id = None  # Save a reference to the output layer id

    def initAlgorithm(self, configuration, p_str=None, Any=None, *args, **kwargs):

        # add all input parameters

        self.addParameter(
            QgsProcessingParameterFeatureSink(
                'OUTPUT',
                'Output layer'
            )
        )

    def processAlgorithm(self, parameters, context, feedback):

        source = self.parameterAsSource(parameters, self.INPUT, context)
        (sink, self.dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
                context, source.fields(), source.wkbType(), source.sourceCrs())

        features = source.getFeatures()

        for feature in features:
            new_feature = QgsFeature()

            # Some API calls and processing to populate new feature

            sink.addFeature(new_feature, QgsFeatureSink.FastInsert)

        return {self.OUTPUT: dest_id}

    def postProcessAlgorithm(self, context, feedback):

        processed_layer = QgsProcessingUtils.mapLayerFromString(self.dest_id, context)

        # Do smth with the layer, e.g. style it

        return {self.OUT: self.dest_id}

Best Answer

QGIS 3:

QGIS 2:

Related Solutions

[GIS] Using memory layer for processing algorithms in QGIS 3

[GIS] pyqgis – post-processing of layer output of QgsProcessingAlgorithm

Related Question