careamics 0.0.19__py3-none-any.whl

careamics/transforms/xy_random_rotate90.py

@@ -0,0 +1,108 @@
+"""Patch transform applying XY random 90 degrees rotations."""
+
+import numpy as np
+from numpy.typing import NDArray
+
+from careamics.transforms.transform import Transform
+
+
+class XYRandomRotate90(Transform):
+    """Applies random 90 degree rotations to the YX axis.
+
+    This transform expects C(Z)YX dimensions.
+
+    Attributes
+    ----------
+    rng : np.random.Generator
+        Random number generator.
+    p : float
+        Probability of applying the transform.
+    seed : Optional[int]
+        Random seed.
+
+    Parameters
+    ----------
+    p : float
+        Probability of applying the transform, by default 0.5.
+    seed : Optional[int]
+        Random seed, by default None.
+    """
+
+    def __init__(self, p: float = 0.5, seed: int | None = None):
+        """Constructor.
+
+        Parameters
+        ----------
+        p : float
+            Probability of applying the transform, by default 0.5.
+        seed : Optional[int]
+            Random seed, by default None.
+        """
+        if p < 0 or p > 1:
+            raise ValueError("Probability must be in [0, 1].")
+
+        # probability to apply the transform
+        self.p = p
+
+        # numpy random generator
+        self.rng = np.random.default_rng(seed=seed)
+
+    def __call__(
+        self,
+        patch: NDArray,
+        target: NDArray | None = None,
+        **additional_arrays: NDArray,
+    ) -> tuple[NDArray, NDArray | None, dict[str, NDArray]]:
+        """Apply the transform to the source patch and the target (optional).
+
+        Parameters
+        ----------
+        patch : np.ndarray
+            Patch, 2D or 3D, shape C(Z)YX.
+        target : Optional[np.ndarray], optional
+            Target for the patch, by default None.
+        **additional_arrays : NDArray
+            Additional arrays that will be transformed identically to `patch` and
+            `target`.
+
+        Returns
+        -------
+        tuple[np.ndarray, Optional[np.ndarray]]
+            Transformed patch and target.
+        """
+        if self.rng.random() > self.p:
+            return patch, target, additional_arrays
+
+        # number of rotations
+        n_rot = int(self.rng.integers(1, 4))
+
+        axes = (-2, -1)
+        patch_transformed = self._apply(patch, n_rot, axes)
+        target_transformed = (
+            self._apply(target, n_rot, axes) if target is not None else None
+        )
+        additional_transformed = {
+            key: self._apply(array, n_rot, axes)
+            for key, array in additional_arrays.items()
+        }
+
+        return patch_transformed, target_transformed, additional_transformed
+
+    def _apply(self, patch: NDArray, n_rot: int, axes: tuple[int, int]) -> NDArray:
+        """Apply the transform to the image.
+
+        Parameters
+        ----------
+        patch : np.ndarray
+            Image or image patch, 2D or 3D, shape C(Z)YX.
+        n_rot : int
+            Number of 90 degree rotations.
+        axes : tuple[int, int]
+            Axes along which to rotate the patch.
+
+        Returns
+        -------
+        np.ndarray
+            Transformed patch.
+        """
+        return np.ascontiguousarray(np.rot90(patch, k=n_rot, axes=axes))

careamics/utils/__init__.py

@@ -0,0 +1,19 @@
+"""Utils module."""
+
+__all__ = [
+    "BaseEnum",
+    "autocorrelation",
+    "check_path_exists",
+    "cwd",
+    "get_careamics_home",
+    "get_logger",
+    "get_ram_size",
+]
+
+
+from .autocorrelation import autocorrelation
+from .base_enum import BaseEnum
+from .context import cwd, get_careamics_home
+from .logging import get_logger
+from .path_utils import check_path_exists
+from .ram import get_ram_size

careamics/utils/autocorrelation.py

@@ -0,0 +1,40 @@
+"""Autocorrelation function."""
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+def autocorrelation(image: NDArray) -> NDArray:
+    """Compute the autocorrelation of an image.
+
+    This method is used to explore spatial correlations in images,
+    in particular in the noise.
+
+    The autocorrelation is normalized to the zero-shift value, which is centered in
+    the resulting images.
+
+    Parameters
+    ----------
+    image : NDArray
+        Input image.
+
+    Returns
+    -------
+    numpy.ndarray
+        Autocorrelation of the input image.
+    """
+    # normalize image
+    image = (image - np.mean(image)) / np.std(image)
+
+    # compute autocorrelation in fourier space
+    image = np.fft.fftn(image)
+    image = np.abs(image) ** 2
+    image = np.fft.ifftn(image).real
+
+    # normalize to zero shift value
+    image = image / image.flat[0]
+
+    # shift zero frequency to center
+    image = np.fft.fftshift(image)
+
+    return image

careamics/utils/base_enum.py

