swcgeom 0.15.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

swcgeom/analysis/sholl.py

@@ -23,10 +23,15 @@ YLABLE = "Count of Intersections"
 class Sholl:
     """Sholl analysis.
 
+    Implementation of original Sholl analysis as described in [1]_. The
+    Sholl analysis is a method to quantify the spatial distribution of
+    neuronal processes. It is based on the number of intersections of
+    concentric circles with the neuronal processes.
+
     References
     ----------
-    [1] Dendritic organization in the neurons of the visual and motor
-    cortices of the cat J. Anat., 87 (1953), pp. 387-406
+    .. [1] Dendritic organization in the neurons of the visual and
+       motor cortices of the cat J. Anat., 87 (1953), pp. 387-406
     """
 
     tree: Tree
@@ -156,6 +161,12 @@ class Sholl:
         return self.get_rs(self.rmax, steps)
 
     def get_count(self) -> npt.NDArray[np.int32]:
+        """Get the count of intersection.
+
+        .. deprecated:: 0.5.0
+            Use :meth:`Sholl.get` instead.
+        """
+
         warnings.warn(
             "`Sholl.get_count` has been renamed to `get` since v0.5.0, "
             "and will be removed in next version",
@@ -164,6 +175,12 @@ class Sholl:
         return self.get().astype(np.int32)
 
     def avg(self) -> float:
+        """Get the average of the count of intersection.
+
+        .. deprecated:: 0.6.0
+            Use :meth:`Shool(x).get().mean()` instead.
+        """
+
         warnings.warn(
             "`Sholl.avg` has been deprecated since v0.6.0 and will be "
             "removed in next version, use `Shool(x).get().mean()` "
@@ -173,6 +190,12 @@ class Sholl:
         return self.get().mean()
 
     def std(self) -> float:
+        """Get the std of the count of intersection.
+
+        .. deprecated:: 0.6.0
+            Use :meth:`Shool(x).get().std()` instead.
+        """
+
         warnings.warn(
             "`Sholl.std` has been deprecate since v0.6.0 and will be "
             "removed in next version, use `Shool(x).get().std()` "
@@ -182,6 +205,12 @@ class Sholl:
         return self.get().std()
 
     def sum(self) -> int:
+        """Get the sum of the count of intersection.
+
+        .. deprecated:: 0.6.0
+            Use :meth:`Shool(x).get().sum()` instead.
+        """
+
         warnings.warn(
             "`Sholl.sum` has been deprecate since v0.6.0 and will be "
             "removed in next version, use `Shool(x).get().sum()` "

swcgeom/core/__init__.py

@@ -3,6 +3,10 @@
 from swcgeom.core import swc_utils
 from swcgeom.core.branch import *
 from swcgeom.core.branch_tree import *
+from swcgeom.core.compartment import (  # Segment and Segments don't expose
+    Compartment,
+    Compartments,
+)
 from swcgeom.core.node import *
 from swcgeom.core.path import *
 from swcgeom.core.population import *

swcgeom/core/branch.py

@@ -5,8 +5,8 @@ from typing import Generic, Iterable, List
 import numpy as np
 import numpy.typing as npt
 
+from swcgeom.core.compartment import Compartment, Compartments
 from swcgeom.core.path import Path
-from swcgeom.core.segment import Segment, Segments
 from swcgeom.core.swc import DictSWC, SWCTypeVar
 
 __all__ = ["Branch"]
@@ -24,9 +24,11 @@ class Branch(Path, Generic[SWCTypeVar]):
     attach: SWCTypeVar
     idx: npt.NDArray[np.int32]
 
-    class Segment(Segment["Branch"]):
+    class Compartment(Compartment["Branch"]):
         """Segment of branch."""
 
+    Segment = Compartment  # Alias
+
     def __repr__(self) -> str:
         return f"Neuron branch with {len(self)} nodes."
 
@@ -36,8 +38,11 @@ class Branch(Path, Generic[SWCTypeVar]):
     def get_ndata(self, key: str) -> npt.NDArray:
         return self.attach.get_ndata(key)[self.idx]
 
-    def get_segments(self) -> Segments[Segment]:
-        return Segments(self.Segment(self, n.pid, n.id) for n in self[1:])
+    def get_compartments(self) -> Compartments[Compartment]:
+        return Compartments(self.Compartment(self, n.pid, n.id) for n in self[1:])
+
+    def get_segments(self) -> Compartments[Compartment]:
+        return self.get_compartments()  # Alias
 
     def detach(self) -> "Branch[DictSWC]":
         """Detach from current attached object."""

swcgeom/core/{segment.py → compartment.py}

@@ -9,11 +9,11 @@ from swcgeom.core.path import Path
 from swcgeom.core.swc import DictSWC, SWCTypeVar
 from swcgeom.core.swc_utils import SWCNames, get_names
 
-__all__ = ["Segment", "Segments"]
+__all__ = ["Compartment", "Compartments", "Segment", "Segments"]
 
 
-class Segment(Path, Generic[SWCTypeVar]):
-    r"""Segment attached to external object."""
+class Compartment(Path, Generic[SWCTypeVar]):
+    r"""Compartment attached to external object."""
 
     attach: SWCTypeVar
     idx: npt.NDArray[np.int32]
@@ -27,7 +27,7 @@ class Segment(Path, Generic[SWCTypeVar]):
     def get_ndata(self, key: str) -> npt.NDArray:
         return self.attach.get_ndata(key)[self.idx]
 
-    def detach(self) -> "Segment[DictSWC]":
+    def detach(self) -> "Compartment[DictSWC]":
         """Detach from current attached object."""
         # pylint: disable=consider-using-dict-items
         attact = DictSWC(
@@ -37,18 +37,18 @@ class Segment(Path, Generic[SWCTypeVar]):
         )
         attact.ndata[self.names.id] = self.id()
         attact.ndata[self.names.pid] = self.pid()
-        return Segment(attact, 0, 1)
+        return Compartment(attact, 0, 1)
 
 
-SegmentT = TypeVar("SegmentT", bound=Segment)
+T = TypeVar("T", bound=Compartment)
 
 
-class Segments(List[SegmentT]):
-    r"""Segments contains a set of segments."""
+class Compartments(List[T]):
+    r"""Comparments contains a set of comparment."""
 
     names: SWCNames
 
-    def __init__(self, segments: Iterable[SegmentT]) -> None:
+    def __init__(self, segments: Iterable[T]) -> None:
         super().__init__(segments)
         self.names = self[0].names if len(self) > 0 else get_names()
 
@@ -94,3 +94,8 @@ class Segments(List[SegmentT]):
         The order of axis 1 is (parent, current node).
         """
         return np.array([s.get_ndata(key) for s in self])
+
+
+# Aliases
+Segment = Compartment
+Segments = Compartments

swcgeom/core/node.py

@@ -95,14 +95,6 @@ class Node(Generic[SWCTypeVar]):
         items = [self.id, self.type, x, y, z, r, self.pid]
         return " ".join(map(str, items))
 
-    def child_ids(self) -> npt.NDArray[np.int32]:
-        warnings.warn(
-            "`Node.child_ids` has been deprecated since v0.3.1 and "
-            "will be removed in next version",
-            DeprecationWarning,
-        )
-        return self.attach.id()[self.attach.pid() == self.id]
-
     def is_bifurcation(self) -> bool:
         return np.count_nonzero(self.attach.pid() == self.id) > 1
 

swcgeom/core/path.py

@@ -1,5 +1,6 @@
-"""Nueron node."""
+"""Nueron path."""
 
+import warnings
 from typing import Generic, Iterable, Iterator, List, overload
 
 import numpy as np
@@ -12,7 +13,7 @@ __all__ = ["Path"]
 
 
 class Path(SWCLike, Generic[SWCTypeVar]):
-    """Neural path.
+    """Neuron path.
 
     A path is a linear set of points without bifurcations.
     """
@@ -31,7 +32,7 @@ class Path(SWCLike, Generic[SWCTypeVar]):
         self.source = self.attach.source
 
     def __iter__(self) -> Iterator[Node]:
-        return (self.get_node(i) for i in range(len(self)))
+        return (self.node(i) for i in range(len(self)))
 
     def __len__(self) -> int:
         return self.id().shape[0]
@@ -50,7 +51,7 @@ class Path(SWCLike, Generic[SWCTypeVar]):
 
     def __getitem__(self, key):
         if isinstance(key, slice):
-            return [self.get_node(i) for i in range(*key.indices(len(self)))]
+            return [self.node(i) for i in range(*key.indices(len(self)))]
 
         if isinstance(key, (int, np.integer)):
             length = len(self)
@@ -60,7 +61,7 @@ class Path(SWCLike, Generic[SWCTypeVar]):
             if key < 0:  # Handle negative indices
                 key += length
 
-            return self.get_node(key)
+            return self.node(key)
 
         if isinstance(key, str):
             return self.get_ndata(key)
@@ -74,6 +75,20 @@ class Path(SWCLike, Generic[SWCTypeVar]):
         return self.attach.get_ndata(key)[self.idx]
 
     def get_node(self, idx: int | np.integer) -> Node:
+        """Get the count of intersection.
+
+        .. deprecated:: 0.16.0
+            Use :meth:`path.node` instead.
+        """
+
+        warnings.warn(
+            "`Path.get_node` has been deprecated since v0.16.0 and "
+            "will be removed in future version",
+            DeprecationWarning,
+        )
+        return self.node(idx)
+
+    def node(self, idx: int | np.integer) -> Node:
         return self.Node(self, idx)
 
     def detach(self) -> "Path[DictSWC]":
@@ -129,7 +144,7 @@ class Path(SWCLike, Generic[SWCTypeVar]):
         The end-to-end straight-line distance between start point and
         end point.
         """
-        return np.linalg.norm(self.get_node(-1).xyz() - self.get_node(0).xyz()).item()
+        return np.linalg.norm(self.node(-1).xyz() - self.node(0).xyz()).item()
 
     def tortuosity(self) -> float:
         """Tortuosity of path.

swcgeom/core/population.py

@@ -2,21 +2,26 @@
 
 import os
 import warnings
+from concurrent.futures import ProcessPoolExecutor
 from functools import reduce
 from typing import (
     Any,
+    Callable,
     Dict,
     Iterable,
     Iterator,
     List,
     Optional,
     Protocol,
+    TypeVar,
     cast,
     overload,
 )
 
 import numpy as np
 import numpy.typing as npt
+from tqdm.contrib.concurrent import process_map
+from typing_extensions import Self
 
 from swcgeom.core.swc import eswc_cols
 from swcgeom.core.tree import Tree
@@ -24,6 +29,9 @@ from swcgeom.core.tree import Tree
 __all__ = ["LazyLoadingTrees", "ChainTrees", "Population", "Populations"]
 
 
+T = TypeVar("T")
+
+
 class Trees(Protocol):
     """Trees protocol support index and len."""
 
@@ -48,6 +56,7 @@ class LazyLoadingTrees:
         kwargs : Dict[str, Any]
             Forwarding to `Tree.from_swc`
         """
+
         super().__init__()
         self.swcs = list(swcs)
         self.trees = [None for _ in swcs]
@@ -61,6 +70,9 @@ class LazyLoadingTrees:
     def __len__(self) -> int:
         return len(self.swcs)
 
+    def __iter__(self) -> Iterator[Tree]:
+        return (self[i] for i in range(self.__len__()))
+
     def load(self, key: int) -> None:
         if self.trees[key] is None:
             self.trees[key] = Tree.from_swc(self.swcs[key], **self.kwargs)
@@ -92,6 +104,9 @@ class ChainTrees:
     def __len__(self) -> int:
         return self.cumsum[-1].item()
 
+    def __iter__(self) -> Iterator[Tree]:
+        return (self[i] for i in range(self.__len__()))
+
 
 class Population:
     """Neuron population."""
@@ -153,15 +168,40 @@ class Population:
     def __repr__(self) -> str:
         return f"Neuron population in '{self.root}'"
 
+    def map(
+        self,
+        fn: Callable[[Tree], T],
+        *,
+        max_worker: Optional[int] = None,
+        verbose: bool = False,
+    ) -> Iterator[T]:
+        """Map a function to all trees in the population.
+
+        This is a straightforward interface for parallelizing
+        computations. The parameters are intentionally kept simple and
+        user-friendly. For more advanced control, consider using
+        `concurrent.futures` directly.
+        """
+
+        trees = (t for t in self.trees)
+
+        if verbose:
+            results = process_map(fn, trees, max_workers=max_worker)
+        else:
+            with ProcessPoolExecutor(max_worker) as p:
+                results = p.map(fn, trees)
+
+        return results
+
     @classmethod
-    def from_swc(cls, root: str, ext: str = ".swc", **kwargs) -> "Population":
+    def from_swc(cls, root: str, ext: str = ".swc", **kwargs) -> Self:
         if not os.path.exists(root):
             raise FileNotFoundError(
                 f"the root does not refers to an existing directory: {root}"
             )
 
         swcs = cls.find_swcs(root, ext)
-        return Population(LazyLoadingTrees(swcs, **kwargs), root=root)
+        return cls(LazyLoadingTrees(swcs, **kwargs), root=root)
 
     @classmethod
     def from_eswc(
@@ -170,7 +210,7 @@ class Population:
         ext: str = ".eswc",
         extra_cols: Optional[Iterable[str]] = None,
         **kwargs,
-    ) -> "Population":
+    ) -> Self:
         extra_cols = list(extra_cols) if extra_cols is not None else []
         extra_cols.extend(k for k, t in eswc_cols)
         return cls.from_swc(root, ext, extra_cols=extra_cols, **kwargs)
@@ -235,7 +275,7 @@ class Populations:
         return Population(ChainTrees(p.trees for p in self.populations))
 
     @classmethod
-    def from_swc(  # pylint: disable=too-many-arguments
+    def from_swc(
         cls,
         roots: Iterable[str],
         ext: str = ".swc",
@@ -243,7 +283,7 @@ class Populations:
         check_same: bool = False,
         labels: Optional[Iterable[str]] = None,
         **kwargs,
-    ) -> "Populations":
+    ) -> Self:
         """Get population from dirs.
 
         Parameters
@@ -275,7 +315,7 @@ class Populations:
             )
             for i, d in enumerate(roots)
         ]
-        return Populations(populations, labels=labels)
+        return cls(populations, labels=labels)
 
     @classmethod
     def from_eswc(
@@ -285,7 +325,7 @@ class Populations:
         *,
         ext: str = ".eswc",
         **kwargs,
-    ) -> "Populations":
+    ) -> Self:
         extra_cols = list(extra_cols) if extra_cols is not None else []
         extra_cols.extend(k for k, t in eswc_cols)
         return cls.from_swc(roots, extra_cols=extra_cols, ext=ext, **kwargs)

swcgeom/core/swc_utils/assembler.py

@@ -6,11 +6,16 @@ This module is deprecated, please use `~.transforms.LinesToTree`
 instead.
 """
 
-
 __all__ = ["assemble_lines", "try_assemble_lines"]
 
 
 def assemble_lines(*args, **kwargs):
+    """Assemble lines to tree.
+
+    .. deprecated:: 0.15.0
+        Use :meth:`~.transforms.LinesToTree` instead.
+    """
+
     raise DeprecationWarning(
         "`assemble_lines` has been replaced by "
         "`~.transforms.LinesToTree` because it can be easy assemble "
@@ -19,6 +24,12 @@ def assemble_lines(*args, **kwargs):
 
 
 def try_assemble_lines(*args, **kwargs):
+    """Try assemble lines to tree.
+
+    .. deprecated:: 0.15.0
+        Use :meth:`~.transforms.LinesToTree` instead.
+    """
+
     raise DeprecationWarning(
         "`try_assemble_lines` has been replaced by "
         "`~.transforms.LinesToTree` because it can be easy assemble "

swcgeom/core/swc_utils/base.py

@@ -1,7 +1,16 @@
 """Base SWC format utils."""
 
 from dataclasses import dataclass
-from typing import Callable, List, Literal, Optional, Tuple, TypeVar, overload
+from typing import (
+    Callable,
+    List,
+    Literal,
+    NamedTuple,
+    Optional,
+    Tuple,
+    TypeVar,
+    overload,
+)
 
 import numpy as np
 import numpy.typing as npt
@@ -23,8 +32,7 @@ T, K = TypeVar("T"), TypeVar("K")
 Topology = Tuple[npt.NDArray[np.int32], npt.NDArray[np.int32]]  # (id, pid)
 
 
-@dataclass
-class SWCNames:
+class SWCNames(NamedTuple):
     """SWC format column names."""
 
     id: str = "id"
@@ -46,8 +54,7 @@ def get_names(names: Optional[SWCNames] = None) -> SWCNames:
     return names or swc_names
 
 
-@dataclass
-class SWCTypes:
+class SWCTypes(NamedTuple):
     """SWC format types.
 
     See Also

swcgeom/core/swc_utils/checker.py

@@ -10,7 +10,6 @@ import pandas as pd
 from swcgeom.core.swc_utils.base import SWCNames, Topology, get_dsu, get_names, traverse
 from swcgeom.utils import DisjointSetUnion
 
-
 __all__ = [
     "is_single_root",
     "is_bifurcate",
@@ -83,6 +82,12 @@ def has_cyclic(topology: Topology) -> bool:
 
 
 def check_single_root(*args, **kwargs) -> bool:
+    """Check if the tree is single root.
+
+    .. deprecated:: 0.5.0
+        Use :meth:`is_single_root` instead.
+    """
+
     warnings.warn(
         "`check_single_root` has been renamed to `is_single_root` since"
         "v0.5.0, and will be removed in next version",
@@ -94,7 +99,12 @@ def check_single_root(*args, **kwargs) -> bool:
 def is_binary_tree(
     df: pd.DataFrame, exclude_root: bool = True, *, names: Optional[SWCNames] = None
 ) -> bool:
-    """Check is it a binary tree."""
+    """Check is it a binary tree.
+
+    .. deprecated:: 0.8.0
+        Use :meth:`is_bifurcate` instead.
+    """
+
     warnings.warn(
         "`is_binary_tree` has been replaced by to `is_bifurcate` since"
         "v0.8.0, and will be removed in next version",

swcgeom/core/tree.py

@@ -22,9 +22,9 @@ import numpy.typing as npt
 import pandas as pd
 
 from swcgeom.core.branch import Branch
+from swcgeom.core.compartment import Compartment, Compartments
 from swcgeom.core.node import Node
 from swcgeom.core.path import Path
-from swcgeom.core.segment import Segment, Segments
 from swcgeom.core.swc import DictSWC, eswc_cols
 from swcgeom.core.swc_utils import SWCNames, get_names, read_swc, traverse
 from swcgeom.core.tree_utils_impl import Mapping, get_subtree_impl
@@ -48,15 +48,6 @@ class Tree(DictSWC):
             children = self.attach.id()[self.attach.pid() == self.id]
             return [Tree.Node(self.attach, idx) for idx in children]
 
-        def get_branch(self) -> "Tree.Branch":
-            warnings.warn(
-                "`Tree.Node.get_branch` has been renamed to "
-                "`Tree.Node.branch` since v0.3.1 and will be removed "
-                "in next version",
-                DeprecationWarning,
-            )
-            return self.branch()
-
         def branch(self) -> "Tree.Branch":
             ns: List["Tree.Node"] = [self]
             while not ns[-1].is_bifurcation() and (p := ns[-1].parent()) is not None:
@@ -115,9 +106,11 @@ class Tree(DictSWC):
         # TODO: should returns `Tree.Node`
         """Neural path."""
 
-    class Segment(Segment["Tree"]):
+    class Compartment(Compartment["Tree"]):
         # TODO: should returns `Tree.Node`
-        """Neural segment."""
+        """Neural compartment."""
+
+    Segment = Compartment  # Alias
 
     class Branch(Branch["Tree"]):
         # TODO: should returns `Tree.Node`
@@ -127,33 +120,33 @@ class Tree(DictSWC):
         self,
         n_nodes: int,
         *,
-        # pylint: disable-next=redefined-builtin
-        id: Optional[npt.NDArray[np.int32]] = None,
-        # pylint: disable-next=redefined-builtin
-        type: Optional[npt.NDArray[np.int32]] = None,
-        x: Optional[npt.NDArray[np.float32]] = None,
-        y: Optional[npt.NDArray[np.float32]] = None,
-        z: Optional[npt.NDArray[np.float32]] = None,
-        r: Optional[npt.NDArray[np.float32]] = None,
-        pid: Optional[npt.NDArray[np.int32]] = None,
         source: str = "",
         comments: Optional[Iterable[str]] = None,
         names: Optional[SWCNames] = None,
         **kwargs: npt.NDArray,
     ) -> None:
         names = get_names(names)
-        id = np.arange(0, n_nodes, step=1, dtype=np.int32) if id is None else id
-        pid = np.arange(-1, n_nodes - 1, step=1, dtype=np.int32) if pid is None else pid
+
+        if names.id not in kwargs:
+            kwargs[names.id] = np.arange(0, n_nodes, step=1, dtype=np.int32)
+
+        if names.pid not in kwargs:
+            kwargs[names.pid] = np.arange(-1, n_nodes - 1, step=1, dtype=np.int32)
 
         ndata = {
-            names.id: padding1d(n_nodes, id, dtype=np.int32),
-            names.type: padding1d(n_nodes, type, dtype=np.int32),
-            names.x: padding1d(n_nodes, x),
-            names.y: padding1d(n_nodes, y),
-            names.z: padding1d(n_nodes, z),
-            names.r: padding1d(n_nodes, r, padding_value=1),
-            names.pid: padding1d(n_nodes, pid, dtype=np.int32),
+            names.id: padding1d(n_nodes, kwargs.pop(names.id, None), dtype=np.int32),
+            names.type: padding1d(
+                n_nodes, kwargs.pop(names.type, None), dtype=np.int32
+            ),
+            names.x: padding1d(n_nodes, kwargs.pop(names.x, None), dtype=np.float32),
+            names.y: padding1d(n_nodes, kwargs.pop(names.y, None), dtype=np.float32),
+            names.z: padding1d(n_nodes, kwargs.pop(names.z, None), dtype=np.float32),
+            names.r: padding1d(
+                n_nodes, kwargs.pop(names.r, None), dtype=np.float32, padding_value=1
+            ),
+            names.pid: padding1d(n_nodes, kwargs.pop(names.pid, None), dtype=np.int32),
         }
+        # ? padding other columns
         super().__init__(
             **ndata, **kwargs, source=source, comments=comments, names=names
         )
@@ -222,13 +215,16 @@ class Tree(DictSWC):
         tip_ids = np.setdiff1d(self.id(), self.pid(), assume_unique=True)
         return [self.node(i) for i in tip_ids]
 
-    def get_segments(self) -> Segments[Segment]:
-        return Segments(self.Segment(self, n.pid, n.id) for n in self[1:])
+    def get_compartments(self) -> Compartments[Compartment]:
+        return Compartments(self.Compartment(self, n.pid, n.id) for n in self[1:])
 
-    def get_branches(self) -> List[Branch]:
-        Info = Tuple[List[Tree.Branch], List[int]]
+    def get_segments(self) -> Compartments[Compartment]:  # Alias
+        return self.get_compartments()
 
-        def collect_branches(node: "Tree.Node", pre: List[Info]) -> Info:
+    def get_branches(self) -> List[Branch]:
+        def collect_branches(
+            node: "Tree.Node", pre: List[Tuple[List[Tree.Branch], List[int]]]
+        ) -> Tuple[List[Tree.Branch], List[int]]:
             if len(pre) == 1:
                 branches, child = pre[0]
                 child.append(node.id)
@@ -251,7 +247,6 @@ class Tree(DictSWC):
     def get_paths(self) -> List[Path]:
         """Get all path from soma to tips."""
         path_dic: Dict[int, List[int]] = {}
-        Paths = List[List[int]]
 
         def assign_path(n: Tree.Node, pre_path: List[int] | None) -> List[int]:
             path = [] if pre_path is None else pre_path.copy()
@@ -259,7 +254,9 @@ class Tree(DictSWC):
             path_dic[n.id] = path
             return path
 
-        def collect_path(n: Tree.Node, children: List[Paths]) -> Paths:
+        def collect_path(
+            n: Tree.Node, children: List[List[List[int]]]
+        ) -> List[List[int]]:
             if len(children) == 0:
                 return [path_dic[n.id]]
 

swcgeom/core/tree_utils.py

@@ -101,11 +101,15 @@ def to_sub_tree(swc_like: SWCLike, sub: Topology) -> Tuple[Tree, Dict[int, int]]
     but if the node you remove is not a leaf node, you need to use
     `propagate_remove` to remove all children.
 
+    .. deprecated:: 0.6.0
+        Use :meth:`to_subtree` instead.
+
     Returns
     -------
     tree : Tree
     id_map : Dict[int, int]
     """
+
     warnings.warn(
         "`to_sub_tree` will be removed in v0.6.0, it is replaced by "
         "`to_subtree` beacuse it is easy to use, and this will be "

swcgeom/images/augmentation.py

@@ -1,4 +1,9 @@
-"""Play augment in image stack."""
+"""Play augment in image stack.
+
+Notes
+-----
+This is expremental code, and the API is subject to change.
+"""
 
 import random
 from typing import List, Literal, Optional