fix pre-commit and tests

Author: LucaMarconato

src/spatialdata/datasets.py

@@ -189,6 +189,7 @@ def _image_blobs(
             masks.append(mask)
 
         x = np.stack(masks, axis=0)
+        model: type[Image2DModel] | type[Image3DModel]
         if ndim == 2:
             dims = ["c", "y", "x"]
             model = Image2DModel
@@ -229,6 +230,7 @@ def _labels_blobs(
                 out[out == val[idx]] = 0
             else:
                 out[out == val[idx]] = i
+        model: type[Labels2DModel] | type[Labels3DModel]
         if ndim == 2:
             dims = ["y", "x"]
             model = Labels2DModel

src/spatialdata/models/pyramids_utils.py

@@ -51,6 +51,36 @@ def to_multiscale(
     scale_factors: ScaleFactors_t,
     chunks: Chunks_t | None = None,
 ) -> DataTree:
+    """Build a multiscale pyramid DataTree from a single-scale image.
+
+    Iteratively downscales the image by the given scale factors using
+    interpolation (order 1 for images with a channel dimension, order 0
+    for labels) and assembles all levels into a DataTree.
+
+    Makes uses of internal ome-zarr-py APIs for dask downscaling.
+
+    TODO: ome-zarr-py will support 3D downscaling once https://github.com/ome/ome-zarr-py/pull/516 is merged, and this
+     function could make use of it. Also the PR will introduce new downscaling methods such as "nearest". Nevertheless,
+     this function supports different scaling factors per axis, which is not supported by ome-zarr-py yet.
+
+    Parameters
+    ----------
+    image
+        Input image/labels as an xarray DataArray (e.g. with dims ``("c", "y", "x")``
+        or ``("y", "x")``). Supports both 2D/3D images and 2D/3D labels.
+    scale_factors
+        Sequence of per-level scale factors. Each element is either an int
+        (applied to all spatial axes) or a dict mapping dimension names to
+        per-axis factors (e.g. ``{"y": 2, "x": 2}``).
+    chunks
+        Optional chunk specification passed to :meth:`dask.array.Array.rechunk`
+        after building the pyramid.
+
+    Returns
+    -------
+    DataTree
+        Multiscale DataTree with children ``scale0``, ``scale1``, etc.
+    """
     dims = [str(dim) for dim in image.dims]
     spatial_dims = [d for d in dims if d != "c"]
     order = 1 if "c" in dims else 0

tests/models/test_pyramids_utils.py

@@ -12,8 +12,8 @@
 @pytest.mark.parametrize(
     ("model", "length", "ndim", "n_channels", "scale_factors", "method"),
     [
-        # (Image2DModel, 128, 2, 3, (2, 2), Methods.XARRAY_COARSEN),
-        # (Image3DModel, 32, 3, 3, (2, 2), Methods.XARRAY_COARSEN),
+        (Image2DModel, 128, 2, 3, (2, 2), Methods.XARRAY_COARSEN),
+        (Image3DModel, 32, 3, 3, (2, 2), Methods.XARRAY_COARSEN),
         (Labels2DModel, 128, 2, 0, (2, 2), Methods.DASK_IMAGE_NEAREST),
         (Labels3DModel, 32, 3, 0, (2, 2), Methods.DASK_IMAGE_NEAREST),
     ],
@@ -38,35 +38,27 @@ def test_to_multiscale_via_ome_zarr_scaler(model, length, ndim, n_channels, scal
     dims = model.dims
     dask_data = dask.array.from_array(array).rechunk(CHUNK_SIZE)
 
-    # # multiscale-spatial-image path (explicit method)
+    # multiscale-spatial-image path (explicit method)
     result_msi = model.parse(dask_data, dims=dims, scale_factors=scale_factors, chunks=CHUNK_SIZE, method=method)
 
     # ome-zarr-py scaler path (method=None triggers the ome-zarr-py scaler)
     result_ozp = model.parse(dask_data, dims=dims, scale_factors=scale_factors, chunks=CHUNK_SIZE)
 
-    # ##
-    # from napari_spatialdata import Interactive
-    # from spatialdata import SpatialData
-    #
-    # sdata = SpatialData.init_from_elements({'msi': result_msi, 'ozp': result_ozp})
-    # Interactive(sdata)
-
-    ##
-
     # Compare data values at each scale level
-    import matplotlib.pyplot as plt
-    _, axes = plt.subplots(len(result_msi.children), 2, figsize=(8, 4 * len(result_msi.children)))
     for i, scale_name in enumerate(result_msi.children):
         msi_arr = result_msi[scale_name].ds["image"]
         ozp_arr = result_ozp[scale_name].ds["image"]
         assert msi_arr.sizes == ozp_arr.sizes
-
-        if msi_arr.ndim == 3:
-            msi_arr = msi_arr[0]
-            ozp_arr = ozp_arr[0]
-        axes[i, 0].imshow(msi_arr.values)
-        axes[i, 1].imshow(ozp_arr.values)
-        pass
-        # np.testing.assert_allclose(msi_arr.values, ozp_arr.values)
-    plt.tight_layout()
-    plt.show()
+        if model in [Image2DModel, Image3DModel]:
+            # exact comparison for images
+            np.testing.assert_allclose(msi_arr.values, ozp_arr.values)
+        else:
+            if i == 0:
+                # no downscaling is performed, so they must be equal
+                np.testing.assert_array_equal(msi_arr.values, ozp_arr.values)
+            else:
+                # we expect differences: ngff-zarr uses "nearest", ozp uses "resize"
+                # TODO: when https://github.com/ome/ome-zarr-py/pull/516 is merged we can use nearest for labels and
+                # expect a much stricter adherence
+                fraction_non_equal = np.sum(msi_arr.values != ozp_arr.values) / np.prod(msi_arr.values.shape)
+                assert fraction_non_equal < 0.5