ngio 0.2.0a2__py3-none-any.whl → 0.5.0b4__py3-none-any.whl

ngio/images/image.py

@@ -1,389 +0,0 @@
-"""Generic class to handle Image-like data in a OME-NGFF file."""
-
-from collections.abc import Collection
-from typing import Literal
-
-from dask import array as da
-
-from ngio.common import Dimensions
-from ngio.images.abstract_image import AbstractImage, consolidate_image
-from ngio.images.create import _create_empty_image
-from ngio.ome_zarr_meta import (
-    ImageMetaHandler,
-    ImplementedImageMetaHandlers,
-    NgioImageMeta,
-    PixelSize,
-)
-from ngio.ome_zarr_meta.ngio_specs import Channel, ChannelsMeta, ChannelVisualisation
-from ngio.utils import (
-    NgioValidationError,
-    StoreOrGroup,
-    ZarrGroupHandler,
-)
-
-
-def _check_channel_meta(meta: NgioImageMeta, dimension: Dimensions) -> ChannelsMeta:
-    """Check the channel metadata."""
-    c_dim = dimension.get("c", strict=False)
-    c_dim = 1 if c_dim is None else c_dim
-
-    if meta.channels_meta is None:
-        return ChannelsMeta.default_init(labels=c_dim)
-
-    if len(meta.channels) != c_dim:
-        raise NgioValidationError(
-            "The number of channels does not match the image. "
-            f"Expected {len(meta.channels)} channels, got {c_dim}."
-        )
-
-    return meta.channels_meta
-
-
-class Image(AbstractImage[ImageMetaHandler]):
-    """A class to handle a single image (or level) in an OME-Zarr image.
-
-    This class is meant to be subclassed by specific image types.
-    """
-
-    def __init__(
-        self,
-        group_handler: ZarrGroupHandler,
-        path: str,
-        meta_handler: ImageMetaHandler | None,
-    ) -> None:
-        """Initialize the Image at a single level.
-
-        Args:
-            group_handler: The Zarr group handler.
-            path: The path to the image in the omezarr file.
-            meta_handler: The image metadata handler.
-
-        """
-        if meta_handler is None:
-            meta_handler = ImplementedImageMetaHandlers().find_meta_handler(
-                group_handler
-            )
-        super().__init__(
-            group_handler=group_handler, path=path, meta_handler=meta_handler
-        )
-        self._channels_meta = _check_channel_meta(self.meta, self.dimensions)
-
-    @property
-    def meta(self) -> NgioImageMeta:
-        """Return the metadata."""
-        return self._meta_handler.meta
-
-    @property
-    def channel_labels(self) -> list[str]:
-        """Return the channels of the image."""
-        channel_labels = []
-        for c in self._channels_meta.channels:
-            channel_labels.append(c.label)
-        return channel_labels
-
-    @property
-    def wavelength_ids(self) -> list[str | None]:
-        """Return the list of wavelength of the image."""
-        wavelength_ids = []
-        for c in self._channels_meta.channels:
-            wavelength_ids.append(c.wavelength_id)
-        return wavelength_ids
-
-    @property
-    def num_channels(self) -> int:
-        """Return the number of channels."""
-        return len(self._channels_meta.channels)
-
-    def consolidate(
-        self,
-        order: Literal[0, 1, 2] = 1,
-        mode: Literal["dask", "numpy", "coarsen"] = "dask",
-    ) -> None:
-        """Consolidate the label on disk."""
-        consolidate_image(self, order=order, mode=mode)
-
-
-class ImagesContainer:
-    """A class to handle the /labels group in an OME-NGFF file."""
-
-    def __init__(self, group_handler: ZarrGroupHandler) -> None:
-        """Initialize the LabelGroupHandler."""
-        self._group_handler = group_handler
-        self._meta_handler = ImplementedImageMetaHandlers().find_meta_handler(
-            group_handler
-        )
-
-    @property
-    def meta(self) -> NgioImageMeta:
-        """Return the metadata."""
-        return self._meta_handler.meta
-
-    @property
-    def levels(self) -> int:
-        """Return the number of levels in the image."""
-        return self._meta_handler.meta.levels
-
-    @property
-    def levels_paths(self) -> list[str]:
-        """Return the paths of the levels in the image."""
-        return self._meta_handler.meta.paths
-
-    @property
-    def num_channels(self) -> int:
-        """Return the number of channels."""
-        image = self.get()
-        return image.num_channels
-
-    @property
-    def channel_labels(self) -> list[str]:
-        """Return the channels of the image."""
-        image = self.get()
-        return image.channel_labels
-
-    @property
-    def wavelength_ids(self) -> list[str | None]:
-        """Return the wavelength of the image."""
-        image = self.get()
-        return image.wavelength_ids
-
-    def initialize_channel_meta(
-        self,
-        labels: Collection[str] | int | None = None,
-        wavelength_id: Collection[str] | None = None,
-        percentiles: tuple[float, float] | None = None,
-        colors: Collection[str] | None = None,
-        active: Collection[bool] | None = None,
-        **omero_kwargs: dict,
-    ) -> None:
-        """Create a ChannelsMeta object with the default unit.
-
-        Args:
-            labels(Collection[str] | int): The list of channels names in the image.
-                If an integer is provided, the channels will be named "channel_i".
-            wavelength_id(Collection[str] | None): The wavelength ID of the channel.
-                If None, the wavelength ID will be the same as the channel name.
-            percentiles(tuple[float, float] | None): The start and end percentiles
-                for each channel. If None, the percentiles will not be computed.
-            colors(Collection[str, NgioColors] | None): The list of colors for the
-                channels. If None, the colors will be random.
-            active (Collection[bool] | None):active(bool): Whether the channel should
-                be shown by default.
-            omero_kwargs(dict): Extra fields to store in the omero attributes.
-        """
-        ref = self.get()
-
-        if percentiles is not None:
-            start, end = compute_image_percentile(
-                ref, start_percentile=percentiles[0], end_percentile=percentiles[1]
-            )
-        else:
-            start, end = None, None
-
-        if labels is None:
-            labels = ref.num_channels
-
-        channel_meta = ChannelsMeta.default_init(
-            labels=labels,
-            wavelength_id=wavelength_id,
-            colors=colors,
-            start=start,
-            end=end,
-            active=active,
-            data_type=ref.dtype,
-            **omero_kwargs,
-        )
-
-        meta = self.meta
-        meta.set_channels_meta(channel_meta)
-        self._meta_handler.write_meta(meta)
-
-    def update_percentiles(
-        self,
-        start_percentile: float = 0.1,
-        end_percentile: float = 99.9,
-    ) -> None:
-        """Update the percentiles of the channels."""
-        if self.meta._channels_meta is None:
-            raise NgioValidationError("The channels meta is not initialized.")
-
-        image = self.get()
-        starts, ends = compute_image_percentile(
-            image, start_percentile=start_percentile, end_percentile=end_percentile
-        )
-
-        channels = []
-        for c, channel in enumerate(self.meta._channels_meta.channels):
-            new_v = ChannelVisualisation(
-                start=starts[c],
-                end=ends[c],
-                **channel.channel_visualisation.model_dump(exclude={"start", "end"}),
-            )
-            new_c = Channel(
-                channel_visualisation=new_v,
-                **channel.model_dump(exclude={"channel_visualisation"}),
-            )
-            channels.append(new_c)
-
-        new_meta = ChannelsMeta(channels=channels)
-
-        meta = self.meta
-        meta.set_channels_meta(new_meta)
-        self._meta_handler.write_meta(meta)
-
-    def derive(
-        self,
-        store: StoreOrGroup,
-        ref_path: str | None = None,
-        shape: Collection[int] | None = None,
-        chunks: Collection[int] | None = None,
-        xy_scaling_factor: float = 2.0,
-        z_scaling_factor: float = 1.0,
-        overwrite: bool = False,
-    ) -> "ImagesContainer":
-        """Create an OME-Zarr image from a numpy array."""
-        return derive_image_container(
-            image_container=self,
-            store=store,
-            ref_path=ref_path,
-            shape=shape,
-            chunks=chunks,
-            xy_scaling_factor=xy_scaling_factor,
-            z_scaling_factor=z_scaling_factor,
-            overwrite=overwrite,
-        )
-
-    def get(
-        self,
-        path: str | None = None,
-        pixel_size: PixelSize | None = None,
-        highest_resolution: bool = True,
-    ) -> Image:
-        """Get an image at a specific level."""
-        if path is not None or pixel_size is not None:
-            highest_resolution = False
-        dataset = self._meta_handler.meta.get_dataset(
-            path=path, pixel_size=pixel_size, highest_resolution=highest_resolution
-        )
-        return Image(
-            group_handler=self._group_handler,
-            path=dataset.path,
-            meta_handler=self._meta_handler,
-        )
-
-
-def compute_image_percentile(
-    image: Image,
-    start_percentile: float = 0.1,
-    end_percentile: float = 99.9,
-) -> tuple[list[float], list[float]]:
-    """Compute the start and end percentiles for each channel of an image.
-
-    Args:
-        image: The image to compute the percentiles for.
-        start_percentile: The start percentile to compute.
-        end_percentile: The end percentile to compute.
-
-    Returns:
-        A tuple containing the start and end percentiles for each channel.
-    """
-    starts, ends = [], []
-    for c in range(image.num_channels):
-        if image.num_channels == 1:
-            data = image.get_array(mode="dask").ravel()
-        else:
-            data = image.get_array(c=c, mode="dask").ravel()
-        # remove all the zeros
-        mask = data > 1e-16
-        data = data[mask]
-        _data = data.compute()
-        if _data.size == 0:
-            starts.append(0.0)
-            ends.append(0.0)
-            continue
-
-        # compute the percentiles
-        _s_perc, _e_perc = da.percentile(
-            data, [start_percentile, end_percentile], method="nearest"
-        ).compute()
-
-        starts.append(float(_s_perc))
-        ends.append(float(_e_perc))
-
-    return starts, ends
-
-
-def derive_image_container(
-    image_container: ImagesContainer,
-    store: StoreOrGroup,
-    ref_path: str | None = None,
-    shape: Collection[int] | None = None,
-    chunks: Collection[int] | None = None,
-    xy_scaling_factor: float = 2.0,
-    z_scaling_factor: float = 1.0,
-    overwrite: bool = False,
-) -> ImagesContainer:
-    """Create an OME-Zarr image from a numpy array."""
-    if ref_path is None:
-        ref_image = image_container.get()
-    else:
-        ref_image = image_container.get(path=ref_path)
-
-    ref_meta = ref_image.meta
-
-    if shape is None:
-        shape = ref_image.shape
-    else:
-        if len(shape) != len(ref_image.shape):
-            raise NgioValidationError(
-                "The shape of the new image does not match the reference image."
-            )
-
-    if chunks is None:
-        chunks = ref_image.chunks
-    else:
-        if len(chunks) != len(ref_image.chunks):
-            raise NgioValidationError(
-                "The chunks of the new image does not match the reference image."
-            )
-
-    handler = _create_empty_image(
-        store=store,
-        shape=shape,
-        xy_pixelsize=ref_image.pixel_size.x,
-        z_spacing=ref_image.pixel_size.z,
-        time_spacing=ref_image.pixel_size.t,
-        levels=ref_meta.levels,
-        xy_scaling_factor=xy_scaling_factor,
-        z_scaling_factor=z_scaling_factor,
-        time_unit=ref_image.pixel_size.time_unit,
-        space_unit=ref_image.pixel_size.space_unit,
-        axes_names=ref_image.dataset.axes_mapper.on_disk_axes_names,
-        chunks=chunks,
-        dtype=ref_image.dtype,
-        overwrite=overwrite,
-        version=ref_meta.version,
-    )
-
-    image_container = ImagesContainer(handler)
-
-    if ref_image.num_channels == image_container.num_channels:
-        labels = ref_image.channel_labels
-        wavelength_id = ref_image.wavelength_ids
-        colors = [
-            c.channel_visualisation.color for c in ref_image._channels_meta.channels
-        ]
-        active = [
-            c.channel_visualisation.active for c in ref_image._channels_meta.channels
-        ]
-
-        image_container.initialize_channel_meta(
-            labels=labels,
-            wavelength_id=wavelength_id,
-            percentiles=None,
-            colors=colors,
-            active=active,
-        )
-    else:
-        image_container.initialize_channel_meta()
-
-    return image_container

