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

careamics/manipulation/__init__.py

@@ -1,4 +0,0 @@
-"""Pixel manipulation functions for N2V."""
-
-
-from .pixel_manipulation import default_manipulate as default_manipulate

careamics/manipulation/pixel_manipulation.py

@@ -1,158 +0,0 @@
-"""
-Pixel manipulation methods.
-
-Pixel manipulation is used in N2V and similar algorithm to replace the value of
-masked pixels.
-"""
-from typing import Callable, Optional, Tuple
-
-import numpy as np
-
-
-def _odd_jitter_func(step: float, rng: np.random.Generator) -> np.ndarray:
-    """
-    Randomly sample a jitter to be applied to the masking grid.
-
-    This is done to account for cases where the step size is not an integer.
-
-    Parameters
-    ----------
-    step : float
-        Step size of the grid, output of np.linspace.
-    rng : np.random.Generator
-        Random number generator.
-
-    Returns
-    -------
-    np.ndarray
-        Array of random jitter to be added to the grid.
-    """
-    # Define the random jitter to be added to the grid
-    odd_jitter = np.where(np.floor(step) == step, 0, rng.integers(0, 2))
-
-    # Round the step size to the nearest integer depending on the jitter
-    return np.floor(step) if odd_jitter == 0 else np.ceil(step)
-
-
-def get_stratified_coords(
-    mask_pixel_perc: float,
-    shape: Tuple[int, ...],
-) -> np.ndarray:
-    """
-    Generate coordinates of the pixels to mask.
-
-    Randomly selects the coordinates of the pixels to mask in a stratified way, i.e.
-    the distance between masked pixels is approximately the same.
-
-    Parameters
-    ----------
-    mask_pixel_perc : float
-        Actual (quasi) percentage of masked pixels across the whole image. Used in
-        calculating the distance between masked pixels across each axis.
-    shape : Tuple[int, ...]
-        Shape of the input patch.
-
-    Returns
-    -------
-    np.ndarray
-        Array of coordinates of the masked pixels.
-    """
-    rng = np.random.default_rng()
-
-    # Define the approximate distance between masked pixels
-    mask_pixel_distance = np.round((100 / mask_pixel_perc) ** (1 / len(shape))).astype(
-        np.int32
-    )
-
-    # Define a grid of coordinates for each axis in the input patch and the step size
-    pixel_coords = []
-    for axis_size in shape:
-        # make sure axis size is evenly divisible by box size
-        num_pixels = int(np.ceil(axis_size / mask_pixel_distance))
-        axis_pixel_coords, step = np.linspace(
-            0, axis_size, num_pixels, dtype=np.int32, endpoint=False, retstep=True
-        )
-        # explain
-        pixel_coords.append(axis_pixel_coords.T)
-
-    # Create a meshgrid of coordinates for each axis in the input patch
-    coordinate_grid_list = np.meshgrid(*pixel_coords)
-    coordinate_grid = np.array(coordinate_grid_list).reshape(len(shape), -1).T
-
-    grid_random_increment = rng.integers(
-        _odd_jitter_func(float(step), rng)
-        * np.ones_like(coordinate_grid).astype(np.int32)
-        - 1,
-        size=coordinate_grid.shape,
-        endpoint=True,
-    )
-    coordinate_grid += grid_random_increment
-    coordinate_grid = np.clip(coordinate_grid, 0, np.array(shape) - 1)
-    return coordinate_grid
-
-
-def default_manipulate(
-    patch: np.ndarray,
-    mask_pixel_percentage: float,
-    roi_size: int = 11,
-    augmentations: Optional[Callable] = None,
-) -> Tuple[np.ndarray, ...]:
-    """
-    Manipulate pixel in a patch, i.e. replace the masked value.
-
-    Parameters
-    ----------
-    patch : np.ndarray
-        Image patch, 2D or 3D, shape (y, x) or (z, y, x).
-    mask_pixel_percentage : floar
-        Approximate percentage of pixels to be masked.
-    roi_size : int
-        Size of the ROI the new pixel value is sampled from, by default 11.
-    augmentations : Callable, optional
-        Augmentations to apply, by default None.
-
-    Returns
-    -------
-    Tuple[np.ndarray]
-        Tuple containing the manipulated patch, the original patch and the mask.
-    """
-    original_patch = patch.copy()
-
-    # Get the coordinates of the pixels to be replaced
-    roi_centers = get_stratified_coords(mask_pixel_percentage, patch.shape)
-    rng = np.random.default_rng()
-
-    # Generate coordinate grid for ROI
-    roi_span_full = np.arange(-np.floor(roi_size / 2), np.ceil(roi_size / 2)).astype(
-        np.int32
-    )
-    # Remove the center pixel from the grid
-    roi_span_wo_center = roi_span_full[roi_span_full != 0]
-
-    # Randomly select coordinates from the grid
-    random_increment = rng.choice(roi_span_wo_center, size=roi_centers.shape)
-
-    # Clip the coordinates to the patch size
-    replacement_coords = np.clip(
-        roi_centers + random_increment,
-        0,
-        [patch.shape[i] - 1 for i in range(len(patch.shape))],
-    )
-    # Get the replacement pixels from all rois
-    replacement_pixels = patch[tuple(replacement_coords.T.tolist())]
-
-    # Replace the original pixels with the replacement pixels
-    patch[tuple(roi_centers.T.tolist())] = replacement_pixels
-    mask = np.where(patch != original_patch, 1, 0).astype(np.uint8)
-
-    patch, original_patch, mask = (
-        (patch, original_patch, mask)
-        if augmentations is None
-        else augmentations(patch, original_patch, mask)
-    )
-
-    return (
-        np.expand_dims(patch, 0),
-        np.expand_dims(original_patch, 0),
-        np.expand_dims(mask, 0),
-    )

