ngio 0.5.0b6__py3-none-any.whl → 0.5.1__py3-none-any.whl

ngio/common/_masking_roi.py

@@ -99,7 +99,14 @@ def compute_slices(segmentation: np.ndarray) -> dict[int, tuple[slice, ...]]:
 
 
 def lazy_compute_slices(segmentation: da.Array) -> dict[int, tuple[slice, ...]]:
-    """Compute slices for each label in a segmentation."""
+    """Compute slices for each label in a segmentation using lazy evaluation.
+
+    Args:
+        segmentation: The dask segmentation array.
+
+    Returns:
+        A dictionary mapping label IDs to their bounding box slices.
+    """
     global_offsets = _compute_offsets(segmentation.chunks)
     delayed_chunks = segmentation.to_delayed()  # type: ignore
 
@@ -120,12 +127,18 @@ def compute_masking_roi(
     pixel_size: PixelSize,
     axes_order: Sequence[str],
 ) -> list[Roi]:
-    """Compute a ROIs for each label in a segmentation.
+    """Compute ROIs for each label in a segmentation.
+
+    This function expects a 2D, 3D, or 4D segmentation array.
+    The axes order should match the segmentation dimensions.
 
-    This function expects a 2D or 3D segmentation array.
-    And this function expects the axes order to be 'zyx' or 'yx'.
-    Other axes orders are not supported.
+    Args:
+        segmentation: The segmentation array (2D, 3D, or 4D).
+        pixel_size: The pixel size metadata for coordinate conversion.
+        axes_order: The order of axes in the segmentation (e.g., 'zyx' or 'yx').
 
