introduce postProcess to handle layers

Author: Daniel

geovita_processing_plugin/algorithms/BegrensSkadeExcavation.py

@@ -32,6 +32,7 @@
 
 import traceback
 from pathlib import Path
+from datetime import datetime
 
 from qgis.core import (
     Qgis,
@@ -49,11 +50,12 @@
     QgsProcessingParameterRasterLayer,
     QgsProcessingParameterString,
     QgsProject,
+    QgsVectorLayer,
+    QgsProcessingOutputFile,
 )
 from qgis.PyQt.QtCore import QCoreApplication
 
 from ..REMEDY_GIS_RiskTool.BegrensSkade import mainBegrensSkade_Excavation
-from ..utilities.AddLayersTask import AddLayersTask
 from ..utilities.gui import GuiUtils
 from ..utilities.logger import CustomLogger
 from ..utilities.methodslib import (
@@ -117,7 +119,6 @@ def __init__(self):
         self.feature_name = None  # Default value
         self.layers_info = {}
         self.styles_dir_path = Path()
-        self.add_layers_task = AddLayersTask()
         self.logger.info("__INIT__ - Finished initialize BegrensSkadeExcavation ")
 
     def tr(self, string):
@@ -449,8 +450,9 @@ def initAlgorithm(self, config):
                 self.OUTPUT_FEATURE_NAME,
                 self.tr(
                     "Naming Conventions for Analysis and Features (Output feature name appended to file-names)"
-                ),
-            )
+                )
+            ),
+            createOutput=True
         )
         self.addParameter(
             QgsProcessingParameterCrs(
@@ -465,6 +467,24 @@ def initAlgorithm(self, config):
                 self.tr("Output Folder"),
             )
         )
+        self.addOutput(
+            QgsProcessingOutputFile(
+                self.OUTPUT_BUILDING,
+                self.tr("Output Buildings Shapefile"),
+            )
+        )
+        self.addOutput(
+            QgsProcessingOutputFile(
+                self.OUTPUT_WALL,
+                self.tr("Output Walls Shapefile"),
+            )
+        )
+        self.addOutput(
+            QgsProcessingOutputFile(
+                self.OUTPUT_CORNER,
+                self.tr("Output Corners Shapefile"),
+            )
+        )
 
         self.logger.info("initAlgorithm - Done setting up the inputs.")
 
@@ -801,7 +821,7 @@ def processAlgorithm(self, parameters, context, feedback):
             return {}
 
         #################### HANDLE THE RESULT ###############################
-        feedback.setProgress(80)
+        feedback.setProgress(90)
         self.logger.info(f"PROCESS - OUTPUT BUILDINGS: {output_shapefiles[0]}")
         self.logger.info(f"PROCESS - OUTPUT WALL: {output_shapefiles[1]}")
         self.logger.info(f"PROCESS - OUTPUT CORNER: {output_shapefiles[2]}")
@@ -820,80 +840,89 @@ def processAlgorithm(self, parameters, context, feedback):
                 "shape_path": output_shapefiles[1],
                 "style_name": "WALL-ANGLE.qml",
             },
-            "BUILDING-TOTAL-SETTLMENT": {
-                "shape_path": output_shapefiles[0],
-                "style_name": "BUILDING-TOTAL-SETTLMENT_sv_tot.qml",
-            },
             "BUILDING-TOTAL-ANGLE": {
                 "shape_path": output_shapefiles[0],
                 "style_name": "BUILDING-TOTAL-ANGLE_max_angle.qml",
             },
+            "BUILDING-TOTAL-SETTLMENT": {
+                "shape_path": output_shapefiles[0],
+                "style_name": "BUILDING-TOTAL-SETTLMENT_sv_tot.qml",
+            }
         }
         if bVulnerability:
             self.layers_info.update(
                 {
-                    "BUILDING-RISK-SETTLMENT": {
-                        "shape_path": output_shapefiles[0],
-                        "style_name": "BUILDING-TOTAL-RISK-SELLMENT_risk_tots.qml",
-                    },
                     "BUILDING-RISK-ANGLE": {
                         "shape_path": output_shapefiles[0],
                         "style_name": "BUILDING-TOTAL-RISK-ANGLE_risk_angle.qml",
                     },
+                    "BUILDING-RISK-SETTLMENT": {
+                        "shape_path": output_shapefiles[0],
+                        "style_name": "BUILDING-TOTAL-RISK-SELLMENT_risk_tots.qml",
+                    }
                 }
             )
 
-        feedback.setProgress(90)
+        feedback.setProgress(100)
         feedback.pushInfo("PROCESS - Finished processing!")
+        
         # Return the results of the algorithm.
