swcgeom 0.16.0__py3-none-any.whl → 0.17.1__py3-none-any.whl

swcgeom/core/tree_utils_impl.py

@@ -5,7 +5,7 @@ Notes
 Do not import `Tree` and keep this file minimized.
 """
 
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import numpy as np
 import numpy.typing as npt
@@ -15,8 +15,8 @@ from swcgeom.core.swc_utils import Topology, to_sub_topology, traverse
 
 __all__ = ["get_subtree_impl", "to_subtree_impl"]
 
-Mapping = Dict[int, int] | List[int]
-TreeArgs = Tuple[int, Dict[str, npt.NDArray[Any]], str, SWCNames]
+Mapping = dict[int, int] | list[int]
+TreeArgs = tuple[int, dict[str, npt.NDArray[Any]], str, SWCNames]
 
 
 def get_subtree_impl(

swcgeom/images/augmentation.py

@@ -6,7 +6,7 @@ This is expremental code, and the API is subject to change.
 """
 
 import random
-from typing import List, Literal, Optional
+from typing import Literal, Optional
 
 import numpy as np
 import numpy.typing as npt
@@ -54,7 +54,7 @@ class Augmentation:
 
     def swapaxes(self, x, mode: Optional[Literal["xy", "xz", "yz"]] = None) -> NDArrf32:
         if mode is None:
-            modes: List[Literal["xy", "xz", "yz"]] = ["xy", "xz", "yz"]
+            modes: list[Literal["xy", "xz", "yz"]] = ["xy", "xz", "yz"]
             mode = modes[self.rand.randint(0, 2)]
 
         match mode:
@@ -69,7 +69,7 @@ class Augmentation:
 
     def flip(self, x, mode: Optional[Literal["xy", "xz", "yz"]] = None) -> NDArrf32:
         if mode is None:
-            modes: List[Literal["xy", "xz", "yz"]] = ["xy", "xz", "yz"]
+            modes: list[Literal["xy", "xz", "yz"]] = ["xy", "xz", "yz"]
             mode = modes[random.randint(0, 2)]
 
         match mode:

swcgeom/images/folder.py

@@ -4,18 +4,9 @@ import math
 import os
 import re
 import warnings
+from collections.abc import Callable, Iterable
 from dataclasses import dataclass
-from typing import (
-    Callable,
-    Generic,
-    Iterable,
-    List,
-    Literal,
-    Optional,
-    Tuple,
-    TypeVar,
-    overload,
-)
+from typing import Generic, Literal, Optional, TypeVar, overload
 
 import numpy as np
 import numpy.typing as npt
@@ -33,7 +24,7 @@ T = TypeVar("T")
 class ImageStackFolderBase(Generic[ScalarType, T]):
     """Image stack folder base."""
 
-    files: List[str]
+    files: list[str]
     transform: Transform[npt.NDArray[ScalarType], T]
 
     # fmt: off
@@ -61,7 +52,10 @@ class ImageStackFolderBase(Generic[ScalarType, T]):
         return read_imgs(fname, dtype=self.dtype).get_full()  # type: ignore
 
     @staticmethod
-    def scan(root: str, *, pattern: Optional[str] = None) -> List[str]:
+    def scan(root: str, *, pattern: Optional[str] = None) -> list[str]:
+        if not os.path.isdir(root):
+            raise NotADirectoryError(f"not a directory: {root}")
+
         is_valid = re.compile(pattern).match if pattern is not None else truthly
 
         fs = []
@@ -168,13 +162,13 @@ class ImageStackFolder(ImageStackFolderBase[ScalarType, T]):
 class LabeledImageStackFolder(ImageStackFolderBase[ScalarType, T]):
     """Image stack folder with label."""
 
-    labels: List[int]
+    labels: list[int]
 
     def __init__(self, files: Iterable[str], labels: Iterable[int], **kwargs):
         super().__init__(files, **kwargs)
         self.labels = list(labels)
 
