4

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, not path or not 'memory:name', we would create the layer reference by writing just layer = processing.run*(...)

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

10

QGIS 3:

  • OPTION 1: run() method with memory output

    result = processing.run("native:buffer",
                            {'INPUT':'D:/foo/bar.shp', 
                             ... # other params
                             'OUTPUT':'memory:buffer' # or '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":"memory:"})["OUTPUT"]

result_layer is now <qgis._core.QgsVectorLayer object at ...>. Since it's a memory layer, if necessary, it has to be added using addMapLayer() method.

Other Processing Options

  • OPTION 2: run() method with file output

    result = processing.run("native:buffer",
                            {'INPUT':'D:/foo/bar.shp', 
                             ... # other params
                             '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', 
                                           ... # other params
                                           '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', 
                                           ... # other params
                                           'OUTPUT':'memory:buffer' # or 'OUTPUT':'TEMPORARY_OUTPUT'
                                          })
    
    # OUTPUT
    # `result = {'OUTPUT': 'buffer_0ae....'}`
    

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


QGIS 2:

  • OPTION 5: 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 6: 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 7: 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 8: 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 reference for output in QGIS 2.

  • I'm not sure to understand.. does it mean the only way to "reuse" the layer outputed is to export it as temporary file? I should missunderstand?! If so, can it be dued to the format of the path: maybe the side of the "/" should be more exploitabled in the other side "\" ? And that could explain why it's read as string? I've noticed when I select an existing folder, the path is write in this side "\" using QFileDialog.getExistingDirectory. At contrary when I write a path for a file that doesn't exist it can be saved with "/". – zlikotp Dec 20 '19 at 11:22
  • 1
    It doesn't mean the only way to reuse. After using a processing tool, you can get output layer in different ways. What I've asked/explained here is which method (run, runandload, etc.) gives directly the reference of output layer returned by a processing tool. All options return mostly file path (as string) except option 1. Only option 1 returns (programmatically) reference/instance/pointer of output layer in memory. – Kadir Şahbaz Dec 20 '19 at 11:57

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.