-        return {
-            self.OUTPUT_BUILDING: output_shapefiles[0],
-            self.OUTPUT_WALL: output_shapefiles[1],
-            self.OUTPUT_CORNER: output_shapefiles[2],
-        }
-
+        return {self.OUTPUT_BUILDING: output_shapefiles[0],
+                self.OUTPUT_WALL: output_shapefiles[1],
+                self.OUTPUT_CORNER: output_shapefiles[2],
+                
+            }
+    
     def postProcessAlgorithm(self, context, feedback):
         """
-        Handles the post-processing steps of the algorithm, specifically adding output layers to the QGIS project.
-
-        This method creates and executes a process to add layers to the QGIS interface, applying predefined styles
-        and organizing them within a specified group. It leverages the `AddLayersTask` class to manage layer
-        addition in a way that ensures thread safety and proper GUI updates.
-
-        Parameters:
-        - context (QgsProcessingContext): The context of the processing, providing access to the QGIS project and other relevant settings.
-        - feedback (QgsProcessingFeedback): The object used to report progress and log messages back to the user.
-
-        Returns:
-        - dict: An empty dictionary. This method does not produce output parameters but instead focuses on the side effect of adding layers to the project.
-
-        Note:
-        This method sets up a task for layer addition, defining success and failure callbacks to provide user feedback.
-        It manually starts the process and handles its completion.
+        This method is called after processAlgorithm finishes.
+        Here, we manually load the output shapefiles, apply QML styles,
+        and place them under a custom group in the layer tree.
         """
-        ######### EXPERIMENTAL ADD LAYERS TO GUI #########
-        # Create the task
-        self.add_layers_task.setParameters(
-            self.layers_info,
-            self.feature_name,
-            self.styles_dir_path,
-            self.logger,
-        )
-
-        # Define a slot to handle the task completion
-        def onTaskCompleted(success):
-            if success:
-                feedback.pushInfo("POSTPROCESS - Layers added successfully.")
-                feedback.setProgress(100)
+        project = context.project()
+        root = project.layerTreeRoot()
+
+        # Create (or find) a group at the top level named by 'self.feature_name'.
+        group_name = self.feature_name
+        group = root.findGroup(group_name)
+        if not group:
+            group = root.insertGroup(0, group_name)
+
+        # 2) Loop through the entries stored in 'self.layers_info' defined during processAlgorithm
+        for layer_label, layer_info in self.layers_info.items():
+            shape_path = layer_info["shape_path"]    # e.g. "C:/somefolder/buildings.shp"
+            style_name = layer_info["style_name"]    # e.g. "BUILDING-TOTAL-SETTLMENT_sv_tot.qml"
+
+            # Generate a unique layer name with timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M")
+            final_layer_name = f"{layer_label}_{timestamp}"
+
+            # Create the QgsVectorLayer from the file path
+            layer = QgsVectorLayer(shape_path, final_layer_name, "ogr")
+            if not layer.isValid():
+                feedback.reportError(f"Could not load layer from file: {shape_path}")
+                continue
+
+            # Load the QML style if it exists
+            style_path = self.styles_dir_path / style_name  # e.g. /path/to/styles/BUILDING-TOTAL-SETTLMENT_sv_tot.qml
+            if style_path.is_file():
+                layer.loadNamedStyle(str(style_path))
+                layer.triggerRepaint()
             else:
-                feedback.reportError("POSTPROCESS - Failed to add layers.")
-                feedback.setProgress(100)
+                feedback.reportError(f"Style file not found: {style_path}")
+
+            # Add the layer to the project (layer registry) *without* adding to the root TOC
+            QgsProject.instance().addMapLayer(layer, False)
+
+            # Place the layer under the group at the bottom
+            group.insertLayer(-1, layer)
 
-        # Connect the task's completed signal to the slot
-        self.add_layers_task.taskCompleted.connect(onTaskCompleted)
+            # Ensure the new layer node is visible
+            node = group.findLayer(layer.id())
+            if node:
+                node.setItemVisibilityChecked(True)
 
-        # Start the task
-        success = self.add_layers_task.run()
-        self.add_layers_task.finished(success)
+            feedback.pushInfo(f"Loaded and styled layer '{final_layer_name}' in group '{group_name}'.")
 
-        return {}
+        feedback.pushInfo("postProcessAlgorithm complete.")
+        return {}

geovita_processing_plugin/algorithms/BegrensSkadeImpactMap.py

@@ -45,13 +45,15 @@
     QgsProcessingParameterDefinition,
     QgsProcessingParameterRasterLayer,
     QgsMessageLog,
+    QgsProcessingOutputFile,
+    QgsRasterLayer
 )
 
 import traceback
+from datetime import datetime
 from pathlib import Path
 
 from .base_algorithm import GvBaseProcessingAlgorithms