ngio/images/label.py

@@ -1,236 +0,0 @@
-"""A module for handling label images in OME-NGFF files."""
-
-from collections.abc import Collection
-from typing import Literal
-
-from ngio.images.abstract_image import AbstractImage, consolidate_image
-from ngio.images.create import _create_empty_label
-from ngio.images.image import Image
-from ngio.ome_zarr_meta import (
-    ImplementedLabelMetaHandlers,
-    LabelMetaHandler,
-    NgioLabelMeta,
-)
-from ngio.ome_zarr_meta.ngio_specs import SpaceUnits, TimeUnits
-from ngio.utils import (
-    NgioValidationError,
-    NgioValueError,
-    StoreOrGroup,
-    ZarrGroupHandler,
-)
-
-
-class Label(AbstractImage[LabelMetaHandler]):
-    """Placeholder class for a label."""
-
-    def __init__(
-        self,
-        group_handler: ZarrGroupHandler,
-        path: str,
-        meta_handler: LabelMetaHandler | None,
-    ) -> None:
-        """Initialize the Image at a single level.
-
-        Args:
-            group_handler: The Zarr group handler.
-            path: The path to the image in the omezarr file.
-            meta_handler: The image metadata handler.
-
-        """
-        if meta_handler is None:
-            meta_handler = ImplementedLabelMetaHandlers().find_meta_handler(
-                group_handler
-            )
-        super().__init__(
-            group_handler=group_handler, path=path, meta_handler=meta_handler
-        )
-
-    @property
-    def meta(self) -> NgioLabelMeta:
-        """Return the metadata."""
-        return self._meta_handler.meta
-
-    def consolidate(
-        self,
-        mode: Literal["dask", "numpy", "coarsen"] = "dask",
-    ) -> None:
-        """Consolidate the label on disk."""
-        consolidate_image(self, mode=mode, order=0)
-
-
-class LabelsContainer:
-    """A class to handle the /labels group in an OME-NGFF file."""
-
-    def __init__(self, group_handler: ZarrGroupHandler) -> None:
-        """Initialize the LabelGroupHandler."""
-        self._group_handler = group_handler
-
-        # Validate the group
-        # Either contains a labels attribute or is empty
-        attrs = self._group_handler.load_attrs()
-        if len(attrs) == 0:
-            # It's an empty group
-            pass
-        elif "labels" in attrs and isinstance(attrs["labels"], list):
-            # It's a valid group
-            pass
-        else:
-            raise NgioValidationError(
-                f"Invalid /labels group. "
-                f"Expected a single labels attribute with a list of label names. "
-                f"Found: {attrs}"
-            )
-
-    def list(self) -> list[str]:
-        """Create the /labels group if it doesn't exist."""
-        attrs = self._group_handler.load_attrs()
-        return attrs.get("labels", [])
-
-    def get(self, name: str, path: str) -> Label:
-        """Get a label from the group."""
-        group_handler = self._group_handler.derive_handler(name)
-        return Label(group_handler, path, None)
-
-    def derive(
-        self,
-        name: str,
-        ref_image: Image,
-        shape: Collection[int] | None = None,
-        chunks: Collection[int] | None = None,
-        dtype: str = "uint16",
-        xy_scaling_factor=2.0,
-        z_scaling_factor=1.0,
-        overwrite: bool = False,
-    ) -> None:
-        """Add a label to the group."""
-        existing_labels = self.list()
-        if name in existing_labels and not overwrite:
-            raise NgioValueError(
-                f"Table '{name}' already exists in the group. "
-                "Use overwrite=True to replace it."
-            )
-
-        label_group = self._group_handler.get_group(name, create_mode=True)
-
-        _derive_label(
-            ref_image=ref_image,
-            store=label_group,
-            shape=shape,
-            chunks=chunks,
-            dtype=dtype,
-            xy_scaling_factor=xy_scaling_factor,
-            z_scaling_factor=z_scaling_factor,
-            overwrite=overwrite,
-        )
-
-        if name not in existing_labels:
-            existing_labels.append(name)
-            self._group_handler.write_attrs({"labels": existing_labels})
-
-    def new(
-        self,
-        name: str,
-        shape: Collection[int],
-        xy_pixelsize: float,
-        z_spacing: float = 1.0,
-        time_spacing: float = 1.0,
-        levels: "int | list[str]" = 5,
-        xy_scaling_factor: float = 2.0,
-        z_scaling_factor: float = 1.0,
-        space_unit: SpaceUnits | str | None = None,
-        time_unit: TimeUnits | str | None = None,
-        axes_names: Collection[str] | None = None,
-        chunks: Collection[int] | None = None,
-        dtype: str = "uint16",
-        overwrite: bool = False,
-        version: str = "0.4",
-    ) -> None:
-        """Add a label to the group."""
-        existing_labels = self.list()
-        if name in existing_labels and not overwrite:
-            raise NgioValueError(
-                f"Table '{name}' already exists in the group. "
-                "Use overwrite=True to replace it."
-            )
-
-        label_group = self._group_handler.get_group(name, create_mode=True)
-
-        _create_empty_label(
-            store=label_group,
-            shape=shape,
-            xy_pixelsize=xy_pixelsize,
-            z_spacing=z_spacing,
-            time_spacing=time_spacing,
-            levels=levels,
-            xy_scaling_factor=xy_scaling_factor,
-            z_scaling_factor=z_scaling_factor,
-            space_unit=space_unit,
-            time_unit=time_unit,
-            axes_names=axes_names,
-            chunks=chunks,
-            dtype=dtype,
-            overwrite=overwrite,
-            version=version,
-        )
-
-        if name not in existing_labels:
-            existing_labels.append(name)
-            self._group_handler.write_attrs({"labels": existing_labels})
-
-
-def _derive_label(
-    ref_image: Image,
-    store: StoreOrGroup,
-    shape: Collection[int] | None = None,
-    chunks: Collection[int] | None = None,
-    dtype: str = "uint16",
-    xy_scaling_factor=2.0,
-    z_scaling_factor=1.0,
-    overwrite: bool = False,
-) -> None:
-    """Create an OME-Zarr image from a numpy array."""
-    ref_meta = ref_image.meta
-    # remove channls if present
-    shape_ref = ref_image.shape
-    chunks_ref = ref_image.chunks
-    axes_names_ref = ref_image.dataset.axes_mapper.on_disk_axes_names
-    c_axis = ref_image.dataset.axes_mapper.get_index("c")
-    if c_axis is not None:
-        shape_ref = shape_ref[:c_axis] + shape_ref[c_axis + 1 :]
-        chunks_ref = chunks_ref[:c_axis] + chunks_ref[c_axis + 1 :]
-        axes_names_ref = axes_names_ref[:c_axis] + axes_names_ref[c_axis + 1 :]
-
-    if shape is None:
-        shape = shape_ref
-
-    if chunks is None:
-        chunks = chunks_ref
-
-    if len(shape) != len(shape_ref):
-        raise NgioValidationError(
-            "The shape of the new image does not match the reference image."
-        )
-
-    if len(chunks) != len(chunks_ref):
-        raise NgioValidationError(
-            "The chunks of the new image does not match the reference image."
-        )
-
-    _ = _create_empty_label(
-        store=store,
-        shape=shape,
-        xy_pixelsize=ref_image.pixel_size.x,
-        z_spacing=ref_image.pixel_size.z,
-        time_spacing=ref_image.pixel_size.t,
-        levels=ref_meta.levels,
-        xy_scaling_factor=xy_scaling_factor,
-        z_scaling_factor=z_scaling_factor,
-        time_unit=ref_image.pixel_size.time_unit,
-        space_unit=ref_image.pixel_size.space_unit,
-        axes_names=axes_names_ref,
-        chunks=chunks,
-        dtype=dtype,
-        overwrite=overwrite,
-        version=ref_meta.version,
-    )
-    return None