Feature/activity mask (#73)

* add activity mask layers

* Add prepare inputs for activity mask

* revert settings

* fix lint

* Update cplus-core version

Makefile

@@ -59,7 +59,7 @@ dev-runserver:
 	@echo "------------------------------------------------------------------"
 	@echo "Start django runserver in dev container"
 	@echo "------------------------------------------------------------------"
-	@docker compose $(ARGS) exec -T dev bash -c "nohup python manage.py runserver 0.0.0.0:8080 &"
+	@docker compose $(ARGS) exec -T dev bash -c "python manage.py runserver 0.0.0.0:8080"
 
 dev-shell:
 	@echo

deployment/docker/requirements.txt

@@ -63,4 +63,4 @@ django-revproxy @ https://github.com/jazzband/django-revproxy/archive/refs/tags/
 rasterio==1.3.10
 
 # cplus core
-git+https://github.com/kartoza/[email protected].4
+git+https://github.com/kartoza/[email protected].8

django_project/cplus_api/utils/worker_analysis.py

@@ -59,6 +59,8 @@ class APITaskConfig(object):
     pathway_uuid_layers = {}
     carbon_uuid_layers = {}
     priority_uuid_layers = {}
+    activity_mask_uuid_layers = {}
+    activity_mask_layer_paths = []
     total_input_layers = 0
     # output selections
     ncs_with_carbon = DEFAULT_VALUES.ncs_with_carbon
@@ -254,6 +256,7 @@ def to_dict(self):
             'pathway_uuid_layers': self.pathway_uuid_layers,
             'carbon_uuid_layers': self.carbon_uuid_layers,
             'priority_uuid_layers': self.priority_uuid_layers,
+            'activity_mask_uuid_layers': self.activity_mask_uuid_layers,
             'total_input_layers': self.total_input_layers,
             'ncs_with_carbon': self.ncs_with_carbon,
             'landuse_project': self.landuse_project,
@@ -271,6 +274,7 @@ def to_dict(self):
                 'user_defined': activity.user_defined,
                 'pathways': [],
                 'priority_layers': activity.priority_layers,
+                'mask_paths': activity.mask_paths,
                 'layer_styles': activity.layer_styles
             }
             for pathway in activity.pathways:
@@ -335,6 +339,7 @@ def from_dict(cls, data: dict) -> typing.Self:
         config.priority_uuid_layers = {}
         config.pathway_uuid_layers = {}
         config.carbon_uuid_layers = {}
+        config.activity_mask_uuid_layers = {}
 
         # store priority layers
         for priority_layer in config.priority_layers:
@@ -387,7 +392,8 @@ def from_dict(cls, data: dict) -> typing.Self:
                 user_defined=activity.get('user_defined', False),
                 pathways=[],
                 priority_layers=filtered_priority_layer,
-                layer_styles=activity.get('layer_styles', {})
+                layer_styles=activity.get('layer_styles', {}),
+                mask_paths=activity.get('mask_uuids', [])
             )
 
             # create pathways
@@ -427,6 +433,17 @@ def from_dict(cls, data: dict) -> typing.Self:
                             str(pw_uuid)
                         ]
 
+            # create activity mask paths
+            mask_uuids = activity.get('mask_uuids', [])
+            for mask_uuid in mask_uuids:
+                if mask_uuid in config.activity_mask_uuid_layers:
+                    config.activity_mask_uuid_layers[mask_uuids].append(
+                        str(mask_uuid))
+                else:
+                    config.activity_mask_uuid_layers[mask_uuid] = [
+                        str(mask_uuid)
+                    ]
+
             config.analysis_activities.append(activity_obj)
 
         # create scenario object
@@ -451,6 +468,7 @@ def from_dict(cls, data: dict) -> typing.Self:
         if config.sieve_mask_uuid:
             config.total_input_layers += 1
         config.total_input_layers += len(config.mask_layer_uuids)
+        config.total_input_layers += len(config.activity_mask_uuid_layers)
         return config
 
 
@@ -553,6 +571,22 @@ def initialize_input_layers(self, scenario_path: str):
                 if key in carbon_uuids
             })
 
+        # init activity mask layers
+        activity_mask_paths = {}
+        for mask_layer in self.task_config.activity_mask_uuid_layers:
+            layer_uuid = mask_layer
+            if layer_uuid not in self.downloaded_layers:
+                layer_paths = self.copy_input_layers_by_uuids(
+                    None, [layer_uuid], scenario_path
+                )
+                activity_mask_paths[layer_uuid] = layer_paths[layer_uuid]
+                self.downloaded_layers.update(layer_paths)
+            else:
+                activity_mask_paths[
+                    layer_uuid
+                ] = self.downloaded_layers[layer_uuid]
+        self.task_config.activity_mask_layer_paths = activity_mask_paths
+
         # Patch/Fix layer_path into priority layers dictionary
         if priority_layer_paths:
             self.patch_layer_path_to_priority_layers(priority_layer_paths)
@@ -561,7 +595,8 @@ def initialize_input_layers(self, scenario_path: str):
         self.patch_layer_path_to_activities(
             priority_layer_paths,
             pathway_layer_paths,
-            carbon_layer_paths
+            carbon_layer_paths,
+            activity_mask_paths
         )
 
         # init snap layer
@@ -672,7 +707,8 @@ def patch_layer_path_to_priority_layers(self, priority_layer_paths):
 
     def patch_layer_path_to_activities(
             self, priority_layer_paths,
-            pathway_layer_paths, carbon_layer_paths):
+            pathway_layer_paths, carbon_layer_paths,
+            activity_mask_layer_paths):
         """Patch/Fix layer_path into activities.
 
         :param priority_layer_paths: Dictionary of Layer UUID and
@@ -684,7 +720,9 @@ def patch_layer_path_to_activities(
         :param carbon_layer_paths: Dictionary of Layer UUID and
             actual file path for carbon layers
         :type carbon_layer_paths: dict
-        """
+        :param activity_mask_layer_paths: Dictionary of Layer UUID and
+            actual file path for mask layers
+        :type activity_mask_layer_paths: dict        """
         pw_uuid_mapped = self.transform_uuid_layer_paths(
             self.task_config.pathway_uuid_layers, pathway_layer_paths)
         priority_uuid_mapped = self.transform_uuid_layer_paths(
@@ -712,6 +750,15 @@ def patch_layer_path_to_activities(
                             carbon_layer_paths[carbon_layer_uuid])
                 pathway.carbon_paths = carbon_paths
 
+            for mask_uuid in activity.mask_paths:
+                mask_paths = []
+                if mask_uuid in activity_mask_layer_paths:
+                    mask_paths.append(
+                        activity_mask_layer_paths[mask_uuid]
+                    )
+                activity.mask_paths = mask_paths
+                self.log_message(activity)
+
         # update reference object
         self.scenario.activities = self.task_config.analysis_activities
         self.analysis_activities = (