swcgeom 0.18.1__py3-none-any.whl → 0.19.0__py3-none-any.whl

swcgeom/images/io.py

@@ -21,7 +21,7 @@ import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable
 from functools import cache, lru_cache
-from typing import Any, Generic, Literal, Optional, TypeVar, cast, overload
+from typing import Any, Generic, Literal, TypeVar, cast, overload
 
 import nrrd
 import numpy as np
@@ -39,10 +39,10 @@ RE_TERAFLY_ROOT = re.compile(r"^RES\((\d+)x(\d+)x(\d+)\)$")
 RE_TERAFLY_NAME = re.compile(r"^\d+(_\d+)?(_\d+)?")
 
 UINT_MAX = {
-    np.dtype(np.uint8): (2**8) - 1,  # type: ignore
-    np.dtype(np.uint16): (2**16) - 1,  # type: ignore
-    np.dtype(np.uint32): (2**32) - 1,  # type: ignore
-    np.dtype(np.uint64): (2**64) - 1,  # type: ignore
+    np.dtype(np.uint8): (2**8) - 1,
+    np.dtype(np.uint16): (2**16) - 1,
+    np.dtype(np.uint32): (2**32) - 1,
+    np.dtype(np.uint64): (2**64) - 1,
 }
 
 AXES_ORDER = {
@@ -83,19 +83,15 @@ class ImageStack(ABC, Generic[ScalarType]):
     def __getitem__(self, key):
         """Get pixel/patch of image stack.
 
-        Returns
-        -------
-        value : ndarray of f32
-            NDArray which shape depends on key. If key is tuple of ints,
+        Returns:
+            value: NDArray which shape depends on key. If key is tuple of ints,
         """
         raise NotImplementedError()
 
     def get_full(self) -> npt.NDArray[ScalarType]:
         """Get full image stack.
 
-        Notes
-        -----
-        this will load the full image stack into memory.
+        NOTE: this will load the full image stack into memory.
         """
         return self[:, :, :, :]
 
@@ -104,29 +100,20 @@ class ImageStack(ABC, Generic[ScalarType]):
         raise NotImplementedError()
 
 
-# fmt:off
 @overload
 def read_imgs(fname: str, *, dtype: ScalarType, **kwargs) -> ImageStack[ScalarType]: ...
 @overload
-def read_imgs(fname: str, *, dtype: None =..., **kwargs) -> ImageStack[np.float32]: ...
-# fmt:on
-
-
+def read_imgs(fname: str, *, dtype: None = ..., **kwargs) -> ImageStack[np.float32]: ...
 def read_imgs(fname: str, **kwargs):  # type: ignore
     """Read image stack.
 
-    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.
+    Args:
+        fname: The path of image stack.
+        dtype: Casting data to specified dtype.
+            If integer and float conversions occur, they will be scaled (assuming floats
+            are between 0 and 1). Default to `np.float32`.
+        **kwargs: Forwarding to the corresponding reader.
     """
-
     kwargs.setdefault("dtype", np.float32)
     if not os.path.exists(fname):
         raise ValueError(f"image stack not exists: {fname}")
@@ -155,27 +142,22 @@ def save_tiff(
     data: npt.NDArray | ImageStack,
     fname: str,
     *,
-    dtype: Optional[np.unsignedinteger | np.floating] = None,
+    dtype: np.unsignedinteger | np.floating | None = None,
     compression: str | Literal[False] = "zlib",
     **kwargs,
 ) -> None:
     """Save image stack as tiff.
 
-    Parameters
-    ----------
-    data : array
-        The image stack.
-    fname : str
-    dtype : np.dtype, optional
-        Casting data to specified dtype. If integer and float
-        conversions occur, they will be scaled (assuming floats are
-        between 0 and 1).
-    compression : str | False, default `zlib`
-        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]
-        Forwarding to `tifffile.imwrite`
+    Args:
+        data: The image stack.
+        fname: str
+        dtype: Casting data to specified dtype.
+            If integer and float conversions occur, they will be scaled (assuming
+            floats are between 0 and 1).
+        compression: 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: Forwarding to `tifffile.imwrite`
     """
     if isinstance(data, ImageStack):
         data = data.get_full()  # TODO: avoid load full imgs to memory
@@ -191,11 +173,11 @@ def save_tiff(
         if np.issubdtype(data.dtype, np.floating) and np.issubdtype(
             dtype, np.unsignedinteger
         ):
-            scaler_factor = UINT_MAX[np.dtype(dtype)]  # type: ignore
+            scaler_factor = UINT_MAX[np.dtype(dtype)]
         elif np.issubdtype(data.dtype, np.unsignedinteger) and np.issubdtype(
             dtype, np.floating
         ):
-            scaler_factor = 1 / UINT_MAX[np.dtype(data.dtype)]  # type: ignore
+            scaler_factor = 1 / UINT_MAX[np.dtype(data.dtype)]
         else:
             scaler_factor = 1
 
@@ -218,7 +200,7 @@ class NDArrayImageStack(ImageStack[ScalarType]):
     """NDArray image stack."""
 
     def __init__(
-        self, imgs: npt.NDArray[Any], *, dtype: Optional[ScalarType] = None
+        self, imgs: npt.NDArray[Any], *, dtype: ScalarType | None = None
     ) -> None:
         super().__init__()
 
@@ -231,13 +213,13 @@ class NDArrayImageStack(ImageStack[ScalarType]):
             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)
+                scalar_factor = 1.0 / UINT_MAX[dtype_raw]
+                imgs = scalar_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)
+                scalar_factor = UINT_MAX[dtype]
+                imgs *= (scalar_factor * imgs).astype(dtype)
             else:
                 imgs = imgs.astype(dtype)
 
