careamics 0.1.0rc4__py3-none-any.whl → 0.1.0rc6__py3-none-any.whl

careamics/config/support/supported_transforms.py

@@ -1,23 +1,12 @@
+"""Transforms supported by CAREamics."""
+
 from careamics.utils import BaseEnum
 
 
 class SupportedTransform(str, BaseEnum):
-    """Transforms officially supported by CAREamics.
-
-    - Flip: from Albumentations, randomly flip the input horizontally, vertically or
-        both, parameter `p` can be used to set the probability to apply the transform.
-    - XYRandomRotate90: #TODO
-    - Normalize # TODO add details, in particular about the parameters
-    - ManipulateN2V # TODO add details, in particular about the parameters
-    - NDFlip
-
-    Note that while any Albumentations (see https://albumentations.ai/) transform can be
-    used in CAREamics, no check are implemented to verify the compatibility of any other
-    transforms than the ones officially supported.
-    """
+    """Transforms officially supported by CAREamics."""
 
-    NDFLIP = "NDFlip"
+    XY_FLIP = "XYFlip"
     XY_RANDOM_ROTATE90 = "XYRandomRotate90"
     NORMALIZE = "Normalize"
     N2V_MANIPULATE = "N2VManipulate"
-    # CUSTOM = "Custom"

careamics/config/tile_information.py

@@ -1,3 +1,5 @@
+"""Pydantic model representing the metadata of a prediction tile."""
+
 from __future__ import annotations
 
 from typing import Optional, Tuple

careamics/config/training_model.py

@@ -1,4 +1,5 @@
 """Training configuration."""
+
 from __future__ import annotations
 
 from pprint import pformat

careamics/config/transformations/__init__.py

@@ -2,13 +2,14 @@
 
 __all__ = [
     "N2VManipulateModel",
-    "NDFlipModel",
+    "XYFlipModel",
     "NormalizeModel",
     "XYRandomRotate90Model",
+    "XorYFlipModel",
 ]
 
 
 from .n2v_manipulate_model import N2VManipulateModel
-from .nd_flip_model import NDFlipModel
 from .normalize_model import NormalizeModel
+from .xy_flip_model import XYFlipModel
 from .xy_random_rotate90_model import XYRandomRotate90Model

careamics/config/transformations/n2v_manipulate_model.py

@@ -1,4 +1,5 @@
 """Pydantic model for the N2VManipulate transform."""
+
 from typing import Literal
 
 from pydantic import ConfigDict, Field, field_validator

careamics/config/transformations/normalize_model.py

@@ -1,4 +1,5 @@
 """Pydantic model for the Normalize transform."""
+
 from typing import Literal
 
 from pydantic import ConfigDict, Field

careamics/config/transformations/transform_model.py

@@ -1,4 +1,5 @@
 """Parent model for the transforms."""
+
 from typing import Any, Dict
 
 from pydantic import BaseModel, ConfigDict

careamics/config/transformations/xy_flip_model.py

@@ -0,0 +1,43 @@
+"""Pydantic model for the XYFlip transform."""
+
+from typing import Literal, Optional
+
+from pydantic import ConfigDict, Field
+
+from .transform_model import TransformModel
+
+
+class XYFlipModel(TransformModel):
+    """
+    Pydantic model used to represent XYFlip transformation.
+
+    Attributes
+    ----------
+    name : Literal["XYFlip"]
+        Name of the transformation.
+    p : float
+        Probability of applying the transform, by default 0.5.
+    seed : Optional[int]
+        Seed for the random number generator,  by default None.
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+    )
+
+    name: Literal["XYFlip"] = "XYFlip"
+    flip_x: bool = Field(
+        True,
+        description="Whether to flip along the X axis.",
+    )
+    flip_y: bool = Field(
+        True,
+        description="Whether to flip along the Y axis.",
+    )
+    p: float = Field(
+        0.5,
+        description="Probability of applying the transform.",
+        ge=0,
+        le=1,
+    )
+    seed: Optional[int] = None

careamics/config/transformations/xy_random_rotate90_model.py

@@ -1,5 +1,6 @@
 """Pydantic model for the XYRandomRotate90 transform."""
-from typing import Literal
+
+from typing import Literal, Optional
 
 from pydantic import ConfigDict, Field
 
@@ -8,16 +9,16 @@ from .transform_model import TransformModel
 
 class XYRandomRotate90Model(TransformModel):
     """
