careamics 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

careamics/transforms/xy_random_rotate90.py

@@ -0,0 +1,101 @@
+"""Patch transform applying XY random 90 degrees rotations."""
+
+from typing import Optional, Tuple
+
+import numpy as np
+
+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: Optional[int] = 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: np.ndarray, target: Optional[np.ndarray] = None
+    ) -> Tuple[np.ndarray, Optional[np.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.
+
+        Returns
+        -------
+        Tuple[np.ndarray, Optional[np.ndarray]]
+            Transformed patch and target.
+        """
+        if self.rng.random() > self.p:
+            return patch, target
+
+        # number of rotations
+        n_rot = 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
+        )
+
+        return patch_transformed, target_transformed
+
+    def _apply(
+        self, patch: np.ndarray, n_rot: int, axes: Tuple[int, int]
+    ) -> np.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__ = [
+    "cwd",
+    "get_ram_size",
+    "check_path_exists",
+    "BaseEnum",
+    "get_logger",
+    "get_careamics_home",
+    "autocorrelation",
+]
+
+
+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,66 @@
+"""
+Context submodule.
+
+A convenience function to change the working directory in order to save data.
+"""
+
+import os
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Iterator, 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/logging.py

@@ -0,0 +1,322 @@
+"""
+Logging submodule.
+
+The methods are responsible for the in-console logger.
+"""
+
+import logging
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, Generator, List, Optional, Union
+
+LOGGERS: dict = {}
+
+
+def get_logger(
+    name: str,
+    log_level: int = logging.INFO,
+    log_path: Optional[Union[str, Path]] = None,
+) -> logging.Logger:
+    """
+    Create a python logger instance with configured handlers.
+
+    Parameters
+    ----------
+    name : str
+        Name of the logger.
+    log_level : int, optional
+        Log level (info, error etc.), by default logging.INFO.
+    log_path : Optional[Union[str, Path]], optional
+        Path in which to save the log, by default None.
+
+    Returns
+    -------
+    logging.Logger
+        Logger.
+    """
+    logger = logging.getLogger(name)
+    logger.propagate = False
+
+    if name in LOGGERS:
+        return logger
+
+    for logger_name in LOGGERS:
+        if name.startswith(logger_name):
+            return logger
+
+    logger.propagate = False
+
+    if log_path:
+        handlers = [
+            logging.StreamHandler(),
+            logging.FileHandler(log_path),
+        ]
+    else:
+        handlers = [logging.StreamHandler()]
+
+    formatter = logging.Formatter("%(message)s")
+
+    for handler in handlers:
+        handler.setFormatter(formatter)  # type: ignore
+        handler.setLevel(log_level)  # type: ignore
+        logger.addHandler(handler)  # type: ignore
+
+    logger.setLevel(log_level)
+    LOGGERS[name] = True
+
+    logger.propagate = False
+
+    return logger
+
+
+class ProgressBar:
+    """
+    Keras style progress bar.
+
+    Adapted from https://github.com/yueyericardo/pkbar.
+
+    Parameters
+    ----------
+    max_value : Optional[int], optional
+        Maximum progress bar value, by default None.
+    epoch : Optional[int], optional
+        Zero-indexed current epoch, by default None.
+    num_epochs : Optional[int], optional
+        Total number of epochs, by default None.
+    stateful_metrics : Optional[List], optional
+        Iterable of string names of metrics that should *not* be averaged over time.
+        Metrics in this list will be displayed as-is. All others will be averaged by
+        the progress bar before display, by default None.
+    always_stateful : bool, optional
+            Whether to set all metrics to be stateful, by default False.
+    mode : str, optional
+        Mode, one of "train", "val", or "predict", by default "train".
+    """
+
+    def __init__(
+        self,
+        max_value: Optional[int] = None,
+        epoch: Optional[int] = None,
+        num_epochs: Optional[int] = None,
+        stateful_metrics: Optional[List] = None,
+        always_stateful: bool = False,
+        mode: str = "train",
+    ) -> None:
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        max_value : Optional[int], optional
+            Maximum progress bar value, by default None.
+        epoch : Optional[int], optional
+            Zero-indexed current epoch, by default None.
+        num_epochs : Optional[int], optional
+            Total number of epochs, by default None.
+        stateful_metrics : Optional[List], optional
+            Iterable of string names of metrics that should *not* be averaged over time.
+            Metrics in this list will be displayed as-is. All others will be averaged by
+            the progress bar before display, by default None.
+        always_stateful : bool, optional
+             Whether to set all metrics to be stateful, by default False.
+        mode : str, optional
+            Mode, one of "train", "val", or "predict", by default "train".
+        """
+        self.max_value = max_value
+        # Width of the progress bar
+        self.width = 30
+        self.always_stateful = always_stateful
+
+        if (epoch is not None) and (num_epochs is not None):
+            print(f"Epoch: {epoch + 1}/{num_epochs}")
+
+        if stateful_metrics:
+            self.stateful_metrics = set(stateful_metrics)
+        else:
+            self.stateful_metrics = set()
+
+        self._dynamic_display = (
+            (hasattr(sys.stdout, "isatty") and sys.stdout.isatty())
+            or "ipykernel" in sys.modules
+            or "posix" in sys.modules
+        )
+        self._total_width = 0
+        self._seen_so_far = 0
+        # We use a dict + list to avoid garbage collection
+        # issues found in OrderedDict
+        self._values: Dict[Any, Any] = {}
+        self._values_order: List[Any] = []
+        self._start = time.time()
+        self._last_update = 0.0
+        self.spin = self.spinning_cursor() if self.max_value is None else None
+        if mode == "train" and self.max_value is None:
+            self.message = "Estimating dataset size"
+        elif mode == "val":
+            self.message = "Validating"
+        elif mode == "predict":
+            self.message = "Denoising"
+
+    def update(
+        self, current_step: int, batch_size: int = 1, values: Optional[List] = None
+    ) -> None:
+        """
+        Update the progress bar.
+
+        Parameters
+        ----------
+        current_step : int
+            Index of the current step.
+        batch_size : int, optional
+            Batch size, by default 1.
+        values : Optional[List], optional
+            Updated metrics values, by default None.
+        """
+        values = values or []
+        for k, v in values:
+            # if torch tensor, convert it to numpy
+            if str(type(v)) == "<class 'torch.Tensor'>":
+                v = v.detach().cpu().numpy()
+
+            if k not in self._values_order:
+                self._values_order.append(k)
+            if k not in self.stateful_metrics and not self.always_stateful:
+                if k not in self._values:
+                    self._values[k] = [
+                        v * (current_step - self._seen_so_far),
+                        current_step - self._seen_so_far,
+                    ]
+                else:
+                    self._values[k][0] += v * (current_step - self._seen_so_far)
+                    self._values[k][1] += current_step - self._seen_so_far
+            else:
+                # Stateful metrics output a numeric value. This representation
+                # means "take an average from a single value" but keeps the
+                # numeric formatting.
+                self._values[k] = [v, 1]
+
+        self._seen_so_far = current_step
+
+        now = time.time()
+        info = f" - {(now - self._start):.0f}s"
+
+        prev_total_width = self._total_width
+        if self._dynamic_display:
+            sys.stdout.write("\b" * prev_total_width)
+            sys.stdout.write("\r")
+        else:
+            sys.stdout.write("\n")
+
+        if self.max_value is not None:
+            bar = f"{current_step}/{self.max_value} ["
+            progress = float(current_step) / self.max_value
+            progress_width = int(self.width * progress)
+            if progress_width > 0:
+                bar += "=" * (progress_width - 1)
+                if current_step < self.max_value:
+                    bar += ">"
+                else:
+                    bar += "="
+            bar += "." * (self.width - progress_width)
+            bar += "]"
+        else:
+            bar = (
+                f"{self.message} {next(self.spin)}, tile "  # type: ignore
+                f"No. {current_step * batch_size}"
+            )
+
+        self._total_width = len(bar)
+        sys.stdout.write(bar)
+
+        if current_step > 0:
+            time_per_unit = (now - self._start) / current_step
+        else:
+            time_per_unit = 0
+
+        if time_per_unit >= 1 or time_per_unit == 0:
+            info += f" {time_per_unit:.0f}s/step"
+        elif time_per_unit >= 1e-3:
+            info += f" {time_per_unit * 1e3:.0f}ms/step"
+        else:
+            info += f" {time_per_unit * 1e6:.0f}us/step"
+
+        for k in self._values_order:
+            info += f" - {k}:"
+            if isinstance(self._values[k], list):
+                avg = self._values[k][0] / max(1, self._values[k][1])
+                if abs(avg) > 1e-3:
+                    info += f" {avg:.4f}"
+                else:
+                    info += f" {avg:.4e}"
+            else:
+                info += f" {self._values[k]}s"
+
+        self._total_width += len(info)
+        if prev_total_width > self._total_width:
+            info += " " * (prev_total_width - self._total_width)
+
+        if self.max_value is not None and current_step >= self.max_value:
+            info += "\n"
+
+        sys.stdout.write(info)
+        sys.stdout.flush()
+
+        self._last_update = now
+
+    def add(self, n: int, values: Optional[List] = None) -> None:
+        """
+        Update the progress bar by n steps.
+
+        Parameters
+        ----------
+        n : int
+            Number of steps to increase the progress bar with.
+        values : Optional[List], optional
+            Updated metrics values, by default None.
+        """
+        self.update(self._seen_so_far + n, 1, values=values)
+
+    def spinning_cursor(self) -> Generator:
+        """
+        Generate a spinning cursor animation.
+
+        Taken from https://github.com/manrajgrover/py-spinners/tree/master.
+
+        Returns
+        -------
+        Generator
+            Generator of animation frames.
+        """
+        while True:
+            yield from [
+                "▓ ----- ▒",
+                "▓ ----- ▒",
+                "▓ ----- ▒",
+                "▓ ->--- ▒",
+                "▓ ->--- ▒",
+                "▓ ->--- ▒",
+                "▓ -->-- ▒",
+                "▓ -->-- ▒",
+                "▓ -->-- ▒",
+                "▓ --->- ▒",
+                "▓ --->- ▒",
+                "▓ --->- ▒",
+                "▓ ----> ▒",
+                "▓ ----> ▒",
+                "▓ ----> ▒",
+                "▒ ----- ░",
+                "▒ ----- ░",
+                "▒ ----- ░",
+                "▒ ->--- ░",
+                "▒ ->--- ░",
+                "▒ ->--- ░",
+                "▒ -->-- ░",
+                "▒ -->-- ░",
+                "▒ -->-- ░",
+                "▒ --->- ░",
+                "▒ --->- ░",
+                "▒ --->- ░",
+                "▒ ----> ░",
+                "▒ ----> ░",
+                "▒ ----> ░",
+            ]