@@ -284,27 +266,23 @@ class NrrdImageStack(NDArrayImageStack[ScalarType]):
 class V3dImageStack(NDArrayImageStack[ScalarType]):
     """v3d image stack."""
 
-    def __init__(
-        self, fname: str, loader: Raw | PBD, *, dtype: ScalarType, **kwargs
-    ) -> None:
-        r = loader()
+    def __init_subclass__(cls, loader: Raw | PBD) -> None:
+        super().__init_subclass__()
+        cls._loader = loader
+
+    def __init__(self, fname: str, *, dtype: ScalarType, **kwargs) -> None:
+        r = self._loader()
         imgs = r.load(fname)
         super().__init__(imgs, dtype=dtype, **kwargs)
 
 
-class V3drawImageStack(V3dImageStack[ScalarType]):
+class V3drawImageStack(V3dImageStack[ScalarType], loader=Raw):
     """v3draw image stack."""
 
-    def __init__(self, fname: str, *, dtype: ScalarType, **kwargs) -> None:
-        super().__init__(fname, loader=Raw, dtype=dtype, **kwargs)
-
 
-class V3dpbdImageStack(V3dImageStack[ScalarType]):
+class V3dpbdImageStack(V3dImageStack[ScalarType], loader=PBD):
     """v3dpbd image stack."""
 
-    def __init__(self, fname: str, *, dtype: ScalarType, **kwargs) -> None:
-        super().__init__(fname, loader=PBD, dtype=dtype, **kwargs)
-
 
 class TeraflyImageStack(ImageStack[ScalarType]):
     """TeraFly image stack.
@@ -312,21 +290,17 @@ class TeraflyImageStack(ImageStack[ScalarType]):
     TeraFly is a terabytes of multidimensional volumetric images file
     format as described in [1]_.
 
-    References
-    ----------
-    .. [1] Bria, Alessandro, Giulio Iannello, Leonardo Onofri, and
-       Hanchuan Peng. “TeraFly: Real-Time Three-Dimensional
-       Visualization and Annotation of Terabytes of Multidimensional
-       Volumetric Images.” Nature Methods 13,
-       no. 3 (March 2016): 192-94. https://doi.org/10.1038/nmeth.3767.
-
-    Notes
-    -----
-    Terafly and Vaa3d use a especial right-handed coordinate system
+    NOTE: 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
+    flip y-axis to makes it a left-handed coordinate system (with origin
     point in the left-bottom and z-axis points front). If you need to
     use its coordinate system, remember to FLIP Y-AXIS BACK.
+
+    References:
+    .. [1] Bria, Alessandro, Giulio Iannello, Leonardo Onofri, and Hanchuan Peng.
+       “TeraFly: Real-Time Three-Dimensional Visualization and Annotation of Terabytes
+       of Multidimensional Volumetric Images.” Nature Methods 13, no. 3 (March 2016):
+       192-94. https://doi.org/10.1038/nmeth.3767.
     """
 
     _listdir: Callable[[str], list[str]]