-    Pydantic model used to represent NDFlip transformation.
+    Pydantic model used to represent the XY random 90 degree rotation transformation.
 
     Attributes
     ----------
     name : Literal["XYRandomRotate90"]
         Name of the transformation.
     p : float
-        Probability of applying the transformation, by default 0.5.
-    is_3D : bool
-        Whether the transformation should be applied in 3D, by default False.
+        Probability of applying the transform, by default 0.5.
+    seed : Optional[int]
+        Seed for the random number generator, by default None.
     """
 
     model_config = ConfigDict(
@@ -25,5 +26,10 @@ class XYRandomRotate90Model(TransformModel):
     )
 
     name: Literal["XYRandomRotate90"] = "XYRandomRotate90"
-    p: float = Field(default=0.5, ge=0.0, le=1.0)
-    is_3D: bool = Field(default=False)
+    p: float = Field(
+        0.5,
+        description="Probability of applying the transform.",
+        ge=0,
+        le=1,
+    )
+    seed: Optional[int] = None

careamics/config/validators/validator_utils.py

@@ -3,6 +3,7 @@ Validator functions.
 
 These functions are used to validate dimensions and axes of inputs.
 """
+
 from typing import List, Optional, Tuple, Union
 
 _AXES = "STCZYX"

careamics/conftest.py

@@ -2,6 +2,7 @@
 
 See https://sybil.readthedocs.io/en/latest/use.html#pytest
 """
+
 from pathlib import Path
 
 import pytest
@@ -13,6 +14,18 @@ from sybil.parsers.doctest import DocTestParser
 
 @pytest.fixture(scope="module")
 def my_path(tmpdir_factory: TempPathFactory) -> Path:
+    """Fixture used in doctest to create a temporary directory.
+
+    Parameters
+    ----------
+    tmpdir_factory : TempPathFactory
+        Temporary path factory from pytest.
+
+    Returns
+    -------
+    Path
+        Temporary directory path.
+    """
     return tmpdir_factory.mktemp("my_path")
 
 

careamics/dataset/dataset_utils/__init__.py

@@ -1,6 +1,5 @@
 """Files and arrays utils used in the datasets."""
 
-
 __all__ = [
     "reshape_array",
     "get_files_size",

careamics/dataset/dataset_utils/dataset_utils.py

@@ -1,4 +1,5 @@
-"""Convenience methods for datasets."""
+"""Dataset utilities."""
+
 from typing import List, Tuple
 
 import numpy as np
@@ -16,12 +17,12 @@ def _get_shape_order(
 
     Parameters
     ----------
-    shape_in : Tuple
+    shape_in : Tuple[int, ...]
         Input shape.
-    ref_axes : str
-        Reference axes.
     axes_in : str
         Input axes.
+    ref_axes : str
+        Reference axes.
 
     Returns
     -------

careamics/dataset/dataset_utils/file_utils.py

@@ -1,3 +1,5 @@
+"""File utilities."""
+
 from fnmatch import fnmatch
 from pathlib import Path
 from typing import List, Union
@@ -11,8 +13,7 @@ logger = get_logger(__name__)
 
 
 def get_files_size(files: List[Path]) -> float:
-    """
-    Get files size in MB.
+    """Get files size in MB.
 
     Parameters
     ----------
@@ -32,7 +33,7 @@ def list_files(
     data_type: Union[str, SupportedData],
     extension_filter: str = "",
 ) -> List[Path]:
-    """Creates a recursive list of files in `data_path`.
+    """Create a recursive list of files in `data_path`.
 
     If `data_path` is a file, its name is validated against the `data_type` using
     `fnmatch`, and the method returns `data_path` itself.

careamics/dataset/dataset_utils/read_tiff.py

@@ -1,3 +1,5 @@
+"""Funtions to read tiff images."""
+
 import logging
 from fnmatch import fnmatch
 from pathlib import Path
@@ -19,8 +21,10 @@ def read_tiff(file_path: Path, *args: list, **kwargs: dict) -> np.ndarray:
     ----------
     file_path : Path
         Path to a file.
-    axes : str
-        Description of axes in format STCZYX.
+    *args : list
+        Additional arguments.
+    **kwargs : dict
+        Additional keyword arguments.
 
     Returns
     -------

careamics/dataset/dataset_utils/read_utils.py

@@ -1,3 +1,5 @@
+"""Read function utilities."""
+
 from typing import Callable, Union
 
 from careamics.config.support import SupportedData

careamics/dataset/dataset_utils/read_zarr.py

@@ -1,3 +1,5 @@
+"""Function to read zarr images."""
+
 from typing import Union
 
 from zarr import Group, core, hierarchy, storage
@@ -6,26 +8,28 @@ from zarr import Group, core, hierarchy, storage
 def read_zarr(
     zarr_source: Group, axes: str
 ) -> Union[core.Array, storage.DirectoryStore, hierarchy.Group]:
-    """Reads a file and returns a pointer.
+    """Read a file and returns a pointer.
 
     Parameters
     ----------
-    file_path : Path
-        pathlib.Path object containing a path to a file
+    zarr_source : Group
+        Zarr storage.
+    axes : str
+        Axes of the data.
 
     Returns
     -------
     np.ndarray
-        Pointer to zarr storage
+        Pointer to zarr storage.
 
     Raises
     ------
     ValueError, OSError
-        if a file is not a valid tiff or damaged
+        if a file is not a valid tiff or damaged.
     ValueError
-        if data dimensions are not 2, 3 or 4
+        if data dimensions are not 2, 3 or 4.
     ValueError
-        if axes parameter from config is not consistent with data dimensions
+        if axes parameter from config is not consistent with data dimensions.
     """
     if isinstance(zarr_source, hierarchy.Group):
         array = zarr_source[0]

