"Could not load source layer for INPUT: memory: not found" error in Processing Script using PyQGIS

Question

I have a workflow where a raster should be polygonized and afterwards simplified. The simplified vector should be saved as a shapefile. I am using the template script from QGIS to create a processing tool.

I am getting the following error:

Could not load source layer for INPUT: memory: not found

There might be other errors as well. I don't understand what to write in OUTPUT: in any of the processing.run tools.

Furthermore, I am not sure when it is necessary to instance variables (e.g. in_raster = self.parameterAsRasterLayer(...) and I am not sure about the return at the end of the script.

class ExampleProcessingAlgorithm(QgsProcessingAlgorithm):
 INPUT_RASTER = 'INPUT_RASTER'
 OUTPUT_POLYGON = 'OUTPUT_POLYGON'
 def initAlgorithm(self, config=None):
 self.addParameter(
 QgsProcessingParameterRasterLayer(
 self.INPUT_RASTER,
 self.tr('Input raster')
 )
 )
 self.addParameter(
 QgsProcessingParameterVectorDestination(
 self.OUTPUT_POLYGON,
 self.tr('Output layer')
 )
 )
 def processAlgorithm(self, parameters, context, feedback):
 in_raster = self.parameterAsRasterLayer(parameters, self.INPUT_RASTER, context)
 #in_fs_limit = self.parameterAsDouble(parameters, self.THRESHOLD, context)
 #out_polygon = self.parameterAsOutputLayer(parameters, self.OUTPUT_POLYGON, context)
 
 polygonized_output = processing.run(
 "gdal:polygonize", 
 {
 'INPUT':in_raster,
 'BAND':1,
 'FIELD':'DN',
 'EIGHT_CONNECTEDNESS':False,
 'EXTRA':'',
 'OUTPUT':'memory:'
 }
 )['OUTPUT']
 simplified = processing.run(
 "native:simplifygeometries", 
 {
 'INPUT':polygonized_output,
 'METHOD':0,
 'TOLERANCE':350,
 'OUTPUT':parameters['OUTPUT_POLYGON']
 },
 context=context,
 feedback=feedback
 )['OUTPUT']
 return {self.OUTPUT_POLYGON: simplified}

Answer 1

The error occurs because the intermediate results stored in memory are not being handled properly. QGIS sometimes has trouble managing layers in memory between processing steps.

To fix this, you can either use temporary files for intermediate outputs instead of relying on in-memory storage, something like:

temp_polygonized_output = os.path.join(tempfile.gettempdir(), 'polygonized_output.shp')
temp_simplified_output = os.path.join(tempfile.gettempdir(), 'simplified_output.shp')
 

or do 'OUTPUT': 'TEMPORARY_OUTPUT' as I did below:

from qgis.PyQt.QtCore import QCoreApplication
from qgis.core import (QgsProcessing,
 QgsFeatureSink,
 QgsProcessingException,
 QgsProcessingAlgorithm,
 QgsProcessingParameterFeatureSource,
 QgsProcessingParameterVectorDestination,
 QgsProcessingParameterRasterLayer,
 QgsProcessingParameterFeatureSink)
from qgis import processing
class ExampleProcessingAlgorithm(QgsProcessingAlgorithm):
 """
 This is an example algorithm that takes a vector layer and
 creates a new identical one.
 It is meant to be used as an example of how to create your own
 algorithms and explain the methods and variables used to do it. An
 algorithm like this will be available in all elements, and there
 is no need for additional work.
 All Processing algorithms should extend the QgsProcessingAlgorithm
 class.
 """
 # Constants are used to refer to parameters and outputs. They will be
 # used when calling the algorithm from another algorithm, or when
 # calling from the QGIS console.
 INPUT_RASTER = 'INPUT'
 OUTPUT_POLYGON = 'OUTPUT'
 def tr(self, string):
 """
 Returns a translatable string with the self.tr() function.
 """
 return QCoreApplication.translate('Processing', string)
 
 def createInstance(self):
 """
 Returns a new instance of the algorithm. This is necessary for
 creating the algorithm from within QGIS.
 """
 return ExampleProcessingAlgorithm()
 def name(self):
 """
 Returns the algorithm name, used for identifying the algorithm. This
 string should be fixed for the algorithm, and must not be localised.
 The name should be unique within each provider. Names should contain
 lowercase alphanumeric characters only and no spaces or other
 formatting characters.
 """
 return 'myscript'
 def initAlgorithm(self, config=None):
 self.addParameter(
 QgsProcessingParameterRasterLayer(
 self.INPUT_RASTER,
 self.tr('Input raster')
 )
 )
 self.addParameter(
 QgsProcessingParameterVectorDestination(
 self.OUTPUT_POLYGON,
 self.tr('Output layer')
 )
 )
 def processAlgorithm(self, parameters, context, feedback):
 in_raster = self.parameterAsRasterLayer(parameters, self.INPUT_RASTER, context)
 # in_fs_limit = self.parameterAsDouble(parameters, self.THRESHOLD, context)
 out_polygon = self.parameterAsOutputLayer(parameters, self.OUTPUT_POLYGON, context)
 polygonized_output = processing.run(
 "gdal:polygonize",
 {
 'INPUT': in_raster,
 'BAND': 1,
 'FIELD': 'DN',
 'EIGHT_CONNECTEDNESS': False,
 'EXTRA': '',
 'OUTPUT': 'TEMPORARY_OUTPUT'
 }
 )['OUTPUT']
 simplified = processing.run(
 "native:simplifygeometries",
 {
 'INPUT': polygonized_output,
 'METHOD': 0,
 'TOLERANCE': 350,
 'OUTPUT': out_polygon
 },
 context=context,
 feedback=feedback
 )['OUTPUT']
 return {self.OUTPUT_POLYGON: simplified}