careamics/prediction/prediction_utils.py

@@ -1,106 +0,0 @@
-"""
-Prediction convenience functions.
-
-These functions are used during prediction.
-"""
-from typing import List
-
-import numpy as np
-import torch
-
-
-def stitch_prediction(
-    tiles: List[np.ndarray],
-    stitching_data: List,
-) -> np.ndarray:
-    """
-    Stitch tiles back together to form a full image.
-
-    Parameters
-    ----------
-    tiles : List[Tuple[np.ndarray, List[int]]]
-        Cropped tiles and their respective stitching coordinates.
-    stitching_data : List
-        List of coordinates obtained from
-        dataset.tiling.compute_crop_and_stitch_coords_1d.
-
-    Returns
-    -------
-    np.ndarray
-        Full image.
-    """
-    # Get whole sample shape
-    input_shape = stitching_data[0][0]
-    predicted_image = np.zeros(input_shape, dtype=np.float32)
-    for tile, (_, overlap_crop_coords, stitch_coords) in zip(tiles, stitching_data):
-        # Compute coordinates for cropping predicted tile
-        slices = tuple([slice(c[0], c[1]) for c in overlap_crop_coords])
-
-        # Crop predited tile according to overlap coordinates
-        cropped_tile = tile.squeeze()[slices]
-
-        # Insert cropped tile into predicted image using stitch coordinates
-        predicted_image[
-            (..., *[slice(c[0], c[1]) for c in stitch_coords])
-        ] = cropped_tile
-    return predicted_image
-
-
-def tta_forward(x: torch.Tensor) -> List[torch.Tensor]:
-    """
-    Augment 8-fold an array.
-
-    The augmentation is performed using all 90 deg rotations and their flipped version,
-    as well as the original image flipped.
-
-    Tensors should be of shape SC(Z)YX, with S and C potentially singleton dimensions.
-
-    Parameters
-    ----------
-    x : torch.Tensor
-        Data to augment.
-
-    Returns
-    -------
-    List
-        Stack of augmented images.
-    """
-    x_aug = [
-        x,
-        torch.rot90(x, 1, dims=(2, 3)),
-        torch.rot90(x, 2, dims=(2, 3)),
-        torch.rot90(x, 3, dims=(2, 3)),
-    ]
-    x_aug_flip = x_aug.copy()
-    for x_ in x_aug:
-        x_aug_flip.append(torch.flip(x_, dims=(1, 3)))
-    return x_aug_flip
-
-
-def tta_backward(x_aug: List[torch.Tensor]) -> np.ndarray:
-    """
-    Invert `tta_forward` and average the 8 images.
-
-    The function takes a list of torch tensors and returns a numpy array.
-
-    Parameters
-    ----------
-    x_aug : List[torch.Tensor]
-        Stack of 8-fold augmented images.
-
-    Returns
-    -------
-    np.ndarray
-        Average of de-augmented x_aug.
-    """
-    x_deaug = [
-        x_aug[0].numpy(),
-        np.rot90(x_aug[1], -1, axes=(2, 3)),
-        np.rot90(x_aug[2], -2, axes=(2, 3)),
-        np.rot90(x_aug[3], -3, axes=(2, 3)),
-        np.flip(x_aug[4].numpy(), axis=(1, 3)),
-        np.rot90(np.flip(x_aug[5].numpy(), axis=(1, 3)), -1, axes=(2, 3)),
-        np.rot90(np.flip(x_aug[6].numpy(), axis=(1, 3)), -2, axes=(2, 3)),
-        np.rot90(np.flip(x_aug[7].numpy(), axis=(1, 3)), -3, axes=(2, 3)),
-    ]
-    return np.mean(x_deaug, 0)