@@ -336,17 +310,13 @@ class TeraflyImageStack(ImageStack[ScalarType]):
         self, root: str, *, dtype: ScalarType, lru_maxsize: int | None = 128
     ) -> None:
         r"""
-        Parameters
-        ----------
-        root : str
-            The root of terafly which contains directories named as
-            `RES(YxXxZ)`.
-        dtype : np.dtype
-        lru_maxsize : int or None, default to 128
-            Forwarding to `functools.lru_cache`. A decompressed array
-            size of (256, 256, 256, 1), which is the typical size of
-            terafly image stack, takes about 256 * 256 * 256 * 1 *
-            4B = 64MB. A cache size of 128 requires about 8GB memeory.
+        Args:
+            root: The root of terafly which contains directories named as `RES(YxXxZ)`.
+            dtype: np.dtype
+            lru_maxsize: Forwarding to `functools.lru_cache`.
+                A decompressed array size of (256, 256, 256, 1), which is the typical
+                size of terafly image stack, takes about 256 * 256 * 256 * 1 * 4B = 64MB.
+                A cache size of 128 requires about 8GB memory.
         """
 
         super().__init__()
@@ -372,11 +342,8 @@ class TeraflyImageStack(ImageStack[ScalarType]):
     def __getitem__(self, key):
         """Get images in max resolution.
 
-        Examples
-        --------
-        ```python
-        imgs[0, 0, 0, 0]            # get value
-        imgs[0:64, 0:64, 0:64, :]   # get patch
+        >>> imgs[0, 0, 0, 0]  # get value # doctest: +SKIP
+        >>> imgs[0:64, 0:64, 0:64, :]  # get patch # doctest: +SKIP
         ```
         """
         if not isinstance(key, tuple):
@@ -399,9 +366,8 @@ class TeraflyImageStack(ImageStack[ScalarType]):
     ) -> npt.NDArray[ScalarType]:
         """Get patch of image stack.
 
-        Returns
-        -------
-        patch : array of shape (X, Y, Z, C)
+        Returns:
+            patch: array of shape (X, Y, Z, C)
         """
         if isinstance(strides, int):
             strides = (strides, strides, strides)
@@ -421,10 +387,9 @@ class TeraflyImageStack(ImageStack[ScalarType]):
     def find_correspond_imgs(self, p, res_level=-1):
         """Find the image which contain this point.
 
-        Returns
-        -------
-        patch : array of shape (X, Y, Z, C)
-        patch_offset : (int, int, int)
+        Returns:
+            patch: array of shape (X, Y, Z, C)
+            patch_offset: (int, int, int)
         """
         p = np.array(p)
         self._check_params(res_level, p)
@@ -442,14 +407,10 @@ class TeraflyImageStack(ImageStack[ScalarType]):
     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]
-            Sequence of root of resolutions respectively.
-        patch_sizes : List of (int, int, int)
-            Sequence of patch size of resolutions respectively.
+        Returns:
+            resolutions: Sequence of sorted resolutions (from small to large).
+            roots: Sequence of root of resolutions respectively.
+            patch_sizes: Sequence of patch size of resolutions respectively.
         """
 
         roots = list(cls.get_resolution_dirs(root))
@@ -497,13 +458,13 @@ class TeraflyImageStack(ImageStack[ScalarType]):
 
         res = self.res[res_level]
         for p in coords:
-            assert np.less(
-                [0, 0, 0], p
-            ).all(), f"indices ({p[0]}, {p[1]}, {p[2]}) out of range (0, 0, 0)"
+            assert np.less([0, 0, 0], p).all(), (
+                f"indices ({p[0]}, {p[1]}, {p[2]}) out of range (0, 0, 0)"
+            )
 
-            assert np.greater(
-                res, p
-            ).all(), f"indices ({p[0]}, {p[1]}, {p[2]}) out of range ({res[0]}, {res[1]}, {res[2]})"
+            assert np.greater(res, p).all(), (
+                f"indices ({p[0]}, {p[1]}, {p[2]}) out of range ({res[0]}, {res[1]}, {res[2]})"
+            )
 
     def _get_range(self, starts, ends, res_level, out):
         # pylint: disable=too-many-locals
@@ -529,13 +490,13 @@ class TeraflyImageStack(ImageStack[ScalarType]):
         if shape[1] > lens[1]:
             starts_y = starts + [0, lens[1], 0]
             ends_y = np.array([starts[0], ends[1], ends[2]])
-            ends_y += [min(shape[0], lens[0]), 0, 0]  # type: ignore
+            ends_y += [min(shape[0], lens[0]), 0, 0]
             self._get_range(starts_y, ends_y, res_level, out[:, lens[1] :, :])
 
         if shape[2] > lens[2]:
             starts_z = starts + [0, 0, lens[2]]
             ends_z = np.array([starts[0], starts[1], ends[2]])
-            ends_z += [min(shape[0], lens[0]), min(shape[1], lens[1]), 0]  # type: ignore
+            ends_z += [min(shape[0], lens[0]), min(shape[1], lens[1]), 0]
             self._get_range(starts_z, ends_z, res_level, out[:, :, lens[2] :])
 
     def _find_correspond_imgs(self, p, res_level):
@@ -580,14 +541,14 @@ class GrayImageStack:
     def __init__(self, imgs: ImageStack) -> None:
         self.imgs = imgs
 
-    # fmt: off
     @overload
     def __getitem__(self, key: Vec3i) -> np.float32: ...
     @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]: ...
-    # fmt: on
+    def __getitem__(
+        self, key: slice | tuple[slice, slice] | tuple[slice, slice, slice]
+    ) -> npt.NDArray[np.float32]: ...
     def __getitem__(self, key):
         """Get pixel/patch of image stack."""
         v = self[key]
@@ -601,14 +562,12 @@ class GrayImageStack:
             return v[:, 0]
         if v.ndim == 1:
             return v[0]
-        raise ValueError("unsupport key")
+        raise ValueError("unsupported key")
 
     def get_full(self) -> npt.NDArray[np.float32]:
         """Get full image stack.
 
