careamics 0.0.8__py3-none-any.whl → 0.0.10__py3-none-any.whl

careamics/dataset_ng/demo_dataset.ipynb

@@ -0,0 +1,271 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import skimage\n",
+    "import tifffile\n",
+    "\n",
+    "from careamics.config import create_n2n_configuration\n",
+    "from careamics.dataset_ng.dataset.dataset import CareamicsDataset, Mode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "example_data = skimage.data.human_mitosis()\n",
+    "\n",
+    "markers = np.zeros_like(example_data)\n",
+    "markers[example_data < 25] = 1\n",
+    "markers[example_data > 50] = 2\n",
+    "\n",
+    "elevation_map = skimage.filters.sobel(example_data)\n",
+    "segmentation = skimage.segmentation.watershed(elevation_map, markers)\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 2)\n",
+    "ax[0].imshow(example_data)\n",
+    "ax[1].imshow(segmentation)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2",
+   "metadata": {},
+   "source": [
+    "### 1. From an array "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 1. Train val from an array\n",
+    "\n",
+    "train_data_config = create_n2n_configuration(\n",
+    "    \"test_exp\",\n",
+    "    data_type=\"array\",\n",
+    "    axes=\"YX\",\n",
+    "    patch_size=(32, 32),\n",
+    "    batch_size=1,\n",
+    "    num_epochs=1,\n",
+    ").data_config\n",
+    "\n",
+    "val_data_config = create_n2n_configuration(\n",
+    "    \"test_exp\",\n",
+    "    data_type=\"array\",\n",
+    "    axes=\"YX\",\n",
+    "    patch_size=(32, 32),\n",
+    "    batch_size=1,\n",
+    "    num_epochs=1,\n",
+    "    augmentations=[],\n",
+    ").data_config\n",
+    "\n",
+    "\n",
+    "train_dataset = CareamicsDataset(\n",
+    "    data_config=train_data_config,\n",
+    "    mode=Mode.TRAINING,\n",
+    "    inputs=[example_data],\n",
+    "    targets=[segmentation],\n",
+    ")\n",
+    "val_dataset = CareamicsDataset(\n",
+    "    data_config=val_data_config,\n",
+    "    mode=Mode.VALIDATING,\n",
+    "    inputs=[example_data],\n",
+    "    targets=[segmentation],\n",
+    ")\n",
+    "\n",
+    "fig, ax = plt.subplots(2, 5, figsize=(10, 5))\n",
+    "ax[0, 0].set_title(\"Train input\")\n",
+    "ax[1, 0].set_title(\"Train target\")\n",
+    "for i in range(5):\n",
+    "    sample, target = train_dataset[i]\n",
+    "    ax[0, i].imshow(sample.data[0])\n",
+    "    ax[1, i].imshow(target.data[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4",
+   "metadata": {},
+   "source": [
+    "### 2. From tiff "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tifffile.imwrite(\"example_data1.tiff\", example_data)\n",
+    "tifffile.imwrite(\"example_target1.tiff\", segmentation)\n",
+    "tifffile.imwrite(\"example_data2.tiff\", example_data[:256, :256])\n",
+    "tifffile.imwrite(\"example_target2.tiff\", segmentation[:256, :256])\n",
+    "\n",
+    "train_data_config = create_n2n_configuration(\n",
+    "    \"test_exp\",\n",
+    "    data_type=\"tiff\",\n",
+    "    axes=\"YX\",\n",
+    "    patch_size=(32, 32),\n",
+    "    batch_size=1,\n",
+    "    num_epochs=1,\n",
+    ").data_config\n",
+    "\n",
+    "val_data_config = create_n2n_configuration(\n",
+    "    \"test_exp\",\n",
+    "    data_type=\"tiff\",\n",
+    "    axes=\"YX\",\n",
+    "    patch_size=(32, 32),\n",
+    "    batch_size=1,\n",
+    "    num_epochs=1,\n",
+    "    augmentations=[],\n",
+    ").data_config\n",
+    "\n",
+    "data = sorted(Path(\"./\").glob(\"example_data*.tiff\"))\n",
+    "targets = sorted(Path(\"./\").glob(\"example_target*.tiff\"))\n",
+    "train_dataset = CareamicsDataset(\n",
+    "    data_config=train_data_config, inputs=data, targets=targets\n",
+    ")\n",
+    "val_dataset = CareamicsDataset(\n",
+    "    data_config=val_data_config, inputs=data, targets=targets\n",
+    ")\n",
+    "\n",
+    "fig, ax = plt.subplots(2, 5, figsize=(10, 5))\n",
+    "ax[0, 0].set_title(\"Train input\")\n",
+    "ax[1, 0].set_title(\"Train target\")\n",
+    "for i in range(5):\n",
+    "    sample, target = train_dataset[i]\n",
+    "    ax[0, i].imshow(sample.data[0])\n",
+    "    ax[1, i].imshow(target.data[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6",
+   "metadata": {},
+   "source": [
+    "### 3. Prediction from array"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from careamics.config import InferenceConfig\n",
+    "\n",
+    "prediction_config = InferenceConfig(\n",
+    "    data_type=\"array\",\n",
+    "    tile_size=(32, 32),\n",
+    "    tile_overlap=(16, 16),\n",
+    "    axes=\"YX\",\n",
+    "    image_means=(example_data.mean(),),\n",
+    "    image_stds=(example_data.std(),),\n",
+    "    tta_transforms=False,\n",
+    "    batch_size=1,\n",
+    ")\n",
+    "prediction_dataset = CareamicsDataset(\n",
+    "    data_config=prediction_config, mode=Mode.PREDICTING, inputs=[example_data]\n",
+    ")\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 5, figsize=(10, 5))\n",
+    "ax[0].set_title(\"Prediction input\")\n",
+    "for i in range(5):\n",
+    "    sample, _ = prediction_dataset[i]\n",
+    "    ax[i].imshow(sample.data[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8",
+   "metadata": {},
+   "source": [
+    "### 4. From custom data type "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data_config = create_n2n_configuration(\n",
+    "    \"test_exp\",\n",
+    "    data_type=\"custom\",\n",
+    "    axes=\"YX\",\n",
+    "    patch_size=(32, 32),\n",
+    "    batch_size=1,\n",
+    "    num_epochs=1,\n",
+    ").data_config\n",
+    "\n",
+    "\n",
+    "def read_data_func_test(data):\n",
+    "    return 255 - example_data\n",
+    "\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 5, figsize=(10, 5))\n",
+    "train_dataset = CareamicsDataset(\n",
+    "    data_config=train_data_config,\n",
+    "    mode=Mode.TRAINING,\n",
+    "    inputs=[example_data],\n",
+    "    targets=[segmentation],\n",
+    "    read_func=read_data_func_test,\n",
+    "    read_kwargs={}\n",
+    ")\n",
+    "\n",
+    "for i in range(5):\n",
+    "    sample, _ = train_dataset[i]\n",
+    "    ax[i].imshow(sample.data[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

careamics/dataset_ng/demo_patch_extractor.py

@@ -0,0 +1,53 @@
+# %%
+import numpy as np
+
+# %%
+from careamics.config.support import SupportedData
+from careamics.dataset_ng.patch_extractor import create_patch_extractor
+from careamics.dataset_ng.patch_extractor.image_stack import InMemoryImageStack
+from careamics.dataset_ng.patching_strategies import RandomPatchingStrategy
+
+# %%
+array = np.arange(36).reshape(6, 6)
+image_stack = InMemoryImageStack.from_array(data=array, axes="YX")
+image_stack.extract_patch(sample_idx=0, coords=(2, 2), patch_size=(3, 3))
+
+# %%
+rng = np.random.default_rng()
+
+# %%
+# define example data
+array1 = np.arange(36).reshape(1, 6, 6)
+array2 = np.arange(50).reshape(2, 5, 5)
+target1 = rng.integers(0, 1, size=array1.shape, endpoint=True)
+target2 = rng.integers(0, 1, size=array2.shape, endpoint=True)
+
+# %%
+print(array1)
+print(array2)
+print(target1)
+print(target2)
+
+# %%
+# define example readers
+input_patch_extractor = create_patch_extractor(
+    [array1, array2], axes="SYX", data_type=SupportedData.ARRAY
+)
+target_patch_extractor = create_patch_extractor(
+    [target1, target2], axes="SYX", data_type=SupportedData.ARRAY
+)
+
+# %%
+# generate random patch specification
+data_shapes = [
+    image_stack.data_shape for image_stack in input_patch_extractor.image_stacks
+]
+patch_specs_generator = RandomPatchingStrategy(data_shapes, patch_size=(2, 2))
+patch_specs = patch_specs_generator.get_patch_spec(18)
+
+# %%
+# extract a subset of patches
+input_patch_extractor.extract_patch(**patch_specs)
+
+# %%
+target_patch_extractor.extract_patch(**patch_specs)

careamics/dataset_ng/demo_patch_extractor_factory.py

@@ -0,0 +1,37 @@
+# %%
+import numpy as np
+
+from careamics.config import create_n2n_configuration
+from careamics.config.support import SupportedData
+from careamics.dataset_ng.patch_extractor.patch_extractor_factory import (
+    create_patch_extractors,
+)
+
+rng = np.random.default_rng()
+
+# %%
+# define example data
+array1 = np.arange(36).reshape(1, 6, 6)
+array2 = np.arange(50).reshape(2, 5, 5)
+target1 = rng.integers(0, 1, size=array1.shape, endpoint=True)
+target2 = rng.integers(0, 1, size=array2.shape, endpoint=True)
+
+# %%
+config = create_n2n_configuration(
+    "test_exp",
+    data_type="array",
+    axes="SYX",
+    patch_size=[8, 8],
+    batch_size=1,
+    num_epochs=1,
+)
+data_config = config.data_config
+
+# %%
+data_type = SupportedData(data_config.data_type)
+train_inputs, train_targets = create_patch_extractors(
+    [array1, array2], [target1, target2], axes=data_config.axes, data_type=data_type
+)
+
+# %%
+train_inputs.extract_patch(data_idx=0, sample_idx=0, coords=(2, 2), patch_size=(3, 3))

careamics/dataset_ng/patch_extractor/__init__.py

@@ -0,0 +1,10 @@
+__all__ = [
+    "ImageStackLoader",
+    "PatchExtractor",
+    "create_patch_extractor",
+    "get_image_stack_loader",
+]
+
+from .image_stack_loader import ImageStackLoader, get_image_stack_loader
+from .patch_extractor import PatchExtractor
+from .patch_extractor_factory import create_patch_extractor

careamics/dataset_ng/patch_extractor/demo_custom_image_stack_loader.py

@@ -0,0 +1,111 @@
+# %%
+from collections.abc import Sequence
+from pathlib import Path
+from typing import TypedDict
+
+import matplotlib.pyplot as plt
+import numpy as np
+import zarr
+from numpy.typing import NDArray
+from zarr.storage import FSStore
+
+from careamics.config import DataConfig
+from careamics.config.support import SupportedData
+from careamics.dataset_ng.patch_extractor import create_patch_extractor
+from careamics.dataset_ng.patch_extractor.image_stack import ZarrImageStack
+from careamics.dataset_ng.patch_extractor.image_stack_loader import ImageStackLoader
+
+
+# %%
+def create_zarr_array(file_path: Path, data_path: str, data: NDArray):
+    store = FSStore(url=file_path.resolve())
+    # create array
+    array = zarr.create(
+        store=store,
+        shape=data.shape,
+        chunks=data.shape,  # only 1 chunk
+        dtype=np.uint16,
+        path=data_path,
+    )
+    # write data
+    array[...] = data
+    store.close()
+
+
+def create_zarr(file_path: Path, data_paths: Sequence[str], data: Sequence[NDArray]):
+    for data_path, array in zip(data_paths, data):
+        create_zarr_array(file_path=file_path, data_path=data_path, data=array)
+
+
+# %% [markdown]
+# ### Create example ZARR file
+
+# %%
+dir_path = Path("/home/melisande.croft/Documents/Data")
+file_name = "test_ngff_image.zarr"
+file_path = dir_path / file_name
+
+data_paths = [
+    "image_1",
+    "group_1/image_1.1",
+    "group_1/image_1.2",
+]
+data_shapes = [(1, 3, 64, 64), (1, 3, 32, 48), (1, 3, 32, 32)]
+data = [np.random.randint(1, 255, size=shape, dtype=np.uint8) for shape in data_shapes]
+if not file_path.is_file() and not file_path.is_dir():
+    create_zarr(file_path, data_paths, data)
+
+# %% [markdown]
+# ### Make sure file exists
+
+# %%
+store = FSStore(url=file_path.resolve(), mode="r")
+
+# %%
+list(store.keys())
+
+# %% [markdown]
+# ### Define custom loading function
+
+
+# %%
+class ZarrSource(TypedDict):
+    store: FSStore
+    data_paths: Sequence[str]
+
+
+def custom_image_stack_loader(source: ZarrSource, axes: str, *args, **kwargs):
+    image_stacks = [
+        ZarrImageStack(store=source["store"], data_path=data_path, axes=axes)
+        for data_path in source["data_paths"]
+    ]
+    return image_stacks
+
+
+# %% [markdown]
+# ### Test custom loading func
+
+# %%
+# dummy data config
+data_config = DataConfig(data_type="custom", patch_size=[64, 64], axes="SCYX")
+
+# %%
+image_stack_loader: ImageStackLoader = custom_image_stack_loader
+
+# %%
+# So pylance knows that datatype is custom to match function overloads
+assert data_config.data_type is SupportedData.CUSTOM
+
+patch_extractor = create_patch_extractor(
+    source={"store": store, "data_paths": data_paths},
+    axes=data_config.axes,
+    data_type=data_config.data_type,
+    image_stack_loader=custom_image_stack_loader,
+)
+
+# %%
+# extract patch and display
+patch = patch_extractor.extract_patch(2, 0, (8, 16), (16, 16))
+plt.imshow(np.moveaxis(patch, 0, -1))
+
+# %%

careamics/dataset_ng/patch_extractor/image_stack/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+    "ImageStack",
+    "InMemoryImageStack",
+    "ZarrImageStack",
+]
+
+from .image_stack_protocol import ImageStack
+from .in_memory_image_stack import InMemoryImageStack
+from .zarr_image_stack import ZarrImageStack

careamics/dataset_ng/patch_extractor/image_stack/image_stack_protocol.py

@@ -0,0 +1,53 @@
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Literal, Protocol, Union
+
+from numpy.typing import DTypeLike, NDArray
+
+
+class ImageStack(Protocol):
+    """
+    An interface for extracting patches from an image stack.
+
+    Attributes
+    ----------
+    source: Path or "array"
+        Origin of the image data.
+    data_shape: Sequence[int]
+        The shape of the data, it is expected to be in the order (SC(Z)YX).
+
+    """
+
+    # TODO: not sure how compatible using Path will be for a zarr array
+    #   (for a zarr array need to specify file path and internal zarr path)
+    @property
+    def source(self) -> Union[Path, Literal["array"]]: ...
+
+    @property
+    def data_shape(self) -> Sequence[int]: ...
+
+    @property
+    def data_dtype(self) -> DTypeLike: ...
+
+    def extract_patch(
+        self, sample_idx: int, coords: Sequence[int], patch_size: Sequence[int]
+    ) -> NDArray:
+        """
+        Extracts a patch for a given sample within the image stack.
+
+        Parameters
+        ----------
+        sample_idx: int
+            Sample index. The first dimension of the image data will be indexed at this
+            value.
+        coords: Sequence of int
+            The coordinates that define the start of a patch.
+        patch_size: Sequence of int
+            The size of the patch in each spatial dimension.
+
+        Returns
+        -------
+        numpy.ndarray
+            A patch of the image data from a particlular sample. It will have the
+            dimensions C(Z)YX.
+        """

careamics/dataset_ng/patch_extractor/image_stack/in_memory_image_stack.py

@@ -0,0 +1,55 @@
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any, Literal, Union
+
+from numpy.typing import DTypeLike, NDArray
+from typing_extensions import Self
+
+from careamics.dataset.dataset_utils import reshape_array
+from careamics.file_io.read import ReadFunc, read_tiff
+
+
+class InMemoryImageStack:
+    """
+    A class for extracting patches from an image stack that has been loaded into memory.
+    """
+
+    def __init__(self, source: Union[Path, Literal["array"]], data: NDArray):
+        self.source: Union[Path, Literal["array"]] = source
+        # data expected to be in SC(Z)YX shape, reason to use from_array constructor
+        self._data: NDArray = data
+        self.data_shape: Sequence[int] = self._data.shape
+        self.data_dtype: DTypeLike = self._data.dtype
+
+    def extract_patch(
+        self, sample_idx: int, coords: Sequence[int], patch_size: Sequence[int]
+    ) -> NDArray:
+        if len(coords) != len(patch_size):
+            raise ValueError("Length of coords and extent must match.")
+        # TODO: test for 2D or 3D?
+        return self._data[
+            (
+                sample_idx,  # type: ignore
+                ...,  # type: ignore
+                *[slice(c, c + e) for c, e in zip(coords, patch_size)],  # type: ignore
+            )
+        ]
+
+    @classmethod
+    def from_array(cls, data: NDArray, axes: str) -> Self:
+        data = reshape_array(data, axes)
+        return cls(source="array", data=data)
+
+    @classmethod
+    def from_tiff(cls, path: Path, axes: str) -> Self:
+        data = read_tiff(path)
+        data = reshape_array(data, axes)
+        return cls(source=path, data=data)
+
+    @classmethod
+    def from_custom_file_type(
+        cls, path: Path, axes: str, read_func: ReadFunc, **read_kwargs: Any
+    ) -> Self:
+        data = read_func(path, **read_kwargs)
+        data = reshape_array(data, axes)
+        return cls(source=path, data=data)