careamics/utils/ascii_logo.txt

@@ -1,9 +0,0 @@
-   ......       ......     ........     ........                                   ....
- -+++----+-   -+++--+++-  :+++---+++:  :+++-----                                   .--:
-.+++     .:   +++.  .+++. :+++   :+++  :+++         :------.   .---:----..:----.   :---    :----:     :----:.
-.+++         .+++.  .+++. :+++   -++=  :+++        +=....=+++  :+++-..=+++-..=++=  -+++  .+++-..++   +++-..=+.
-.+++         .++++++++++. :++++++++=.  :++++++:          .+++. :+++   :+++   -+++  -+++  :+++       .+++=.
-.+++         .+++.  .+++. :+++   -+++  :+++        :=++==++++. :+++   :+++   -+++  -+++  :+++        .-=+++=:
-.+++     ..  .+++.  .+++. :+++   :+++  :+++       .+++.  .+++. :+++   :+++   -+++  -+++  :+++   ..   ..  :+++.
- -++=-::-+=  .+++.  .+++. :+++   :+++  :+++-::::   =++=--=+++. :+++   :+++   -+++  -+++   =++=:-+=   =+-:=++=
-   ......     ...    ...   ...    ...   ........     .... ...   ...    ...   ....  ....     ....      .....

careamics/utils/augment.py

@@ -1,65 +0,0 @@
-"""Augmentation module."""
-from typing import Tuple
-
-import numpy as np
-
-
-# TODO: unused?
-def _flip_and_rotate(
-    image: np.ndarray, rotate_state: int, flip_state: int
-) -> np.ndarray:
-    """
-    Apply the given number of 90 degrees rotations and flip to an array.
-
-    Parameters
-    ----------
-    image : np.ndarray
-        Array containing single image or patch, 2D or 3D.
-    rotate_state : int
-        Number of 90 degree rotations to apply.
-    flip_state : int
-        0 or 1, whether to flip the array or not.
-
-    Returns
-    -------
-    np.ndarray
-        Flipped and rotated array.
-    """
-    rotated = np.rot90(image, k=rotate_state, axes=(-2, -1))
-    flipped = np.flip(rotated, axis=-1) if flip_state == 1 else rotated
-    return flipped.copy()
-
-
-def augment_batch(
-    patch: np.ndarray,
-    original_image: np.ndarray,
-    mask: np.ndarray,
-    seed: int = 42,
-) -> Tuple[np.ndarray, ...]:
-    """
-    Apply augmentation function to patches and masks.
-
-    Parameters
-    ----------
-    patch : np.ndarray
-        Array containing single image or patch, 2D or 3D with masked pixels.
-    original_image : np.ndarray
-        Array containing original image or patch, 2D or 3D.
-    mask : np.ndarray
-        Array containing only masked pixels, 2D or 3D.
-    seed : int, optional
-        Seed for random number generator, controls the rotation and falipping.
-
-    Returns
-    -------
-    Tuple[np.ndarray, ...]
-        Tuple of augmented arrays.
-    """
-    rng = np.random.default_rng(seed=seed)
-    rotate_state = rng.integers(0, 4)
-    flip_state = rng.integers(0, 2)
-    return (
-        _flip_and_rotate(patch, rotate_state, flip_state),
-        _flip_and_rotate(original_image, rotate_state, flip_state),
-        _flip_and_rotate(mask, rotate_state, flip_state),
-    )

careamics/utils/normalization.py