@@ -0,0 +1,60 @@
+"""A base class for Enum that allows checking if a value is in the Enum."""
+
+from enum import Enum, EnumMeta
+from typing import Any
+
+
+class _ContainerEnum(EnumMeta):
+    """Metaclass for Enum with __contains__ method."""
+
+    def __contains__(cls, item: Any) -> bool:
+        """Check if an item is in the Enum.
+
+        Parameters
+        ----------
+        item : Any
+            Item to check.
+
+        Returns
+        -------
+        bool
+            True if the item is in the Enum, False otherwise.
+        """
+        try:
+            cls(item)
+        except ValueError:
+            return False
+        return True
+
+    @classmethod
+    def has_value(cls, value: Any) -> bool:
+        """Check if a value is in the Enum.
+
+        Parameters
+        ----------
+        value : Any
+            Value to check.
+
+        Returns
+        -------
+        bool
+            True if the value is in the Enum, False otherwise.
+        """
+        return value in cls._value2member_map_
+
+
+class BaseEnum(Enum, metaclass=_ContainerEnum):
+    """Base Enum class, allowing checking if a value is in the enum.
+
+    Example
+    -------
+    >>> from careamics.utils.base_enum import BaseEnum
+    >>> # Define a new enum
+    >>> class BaseEnumExtension(BaseEnum):
+    ...     VALUE = "value"
+    >>> # Check if value is in the enum
+    >>> "value" in BaseEnumExtension
+    True
+    """
+
+    pass

careamics/utils/context.py

@@ -0,0 +1,67 @@
+"""
+Context submodule.
+
+A convenience function to change the working directory in order to save data.
+"""
+
+import os
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Union
+
+
+def get_careamics_home() -> Path:
+    """Return the CAREamics home directory.
+
+    CAREamics home directory is a hidden folder in home.
+
+    Returns
+    -------
+    Path
+        CAREamics home directory path.
+    """
+    home = Path.home() / ".careamics"
+
+    if not home.exists():
+        home.mkdir(parents=True, exist_ok=True)
+
+    return home
+
+
+@contextmanager
+def cwd(path: Union[str, Path]) -> Iterator[None]:
+    """
+    Change the current working directory to the given path.
+
+    This method can be used to generate files in a specific directory, once out of the
+    context, the working directory is set back to the original one.
+
+    Parameters
+    ----------
+    path : Union[str,Path]
+        New working directory path.
+
+    Returns
+    -------
+    Iterator[None]
+        None values.
+
+    Examples
+    --------
+    The context is whcnaged within the block and then restored to the original one.
+
+    >>> with cwd(my_path):
+    ...     pass # do something
+    """
+    path = Path(path)
+
+    if not path.exists():
+        path.mkdir(parents=True, exist_ok=True)
+
+    old_pwd = Path(".").absolute()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(old_pwd)

careamics/utils/deprecation.py

@@ -0,0 +1,63 @@
+"""Deprecation utilities."""
+
+import functools
+import warnings
+from collections.abc import Callable
+from typing import Any
+
+
+# TODO useful until py3.13 which has warnings.deprecated decorator
+def deprecated(msg: str = "This function is deprecated") -> Callable:
+    """Decorator to mark functions as deprecated.
+
+    Parameters
+    ----------
+    msg : str
+        The deprecation message to display when the function is called.
+
+    Returns
+    -------
+    Callable
+        The decorator that marks the function as deprecated.
+    """
+
+    def decorator(func: Callable) -> Callable:
+        """Decorator.
+
+        Parameters
+        ----------
+        func : Callable
+            The function to be decorated.
+
+        Returns
+        -------
+        Callable
+            The wrapped function.
+        """
+
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            """Wrapper.
+
+            Parameters
+            ----------
+            *args : Any
+                Positional arguments for the original function.
+            **kwargs : Any
+                Keyword arguments for the original function.
+
+            Returns
+            -------
+            Any
+                The return value of the original function.
+            """
+            warnings.warn(
+                f"{func.__name__} is deprecated: {msg}",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

careamics/utils/lightning_utils.py

@@ -0,0 +1,71 @@
+"""PyTorch lightning utilities."""
+
+from pathlib import Path
+from typing import Union
+
+
+def read_csv_logger(experiment_name: str, log_folder: Union[str, Path]) -> dict:
+    """Return the loss curves from the csv logs.
+
+    Parameters
+    ----------
+    experiment_name : str
+        Name of the experiment.
+    log_folder : Path or str
+        Path to the folder containing the csv logs.
+
+    Returns
+    -------
+    dict
+        Dictionary containing the loss curves, with keys "train_epoch", "val_epoch",
+        "train_loss" and "val_loss".
+    """
+    path = Path(log_folder) / experiment_name
+
+    # find the most recent of version_* folders
+    versions = [int(v.name.split("_")[-1]) for v in path.iterdir() if v.is_dir()]
+    version = max(versions)
+
+    path_log = path / f"version_{version}" / "metrics.csv"
+
+    with open(path_log) as f:
+        lines = f.readlines()
+
+        header = lines[0].strip().split(",")
+        metrics: dict[str, list] = {value: [] for value in header}
+        print(metrics)
+
+        for single_line in lines[1:]:
+            values = single_line.strip().split(",")
+
+            for k, v in zip(header, values, strict=False):
+                metrics[k].append(v)
+
+    # train and val are not logged on the same row and can have different lengths
+    train_epoch = [
+        int(metrics["epoch"][i])
+        for i in range(len(metrics["epoch"]))
+        if metrics["train_loss_epoch"][i] != ""
+    ]
+    val_epoch = [
+        int(metrics["epoch"][i])
+        for i in range(len(metrics["epoch"]))
+        if metrics["val_loss"][i] != ""
+    ]
+    train_losses = [
+        float(metrics["train_loss_epoch"][i])
+        for i in range(len(metrics["train_loss_epoch"]))
+        if metrics["train_loss_epoch"][i] != ""
+    ]
+    val_losses = [
+        float(metrics["val_loss"][i])
+        for i in range(len(metrics["val_loss"]))
+        if metrics["val_loss"][i] != ""
+    ]
+
+    return {
+        "train_epoch": train_epoch,
+        "val_epoch": val_epoch,
+        "train_loss": train_losses,
+        "val_loss": val_losses,
+    }