Open-EO#334 global extent buffer

* Open-EO#334 reproject bbox before applying buffer, add resample to mask

* Open-EO#334 to_scl_dilation_mask should block resampling params

* Open-EO#334 test fixes

* Open-EO#334 add test

* Open-EO#334 fix test

* Open-EO#334 extra check on actual resampling

* Open-EO#334 test fixes

Author: jdries

openeo_driver/ProcessGraphDeserializer.py

@@ -17,6 +17,8 @@
 
 import geopandas as gpd
 import numpy as np
+from pyproj import CRS
+from pyproj.exceptions import CRSError
 
 import openeo.udf
 import openeo_processes
@@ -506,6 +508,15 @@ def extract_arg(args: ProcessArgs, name: str, process_id="n/a"):
     # TODO: eliminate this function, use `ProcessArgs.get_required()` directly
     return _as_process_args(args, process_id=process_id).get_required(name=name)
 
+def _collection_crs(collection_id, env) -> str:
+    metadata = None
+    try:
+        metadata = env.backend_implementation.catalog.get_collection_metadata(collection_id)
+    except CollectionNotFoundException:
+        return None
+    crs = metadata.get('cube:dimensions', {}).get('x', {}).get('reference_system', None)
+    return crs
+
 
 def _align_extent(extent,collection_id,env,target_resolution=None):
     metadata = None
@@ -593,18 +604,37 @@ def _extract_load_parameters(env: EvalEnv, source_id: tuple) -> LoadParameters:
             if "weak_spatial_extent" in constraint:
                 extent = constraint["weak_spatial_extent"]
             if extent is not None:
+                collection_crs = _collection_crs(collection_id[1][0], env)
+                crs = constraint.get("resample", {}).get("target_crs", collection_crs)
+
                 if "pixel_buffer" in constraint:
-                    buffer = constraint["pixel_buffer"]["buffer_size"]
-                    extent = {
-                        "west": extent["west"] - buffer[0],
-                        "east": extent["east"] + buffer[0],
-                        "south": extent["south"] - buffer[1],
-                        "north": extent["north"] + buffer[1],
-                        "crs": extent["crs"]
-                    }
 
+                    buffer = constraint["pixel_buffer"]["buffer_size"]
 
-                if "resample" not in constraint or not constraint["resample"].get("target_crs",None):
+                    if crs is not None:
+                        bbox = BoundingBox.from_dict(extent, default_crs=4326)
+                        extent = bbox.reproject(crs).as_dict()
+
+                        extent = {
+                            "west": extent["west"] - buffer[0],
+                            "east": extent["east"] + buffer[0],
+                            "south": extent["south"] - buffer[1],
+                            "north": extent["north"] + buffer[1],
+                            "crs": extent["crs"]
+                        }
+                    else:
+                        _log.warning("Not applying buffer to extent because the target CRS is not known.")
+
+                no_resampling = "resample" not in constraint or crs == collection_crs
+                if (not no_resampling) and collection_crs is not None and ("42001" in str(collection_crs)):
+                    #resampling auto utm to utm is still considered no resampling
+                    try:
+                        no_resampling = "UTM zone" in CRS.from_user_input(crs).to_wkt()
+                    except CRSError as e:
+                        pass
+
+
+                if  no_resampling:
                     # Ensure that the extent that the user provided is aligned with the collection's native grid.
                     target_resolution = constraint.get("resample",{}).get("resolution",None)
                     extent = _align_extent(extent, collection_id[1][0], env,target_resolution)

openeo_driver/dry_run.py

@@ -371,7 +371,7 @@ def get_source_constraints(self, merge=True) -> List[SourceConstraint]:
                 # under the condition that no operations occur in between that may be affected
                 for op in [
                     "apply_kernel", "reduce_dimension", "apply", "apply_dimension",
-                    "apply_neighborhood", "reduce_dimension_binary", "mask"
+                    "apply_neighborhood", "reduce_dimension_binary", "mask", "to_scl_dilation_mask"
                 ]:
                     args = resampling_op.get_arguments_by_operation(op)
                     if args:
@@ -539,9 +539,10 @@ def filter_labels(self, condition: dict,dimension: str, context: Optional[dict]
     def mask(self, mask: 'DryRunDataCube', replacement=None) -> 'DryRunDataCube':
         # TODO: if mask cube has no temporal or bbox extent: copy from self?
         # TODO: or add reference to the self trace to the mask trace and vice versa?
-        cube = self._process("mask", {"mask": mask})
+        mask_resampled = mask._process("resample_cube_spatial", arguments={"target": self, "method": "near"})
+        cube = self._process("mask", {"mask": mask_resampled})
         return DryRunDataCube(
-            traces=cube._traces + mask._traces, data_tracer=cube._data_tracer,
+            traces=cube._traces + mask_resampled._traces, data_tracer=cube._data_tracer,
             metadata=cube.metadata
         )
 
@@ -783,6 +784,7 @@ def to_scl_dilation_mask(
         cube = self._process("process_type", [ProcessType.FOCAL_SPACE])
         size = kernel2_size
         cube = cube._process("pixel_buffer", arguments={"buffer_size": [size/2.0,size/2.0]})
+        cube = cube._process("to_scl_dilation_mask", arguments={})
         return cube
 
     def mask_l1c(self) -> 'DriverDataCube':

openeo_driver/util/geometry.py

@@ -458,7 +458,7 @@ def __init__(
 
     @staticmethod
     def normalize_crs(crs: Union[str, int]) -> str:
-        if crs == "Auto42001":
+        if crs == "Auto42001" or crs == "AUTO:42001":
             return crs
         proj_crs = CRS.from_user_input(crs)
         maybeEPSG = proj_crs.to_epsg()
@@ -547,6 +547,10 @@ def reproject(self, crs) -> "BoundingBox":
         """
         self.assert_crs()
         crs = self.normalize_crs(crs)
+        isUTM = crs == "AUTO:42001" or "Auto42001" in str(crs)
+        if isUTM:
+            return self.reproject_to_best_utm()
+
         if crs == self.crs:
             return self
         transform = pyproj.Transformer.from_crs(