@@ -1,55 +0,0 @@
-"""
-Normalization submodule.
-
-These methods are used to normalize and denormalize images.
-"""
-import numpy as np
-
-
-def normalize(img: np.ndarray, mean: float, std: float) -> np.ndarray:
-    """
-    Normalize an image using mean and standard deviation.
-
-    Images are normalised by subtracting the mean and dividing by the standard
-    deviation.
-
-    Parameters
-    ----------
-    img : np.ndarray
-        Image to normalize.
-    mean : float
-        Mean.
-    std : float
-        Standard deviation.
-
-    Returns
-    -------
-    np.ndarray
-        Normalized array.
-    """
-    zero_mean = img - mean
-    return zero_mean / std
-
-
-def denormalize(img: np.ndarray, mean: float, std: float) -> np.ndarray:
-    """
-    Denormalize an image using mean and standard deviation.
-
-    Images are denormalised by multiplying by the standard deviation and adding the
-    mean.
-
-    Parameters
-    ----------
-    img : np.ndarray
-        Image to denormalize.
-    mean : float
-        Mean.
-    std : float
-        Standard deviation.
-
-    Returns
-    -------
-    np.ndarray
-        Denormalized array.
-    """
-    return img * std + mean

careamics/utils/validators.py

@@ -1,170 +0,0 @@
-"""
-Validator functions.
-
-These functions are used to validate dimensions and axes of inputs.
-"""
-from typing import List
-
-import numpy as np
-
-AXES = "STCZYX"
-
-
-def check_axes_validity(axes: str) -> None:
-    """
-    Sanity check on axes.
-
-    The constraints on the axes are the following:
-    - must be a combination of 'STCZYX'
-    - must not contain duplicates
-    - must contain at least 2 contiguous axes: X and Y
-    - must contain at most 4 axes
-    - cannot contain both S and T axes
-    - C is currently not allowed
-
-    Parameters
-    ----------
-    axes : str
-        Axes to validate.
-    """
-    _axes = axes.upper()
-
-    # Minimum is 2 (XY) and maximum is 4 (TZYX)
-    if len(_axes) < 2 or len(_axes) > 4:
-        raise ValueError(
-            f"Invalid axes {axes}. Must contain at least 2 and at most 4 axes."
-        )
-
-    # all characters must be in REF_AXES = 'STCZYX'
-    if not all(s in AXES for s in _axes):
-        raise ValueError(f"Invalid axes {axes}. Must be a combination of {AXES}.")
-
-    # check for repeating characters
-    for i, s in enumerate(_axes):
-        if i != _axes.rfind(s):
-            raise ValueError(
-                f"Invalid axes {axes}. Cannot contain duplicate axes"
-                f" (got multiple {axes[i]})."
-            )
-
-    # currently no implementation for C
-    if "C" in _axes:
-        raise NotImplementedError("Currently, C axis is not supported.")
-
-    # prevent S and T axes at the same time
-    if "T" in _axes and "S" in _axes:
-        raise NotImplementedError(
-            f"Invalid axes {axes}. Cannot contain both S and T axes."
-        )
-
-    # prior: X and Y contiguous (#FancyComments)
-    # right now the next check is invalidating this, but in the future, we might
-    # allow random order of axes (or at least XY and YX)
-    if "XY" not in _axes and "YX" not in _axes:
-        raise ValueError(f"Invalid axes {axes}. X and Y must be contiguous.")
-
-    # check that the axes are in the right order
-    for i, s in enumerate(_axes):
-        if i < len(_axes) - 1:
-            index_s = AXES.find(s)
-            index_next = AXES.find(_axes[i + 1])
-
-            if index_s > index_next:
-                raise ValueError(
-                    f"Invalid axes {axes}. Axes must be in the order {AXES}."
-                )
-
-
-def add_axes(input_array: np.ndarray, axes: str) -> np.ndarray:
-    """
-    Add missing axes to the input, typically batch and channel.
-
-    This method validates the axes first. Then it inspects the input array and add
-    missing dimensions if necessary.
-
-    Parameters
-    ----------
-    input_array : np.ndarray
-        Input array.
-    axes : str
-        Axes to add.
-
-    Returns
-    -------
-    np.ndarray
-        Array with new singleton axes.
-    """
-    # validate axes
-    check_axes_validity(axes)
-
-    # is 3D
-    is_3D = "Z" in axes
-
-    # number of dims
-    n_dims = 5 if is_3D else 4
-
-    # array of dim 2, 3 or 4
-    if len(input_array.shape) < n_dims:
-        if "S" not in axes and "T" not in axes:
-            input_array = input_array[np.newaxis, ...]
-
-        # still missing C dimension
-        if len(input_array.shape) < n_dims:
-            input_array = input_array[:, np.newaxis, ...]
-
-    return input_array
-
-
-def check_tiling_validity(tile_shape: List[int], overlaps: List[int]) -> None:
-    """
-    Check that the tiling parameters are valid.
-
-    Parameters
-    ----------
-    tile_shape : List[int]
-        Shape of the tiles.
-    overlaps : List[int]
-        Overlap between tiles.
-
-    Raises
-    ------
-    ValueError
-        If one of the parameters is None.
-    ValueError
-        If one of the element is zero.
-    ValueError
-        If one of the element is non-divisible by 2.
-    ValueError
-        If the number of elements in `overlaps` and `tile_shape` is different.
-    ValueError
-        If one of the overlaps is larger than the corresponding tile shape.
-    """
-    # cannot be None
-    if tile_shape is None or overlaps is None:
-        raise ValueError(
-            "Cannot use tiling without specifying `tile_shape` and "
-            "`overlaps`, make sure they have been correctly specified."
-        )
-
-    # non-zero and divisible by two
-    for dims_list in [tile_shape, overlaps]:
-        for dim in dims_list:
-            if dim < 1:
-                raise ValueError(f"Entry must be non-null positive (got {dim}).")
-
-            if dim % 2 != 0:
-                raise ValueError(f"Entry must be divisible by 2 (got {dim}).")
-
-    # same length
-    if len(overlaps) != len(tile_shape):
-        raise ValueError(
-            f"Overlaps ({len(overlaps)}) and tile shape ({len(tile_shape)}) must "
-            f"have the same number of dimensions."
-        )
-
-    # overlaps smaller than tile shape
-    for overlap, tile_dim in zip(overlaps, tile_shape):
-        if overlap >= tile_dim:
-            raise ValueError(
-                f"Overlap ({overlap}) must be smaller than tile shape ({tile_dim})."
-            )