careamics/dataset/in_memory_dataset.py

@@ -1,4 +1,5 @@
 """In-memory dataset module."""
+
 from __future__ import annotations
 
 import copy
@@ -8,11 +9,13 @@ from typing import Any, Callable, List, Optional, Tuple, Union
 import numpy as np
 from torch.utils.data import Dataset
 
+from careamics.transforms import Compose
+
 from ..config import DataConfig, InferenceConfig
 from ..config.tile_information import TileInformation
+from ..config.transformations import NormalizeModel
 from ..utils.logging import get_logger
 from .dataset_utils import read_tiff, reshape_array
-from .patching.patch_transform import get_patch_transform
 from .patching.patching import (
     prepare_patches_supervised,
     prepare_patches_supervised_array,
@@ -25,24 +28,49 @@ logger = get_logger(__name__)
 
 
 class InMemoryDataset(Dataset):
-    """Dataset storing data in memory and allowing generating patches from it."""
+    """Dataset storing data in memory and allowing generating patches from it.
+
+    Parameters
+    ----------
+    data_config : DataConfig
+        Data configuration.
+    inputs : Union[np.ndarray, List[Path]]
+        Input data.
+    input_target : Optional[Union[np.ndarray, List[Path]]], optional
+        Target data, by default None.
+    read_source_func : Callable, optional
+        Read source function for custom types, by default read_tiff.
+    **kwargs : Any
+        Additional keyword arguments, unused.
+    """
 
     def __init__(
         self,
         data_config: DataConfig,
         inputs: Union[np.ndarray, List[Path]],
-        data_target: Optional[Union[np.ndarray, List[Path]]] = None,
+        input_target: Optional[Union[np.ndarray, List[Path]]] = None,
         read_source_func: Callable = read_tiff,
         **kwargs: Any,
     ) -> None:
         """
         Constructor.
 
-        # TODO
+        Parameters
+        ----------
+        data_config : DataConfig
+            Data configuration.
+        inputs : Union[np.ndarray, List[Path]]
+            Input data.
+        input_target : Optional[Union[np.ndarray, List[Path]]], optional
+            Target data, by default None.
+        read_source_func : Callable, optional
+            Read source function for custom types, by default read_tiff.
+        **kwargs : Any
+            Additional keyword arguments, unused.
         """
         self.data_config = data_config
         self.inputs = inputs
-        self.data_target = data_target
+        self.input_targets = input_target
         self.axes = self.data_config.axes
         self.patch_size = self.data_config.patch_size
 
@@ -50,28 +78,25 @@ class InMemoryDataset(Dataset):
         self.read_source_func = read_source_func
 
         # Generate patches
-        supervised = self.data_target is not None
-        patches = self._prepare_patches(supervised)
+        supervised = self.input_targets is not None
+        patch_data = self._prepare_patches(supervised)
 
         # Add results to members
-        self.data, self.data_targets, computed_mean, computed_std = patches
+        self.patches, self.patch_targets, computed_mean, computed_std = patch_data
 
         if not self.data_config.mean or not self.data_config.std:
             self.mean, self.std = computed_mean, computed_std
             logger.info(f"Computed dataset mean: {self.mean}, std: {self.std}")
 
-            # if the transforms are not an instance of Compose
-            if self.data_config.has_transform_list():
-                # update mean and std in configuration
-                # the object is mutable and should then be recorded in the CAREamist obj
-                self.data_config.set_mean_and_std(self.mean, self.std)
+            # update mean and std in configuration
+            # the object is mutable and should then be recorded in the CAREamist obj
+            self.data_config.set_mean_and_std(self.mean, self.std)
         else:
             self.mean, self.std = self.data_config.mean, self.data_config.std
 
         # get transforms
-        self.patch_transform = get_patch_transform(
-            patch_transforms=self.data_config.transforms,
-            with_target=self.data_target is not None,
+        self.patch_transform = Compose(
+            transform_list=self.data_config.transforms,
         )
 
     def _prepare_patches(
@@ -92,18 +117,18 @@ class InMemoryDataset(Dataset):
         """
         if supervised:
             if isinstance(self.inputs, np.ndarray) and isinstance(
-                self.data_target, np.ndarray
+                self.input_targets, np.ndarray
             ):
                 return prepare_patches_supervised_array(
                     self.inputs,
                     self.axes,
-                    self.data_target,
+                    self.input_targets,
                     self.patch_size,
                 )
-            elif isinstance(self.inputs, list) and isinstance(self.data_target, list):
+            elif isinstance(self.inputs, list) and isinstance(self.input_targets, list):
                 return prepare_patches_supervised(
                     self.inputs,
-                    self.data_target,
+                    self.input_targets,
                     self.axes,
                     self.patch_size,
                     self.read_source_func,
@@ -112,7 +137,7 @@ class InMemoryDataset(Dataset):
                 raise ValueError(
                     f"Data and target must be of the same type, either both numpy "
                     f"arrays or both lists of paths, got {type(self.inputs)} (data) "
-                    f"and {type(self.data_target)} (target)."
+                    f"and {type(self.input_targets)} (target)."
                 )
         else:
             if isinstance(self.inputs, np.ndarray):
@@ -138,9 +163,9 @@ class InMemoryDataset(Dataset):
         int
             Length of the dataset.
         """
-        return len(self.data)
+        return len(self.patches)
 
-    def __getitem__(self, index: int) -> Tuple[np.ndarray]:
+    def __getitem__(self, index: int) -> Tuple[np.ndarray, ...]:
         """
         Return the patch corresponding to the provided index.
 
@@ -159,40 +184,17 @@ class InMemoryDataset(Dataset):
         ValueError
             If dataset mean and std are not set.
         """
-        patch = self.data[index]
+        patch = self.patches[index]
 
         # if there is a target
-        if self.data_target is not None:
+        if self.patch_targets is not None:
             # get target
-            target = self.data_targets[index]
-
-            # Albumentations requires Channel last
-            c_patch = np.moveaxis(patch, 0, -1)
-            c_target = np.moveaxis(target, 0, -1)
+            target = self.patch_targets[index]
 
-            # Apply transforms
-            transformed = self.patch_transform(image=c_patch, target=c_target)
-
-            # move axes back
-            patch = np.moveaxis(transformed["image"], -1, 0)
-            target = np.moveaxis(transformed["target"], -1, 0)
-
-            return patch, target
+            return self.patch_transform(patch=patch, target=target)
 
         elif self.data_config.has_n2v_manipulate():
-            # Albumentations requires Channel last
-            patch = np.moveaxis(patch, 0, -1)
-
-            # Apply transforms
-            transformed_patch = self.patch_transform(image=patch)["image"]
-            manip_patch, patch, mask = transformed_patch
-
-            # move C axes back
-            manip_patch = np.moveaxis(manip_patch, -1, 0)
-            patch = np.moveaxis(patch, -1, 0)
-            mask = np.moveaxis(mask, -1, 0)
-
-            return (manip_patch, patch, mask)
+            return self.patch_transform(patch=patch)
         else:
             raise ValueError(
                 "Something went wrong! No target provided (not supervised training) "
@@ -247,25 +249,25 @@ class InMemoryDataset(Dataset):
         indices = np.random.choice(total_patches, n_patches, replace=False)
 
         # extract patches
-        val_patches = self.data[indices]
+        val_patches = self.patches[indices]
 
         # remove patches from self.patch
-        self.data = np.delete(self.data, indices, axis=0)
+        self.patches = np.delete(self.patches, indices, axis=0)
 
         # same for targets
-        if self.data_targets is not None:
-            val_targets = self.data_targets[indices]
-            self.data_targets = np.delete(self.data_targets, indices, axis=0)
+        if self.patch_targets is not None:
+            val_targets = self.patch_targets[indices]
+            self.patch_targets = np.delete(self.patch_targets, indices, axis=0)
 
         # clone the dataset
         dataset = copy.deepcopy(self)
 
         # reassign patches
-        dataset.data = val_patches
+        dataset.patches = val_patches
 
         # reassign targets
-        if self.data_targets is not None:
-            dataset.data_targets = val_targets
+        if self.patch_targets is not None:
+            dataset.patch_targets = val_targets
 
         return dataset
 
@@ -274,7 +276,16 @@ class InMemoryPredictionDataset(Dataset):
     """
     Dataset storing data in memory and allowing generating patches from it.
 
-    # TODO
+    Parameters
+    ----------
+    prediction_config : InferenceConfig
+        Prediction configuration.
+    inputs : np.ndarray
+        Input data.
+    data_target : Optional[np.ndarray], optional
+        Target data, by default None.
+    read_source_func : Optional[Callable], optional
+        Read source function for custom types, by default read_tiff.
     """
 
     def __init__(
@@ -288,10 +299,14 @@ class InMemoryPredictionDataset(Dataset):
 
         Parameters
         ----------
-        array : np.ndarray
-            Array containing the data.
-        axes : str
-            Description of axes in format STCZYX.
+        prediction_config : InferenceConfig
+            Prediction configuration.
+        inputs : np.ndarray
+            Input data.
+        data_target : Optional[np.ndarray], optional
+            Target data, by default None.
+        read_source_func : Optional[Callable], optional
+            Read source function for custom types, by default read_tiff.
 
         Raises
         ------
@@ -318,9 +333,8 @@ class InMemoryPredictionDataset(Dataset):
         self.mean, self.std = self.pred_config.mean, self.pred_config.std
 
         # get transforms
-        self.patch_transform = get_patch_transform(
-            patch_transforms=self.pred_config.transforms,
-            with_target=self.data_target is not None,
+        self.patch_transform = Compose(
+            transform_list=[NormalizeModel(mean=self.mean, std=self.std)],
         )
 
     def _prepare_tiles(self) -> List[Tuple[np.ndarray, TileInformation]]:
@@ -335,7 +349,7 @@ class InMemoryPredictionDataset(Dataset):
         # reshape array
         reshaped_sample = reshape_array(self.input_array, self.axes)
 
-        if self.tiling:
+        if self.tiling and self.tile_size is not None and self.tile_overlap is not None:
             # generate patches, which returns a generator
             patch_generator = extract_tiles(
                 arr=reshaped_sample,
@@ -379,13 +393,7 @@ class InMemoryPredictionDataset(Dataset):
         """
         tile_array, tile_info = self.data[index]
 
-        # Albumentations requires channel last, use the XArrayTile array
-        patch = np.moveaxis(tile_array, 0, -1)
-
         # Apply transforms
-        transformed_patch = self.patch_transform(image=patch)["image"]
-
-        # move C axes back
-        transformed_patch = np.moveaxis(transformed_patch, -1, 0)
+        transformed_tile, _ = self.patch_transform(patch=tile_array)
 
-        return transformed_patch, tile_info
+        return transformed_tile, tile_info