-        Notes
-        -----
-        this will load the full image stack into memory.
+        NOTE: this will load the full image stack into memory.
         """
         return self.imgs.get_full()[:, :, :, 0]
 

swcgeom/transforms/__init__.py

@@ -15,16 +15,16 @@
 
 """A series of transformations to compose codes."""
 
-from swcgeom.transforms.base import *
-from swcgeom.transforms.branch import *
-from swcgeom.transforms.branch_tree import *
-from swcgeom.transforms.geometry import *
-from swcgeom.transforms.image_preprocess import *
-from swcgeom.transforms.image_stack import *
-from swcgeom.transforms.images import *
-from swcgeom.transforms.mst import *
-from swcgeom.transforms.neurolucida_asc import *
-from swcgeom.transforms.path import *
-from swcgeom.transforms.population import *
-from swcgeom.transforms.tree import *
-from swcgeom.transforms.tree_assembler import *
+from swcgeom.transforms.base import *  # noqa: F403
+from swcgeom.transforms.branch import *  # noqa: F403
+from swcgeom.transforms.branch_tree import *  # noqa: F403
+from swcgeom.transforms.geometry import *  # noqa: F403
+from swcgeom.transforms.image_preprocess import *  # noqa: F403
+from swcgeom.transforms.image_stack import *  # noqa: F403
+from swcgeom.transforms.images import *  # noqa: F403
+from swcgeom.transforms.mst import *  # noqa: F403
+from swcgeom.transforms.neurolucida_asc import *  # noqa: F403
+from swcgeom.transforms.path import *  # noqa: F403
+from swcgeom.transforms.population import *  # noqa: F403
+from swcgeom.transforms.tree import *  # noqa: F403
+from swcgeom.transforms.tree_assembler import *  # noqa: F403

swcgeom/transforms/base.py

@@ -18,12 +18,19 @@
 from abc import ABC, abstractmethod
 from typing import Any, Generic, TypeVar, overload
 
+from typing_extensions import override
+
 __all__ = ["Transform", "Transforms", "Identity"]
 
-T, K = TypeVar("T"), TypeVar("K")
+T = TypeVar("T")
+K = TypeVar("K")
 
-T1, T2, T3 = TypeVar("T1"), TypeVar("T2"), TypeVar("T3")  # pylint: disable=invalid-name
-T4, T5, T6 = TypeVar("T4"), TypeVar("T5"), TypeVar("T6")  # pylint: disable=invalid-name
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+T3 = TypeVar("T3")
+T4 = TypeVar("T4")
+T5 = TypeVar("T5")
+T6 = TypeVar("T6")
 
 
 class Transform(ABC, Generic[T, K]):
@@ -36,9 +43,7 @@ class Transform(ABC, Generic[T, K]):
     def __call__(self, x: T) -> K:
         """Apply transform.
 
