ngio 0.1.6__py3-none-any.whl → 0.2.0a1__py3-none-any.whl

ngio/core/dimensions.py

@@ -1,122 +0,0 @@
-"""Dimension metadata.
-
-This is not related to the NGFF metadata,
-but it is based on the actual metadata of the image data.
-"""
-
-from collections import OrderedDict
-
-
-class Dimensions:
-    """Dimension metadata."""
-
-    def __init__(
-        self,
-        on_disk_shape: tuple[int, ...],
-        axes_names: list[str],
-        axes_order: list[int],
-    ) -> None:
-        """Create a Dimension object from a Zarr array.
-
-        Args:
-            on_disk_shape (tuple[int, ...]): The shape of the array on disk.
-            axes_names (list[str]): The names of the axes in the canonical order.
-            axes_order (list[int]): The mapping between the canonical order and the on
-                disk order.
-        """
-        self._on_disk_shape = on_disk_shape
-
-        for s in on_disk_shape:
-            if s < 1:
-                raise ValueError("The shape must be greater equal to 1.")
-
-        if len(self._on_disk_shape) != len(axes_names):
-            raise ValueError(
-                "The number of axes names must match the number of dimensions."
-            )
-
-        self._axes_names = axes_names
-        self._axes_order = axes_order
-
-        self._shape = [self._on_disk_shape[i] for i in axes_order]
-        self._shape_dict = OrderedDict(zip(axes_names, self._shape, strict=True))
-
-    def __str__(self) -> str:
-        """Return the string representation of the object."""
-        _dimensions = ", ".join(
-            [f"{name}={self._shape_dict[name]}" for name in self._axes_names]
-        )
-        return f"Dimensions({_dimensions})"
-
-    def __repr__(self) -> str:
-        """Return the string representation of the object."""
-        return str(self)
-
-    @property
-    def shape(self) -> tuple[int, ...]:
-        """Return the shape as a tuple in the canonical order."""
-        return tuple(self._shape)
-
-    @property
-    def on_disk_shape(self) -> tuple[int, ...]:
-        """Return the shape as a tuple."""
-        return self._on_disk_shape
-
-    def ad_dict(self) -> dict[str, int]:
-        """Return the shape as a dictionary."""
-        return self._shape_dict
-
-    def get(self, ax_name: str, default: int = 1) -> int:
-        """Return the dimension of the given axis name."""
-        return self._shape_dict.get(ax_name, default)
-
-    @property
-    def on_disk_ndim(self) -> int:
-        """Return the number of dimensions on disk."""
-        return len(self._on_disk_shape)
-
-    @property
-    def is_time_series(self) -> bool:
-        """Return whether the data is a time series."""
-        t = self._shape_dict.get("t", 1)
-        if t == 1:
-            return False
-        return True
-
-    @property
-    def is_2d(self) -> bool:
-        """Return whether the data is 2D."""
-        z = self._shape_dict.get("z", 1)
-        if z != 1:
-            return False
-        return True
-
-    @property
-    def is_2d_time_series(self) -> bool:
-        """Return whether the data is a 2D time series."""
-        return self.is_2d and self.is_time_series
-
-    @property
-    def is_3d(self) -> bool:
-        """Return whether the data is 3D."""
-        return not self.is_2d
-
-    @property
-    def is_3d_time_series(self) -> bool:
-        """Return whether the data is a 3D time series."""
-        return self.is_3d and self.is_time_series
-
-    @property
-    def is_multi_channels(self) -> bool:
-        """Return whether the data has multiple channels."""
-        c = self._shape_dict.get("c", 1)
-        if c == 1:
-            return False
-        return True
-
-    def find_axis(self, ax_name: str) -> int | None:
-        """Return the index of the axis name."""
-        for i, ax in enumerate(self._axes_names):
-            if ax == ax_name:
-                return i
-        return None

ngio/core/image_handler.py