+    Returns:
+        A list of Roi objects, one for each unique label in the segmentation.
     """
     if segmentation.ndim not in [2, 3, 4]:
         raise NgioValueError("Only 2D, 3D, and 4D segmentations are supported.")

ngio/common/_pyramid.py

@@ -1,3 +1,5 @@
+import itertools
+import math
 from collections.abc import Callable, Mapping, Sequence
 from typing import Any, Literal
 
@@ -195,7 +197,7 @@ ChunksLike = tuple[int, ...] | Literal["auto"]
 ShardsLike = tuple[int, ...] | Literal["auto"]
 
 
-def shapes_from_scaling_factors(
+def compute_shapes_from_scaling_factors(
     base_shape: tuple[int, ...],
     scaling_factors: tuple[float, ...],
     num_levels: int,
@@ -215,7 +217,7 @@ def shapes_from_scaling_factors(
     for _ in range(num_levels):
         shapes.append(current_shape)
         current_shape = tuple(
-            max(1, int(s / f))
+            max(1, math.floor(s / f))
             for s, f in zip(current_shape, scaling_factors, strict=True)
         )
     return shapes
@@ -233,6 +235,7 @@ class PyramidLevel(BaseModel):
     path: str
     shape: tuple[int, ...]
     scale: tuple[float, ...]
+    translation: tuple[float, ...]
     chunks: ChunksLike = "auto"
     shards: ShardsLike | None = None
 
@@ -247,6 +250,12 @@ class PyramidLevel(BaseModel):
         if any(isinstance(s, float) and s < 0 for s in self.scale):
             raise NgioValueError("Scale values must be positive.")
 
+        if len(self.translation) != len(self.shape):
+            raise NgioValueError(
+                "Translation must have the same length as shape "
+                f"({len(self.shape)}), got {len(self.translation)}"
+            )
+
         if isinstance(self.chunks, tuple):
             if len(self.chunks) != len(self.shape):
                 raise NgioValueError(
@@ -271,6 +280,63 @@ class PyramidLevel(BaseModel):
         return self
 
 
+def compute_scales_from_shapes(
+    shapes: Sequence[tuple[int, ...]],
+    base_scale: tuple[float, ...],
+) -> list[tuple[float, ...]]:
+    scales = [base_scale]
+    scale_ = base_scale
+    for current_shape, next_shape in itertools.pairwise(shapes):
+        # This only works for downsampling pyramids
+        # The _check_order function (called before) ensures that the
+        # shapes are decreasing
+        _scaling_factor = tuple(
+            s1 / s2
+            for s1, s2 in zip(
+                current_shape,
+                next_shape,
+                strict=True,
+            )
+        )
+        scale_ = tuple(s * f for s, f in zip(scale_, _scaling_factor, strict=True))
+        scales.append(scale_)
+    return scales
+
+
+def _compute_translations_from_shapes(
+    scales: Sequence[tuple[float, ...]],
+    base_translation: Sequence[float] | None,
+) -> list[tuple[float, ...]]:
+    translations = []
+    if base_translation is None:
+        n_dim = len(scales[0])
+        base_translation = tuple(0.0 for _ in range(n_dim))
+    else:
+        base_translation = tuple(base_translation)
+
+    translation_ = base_translation
+    for _ in scales:
+        # TBD: How to update translation
+        # For now, we keep it constant but we should probably change it
+        # to reflect the shift introduced by downsampling
+        # translation_ = translation_ + _scaling_factor
+        translations.append(translation_)
+    return translations
+
+
+def _compute_scales_from_factors(
+    base_scale: tuple[float, ...], scaling_factors: tuple[float, ...], num_levels: int
+) -> list[tuple[float, ...]]:
+    precision_scales = []
+    current_scale = base_scale
+    for _ in range(num_levels):
+        precision_scales.append(current_scale)
+        current_scale = tuple(
+            s * f for s, f in zip(current_scale, scaling_factors, strict=True)
+        )
+    return precision_scales
+
+
 class ImagePyramidBuilder(BaseModel):
     levels: list[PyramidLevel]
     axes: tuple[str, ...]
@@ -290,6 +356,7 @@ class ImagePyramidBuilder(BaseModel):
         base_shape: tuple[int, ...],
         base_scale: tuple[float, ...],
         axes: tuple[str, ...],
+        base_translation: Sequence[float] | None = None,
         chunks: ChunksLike = "auto",
         shards: ShardsLike | None = None,
         data_type: str = "uint16",
@@ -297,16 +364,39 @@ class ImagePyramidBuilder(BaseModel):
         compressors: Any = "auto",
         zarr_format: Literal[2, 3] = 2,
         other_array_kwargs: Mapping[str, Any] | None = None,
+        precision_scale: bool = True,
     ) -> "ImagePyramidBuilder":
-        shapes = shapes_from_scaling_factors(
+        # Since shapes needs to be rounded to integers, we compute them here
+        # and then pass them to from_shapes
+        # This ensures that the shapes and scaling factors are consistent
+        # and avoids accumulation of rounding errors
+        shapes = compute_shapes_from_scaling_factors(
             base_shape=base_shape,
             scaling_factors=scaling_factors,
             num_levels=len(levels_paths),
         )
+
+        if precision_scale:
+            # Compute precise scales from shapes
+            # Since shapes are rounded to integers, the scaling factors
+            # may not be exactly the same as the input scaling factors
+            # Thus, we compute the scales from the shapes to ensure consistency
+            base_scale_ = compute_scales_from_shapes(
+                shapes=shapes,
+                base_scale=base_scale,
+            )
+        else:
+            base_scale_ = _compute_scales_from_factors(
+                base_scale=base_scale,
+                scaling_factors=scaling_factors,
+                num_levels=len(levels_paths),
+            )
+
         return cls.from_shapes(
             shapes=shapes,
-            base_scale=base_scale,
+            base_scale=base_scale_,
             axes=axes,
+            base_translation=base_translation,
             levels_paths=levels_paths,
             chunks=chunks,
             shards=shards,
@@ -321,8 +411,9 @@ class ImagePyramidBuilder(BaseModel):
     def from_shapes(
         cls,
         shapes: Sequence[tuple[int, ...]],
-        base_scale: tuple[float, ...],
+        base_scale: tuple[float, ...] | list[tuple[float, ...]],
         axes: tuple[str, ...],
+        base_translation: Sequence[float] | None = None,
         levels_paths: Sequence[str] | None = None,
         chunks: ChunksLike = "auto",
         shards: ShardsLike | None = None,
@@ -335,34 +426,42 @@ class ImagePyramidBuilder(BaseModel):
         levels = []
         if levels_paths is None:
             levels_paths = tuple(str(i) for i in range(len(shapes)))
+
         _check_order(shapes)
-        scale_ = base_scale
-        for i, (path, shape) in enumerate(zip(levels_paths, shapes, strict=True)):
-            levels.append(
-                PyramidLevel(
-                    path=path,
-                    shape=shape,
-                    scale=scale_,
-                    chunks=chunks,
-                    shards=shards,
+        if isinstance(base_scale, tuple) and all(
+            isinstance(s, float) for s in base_scale
+        ):
+            scales = compute_scales_from_shapes(shapes, base_scale)
+        elif isinstance(base_scale, list):
+            scales = base_scale
+            if len(scales) != len(shapes):
+                raise NgioValueError(
+                    "Scales must have the same length as shapes "
+                    f"({len(shapes)}), got {len(scales)}"
                 )
+        else:
+            raise NgioValueError(
+                "base_scale must be either a tuple of floats or a list of tuples "
+                " of floats."
             )
-            if i + 1 < len(shapes):
-                # This only works for downsampling pyramids
-                # The _check_order function ensures that
-                # shapes are decreasing
-                next_shape = shapes[i + 1]
-                scaling_factor = tuple(
-                    s1 / s2
-                    for s1, s2 in zip(
-                        shape,
-                        next_shape,
-                        strict=True,
-                    )
-                )
-                scale_ = tuple(
-                    s * f for s, f in zip(scale_, scaling_factor, strict=True)
-                )
+
+        translations = _compute_translations_from_shapes(scales, base_translation)
+        for level_path, shape, scale, translation in zip(
+            levels_paths,
+            shapes,
+            scales,
+            translations,
+            strict=True,
+        ):
+            level = PyramidLevel(
+                path=level_path,
+                shape=shape,
+                scale=scale,
+                translation=translation,
+                chunks=chunks,
+                shards=shards,
+            )
+            levels.append(level)
         other_array_kwargs = other_array_kwargs or {}
         return cls(
             levels=levels,

ngio/hcs/_plate.py

@@ -1,7 +1,7 @@
 """A module for handling the Plate Sequence in an OME-Zarr file."""
 
 import asyncio
-import warnings
+import logging
 from collections.abc import Sequence
 from typing import Literal
 
@@ -48,6 +48,8 @@ from ngio.utils import (
     ZarrGroupHandler,
 )
 
+logger = logging.getLogger(f"ngio:{__name__}")
+
 
 def _try_get_table_container(
     handler: ZarrGroupHandler, create_mode: bool = True
@@ -918,12 +920,10 @@ class OmeZarrPlate:
 
         """
         if check_type is not None:
-            warnings.warn(
-                "The 'check_type' argument is deprecated, and will be removed in "
-                "ngio=0.3. Use 'get_table_as' instead or one of the "
-                "type specific get_*table() methods.",
-                DeprecationWarning,
-                stacklevel=2,
+            logger.warning(
+                "The 'check_type' argument is deprecated and will be removed in "
+                "ngio=0.6. Please use 'get_table_as' instead or one of the "
+                "type specific get_*table() methods."
             )
         return self.tables_container.get(name=name, strict=False)
 
@@ -1182,9 +1182,21 @@ def _create_empty_plate_from_meta(
     meta: NgioPlateMeta,
     overwrite: bool = False,
 ) -> ZarrGroupHandler:
-    """Create an empty OME-Zarr plate from metadata."""
+    """Create an empty OME-Zarr plate from metadata.
+
+    Args:
+        store: The Zarr store or group to create the plate in.
+        meta: The plate metadata to use.
+        overwrite: Whether to overwrite an existing plate.
+
+    Returns:
+        The ZarrGroupHandler for the created plate.
+    """
     mode = "w" if overwrite else "w-"
-    group_handler = ZarrGroupHandler(store=store, cache=True, mode=mode)
+    zarr_format = 2 if meta.plate.version == "0.4" else 3
+    group_handler = ZarrGroupHandler(
+        store=store, cache=True, mode=mode, zarr_format=zarr_format
+    )
     update_ngio_plate_meta(group_handler, meta)
     return group_handler
 
@@ -1211,11 +1223,9 @@ def create_empty_plate(
         overwrite (bool): Whether to overwrite the existing plate.
     """
     if version is not None:
-        warnings.warn(
-            "The 'version' argument is deprecated, and will be removed in ngio=0.3. "
-            "Please use 'ngff_version' instead.",
-            DeprecationWarning,
-            stacklevel=2,
+        logger.warning(
+            "The 'version' argument is deprecated and will be removed in ngio=0.6. "
+            "Please use 'ngff_version' instead."
         )
         ngff_version = version
     plate_meta = NgioPlateMeta.default_init(
@@ -1268,11 +1278,9 @@ def derive_ome_zarr_plate(
         overwrite (bool): Whether to overwrite the existing plate.
     """
     if version is not None:
-        warnings.warn(
-            "The 'version' argument is deprecated, and will be removed in ngio=0.3. "
-            "Please use 'ngff_version' instead.",
-            DeprecationWarning,
-            stacklevel=2,
+        logger.warning(
+            "The 'version' argument is deprecated and will be removed in ngio=0.6. "
+            "Please use 'ngff_version' instead."
         )
         ngff_version = version
 
@@ -1333,11 +1341,9 @@ def create_empty_well(
         overwrite (bool): Whether to overwrite the existing well.
     """
     if version is not None:
-        warnings.warn(
-            "The 'version' argument is deprecated, and will be removed in ngio=0.3. "
-            "Please use 'ngff_version' instead.",
-            DeprecationWarning,
-            stacklevel=2,
+        logger.warning(
+            "The 'version' argument is deprecated and will be removed in ngio=0.6. "
+            "Please use 'ngff_version' instead."
         )
         ngff_version = version
     group_handler = ZarrGroupHandler(