-        Notes
-        -----
-        All subclasses should overwrite :meth:`__call__`, supporting
+        NOTE: All subclasses should overwrite :meth:`__call__`, supporting
         applying transform in `x`.
         """
         raise NotImplementedError()
@@ -57,18 +62,14 @@ class Transform(ABC, Generic[T, K]):
         which can be particularly useful for debugging and model
         architecture introspection.
 
-        Examples
-        --------
-        class Foo(Transform[T, K]):
-            def __init__(self, my_parameter: int = 1):
-                self.my_parameter = my_parameter
-
-            def extra_repr(self) -> str:
-                return f"my_parameter={self.my_parameter}"
+        >>> class Foo(Transform[T, K]):
+        ...     def __init__(self, my_parameter: int = 1):
+        ...         self.my_parameter = my_parameter
+        ...
+        ...     def extra_repr(self) -> str:
+        ...         return f"my_parameter={self.my_parameter}"
 
-        Notes
-        -----
-        This method should be overridden in custom modules to provide
+        NOTE: This method should be overridden in custom modules to provide
         specific details relevant to the module's functionality and
         configuration.
         """
@@ -80,7 +81,7 @@ class Transforms(Transform[T, K]):
 
     transforms: list[Transform[Any, Any]]
 
-    # fmt:off
+    # fmt: off
     @overload
     def __init__(self, t1: Transform[T, K], /) -> None: ...
     @overload
@@ -100,11 +101,16 @@ class Transforms(Transform[T, K]):
                        t3: Transform[T2, T3], t4: Transform[T3, T4],
                        t5: Transform[T4, T5], t6: Transform[T5, K], /) -> None: ...
     @overload
+    def __init__(self, t1: Transform[T, T1],  t2: Transform[T1, T2],
+                       t3: Transform[T2, T3], t4: Transform[T3, T4],
+                       t5: Transform[T4, T5], t6: Transform[T5, T6],
+                       t7: Transform[T6, K], /) -> None: ...
+    @overload
     def __init__(self, t1: Transform[T, T1],  t2: Transform[T1, T2],
                        t3: Transform[T2, T3], t4: Transform[T3, T4],
                        t5: Transform[T4, T5], t6: Transform[T5, T6],
                        t7: Transform[T6, Any], /, *transforms: Transform[Any, K]) -> None: ...
-    # fmt:on
+    # fmt: on
     def __init__(self, *transforms: Transform[Any, Any]) -> None:
         trans = []
         for t in transforms:
@@ -114,6 +120,7 @@ class Transforms(Transform[T, K]):
                 trans.append(t)
         self.transforms = trans
 
+    @override
     def __call__(self, x: T) -> K:
         """Apply transforms."""
         for transform in self.transforms:
@@ -127,6 +134,7 @@ class Transforms(Transform[T, K]):
     def __len__(self) -> int:
         return len(self.transforms)
 
+    @override
     def extra_repr(self) -> str:
         return ", ".join([str(transform) for transform in self])
 
@@ -134,5 +142,6 @@ class Transforms(Transform[T, K]):
 class Identity(Transform[T, T]):
     """Resurn input as-is."""
 
+    @override
     def __call__(self, x: T) -> T:
         return x

swcgeom/transforms/branch.py

@@ -21,6 +21,7 @@ from typing import cast
 import numpy as np
 import numpy.typing as npt
 from scipy import signal
+from typing_extensions import override
 
 from swcgeom.core import Branch, DictSWC
 from swcgeom.transforms.base import Transform
@@ -40,13 +41,13 @@ __all__ = ["BranchLinearResampler", "BranchConvSmoother", "BranchStandardizer"]
 class _BranchResampler(Transform[Branch, Branch], ABC):
     r"""Resample branch."""
 
+    @override
     def __call__(self, x: Branch) -> Branch:
         xyzr = self.resample(x.xyzr())
         return Branch.from_xyzr(xyzr)
 
     @abstractmethod