@@ -1,228 +0,0 @@
-"""A module to handle OME-NGFF images stored in Zarr format."""
-
-from typing import Any, Literal
-
-from ngio.core.image_like_handler import ImageLike
-from ngio.core.roi import WorldCooROI
-from ngio.io import AccessModeLiteral, StoreOrGroup
-from ngio.ngff_meta import PixelSize
-from ngio.ngff_meta.fractal_image_meta import ImageMeta
-from ngio.utils._common_types import ArrayLike
-
-
-class Image(ImageLike):
-    """A class to handle OME-NGFF images stored in Zarr format.
-
-    This class provides methods to load image data and metadata from
-    an OME-Zarr file.
-    """
-
-    def __init__(
-        self,
-        store: StoreOrGroup,
-        *,
-        path: str | None = None,
-        idx: int | None = None,
-        pixel_size: PixelSize | None = None,
-        highest_resolution: bool = False,
-        strict: bool = True,
-        cache: bool = True,
-        mode: AccessModeLiteral = "r+",
-        label_group: Any = None,
-    ) -> None:
-        """Initialize the the Image Object.
-
-        Note: Only one of `path`, `idx`, 'pixel_size' or 'highest_resolution'
-        should be provided.
-
-        store (StoreOrGroup): The Zarr store or group containing the image data.
-        path (str | None): The path to the level.
-        idx (int | None): The index of the level.
-        pixel_size (PixelSize | None): The pixel size of the level.
-        highest_resolution (bool): Whether to get the highest resolution level.
-        strict (bool): Whether to raise an error where a pixel size is not found
-            to match the requested "pixel_size".
-        cache (bool): Whether to cache the metadata.
-        mode (AccessModeLiteral): The mode to open the group in.
-        label_group: The group containing the labels.
-        """
-        super().__init__(
-            store=store,
-            path=path,
-            idx=idx,
-            pixel_size=pixel_size,
-            highest_resolution=highest_resolution,
-            strict=strict,
-            meta_mode="image",
-            cache=cache,
-            mode=mode,
-            _label_group=label_group,
-        )
-
-    def __repr__(self) -> str:
-        """Return the string representation of the class."""
-        name = "Image("
-        len_name = len(name)
-        return (
-            f"{name}"
-            f"group_path={self.group_path}, \n"
-            f"{' ':>{len_name}}path={self.path},\n"
-            f"{' ':>{len_name}}{self.pixel_size},\n"
-            f"{' ':>{len_name}}{self.dimensions},\n"
-            ")"
-        )
-
-    @property
-    def metadata(self) -> ImageMeta:
-        """Return the metadata of the image."""
-        meta = super().metadata
-        assert isinstance(meta, ImageMeta)
-        return meta
-
-    @property
-    def channel_labels(self) -> list[str]:
-        """Return the names of the channels in the image."""
-        return self.metadata.channel_labels
-
-    @property
-    def num_channels(self) -> int:
-        """Return the number of channels in the image."""
-        return self.dimensions.get("c", 1)
-
-    def get_channel_idx(
-        self,
-        label: str | None = None,
-        wavelength_id: str | None = None,
-    ) -> int | None:
-        """Return the index of the channel.
-
-        If the channels are not labelled, the index returned is none
-        """
-        return self.metadata.get_channel_idx(label=label, wavelength_id=wavelength_id)
-
-    def get_array_from_roi(
-        self,
-        roi: WorldCooROI,
-        c: int | str | None = None,
-        t: int | slice | None = None,
-        mode: Literal["numpy"] | Literal["dask"] = "numpy",
-        preserve_dimensions: bool = False,
-    ) -> ArrayLike:
-        """Return the image data from a region of interest (ROI).
-
-        Args:
-            roi (WorldCooROI): The region of interest.
-            c (int | str | None): The channel index or label.
-            t (int | slice | None): The time index or slice.
-            mode (str): The mode to return the data.
-            preserve_dimensions (bool): Whether to preserve the dimensions of the data.
-
-        Returns:
-            ArrayLike: The image data.
-        """
-        if isinstance(c, str):
-            c = self.get_channel_idx(label=c)
-
-        return self._get_array_from_roi(
-            roi=roi, t=t, c=c, mode=mode, preserve_dimensions=preserve_dimensions
-        )
-
-    def set_array_from_roi(
-        self,
-        patch: ArrayLike,
-        roi: WorldCooROI,
-        c: int | str | None = None,
-        t: int | slice | None = None,
-        preserve_dimensions: bool = False,
-    ) -> None:
-        """Set the image data from a region of interest (ROI).
-
-        Args:
-            roi (WorldCooROI): The region of interest.
-            patch (ArrayLike): The patch to set.
-            c (int | str | None): The channel index or label.
-            t (int | slice | None): The time index or slice.
-            preserve_dimensions (bool): Whether to preserve the dimensions of the data.
-
-        """
-        if isinstance(c, str):
-            c = self.get_channel_idx(label=c)
-
-        return self._set_array_from_roi(
-            patch=patch, roi=roi, t=t, c=c, preserve_dimensions=preserve_dimensions
-        )
-
-    def get_array(
-        self,
-        *,
-        x: int | slice | None = None,
-        y: int | slice | None = None,
-        z: int | slice | None = None,
-        c: int | str | None = None,
-        t: int | slice | None = None,
-        mode: Literal["numpy"] | Literal["dask"] = "numpy",
-        preserve_dimensions: bool = False,
-    ) -> ArrayLike:
-        """Return the image data.
-
-        Args:
-            x (int | slice | None): The x index or slice.
-            y (int | slice | None): The y index or slice.
-            z (int | slice | None): The z index or slice.
-            c (int | str | None): The channel index or label.
-            t (int | slice | None): The time index or slice.
-            mode (str): The mode to return the data.
-            preserve_dimensions (bool): Whether to preserve the dimensions of the data.
-
-        Returns:
-            ArrayLike: The image data.
-        """
-        if isinstance(c, str):
-            c = self.get_channel_idx(label=c)
-
-        return self._get_array(
-            x=x,
-            y=y,
-            z=z,
-            t=t,
-            c=c,
-            mode=mode,
-            preserve_dimensions=preserve_dimensions,
-        )
-
-    def set_array(
-        self,
-        patch: ArrayLike,
-        x: int | slice | None = None,
-        y: int | slice | None = None,
-        z: int | slice | None = None,
-        c: int | str | None = None,
-        t: int | slice | None = None,
-        preserve_dimensions: bool = False,
-    ) -> None:
-        """Set the image data in the zarr array.
-
-        Args:
-            patch (ArrayLike): The patch to set.
-            x (int | slice | None): The x index or slice.
-            y (int | slice | None): The y index or slice.
-            z (int | slice | None): The z index or slice.
-            c (int | str | None): The channel index or label.
-            t (int | slice | None): The time index or slice.
-            preserve_dimensions (bool): Whether to preserve the dimensions of the data.
-        """
-        if isinstance(c, str):
-            c = self.get_channel_idx(label=c)
-        return self._set_array(
-            patch=patch,
-            x=x,
-            y=y,
-            z=z,
-            t=t,
-            c=c,
-            preserve_dimensions=preserve_dimensions,
-        )
-
-    def consolidate(self, order: Literal[0, 1, 2] = 1) -> None:
-        """Consolidate the image."""
-        self._consolidate(order=order)