-    def __getitem__(self, idx: int) -> Tuple[T, int]:
+    def __getitem__(self, idx: int) -> tuple[T, int]:
         return self._get(self.files[idx]), self.labels[idx]
 
     @classmethod
@@ -205,7 +199,7 @@ class PathImageStackFolder(ImageStackFolderBase[ScalarType, T]):
         super().__init__(files, **kwargs)
         self.root = root
 
-    def __getitem__(self, idx: int) -> Tuple[T, str]:
+    def __getitem__(self, idx: int) -> tuple[T, str]:
         relpath = os.path.relpath(self.files[idx], self.root)
         return self._get(self.files[idx]), relpath
 

swcgeom/images/io.py

@@ -4,20 +4,9 @@ import os
 import re
 import warnings
 from abc import ABC, abstractmethod
+from collections.abc import Callable, Iterable
 from functools import cache, lru_cache
-from typing import (
-    Any,
-    Callable,
-    Generic,
-    Iterable,
-    List,
-    Literal,
-    Optional,
-    Tuple,
-    TypeVar,
-    cast,
-    overload,
-)
+from typing import Any, Generic, Literal, Optional, TypeVar, cast, overload
 
 import nrrd
 import numpy as np
@@ -27,7 +16,7 @@ from v3dpy.loaders import PBD, Raw
 
 __all__ = ["read_imgs", "save_tiff", "read_images"]
 
-Vec3i = Tuple[int, int, int]
+Vec3i = tuple[int, int, int]
 ScalarType = TypeVar("ScalarType", bound=np.generic, covariant=True)
 
 RE_TERAFLY_ROOT = re.compile(r"^RES\((\d+)x(\d+)x(\d+)\)$")
@@ -58,17 +47,17 @@ class ImageStack(ABC, Generic[ScalarType]):
     def __getitem__(self, key: int) -> npt.NDArray[ScalarType]: ...                     # array of shape (Y, Z, C)
     @overload
     @abstractmethod
-    def __getitem__(self, key: Tuple[int, int]) -> npt.NDArray[ScalarType]: ...         # array of shape (Z, C)
+    def __getitem__(self, key: tuple[int, int]) -> npt.NDArray[ScalarType]: ...         # array of shape (Z, C)
     @overload
     @abstractmethod
-    def __getitem__(self, key: Tuple[int, int, int]) -> npt.NDArray[ScalarType]: ...    # array of shape (C,)
+    def __getitem__(self, key: tuple[int, int, int]) -> npt.NDArray[ScalarType]: ...    # array of shape (C,)
     @overload
     @abstractmethod
-    def __getitem__(self, key: Tuple[int, int, int, int]) -> ScalarType: ...            # value
+    def __getitem__(self, key: tuple[int, int, int, int]) -> ScalarType: ...            # value
     @overload
     @abstractmethod
     def __getitem__(
-        self, key: slice | Tuple[slice, slice] | Tuple[slice, slice, slice] |  Tuple[slice, slice, slice, slice],
+        self, key: slice | tuple[slice, slice] | tuple[slice, slice, slice] |  tuple[slice, slice, slice, slice],
     ) -> npt.NDArray[ScalarType]: ... # array of shape (X, Y, Z, C)
     @overload
     @abstractmethod
@@ -95,7 +84,7 @@ class ImageStack(ABC, Generic[ScalarType]):
         return self[:, :, :, :]
 
     @property
-    def shape(self) -> Tuple[int, int, int, int]:
+    def shape(self) -> tuple[int, int, int, int]:
         raise NotImplementedError()
 
 
