Como carregar a saída de memória do processamento QGIS?

Muitos algoritmos de processamento têm uma opção para salvar a saída como memória. Se executado a partir da caixa de ferramentas, isso funciona bem, porque você pode marcar a caixa "Abrir arquivo de saída após executar o algoritmo".

Observando o código fonte do QGIS, o código para carregar a camada de memória parece estar definido na função Postprocessing.handleAlgorithmResults. A função usa o acesso a uma alg.outputslista e faz o seguinte:

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                                # NOTE!!
                QgsMapLayerRegistry.instance().addMapLayers([layer])   # NOTE!!
            else:
                # ... 

Quando você executa algoritmos de processamento no console, existe uma maneira de carregar a camada sem acesso a esse objeto? eu posso correr

processing.runalg("qgis:intersection", layer1, layer2, "memory:")

ou mesmo

processing.runalg("qgis:intersection", layer1, layer2, "memory:myLayerName")

No entanto, não consigo encontrar uma maneira de obter a saída resultante.

Aaaand eu encontrei. Use processing.runandload, que carrega a camada de saída no sumário após executar o algoritmo.

processing.runandload("qgis:intersection", layer1, layer2, "memory:myLayerName")
layer = QgsMapLayerRegistry.instance().mapLayersByName("memory:myLayerName")[0]
# Should do error checking as well, but this works!!

é o caminho correto, está explicado na documentação http://docs.qgis.org/2.14/es/docs/user_manual/processing/console.html

o próximo código funciona na memória, exceto o último que é carregado

MDT=path/mdt.tif
drain=processing.runalg("grass:r.drain",MDT,"",(pun),False,False,False,"%f,%f,%f,%f"% (xmin, xmax, ymin, ymax),0,-1,0.00100,None)
vect=processing.runalg("grass:r.to.vect",drain['output'],0,False,"%f,%f,%f,%f"% (xmin, xmax, ymin, ymax),0,None)
bu=processing.runalg("qgis:fixeddistancebuffer",vect['output'],Metros_afecta,1,False,None)
buf=bu['OUTPUT']
bufe= QgsVectorLayer(buf,"area", "ogr")
#the last load the layer 
QgsMapLayerRegistry.instance().addMapLayers([bufe])

o processing.runalgretorna um dicionário neste caso bu['OUTPUT']. OUTPUTÉ A CHAVE, e o valor é um caminho temporário. Você pode ver a chave com processeing.alghelp ("name processing") como processing, alghelp ("grass: r.drain")

Retorna

processing.alghelp("grass:r.drain")
ALGORITHM: r.drain - Traces a flow through an elevation model on a raster map.
input <ParameterRaster>
coordinate <ParameterString>
vector_points <ParameterMultipleInput>
-c <ParameterBoolean>
-a <ParameterBoolean>
-n <ParameterBoolean>
GRASS_REGION_PARAMETER <ParameterExtent>
GRASS_REGION_CELLSIZE_PARAMETER <ParameterNumber>
GRASS_SNAP_TOLERANCE_PARAMETER <ParameterNumber>
GRASS_MIN_AREA_PARAMETER <ParameterNumber>
output <OutputRaster>

neste caso, a chave é emitida , tome cuidado com letras maiúsculas que você deve escrever em maiúsculas ou sem maiúsculas, neste caso não maiúsculas.

Não tenho certeza se isso o ajudará em seu contexto (você deseja executar seu código como autônomo ou no QGIS após a conclusão de um algoritmo de processamento?). Se for o último, você poderá consultar facilmente objetos QGsVector-e carregados QGsRasterlayer, olhando para o registro do QGIS MapLayer.

# General function to retrieve a layer with a given name
def getLayerByName( layerName ):
  layerMap = QgsMapLayerRegistry.instance().mapLayers()
  for name, layer in layerMap.iteritems():
    if layer.name() == layerName:
        if layer.isValid():
          return layer
        else:
          return None

Em geral, todas as camadas devem ter uma fonte em algum lugar no disco rígido, mesmo que o resultado seja adicionado apenas após um alg de processamento concluir seus cálculos. Se você examinar os metadados das camadas, poderá encontrar a fonte real de uma camada (se originada do processamento normalmente estiver em algum lugar de uma pasta temporária)