-from ..utilities.AddLayersTask import AddLayersTask
 from ..utilities.gui import GuiUtils
 from ..utilities.logger import CustomLogger
 from ..utilities.methodslib import (
@@ -116,7 +118,6 @@ def __init__(self):
         self.feature_name = None  # Default value
         self.layers_info = {}
         self.styles_dir_path = Path()
-        self.add_layers_task = AddLayersTask()
         self.logger.info("__INIT__ - Finished initialize BegrensSkadeImpactMap ")
 
     def name(self):
@@ -375,6 +376,14 @@ def initAlgorithm(self, config):
         )
         param.setFlags(QgsProcessingParameterDefinition.FlagAdvanced)
         self.addParameter(param)
+        
+        # We add the output definition
+        self.addOutput(
+            QgsProcessingOutputFile(
+                self.OUTPUT_RASTER,
+                self.tr("Output Raster impact map"),
+            )
+        )
 
     def processAlgorithm(self, parameters, context, feedback):
         """
@@ -617,49 +626,62 @@ def processAlgorithm(self, parameters, context, feedback):
             }
         }
 
-        feedback.setProgress(90)
+        feedback.setProgress(100)
         feedback.pushInfo("PROCESS - Finished processing!")
         # Return the results of the algorithm.
-        return {self.OUTPUT_FOLDER: output_raster_path}
+        return {self.OUTPUT_RASTER: output_raster_path}
 
     def postProcessAlgorithm(self, context, feedback):
         """
-        Handles the post-processing steps of the algorithm, specifically adding output layers to the QGIS project.
-
-        This method creates and executes a process to add layers to the QGIS interface, applying predefined styles 
-        and organizing them within a specified group. It leverages the `AddLayersTask` class to manage layer 
-        addition in a way that ensures thread safety and proper GUI updates.
-
-        Parameters:
-        - context (QgsProcessingContext): The context of the processing, providing access to the QGIS project and other relevant settings.
-        - feedback (QgsProcessingFeedback): The object used to report progress and log messages back to the user.
+        After processAlgorithm finishes, load the produced raster (output_raster_path),
+        apply a QML style, and place it into a custom group in the TOC.
+        """
+        project = context.project()
+        root = project.layerTreeRoot()
+
+        # 1) Define or find the group at the top level
+        group_name = self.feature_name
+        group = root.findGroup(group_name)
+        if not group:
+            group = root.insertGroup(0, group_name)
+
+        # The self.layers_info just have one key: "IMPACT-MAP",
+        #    but let's loop in case there are added more raster layers in future
+        for layer_label, layer_info in self.layers_info.items():
+            raster_path = layer_info["shape_path"]
+            style_name = layer_info["style_name"]
+            style_path = self.styles_dir_path / style_name
+
+            # Build a unique name with timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M")
+            final_layer_name = f"{layer_label}_{timestamp}"
+
+            # Create a QgsRasterLayer
+            # Use "gdal" or an appropriate provider for your raster format
+            raster_layer = QgsRasterLayer(raster_path, final_layer_name, "gdal")
+            if not raster_layer.isValid():
+                feedback.reportError(f"Invalid raster layer from file: {raster_path}")
+                continue
+
+            # Attempt to load a QML style (if it references valid raster symbology)
+            if style_path.is_file():
+                raster_layer.loadNamedStyle(str(style_path))
+                raster_layer.triggerRepaint()
+            else:
+                feedback.reportError(f"Style file not found: {style_path}")
 
-        Returns:
-        - dict: An empty dictionary. This method does not produce output parameters but instead focuses on the side effect of adding layers to the project.
+            # Add the layer to the project, but do *not* place it in the root
+            QgsProject.instance().addMapLayer(raster_layer, False)
 
-        Note:
-        This method sets up a task for layer addition, defining success and failure callbacks to provide user feedback. 
-        It manually starts the process and handles its completion.
-        """
-        ######### EXPERIMENTAL ADD LAYERS TO GUI #########
-        # Create the task
-        self.add_layers_task.setParameters(
-            self.layers_info, self.feature_name, self.styles_dir_path, self.logger
-        )
+            # Insert it in our custom group
+            group.insertLayer(0, raster_layer)
 
-        # Define a slot to handle the task completion
-        def onTaskCompleted(success):
-            if success:
-                feedback.pushInfo("POSTPROCESS - Layers added successfully.")
-                feedback.setProgress(100)
-            else:
-                feedback.reportError("POSTPROCESS - Failed to add layers.")
-                feedback.setProgress(100)
+            # Make sure it's visible
+            node = group.findLayer(raster_layer.id())
+            if node:
+                node.setItemVisibilityChecked(True)
 
-        # Connect the task's completed signal to the slot
-        self.add_layers_task.taskCompleted.connect(onTaskCompleted)
+            feedback.pushInfo(f"Loaded and styled raster layer '{final_layer_name}' in group '{group_name}'.")
 
-        # Start the task
-        success = self.add_layers_task.run()
-        self.add_layers_task.finished(success)
+        feedback.pushInfo("postProcessAlgorithm complete.")
         return {}