Update: filtering of DIC standard uncertainty

Author: heptaflar

kaleidoscope/algorithms/filter.py

@@ -6,6 +6,7 @@
 """
 
 from numbers import Real
+from typing import Literal
 
 from dask import array as da
 from dask_image.ndfilters import gaussian_filter
@@ -69,14 +70,20 @@ class Median(Algorithm):
 
     @override
     def apply_to(
-        self, data: da.Array, *, dims: tuple[str, ...], size: int = 3
+        self,
+        data: da.Array,
+        *,
+        dims: tuple[str, ...],
+        size: int = 3,
+        mode: Literal["constant", "wrap"] = "constant",
     ) -> da.Array:
         """
         Applies a lateral median filter to data.
 
         :param data: The data.
         :param dims: The dimension names.
         :param size: The size of the uniform kernel (pixels).
+        :param mode: How to extend the image.
         :return: The filtered data.
         """
         sizes = [
@@ -86,8 +93,8 @@ def apply_to(
         m = da.isnan(data)
         v = da.where(m, 0.0, data)
         w = da.where(m, 0.0, 1.0)
-        v = median_filter(v, sizes, mode="constant")
-        w = median_filter(w, sizes, mode="constant")
+        v = median_filter(v, sizes, mode=mode)
+        w = median_filter(w, sizes, mode=mode)
         return da.where(m, data, v / w)
 
     @property

kaleidoscope/config/config.collect.json

@@ -9,16 +9,17 @@
       "long_name": "standard uncertainty of Dissolved Inorganic Carbon in seawater"
     },
     "filter": {
-      "kind": "Gaussian",
-      "fwhm": 1.0
+      "kind": "median",
+      "size": 3,
+      "mode": "wrap"
     }
   },
   "DOC": {
     "attrs": {
       "long_name": "standard uncertainty of estimated DOC"
     },
     "filter": {
-      "kind": "Gaussian",
+      "kind": "gaussian",
       "fwhm": 4.0
     }
   },
@@ -27,7 +28,7 @@
       "long_name": "standard uncertainty of PIC"
     },
     "filter": {
-      "kind": "Gaussian",
+      "kind": "gaussian",
       "fwhm": 4.0
     }
   },
@@ -36,7 +37,7 @@
       "long_name": "standard uncertainty of POC"
     },
     "filter": {
-      "kind": "Gaussian",
+      "kind": "gaussian",
       "fwhm": 4.0
     }
   },
@@ -45,7 +46,7 @@
       "long_name": "standard uncertainty of Phytoplankton Carbon concentration in seawater"
     },
     "filter": {
-      "kind": "Gaussian",
+      "kind": "gaussian",
       "fwhm": 4.0
     }
   },
@@ -54,7 +55,7 @@
       "long_name": "standard uncertainty of Phytoplankton Primary Production"
     },
     "filter": {
-      "kind": "Gaussian",
+      "kind": "gaussian",
       "fwhm": 4.0
     }
   },
@@ -64,7 +65,7 @@
       "description": "standard uncertainty of Predicted DOC values"
     },
     "filter": {
-      "kind": "Gaussian",
+      "kind": "gaussian",
       "fwhm": 4.0
     }
   }

kaleidoscope/operators/collectop.py

@@ -17,6 +17,8 @@
 from ..algorithms.codec import decode
 from ..algorithms.codec import encode
 from ..algorithms.filter import Gaussian
+from ..algorithms.filter import Median
+from ..algorithms.filter import Uniform
 from ..interface.logging import Logging
 from ..interface.operator import Operator
 from ..logger import get_logger
@@ -28,9 +30,27 @@ def _filter(x: da.Array, dims: tuple, filter_config: dict) -> da.Array:
     fluctuations caused by finite sampling of error probability
     density functions.
     """
-    return Gaussian(dtype=x.dtype, m=x.ndim, n=x.ndim).apply_to(
-        x, dims=dims, fwhm=filter_config.get("fwhm", 1.0)
-    )
+    match filter_config.get("kind", "_"):
+        case "gaussian":
+            return Gaussian(dtype=x.dtype, m=x.ndim, n=x.ndim).apply_to(
+                x, dims=dims, fwhm=filter_config.get("fwhm", 4.0)
+            )
+        case "median":
+            # noinspection PyTypeChecker
+            return Median(dtype=x.dtype, m=x.ndim, n=x.ndim).apply_to(
+                x,
+                dims=dims,
+                size=filter_config.get("size", 3),
+                mode=filter_config.get("mode", "constant"),
+            )
+        case "uniform":
+            return Uniform(dtype=x.dtype, m=x.ndim, n=x.ndim).apply_to(
+                x, dims=dims, size=filter_config.get("size", 3)
+            )
+        case _:
+            return Uniform(dtype=x.dtype, m=x.ndim, n=x.ndim).apply_to(
+                x, dims=dims, size=3
+            )
 
 
 def _std(
@@ -50,7 +70,7 @@ def _std(
     """
     return da.sqrt(
         _filter(_mse(x[1:] - x[:1]), dims, filter_config)
-        if filtered
+        if filtered and filter_config
         else _mse(x[1:] - x[:1])
     )