@@ -107,26 +96,42 @@ def read_imgs(fname: str, *, dtype: None =..., **kwargs) -> ImageStack[np.float3
 # fmt:on
 
 
-def read_imgs(fname: str, *, dtype=None, **kwargs):  # type: ignore
-    """Read image stack."""
+def read_imgs(fname: str, **kwargs):  # type: ignore
+    """Read image stack.
 
-    kwargs["dtype"] = dtype or np.float32
+    Parameters
+    ----------
+    fname : str
+        The path of image stack.
+    dtype : np.dtype, default to `np.float32`
+        Casting data to specified dtype. If integer and float
+        conversions occur, they will be scaled (assuming floats are
+        between 0 and 1).
+    **kwargs : dict[str, Any]
+        Forwarding to the corresponding reader.
+    """
 
-    ext = os.path.splitext(fname)[-1]
-    if ext in [".tif", ".tiff"]:
-        return TiffImageStack(fname, **kwargs)
-    if ext in [".nrrd"]:
-        return NrrdImageStack(fname, **kwargs)
-    if ext in [".v3dpbd"]:
-        return V3dpbdImageStack(fname, **kwargs)
-    if ext in [".v3draw"]:
-        return V3drawImageStack(fname, **kwargs)
-    if ext in [".npy", ".npz"]:
-        return NDArrayImageStack(np.load(fname), **kwargs)
+    kwargs.setdefault("dtype", np.float32)
+    if not os.path.exists(fname):
+        raise ValueError(f"image stack not exists: {fname}")
+
+    # match file extension
+    match os.path.splitext(fname)[-1]:
+        case ".tif" | ".tiff":
+            return TiffImageStack(fname, **kwargs)
+        case ".nrrd":
+            return NrrdImageStack(fname, **kwargs)
+        case ".v3dpbd":
+            return V3dpbdImageStack(fname, **kwargs)
+        case ".v3draw":
+            return V3drawImageStack(fname, **kwargs)
+        case ".npy":
+            return NDArrayImageStack(np.load(fname), **kwargs)
+
+    # try to read as terafly
     if TeraflyImageStack.is_root(fname):
         return TeraflyImageStack(fname, **kwargs)
-    if not os.path.exists(fname):
-        raise ValueError("image stack not exists")
+
     raise ValueError("unsupported image stack")
 
 
@@ -135,7 +140,6 @@ def save_tiff(
     fname: str,
     *,
     dtype: Optional[np.unsignedinteger | np.floating] = None,
-    swap_xy: Optional[bool] = None,
     compression: str | Literal[False] = "zlib",
     **kwargs,
 ) -> None:
@@ -154,7 +158,7 @@ def save_tiff(
         Compression algorithm, forwarding to `tifffile.imwrite`. If no
         algorithnm is specify specified, we will use the zlib algorithm
         with compression level 6 by default.
-    **kwargs : Dict[str, Any]
+    **kwargs : dict[str, Any]
         Forwarding to `tifffile.imwrite`
     """
     if isinstance(data, ImageStack):
@@ -164,17 +168,6 @@ def save_tiff(
         data = np.expand_dims(data, -1)  # (_, _, _)  -> (_, _, _, C), C === 1
 
     axes = "ZXYC"
-    if swap_xy is not None:
-        warnings.warn(
-            "flag `swap_xy` is easy to implement in user space and "
-            "is more flexiable. Since this flag is rarely used, we "
-            "decided to remove it in the next version",
-            DeprecationWarning,
-        )
-        if swap_xy is True:
-            axes = "ZYXC"
-            data = data.swapaxes(0, 1)  # (X, Y, _, _) -> (Y, X, _, _)
-
     assert data.ndim == 4, "should be an array of shape (X, Y, Z, C)"
     assert data.shape[-1] in [1, 3], "support 'miniblack' or 'rgb'"
 
@@ -209,12 +202,7 @@ class NDArrayImageStack(ImageStack[ScalarType]):
     """NDArray image stack."""
 
     def __init__(
-        self,
-        imgs: npt.NDArray[Any],
-        swap_xy: Optional[bool] = None,
-        filp_xy: Optional[bool] = None,
-        *,
-        dtype: ScalarType,
+        self, imgs: npt.NDArray[Any], *, dtype: Optional[ScalarType] = None
     ) -> None:
         super().__init__()
 
@@ -222,34 +210,22 @@ class NDArrayImageStack(ImageStack[ScalarType]):
             imgs = np.expand_dims(imgs, -1)
         assert imgs.ndim == 4, "Should be shape of (X, Y, Z, C)"
 
-        if swap_xy is not None:
-            warnings.warn(
-                "flag `swap_xy` now is unnecessary, tifffile will "
-                "automatically adjust dimensions according to "
-                "`tags.axes`, so this flag will be removed in the next "
-                " version",
-                DeprecationWarning,
-            )
-            if swap_xy is True:
-                imgs = imgs.swapaxes(0, 1)  # (Y, X, _, _) -> (X, Y, _, _)
-
-        if filp_xy is not None:
-            warnings.warn(
-                "flag `filp_xy` is easy to implement in user space and "
-                "is more flexiable. Since this flag is rarely used, we "
-                "decided to remove it in the next version",
-                DeprecationWarning,
-            )
-            if filp_xy is True:
-                imgs = np.flip(imgs, (0, 1))  # (X, Y, Z, C)
+        if dtype is not None:
+            dtype_raw = imgs.dtype
+            if np.issubdtype(dtype, np.floating) and np.issubdtype(
+                dtype_raw, np.unsignedinteger
+            ):
+                sclar_factor = 1.0 / UINT_MAX[dtype_raw]
+                imgs = sclar_factor * imgs.astype(dtype)
+            elif np.issubdtype(dtype, np.unsignedinteger) and np.issubdtype(
+                dtype_raw, np.floating
+            ):
+                sclar_factor = UINT_MAX[dtype]  # type: ignore
+                imgs *= (sclar_factor * imgs).astype(dtype)
+            else:
+                imgs = imgs.astype(dtype)
 
-        dtype_raw = imgs.dtype
-        self.imgs = imgs.astype(dtype)
-        if np.issubdtype(dtype, np.floating) and np.issubdtype(
-            dtype_raw, np.unsignedinteger
-        ):  # TODO: add a option to disable this
-            sclar_factor = 1.0 / UINT_MAX[imgs.dtype]
-            self.imgs *= sclar_factor
+        self.imgs = imgs
 
     def __getitem__(self, key):
         return self.imgs.__getitem__(key)
@@ -258,22 +234,14 @@ class NDArrayImageStack(ImageStack[ScalarType]):
         return self.imgs
 
     @property
-    def shape(self) -> Tuple[int, int, int, int]:
-        return cast(Tuple[int, int, int, int], self.imgs.shape)
+    def shape(self) -> tuple[int, int, int, int]:
+        return cast(tuple[int, int, int, int], self.imgs.shape)
 
 
 class TiffImageStack(NDArrayImageStack[ScalarType]):
     """Tiff image stack."""
 
-    def __init__(
-        self,
-        fname: str,
-        swap_xy: Optional[bool] = None,
-        filp_xy: Optional[bool] = None,
-        *,
-        dtype: ScalarType,
-        **kwargs,
-    ) -> None:
+    def __init__(self, fname: str, *, dtype: ScalarType, **kwargs) -> None:
         with tifffile.TiffFile(fname, **kwargs) as f:
             s = f.series[0]
             imgs, axes = s.asarray(), s.axes
@@ -285,23 +253,15 @@ class TiffImageStack(NDArrayImageStack[ScalarType]):
 
         orders = [AXES_ORDER[c] for c in axes]
         imgs = imgs.transpose(np.argsort(orders))
-        super().__init__(imgs, swap_xy=swap_xy, filp_xy=filp_xy, dtype=dtype)
+        super().__init__(imgs, dtype=dtype)
 
 
 class NrrdImageStack(NDArrayImageStack[ScalarType]):
     """Nrrd image stack."""
 
-    def __init__(
-        self,
-        fname: str,
-        swap_xy: Optional[bool] = None,
-        filp_xy: Optional[bool] = None,
-        *,
-        dtype: ScalarType,
-        **kwargs,
-    ) -> None:
+    def __init__(self, fname: str, *, dtype: ScalarType, **kwargs) -> None:
         imgs, header = nrrd.read(fname, **kwargs)
-        super().__init__(imgs, swap_xy=swap_xy, filp_xy=filp_xy, dtype=dtype)
+        super().__init__(imgs, dtype=dtype)
         self.header = header
 
 
@@ -353,7 +313,7 @@ class TeraflyImageStack(ImageStack[ScalarType]):
     use its coordinate system, remember to FLIP Y-AXIS BACK.
     """
 
-    _listdir: Callable[[str], List[str]]
+    _listdir: Callable[[str], list[str]]
     _read_patch: Callable[[str], npt.NDArray]
 
     def __init__(
@@ -379,12 +339,17 @@ class TeraflyImageStack(ImageStack[ScalarType]):
         self.res, self.res_dirs, self.res_patch_sizes = self.get_resolutions(root)
 
         @cache
-        def listdir(path: str) -> List[str]:
+        def listdir(path: str) -> list[str]:
             return os.listdir(path)
 
         @lru_cache(maxsize=lru_maxsize)
         def read_patch(path: str) -> npt.NDArray[ScalarType]:
-            return read_imgs(path, dtype=dtype).get_full()
+            match os.path.splitext(path)[-1]:
+                case "raw":
+                    # Treat it as a v3draw file
+                    return V3drawImageStack(path, dtype=dtype).get_full()
+                case _:
+                    return read_imgs(path, dtype=dtype).get_full()
 
         self._listdir, self._read_patch = listdir, read_patch
 
@@ -453,19 +418,19 @@ class TeraflyImageStack(ImageStack[ScalarType]):
         raise NotImplementedError()  # TODO
 
     @property
-    def shape(self) -> Tuple[int, int, int, int]:
+    def shape(self) -> tuple[int, int, int, int]:
         res_max = self.res[-1]
         return res_max[0], res_max[1], res_max[2], 1
 
     @classmethod
-    def get_resolutions(cls, root: str) -> Tuple[List[Vec3i], List[str], List[Vec3i]]:
+    def get_resolutions(cls, root: str) -> tuple[list[Vec3i], list[str], list[Vec3i]]:
         """Get all resolutions.
 
         Returns
         -------
         resolutions : List of (int, int, int)
             Sequence of sorted resolutions (from small to large).
-        roots : List[str]
+        roots : list[str]
             Sequence of root of resolutions respectively.
         patch_sizes : List of (int, int, int)
             Sequence of patch size of resolutions respectively.
@@ -605,7 +570,7 @@ class GrayImageStack:
     @overload
     def __getitem__(self, key: npt.NDArray[np.integer[Any]]) -> np.float32: ...
     @overload
-    def __getitem__(self, key: slice | Tuple[slice, slice] | Tuple[slice, slice, slice]) -> npt.NDArray[np.float32]: ...
+    def __getitem__(self, key: slice | tuple[slice, slice] | tuple[slice, slice, slice]) -> npt.NDArray[np.float32]: ...
     # fmt: on
     def __getitem__(self, key):
         """Get pixel/patch of image stack."""
@@ -632,7 +597,7 @@ class GrayImageStack:
         return self.imgs.get_full()[:, :, :, 0]
 
     @property
-    def shape(self) -> Tuple[int, int, int]:
+    def shape(self) -> tuple[int, int, int]:
         return self.imgs.shape[:-1]
 
 

swcgeom/transforms/image_stack.py

@@ -12,7 +12,8 @@ pip install swcgeom[all]
 import os
 import re
 import time
-from typing import Iterable, List, Optional, Tuple
+from collections.abc import Iterable
+from typing import Optional
 
 import numpy as np
 import numpy.typing as npt
@@ -69,7 +70,7 @@ class ToImageStack(Transform[Tree, npt.NDArray[np.uint8]]):
         x: Tree,
         verbose: bool = True,
         *,
-        ranges: Optional[Tuple[npt.ArrayLike, npt.ArrayLike]] = None,
+        ranges: Optional[tuple[npt.ArrayLike, npt.ArrayLike]] = None,
     ) -> Iterable[npt.NDArray[np.uint8]]:
         if verbose:
             print("To image stack: " + x.source)
@@ -133,7 +134,7 @@ class ToImageStack(Transform[Tree, npt.NDArray[np.uint8]]):
         scene = ObjectsScene()
         scene.set_background((0, 0, 0))
 
-        def leave(n: Tree.Node, children: List[Tree.Node]) -> Tree.Node:
+        def leave(n: Tree.Node, children: list[Tree.Node]) -> Tree.Node:
             for c in children:
                 sdf = RoundCone(_tp3f(n.xyz()), _tp3f(c.xyz()), n.r, c.r).into()
                 scene.add_object(SDFObject(sdf, material).into())
@@ -175,7 +176,7 @@ class ToImageStack(Transform[Tree, npt.NDArray[np.uint8]]):
     def save_tif(
         fname: str,
         frames: Iterable[npt.NDArray[np.uint8]],
-        resolution: Tuple[float, float] = (1, 1),
+        resolution: tuple[float, float] = (1, 1),
     ) -> None:
         with tifffile.TiffWriter(fname) as tif:
             for frame in frames:
@@ -191,7 +192,7 @@ class ToImageStack(Transform[Tree, npt.NDArray[np.uint8]]):
                 )
 
 
-def _tp3f(x: npt.NDArray) -> Tuple[float, float, float]:
+def _tp3f(x: npt.NDArray) -> tuple[float, float, float]:
     """Convert to tuple of 3 floats."""
     assert len(x) == 3
     return (float(x[0]), float(x[1]), float(x[2]))

swcgeom/transforms/images.py

@@ -1,19 +1,22 @@
 """Image stack related transform."""
 
 import warnings
-from typing import Tuple
 
 import numpy as np
 import numpy.typing as npt
 
-from swcgeom.transforms.base import Transform
+from swcgeom.transforms.base import Identity, Transform
 
 __all__ = [
     "ImagesCenterCrop",
     "ImagesScale",
     "ImagesClip",
+    "ImagesFlip",
+    "ImagesFlipY",
     "ImagesNormalizer",
     "ImagesMeanVarianceAdjustment",
+    "ImagesScaleToUnitRange",
+    "ImagesHistogramEqualization",
     "Center",  # legacy
 ]
 
@@ -24,7 +27,7 @@ NDArrayf32 = npt.NDArray[np.float32]
 class ImagesCenterCrop(Transform[NDArrayf32, NDArrayf32]):
     """Get image stack center."""
 
-    def __init__(self, shape_out: int | Tuple[int, int, int]):
+    def __init__(self, shape_out: int | tuple[int, int, int]):
         super().__init__()
         self.shape_out = (
             shape_out
@@ -45,11 +48,11 @@ class ImagesCenterCrop(Transform[NDArrayf32, NDArrayf32]):
 class Center(ImagesCenterCrop):
     """Get image stack center.
 
-    .. deprecated:: 0.5.0
+    .. deprecated:: 0.16.0
         Use :class:`ImagesCenterCrop` instead.
     """
 
-    def __init__(self, shape_out: int | Tuple[int, int, int]):
+    def __init__(self, shape_out: int | tuple[int, int, int]):
         warnings.warn(
             "`Center` is deprecated, use `ImagesCenterCrop` instead",
             DeprecationWarning,
@@ -66,6 +69,9 @@ class ImagesScale(Transform[NDArrayf32, NDArrayf32]):
     def __call__(self, x: NDArrayf32) -> NDArrayf32:
         return self.scaler * x
 
+    def extra_repr(self) -> str:
+        return f"scaler={self.scaler}"
+
 
 class ImagesClip(Transform[NDArrayf32, NDArrayf32]):
     def __init__(self, vmin: float = 0, vmax: float = 1, /) -> None:
@@ -75,6 +81,41 @@ class ImagesClip(Transform[NDArrayf32, NDArrayf32]):
     def __call__(self, x: NDArrayf32) -> NDArrayf32:
         return np.clip(x, self.vmin, self.vmax)
 
+    def extra_repr(self) -> str:
+        return f"vmin={self.vmin}, vmax={self.vmax}"
+
+
+class ImagesFlip(Transform[NDArrayf32, NDArrayf32]):
+    """Flip image stack along axis."""
+
+    def __init__(self, axis: int, /) -> None:
+        super().__init__()
+        self.axis = axis
+
+    def __call__(self, x: NDArrayf32) -> NDArrayf32:
+        return np.flip(x, axis=self.axis)
+
+    def extra_repr(self) -> str:
+        return f"axis={self.axis}"
+
+
+class ImagesFlipY(ImagesFlip):
+    """Flip image stack along Y-axis.
+
+    See Also
+    --------
+    ~.images.io.TeraflyImageStack:
+        Terafly and Vaa3d use a especial right-handed coordinate system
+        (with origin point in the left-top and z-axis points front),
+        but we flip y-axis to makes it a left-handed coordinate system
+        (with orgin point in the left-bottom and z-axis points front).
+        If you need to use its coordinate system, remember to FLIP
+        Y-AXIS BACK.
+    """
+
+    def __init__(self, axis: int = 1, /) -> None:
+        super().__init__(axis)  # (X, Y, Z, C)
+
 
 class ImagesNormalizer(Transform[NDArrayf32, NDArrayf32]):
     """Normalize image stack."""
@@ -100,3 +141,62 @@ class ImagesMeanVarianceAdjustment(Transform[NDArrayf32, NDArrayf32]):
 
     def __call__(self, x: NDArrayf32) -> NDArrayf32:
         return (x - self.mean) / self.variance
+
+    def extra_repr(self) -> str:
+        return f"mean={self.mean}, variance={self.variance}"
+
+
+class ImagesScaleToUnitRange(Transform[NDArrayf32, NDArrayf32]):
+    """Scale image stack to unit range."""
+
+    def __init__(self, vmin: float, vmax: float, *, clip: bool = True) -> None:
+        """Scale image stack to unit range.
+
+        Parameters
+        ----------
+        vmin : float
+            Minimum value.
+        vmax : float
+            Maximum value.
+        clip : bool, default True
+            Clip values to [0, 1] to avoid numerical issues.
+        """
+
+        super().__init__()
+        self.vmin = vmin
+        self.vmax = vmax
+        self.diff = vmax - vmin
+        self.clip = clip
+        self.post = ImagesClip(0, 1) if self.clip else Identity()
+
+    def __call__(self, x: NDArrayf32) -> NDArrayf32:
+        return self.post((x - self.vmin) / self.diff)
+
+    def extra_repr(self) -> str:
+        return f"vmin={self.vmin}, vmax={self.vmax}, clip={self.clip}"
+
+
+class ImagesHistogramEqualization(Transform[NDArrayf32, NDArrayf32]):
+    """Image histogram equalization.
+
+    References
+    ----------
+    http://www.janeriksolem.net/histogram-equalization-with-python-and.html
+    """
+
+    def __init__(self, bins: int = 256) -> None:
+        super().__init__()
+        self.bins = bins
+
+    def __call__(self, x: NDArrayf32) -> NDArrayf32:
+        # get image histogram
+        hist, bin_edges = np.histogram(x.flatten(), self.bins, density=True)
+        cdf = hist.cumsum()  # cumulative distribution function
+        cdf = cdf / cdf[-1]  # normalize
+
+        # use linear interpolation of cdf to find new pixel values
+        equalized = np.interp(x.flatten(), bin_edges[:-1], cdf)
+        return equalized.reshape(x.shape).astype(np.float32)
+
+    def extra_repr(self) -> str:
+        return f"bins={self.bins}"