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

ngio/ngff_meta/v04/zarr_utils.py

@@ -1,376 +0,0 @@
-"""Zarr utilities for loading metadata from OME-NGFF 0.4."""
-
-from typing import Literal
-
-from ngio.io import (
-    AccessModeLiteral,
-    Group,
-    StoreOrGroup,
-    open_group_wrapper,
-)
-from ngio.io._zarr import _is_group_readonly
-from ngio.ngff_meta.fractal_image_meta import (
-    Axis,
-    Channel,
-    ChannelVisualisation,
-    Dataset,
-    ImageLabelMeta,
-    ImageMeta,
-    LabelMeta,
-    Omero,
-)
-from ngio.ngff_meta.v04.specs import (
-    Axis04,
-    Channel04,
-    Dataset04,
-    Multiscale04,
-    NgffImageMeta04,
-    Omero04,
-    ScaleCoordinateTransformation04,
-    Transformation04,
-    TranslationCoordinateTransformation04,
-    Window04,
-)
-
-
-def check_ngff_image_meta_v04(store: StoreOrGroup) -> bool:
-    """Check if a Zarr Group contains the OME-NGFF v0.4."""
-    store = open_group_wrapper(store=store, mode="r", zarr_format=2)
-    attrs = dict(store.attrs)
-    multiscales = attrs.get("multiscales", None)
-    if multiscales is None:
-        return False
-
-    version = multiscales[0].get("version", None)
-    if version != "0.4":
-        return False
-
-    return True
-
-
-def load_vanilla_ngff_image_meta_v04(group: Group) -> NgffImageMeta04:
-    """Load the OME-NGFF 0.4 image meta model."""
-    return NgffImageMeta04(**group.attrs)
-
-
-def _transform_dataset(
-    datasets04: list[Dataset04],
-    axes: list[Axis04],
-    coo_transformation04: list[Transformation04] | None,
-) -> list[Dataset]:
-    # coo_transformation validation
-    # only one scale transformation is allowed as top-level
-    if coo_transformation04 is not None:
-        if len(coo_transformation04) != 1:
-            raise ValueError("Only one scale transformation is allowed as top-level.")
-
-        if not isinstance(coo_transformation04[0], ScaleCoordinateTransformation04):
-            raise ValueError(
-                "Invalid coordinate transformations. \
-                Only scale transformation is allowed."
-            )
-
-        top_scale = coo_transformation04[0].scale
-    else:
-        top_scale = None
-
-    fractal_datasets = []
-    for dataset04 in datasets04:
-        scale, translation = None, None
-        for transformation in dataset04.coordinateTransformations:
-            if isinstance(transformation, TranslationCoordinateTransformation04):
-                translation = transformation.translation
-
-            if isinstance(transformation, ScaleCoordinateTransformation04):
-                scale = transformation.scale
-                if top_scale is not None:
-                    # Combine the scale transformation with the top-level scale
-                    if len(scale) != len(top_scale):
-                        raise ValueError(
-                            "Inconsistent scale transformation. \
-                            The scale transformation must have the same length."
-                        )
-                    # Combine the scale transformation with the top-level scale
-                    scale = [s * ts for s, ts in zip(scale, top_scale, strict=True)]
-                scale = scale
-        fractal_datasets.append(
-            Dataset(
-                path=dataset04.path,
-                on_disk_axes=axes,
-                on_disk_scale=scale,
-                on_disk_translation=translation,
-            )
-        )
-    return fractal_datasets
-
-
-def vanilla_omero_v04_to_fractal(omero04: Omero04) -> Omero:
-    """Convert the Omero04 to Omero."""
-    list_channels = []
-    for channel04 in omero04.channels:
-        # Convert the window to a dictionary
-        label = channel04.label
-
-        if "wavelength_id" in channel04.extra_fields:
-            # If the wavelength_id is present, pop it from the extra fields
-            # so that it is not added to the channel_visualisation
-            wavelength_id = channel04.extra_fields.pop("wavelength_id")
-        else:
-            wavelength_id = label
-
-        if channel04.window is None:
-            window04 = Window04(
-                start=0,
-                end=65535,
-                min=0,
-                max=65535,
-            )
-        else:
-            window04 = channel04.window
-
-        ch_visualisation = ChannelVisualisation(
-            color=channel04.color,
-            active=channel04.active,
-            start=window04.start,
-            end=window04.end,
-            min=window04.min,
-            max=window04.max,
-            **channel04.extra_fields,
-        )
-
-        channel = Channel(
-            label=label,
-            wavelength_id=wavelength_id,
-            channel_visualisation=ch_visualisation,
-        )
-        list_channels.append(channel)
-
-    return Omero(
-        channels=list_channels,
-        **omero04.extra_fields,
-    )
-
-
-def fractal_omero_to_vanilla_v04(omero: Omero) -> Omero04:
-    """Convert the Omero to Omero04."""
-    list_channels04 = []
-    for channel in omero.channels:
-        # Convert the window to a Window04 object
-        window04 = Window04(
-            start=channel.channel_visualisation.start,
-            end=channel.channel_visualisation.end,
-            min=channel.channel_visualisation.min,
-            max=channel.channel_visualisation.max,
-        )
-        channel04 = Channel04(
-            label=channel.label,
-            color=channel.channel_visualisation.color,
-            active=channel.channel_visualisation.active,
-            window=window04,
-            wavelength_id=channel.wavelength_id,
-            **channel.channel_visualisation.extra_fields,
-        )
-        list_channels04.append(channel04)
-
-    return Omero04(
-        version="0.4",
-        channels=list_channels04,
-        **omero.extra_fields,
-    )
-
-
-def vanilla_ngff_image_meta_v04_to_fractal(
-    meta04: NgffImageMeta04,
-    meta_mode: Literal["image", "label"] = "image",
-) -> ImageLabelMeta:
-    """Convert the NgffImageMeta04 to ImageMeta."""
-    if not isinstance(meta04, NgffImageMeta04):
-        raise ValueError("Invalid metadata type. Expected NgffImageMeta04.")
-
-    multiscale04 = meta04.multiscales[0]
-    axes = [Axis(name=axis.name, unit=axis.unit) for axis in multiscale04.axes]
-    fractal_datasets = _transform_dataset(
-        datasets04=multiscale04.datasets,
-        axes=axes,
-        coo_transformation04=multiscale04.coordinateTransformations,
-    )
-
-    if meta_mode == "label":
-        return LabelMeta(
-            version="0.4",
-            name=multiscale04.name,
-            datasets=fractal_datasets,
-        )
-
-    if meta04.omero is not None:
-        fractal_omero = vanilla_omero_v04_to_fractal(omero04=meta04.omero)
-    else:
-        fractal_omero = None
-
-    return ImageMeta(
-        version="0.4",
-        name=multiscale04.name,
-        datasets=fractal_datasets,
-        omero=fractal_omero,
-    )
-
-
-def fractal_ngff_image_meta_to_vanilla_v04(
-    meta: ImageLabelMeta,
-) -> NgffImageMeta04:
-    """Convert the ImageMeta to NgffImageMeta."""
-    axes04 = [Axis04(**axis.model_dump()) for axis in meta.axes]
-    dataset04 = []
-    for dataset in meta.datasets:
-        transformations = [
-            ScaleCoordinateTransformation04(type="scale", scale=dataset.scale)
-        ]
-        if dataset.translation is not None:
-            transformations.append(
-                TranslationCoordinateTransformation04(
-                    type="translation", translation=dataset.translation
-                )
-            )
-        dataset04.append(
-            Dataset04(path=dataset.path, coordinateTransformations=transformations)
-        )
-    multiscale04 = Multiscale04(
-        name=meta.name,
-        axes=axes04,
-        datasets=dataset04,
-        version="0.4",
-    )
-
-    if isinstance(meta, LabelMeta):
-        return NgffImageMeta04(multiscales=[multiscale04])
-
-    if meta.omero is not None:
-        omero04 = fractal_omero_to_vanilla_v04(meta.omero)
-    else:
-        omero04 = None
-
-    return NgffImageMeta04(
-        multiscales=[multiscale04],
-        omero=omero04,
-    )
-
-
-def load_ngff_image_meta_v04(
-    group: Group, meta_mode: Literal["image", "label"]
-) -> ImageLabelMeta:
-    """Load the OME-NGFF 0.4 image meta model."""
-    if not check_ngff_image_meta_v04(store=group):
-        raise ValueError(
-            "The Zarr store does not contain the correct OME-Zarr version."
-        )
-    meta04 = load_vanilla_ngff_image_meta_v04(group=group)
-    return vanilla_ngff_image_meta_v04_to_fractal(meta04=meta04, meta_mode=meta_mode)
-
-
-def write_ngff_image_meta_v04(group: Group, meta: ImageLabelMeta) -> None:
-    """Write the OME-NGFF 0.4 image meta model."""
-    if dict(group.attrs):
-        # If group is not empty, check if the version is correct
-        if not check_ngff_image_meta_v04(store=group):
-            raise ValueError(
-                "The Zarr store does not contain the correct OME-Zarr version."
-            )
-    meta04 = fractal_ngff_image_meta_to_vanilla_v04(meta=meta)
-    group.attrs.update(meta04.model_dump(exclude_none=True))
-
-
-class NgffImageMetaZarrHandlerV04:
-    """Class for loading and writing OME-NGFF 0.4 metadata."""
-
-    def __init__(
-        self,
-        store: StoreOrGroup,
-        meta_mode: Literal["image", "label"],
-        cache: bool = False,
-        mode: AccessModeLiteral = "a",
-    ):
-        """Initialize the handler.
-
-        Args:
-            store (StoreOrGroup): The Zarr store or group containing the image data.
-            meta_mode (str): The mode of the metadata handler.
-            cache (bool): Whether to cache the metadata.
-            mode (str): The mode of the store.
-        """
-        if isinstance(store, Group):
-            if hasattr(store, "store_path"):
-                self._store = store.store_path
-            else:
-                self._store = store.store
-
-            self._group = store
-
-        else:
-            self._store = store
-            self._group = open_group_wrapper(store=store, mode=mode, zarr_format=2)
-
-        self.meta_mode = meta_mode
-        self.cache = cache
-        self._meta: None | ImageLabelMeta = None
-
-    @property
-    def zarr_version(self) -> int:
-        """Return the Zarr version.
-
-        This is not strictly necessary, but it is necessary
-        to make sure the zarr python creare consistent zarr files.
-        """
-        return 2
-
-    @property
-    def store(self) -> StoreOrGroup:
-        """Return the Zarr store."""
-        return self._store
-
-    @property
-    def group(self) -> Group:
-        """Return the Zarr group."""
-        return self._group
-
-    @staticmethod
-    def check_version(store: StoreOrGroup) -> bool:
-        """Check if the version of the metadata is supported."""
-        return check_ngff_image_meta_v04(store=store)
-
-    def load_meta(self) -> ImageLabelMeta:
-        """Load the OME-NGFF 0.4 metadata."""
-        if not self.check_version(store=self.group):
-            raise ValueError(
-                "The Zarr store does not contain the correct OME-Zarr version."
-            )
-
-        if self.cache:
-            if self._meta is None:
-                self._meta = load_ngff_image_meta_v04(
-                    self.group, meta_mode=self.meta_mode
-                )
-            return self._meta
-
-        return load_ngff_image_meta_v04(self.group, meta_mode=self.meta_mode)
-
-    def write_meta(self, meta: ImageLabelMeta) -> None:
-        """Write the OME-NGFF 0.4 metadata."""
-        if _is_group_readonly(self.group):
-            raise ValueError(
-                "The store is read-only. Cannot write the metadata to the store."
-            )
-
-        write_ngff_image_meta_v04(group=self.group, meta=meta)
-
-        if self.cache:
-            self.update_cache(meta)
-
-    def update_cache(self, meta: ImageLabelMeta) -> None:
-        """Update the cached metadata."""
-        if not self.cache:
-            raise ValueError("Cache is not enabled.")
-        self._meta = meta
-
-    def clear_cache(self) -> None:
-        """Clear the cached metadata."""
-        self._meta = None

