Merge pull request #496 from will-moore/scaler_preserve_dtype

Ensure that laplacian and gaussian scaling preserves dtype

Author: will-moore

ome_zarr/scale.py

@@ -203,25 +203,25 @@ def _resize(
 
     def gaussian(self, base: np.ndarray) -> list[np.ndarray]:
         """Downsample using :func:`skimage.transform.pyramid_gaussian`."""
-        return list(
-            pyramid_gaussian(
-                base,
-                downscale=self.downscale,
-                max_layer=self.max_layer,
-                channel_axis=None,
-            )
+        dtype = base.dtype
+        pyramid = pyramid_gaussian(
+            base,
+            downscale=self.downscale,
+            max_layer=self.max_layer,
+            channel_axis=None,
         )
+        return [level.astype(dtype) for level in pyramid]
 
     def laplacian(self, base: np.ndarray) -> list[np.ndarray]:
         """Downsample using :func:`skimage.transform.pyramid_laplacian`."""
-        return list(
-            pyramid_laplacian(
-                base,
-                downscale=self.downscale,
-                max_layer=self.max_layer,
-                channel_axis=None,
-            )
+        dtype = base.dtype
+        pyramid = pyramid_laplacian(
+            base,
+            downscale=self.downscale,
+            max_layer=self.max_layer,
+            channel_axis=None,
         )
+        return [level.astype(dtype) for level in pyramid]
 
     def local_mean(self, base: np.ndarray) -> list[np.ndarray]:
         """Downsample using :func:`skimage.transform.downscale_local_mean`."""

tests/test_scaler.py

@@ -25,20 +25,21 @@ def create_data(self, shape, dtype=np.uint8, mean_val=10):
         rng = np.random.default_rng(0)
         return rng.poisson(mean_val, size=shape).astype(dtype)
 
-    def check_downscaled(self, downscaled, shape, scale_factor=2):
-        expected_shape = shape
-        for data in downscaled:
-            assert data.shape == expected_shape
-            assert data.dtype == downscaled[0].dtype
-            expected_shape = expected_shape[:-2] + tuple(
-                sh // scale_factor for sh in expected_shape[-2:]
-            )
+    def check_downscaled(self, downscaled, data, scale_factor=2):
+        expected_shape = data.shape
+        for level in downscaled:
+            assert level.dtype == data.dtype
+            if scale_factor is not None:
+                assert level.shape == expected_shape
+                expected_shape = expected_shape[:-2] + tuple(
+                    sh // scale_factor for sh in expected_shape[-2:]
+                )
 
     def test_nearest(self, shape):
         data = self.create_data(shape)
         scaler = Scaler()
         downscaled = scaler.nearest(data)
-        self.check_downscaled(downscaled, shape)
+        self.check_downscaled(downscaled, data)
 
     def test_nearest_via_method(self, shape):
         data = self.create_data(shape)
@@ -48,7 +49,7 @@ def test_nearest_via_method(self, shape):
 
         scaler.method = "nearest"
         downscaled = scaler.func(data)
-        self.check_downscaled(downscaled, shape)
+        self.check_downscaled(downscaled, data)
 
         assert (
             np.sum(
@@ -60,27 +61,27 @@ def test_nearest_via_method(self, shape):
             == 0
         )
 
-    # this fails because of wrong channel dimension; need to fix in follow-up PR
-    @pytest.mark.xfail
+    # NB: gaussian downscales ALL dimensions, not just YX
+    # so we SKIP the check on shape
     def test_gaussian(self, shape):
         data = self.create_data(shape)
         scaler = Scaler()
         downscaled = scaler.gaussian(data)
-        self.check_downscaled(downscaled, shape)
+        self.check_downscaled(downscaled, data, scale_factor=None)
 
-    # this fails because of wrong channel dimension; need to fix in follow-up PR
-    @pytest.mark.xfail
+    # NB: laplacian downscales ALL dimensions, not just YX
+    # so we SKIP the check on shape
     def test_laplacian(self, shape):
         data = self.create_data(shape)
         scaler = Scaler()
         downscaled = scaler.laplacian(data)
-        self.check_downscaled(downscaled, shape)
+        self.check_downscaled(downscaled, data, scale_factor=None)
 
     def test_local_mean(self, shape):
         data = self.create_data(shape)
         scaler = Scaler()
         downscaled = scaler.local_mean(data)
-        self.check_downscaled(downscaled, shape)
+        self.check_downscaled(downscaled, data)
 
     def test_local_mean_via_method(self, shape):
         data = self.create_data(shape)
@@ -90,7 +91,7 @@ def test_local_mean_via_method(self, shape):
 
         scaler.method = "local_mean"
         downscaled = scaler.func(data)
-        self.check_downscaled(downscaled, shape)
+        self.check_downscaled(downscaled, data)
 
         assert (
             np.sum(
@@ -107,7 +108,7 @@ def test_zoom(self, shape):
         data = self.create_data(shape)
         scaler = Scaler()
         downscaled = scaler.zoom(data)
-        self.check_downscaled(downscaled, shape)
+        self.check_downscaled(downscaled, data)
 
     def test_scale_dask(self, shape):
         data = self.create_data(shape)