careamics/utils/wandb.py

@@ -1,121 +0,0 @@
-"""
-A WandB logger for CAREamics.
-
-Implements a WandB class for use within the Engine.
-"""
-import sys
-from pathlib import Path
-from typing import Dict, Union
-
-import torch
-import wandb
-
-from careamics.config import Configuration
-
-
-def is_notebook() -> bool:
-    """
-    Check if the code is executed from a notebook or a qtconsole.
-
-    Returns
-    -------
-    bool
-        True if the code is executed from a notebooks, False otherwise.
-    """
-    try:
-        from IPython import get_ipython
-
-        shell = get_ipython().__class__.__name__
-        if shell == "ZMQInteractiveShell":
-            return True  # Jupyter notebook or qtconsole
-        else:
-            return False
-    except (NameError, ModuleNotFoundError):
-        return False
-
-
-class WandBLogging:
-    """
-    WandB logging class.
-
-    Parameters
-    ----------
-    experiment_name : str
-        Name of the experiment.
-    log_path : Path
-        Path in which to save the WandB log.
-    config : Configuration
-        Configuration of the model.
-    model_to_watch : torch.nn.Module
-        Model.
-    save_code : bool, optional
-        Whether to save the code, by default True.
-    """
-
-    def __init__(
-        self,
-        experiment_name: str,
-        log_path: Path,
-        config: Configuration,
-        model_to_watch: torch.nn.Module,
-        save_code: bool = True,
-    ):
-        """
-        Constructor.
-
-        Parameters
-        ----------
-        experiment_name : str
-            Name of the experiment.
-        log_path : Path
-            Path in which to save the WandB log.
-        config : Configuration
-            Configuration of the model.
-        model_to_watch : torch.nn.Module
-            Model.
-        save_code : bool, optional
-            Whether to save the code, by default True.
-        """
-        self.run = wandb.init(
-            project="careamics-restoration",
-            dir=log_path,
-            name=experiment_name,
-            config=config.model_dump() if config else None,
-            # save_code=save_code,
-        )
-        if model_to_watch:
-            wandb.watch(model_to_watch, log="all", log_freq=1)
-        if save_code:
-            if is_notebook():
-                # Get all sys path and select the root
-                code_path = Path([p for p in sys.path if "caremics" in p][-1]).parent
-            else:
-                code_path = Path("../")
-            self.log_code(code_path)
-
-    def log_metrics(self, metric_dict: Dict) -> None:
-        """
-        Log metrics to wandb.
-
-        Parameters
-        ----------
-        metric_dict : Dict
-            New metrics entry.
-        """
-        self.run.log(metric_dict, commit=True)
-
-    def log_code(self, code_path: Union[str, Path]) -> None:
-        """
-        Log code to wandb.
-
-        Parameters
-        ----------
-        code_path : Union[str, Path]
-            Path to the code.
-        """
-        self.run.log_code(
-            root=code_path,
-            include_fn=lambda path: path.endswith(".py")
-            or path.endswith(".yml")
-            or path.endswith(".yaml"),
-        )