ngio/pipes/__init__.py

@@ -1,7 +0,0 @@
-"""A module to handle data transforms for image data."""
-
-from ngio.pipes._slicer_transforms import NaiveSlicer, RoiSlicer
-from ngio.pipes._zoom_utils import on_disk_zoom
-from ngio.pipes.data_pipe import DataTransformPipe
-
-__all__ = ["DataTransformPipe", "NaiveSlicer", "RoiSlicer", "on_disk_zoom"]

ngio/pipes/_slicer_transforms.py

@@ -1,176 +0,0 @@
-from typing import Protocol  # noqa: I001
-
-import dask.delayed
-import numpy as np
-from dask import array as da
-import dask
-from dask.delayed import Delayed
-
-from ngio.utils._common_types import ArrayLike
-from ngio.core.roi import RasterCooROI
-import zarr
-
-
-class SlicerTransform(Protocol):
-    """A special class of transform that load a specific slice of the data."""
-
-    def get(self, data: ArrayLike) -> ArrayLike:
-        """Select a slice of the data and return the result."""
-        ...
-
-    def set(
-        self,
-        data: ArrayLike,
-        patch: ArrayLike,
-    ) -> None:
-        """Replace the slice of the data with the patch and return the result."""
-        ...
-
-
-@dask.delayed
-def _slice_set_delayed(
-    data: zarr.Array,
-    patch: Delayed,
-    slices: tuple[slice, ...],
-    axes_order: list[int] | None,
-) -> None:
-    if axes_order is not None:
-        patch = da.transpose(patch, axes_order)
-
-    if isinstance(patch, Delayed):
-        shape = tuple([s.stop - s.start for s in slices])
-        patch = da.from_delayed(patch, shape=shape, dtype=data.dtype)
-    da.to_zarr(arr=patch, url=data, region=slices)
-
-
-class NaiveSlicer:
-    """A simple slicer that requires all axes to be specified."""
-
-    def __init__(
-        self,
-        on_disk_axes_name: list[str],
-        axes_order: list[int],
-        t: int | slice | None = None,
-        c: int | slice | None = None,
-        z: int | slice | None = None,
-        y: int | slice | None = None,
-        x: int | slice | None = None,
-        preserve_dimensions: bool = True,
-    ):
-        """Initialize the NaiveSlicer object."""
-        self.on_disk_axes_name = on_disk_axes_name
-
-        # Check if axes_order is trivial
-        if axes_order != list(range(len(axes_order))):
-            self.axes_order = axes_order
-        else:
-            self.axes_order = None
-
-        self.slices = {
-            "t": self._parse_input(t, preserve_dimensions),
-            "c": self._parse_input(c, preserve_dimensions),
-            "z": self._parse_input(z, preserve_dimensions),
-            "y": self._parse_input(y, preserve_dimensions),
-            "x": self._parse_input(x, preserve_dimensions),
-        }
-
-        self.slice_on_disk_order = tuple(
-            [self.slices[axis] for axis in self.on_disk_axes_name]
-        )
-
-    def __repr__(self) -> str:
-        """Return the string representation of the object."""
-        slices = ", ".join([f"{axis}={slice_}" for axis, slice_ in self.slices.items()])
-        return f"NaiveSlicer({slices})"
-
-    def _parse_input(
-        self, x: int | slice | None, preserve_dimensions: bool = True
-    ) -> slice:
-        """Parse the input."""
-        if x is None:
-            return slice(None)
-        elif isinstance(x, int):
-            if preserve_dimensions:
-                return slice(x, x + 1)
-            else:
-                return x
-        elif isinstance(x, slice):
-            return x
-
-        raise ValueError(f"Invalid slice definition {x} of type {type(x)}")
-
-    def _shape_from_slices(self) -> tuple[int, ...]:
-        """Return the shape of the slice."""
-        slices = self.slice_on_disk_order
-        return tuple([s.stop - s.start for s in slices])
-
-    def get(self, data: ArrayLike) -> ArrayLike:
-        """Select a slice of the data and return the result."""
-        patch = data[self.slice_on_disk_order]
-
-        # If sel.axis_order is trivial, skip the transpose
-        if self.axes_order is None:
-            return patch
-
-        if isinstance(patch, np.ndarray):
-            patch = np.transpose(patch, self.axes_order)
-        elif isinstance(patch, da.core.Array):
-            patch = da.transpose(patch, self.axes_order)
-        else:
-            raise ValueError(
-                f"Invalid patch type {type(patch)}, "
-                "supported types are np.ndarray and da.core.Array"
-            )
-        return patch
-
-    def set(self, data: ArrayLike, patch: ArrayLike) -> None:
-        """Replace the slice of the data with the patch and return the result."""
-        # If sel.axis_order is trivial, skip the transpose
-        if isinstance(patch, np.ndarray):
-            if self.axes_order is not None:
-                patch = np.transpose(patch, self.axes_order)
-            data[self.slice_on_disk_order] = patch
-        elif isinstance(patch, (da.core.Array, Delayed)):  # noqa: UP038
-            if self.axes_order is not None:
-                patch = da.transpose(patch, self.axes_order)
-
-            if isinstance(patch, Delayed):
-                patch = da.from_delayed(
-                    patch, shape=self._shape_from_slices(), dtype=data.dtype
-                )
-            da.to_zarr(arr=patch, url=data, region=self.slice_on_disk_order)
-        else:
-            raise ValueError(
-                f"Invalid patch type {type(patch)}, "
-                "supported types are np.ndarray and da.core.Array"
-            )
-
-
-class RoiSlicer(NaiveSlicer):
-    """A slicer that requires all axes to be specified."""
-
-    def __init__(
-        self,
-        on_disk_axes_name: list[str],
-        axes_order: list[int],
-        roi: RasterCooROI,
-        t: int | slice | None = None,
-        c: int | slice | None = None,
-        preserve_dimensions: bool = True,
-    ):
-        """Initialize the RoiSlicer object."""
-        super().__init__(
-            on_disk_axes_name=on_disk_axes_name,
-            axes_order=axes_order,
-            t=t,
-            c=c,
-            z=roi.z_slice(),
-            y=roi.y_slice(),
-            x=roi.x_slice(),
-            preserve_dimensions=preserve_dimensions,
-        )
-
-    def __repr__(self) -> str:
-        """Return the string representation of the object."""
-        slices = ", ".join([f"{axis}={slice_}" for axis, slice_ in self.slices.items()])
-        return f"RoiSlicer({slices})"