-    def resample(self, xyzr: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
-        raise NotImplementedError()
+    def resample(self, xyzr: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]: ...
 
 
 class BranchLinearResampler(_BranchResampler):
@@ -55,26 +56,21 @@ class BranchLinearResampler(_BranchResampler):
     def __init__(self, n_nodes: int) -> None:
         """Resample branch to special num of nodes.
 
-        Parameters
-        ----------
-        n_nodes : int
-            Number of nodes after resample.
+        Args:
+            n_nodes: Number of nodes after resample.
         """
         super().__init__()
         self.n_nodes = n_nodes
 
+    @override
     def resample(self, xyzr: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
         """Resampling by linear interpolation, DO NOT keep original node.
 
-        Parameters
-        ----------
-        xyzr : np.ndarray[np.float32]
-            The array of shape (N, 4).
+        Args:
+            xyzr: The array of shape (N, 4).
 
-        Returns
-        -------
-        coordinates : ~numpy.NDArray[float64]
-            An array of shape (n_nodes, 4).
+        Returns:
+            coordinates: An array of shape (n_nodes, 4).
         """
 
         xp = np.cumsum(np.linalg.norm(xyzr[1:, :3] - xyzr[:-1, :3], axis=1))
@@ -87,6 +83,7 @@ class BranchLinearResampler(_BranchResampler):
         r = np.interp(xvals, xp, xyzr[:, 3])
         return cast(npt.NDArray[np.float32], np.stack([x, y, z, r], axis=1))
 
+    @override
     def extra_repr(self) -> str:
         return f"n_nodes={self.n_nodes}"
 
@@ -97,18 +94,15 @@ class BranchIsometricResampler(_BranchResampler):
         self.distance = distance
         self.adjust_last_gap = adjust_last_gap
 
+    @override
     def resample(self, xyzr: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
         """Resampling by isometric interpolation, DO NOT keep original node.
 
-        Parameters
-        ----------
-        xyzr : np.ndarray[np.float32]
-            The array of shape (N, 4).
+        Args:
+            xyzr: The array of shape (N, 4).
 
-        Returns
-        -------
-        new_xyzr : ~numpy.NDArray[float32]
-            An array of shape (n_nodes, 4).
+        Returns:
+            new_xyzr: An array of shape (n_nodes, 4).
         """
 
         # Compute the cumulative distances between consecutive points
@@ -138,6 +132,7 @@ class BranchIsometricResampler(_BranchResampler):
         new_xyzr[:, 3] = np.interp(new_distances, cumulative_distances, xyzr[:, 3])
         return new_xyzr
 
+    @override
     def extra_repr(self) -> str:
         return f"distance={self.distance},adjust_last_gap={self.adjust_last_gap}"
 
@@ -147,15 +142,14 @@ class BranchConvSmoother(Transform[Branch, Branch[DictSWC]]):
 
     def __init__(self, n_nodes: int = 5) -> None:
         """
-        Parameters
-        ----------
-        n_nodes : int, default `5`
-            Window size.
+        Args:
+            n_nodes: Window size.
         """
         super().__init__()
         self.n_nodes = n_nodes
         self.kernel = np.ones(n_nodes)
 
+    @override
     def __call__(self, x: Branch) -> Branch[DictSWC]:
         x = x.detach()
         c = signal.convolve(np.ones(x.number_of_nodes()), self.kernel, mode="same")
@@ -173,10 +167,11 @@ class BranchConvSmoother(Transform[Branch, Branch[DictSWC]]):
 class BranchStandardizer(Transform[Branch, Branch[DictSWC]]):
     r"""Standardize branch.
 
-    Standardized branch starts at (0, 0, 0), ends at (1, 0, 0), up at
-    y, and scale max radius to 1.
+    Standardized branch starts at (0, 0, 0), ends at (1, 0, 0), up at y, and scale max
+    radius to 1.
     """
 
+    @override
     def __call__(self, x: Branch) -> Branch:
         xyzr = x.xyzr()
         xyz, r = xyzr[:, 0:3], xyzr[:, 3:4]
@@ -191,23 +186,18 @@ class BranchStandardizer(Transform[Branch, Branch[DictSWC]]):
     def get_matrix(xyz: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
         r"""Get standardize transformation matrix.
 
-        Standardized branch starts at (0, 0, 0), ends at (1, 0, 0), up
-        at y.
+        Standardized branch starts at (0, 0, 0), ends at (1, 0, 0), up at y.
 
-        Parameters
-        ----------
-        xyz : np.ndarray[np.float32]
-            The `x`, `y`, `z` matrix of shape (N, 3) of branch.
+        Args:
+            xyz: The `x`, `y`, `z` matrix of shape (N, 3) of branch.
 
-        Returns
-        -------
-        T : np.ndarray[np.float32]
-            An homogeneous transformation matrix of shape (4, 4).
+        Returns:
+            T: An homogeneous transformation matrix of shape (4, 4).
         """
 
-        assert (
-            xyz.ndim == 2 and xyz.shape[1] == 3
-        ), f"xyz should be of shape (N, 3), got {xyz.shape}"
+        assert xyz.ndim == 2 and xyz.shape[1] == 3, (
+            f"xyz should be of shape (N, 3), got {xyz.shape}"
+        )
 
         xyz = xyz[:, :3]
         T = np.identity(4)