ngio/pipes/_transforms.py

@@ -1,33 +0,0 @@
-from typing import Protocol
-
-from scipy.ndimage import zoom
-
-from ngio.utils._common_types import ArrayLike
-
-
-class Transform(Protocol):
-    """A protocol for data transforms to be performed on image data."""
-
-    def get(self, data: ArrayLike) -> ArrayLike:
-        """Apply the transform to the data and return the result."""
-        ...
-
-    def set(self, data: ArrayLike) -> ArrayLike:
-        """Apply the reverse transform to the data and return the result."""
-        ...
-
-
-class ZoomTransform:
-    """A transform to zoom in or out of the data."""
-
-    def __init__(self, zoom_factor: list[float]):
-        """Initialize the ZoomTransform object."""
-        self.zoom_factor = zoom_factor
-
-    def get(self, data: ArrayLike) -> ArrayLike:
-        """Apply the zoom transform to the data and return the result."""
-        return zoom(data, self.zoom_factor)
-
-    def set(self, data: ArrayLike) -> ArrayLike:
-        """Apply the reverse zoom transform to the data and return the result."""
-        return zoom(data, [1 / factor for factor in self.zoom_factor])

ngio/pipes/data_pipe.py

@@ -1,52 +0,0 @@
-"""A module to handle data transforms for image data."""
-
-from ngio.pipes._slicer_transforms import SlicerTransform
-from ngio.pipes._transforms import Transform
-from ngio.utils._common_types import ArrayLike
-
-
-class DataTransformPipe:
-    """A class to handle a pipeline of data transforms.
-
-    For example, a pipeline of transforms can be:
-        - Select a subset of the data
-        - Shuffle the axes of the data
-        - Normalize the data
-
-    All these in reverse order will be applied to the data when setting a patch.
-
-    """
-
-    def __init__(self, slicer: SlicerTransform, *data_transforms: Transform):
-        """Initialize the DataLoadPipe object.
-
-        Args:
-            slicer (SlicerTransform): The first transform to be applied to the
-                data MUST be a slicer.
-            *data_transforms (Transform): A list of transforms to be
-                applied to the data in order.
-        """
-        self.slicer = slicer
-        self.list_of_transforms = data_transforms
-
-    def __repr__(self) -> str:
-        """Return the string representation of the object."""
-        list_transforms = ", ".join(
-            [str(transform) for transform in self.list_of_transforms]
-        )
-        return f"DataTransformPipe(slicer={self.slicer}, transforms={list_transforms})"
-
-    def get(self, data: ArrayLike) -> ArrayLike:
-        """Apply all the transforms to the data and return the result."""
-        data = self.slicer.get(data)
-        for transform in self.list_of_transforms:
-            data = transform.get(data)
-        return data
-
-    def set(self, data: ArrayLike, patch: ArrayLike) -> None:
-        """Apply all the reverse transforms to the data and return the result."""
-        for transform in reversed(self.list_of_transforms):
-            patch = transform.set(patch)
-
-        # Write the patch to the data and save it
-        self.slicer.set(data, patch)