swcgeom 0.11.1__py3-none-any.whl → 0.13.0__py3-none-any.whl

swcgeom/transforms/images.py

@@ -6,7 +6,7 @@ from typing import Tuple
 import numpy as np
 import numpy.typing as npt
 
-from .base import Transform
+from swcgeom.transforms.base import Transform
 
 __all__ = ["Center"]
 

swcgeom/transforms/mst.py

@@ -1,15 +1,16 @@
 """Minimum spanning tree."""
 
+import warnings
 from typing import Optional
 
 import numpy as np
-import numpy.typing as npt
 import pandas as pd
 from numpy import ma
+from numpy import typing as npt
 
-from ..core import Tree
-from ..core.swc_utils import SWCNames, get_names
-from .base import Transform
+from swcgeom.core import Tree, sort_tree
+from swcgeom.core.swc_utils import SWCNames, SWCTypes, get_names, get_types
+from swcgeom.transforms.base import Transform
 
 __all__ = ["PointsToCuntzMST", "PointsToMST"]
 
@@ -30,7 +31,14 @@ class PointsToCuntzMST(Transform[npt.NDArray[np.float32], Tree]):
     """
 
     def __init__(
-        self, *, bf: float = 0.4, furcations: int = 2, exclude_soma: bool = True
+        self,
+        *,
+        bf: float = 0.4,
+        furcations: int = 2,
+        exclude_soma: bool = True,
+        sort: bool = True,
+        names: Optional[SWCNames] = None,
+        types: Optional[SWCTypes] = None,
     ) -> None:
         """
         Parameters
@@ -42,10 +50,15 @@ class PointsToCuntzMST(Transform[npt.NDArray[np.float32], Tree]):
             no suppression.
         exclude_soma : bool, default `True`
             Suppress multi-furcations exclude soma.
+        names : SWCNames, optional
+        types : SWCTypes, optional
         """
         self.bf = np.clip(bf, 0, 1)
         self.furcations = furcations
         self.exclude_soma = exclude_soma
+        self.sort = sort
+        self.names = get_names(names)
+        self.types = get_types(types)
 
     def __call__(  # pylint: disable=too-many-locals
         self,
@@ -63,7 +76,17 @@ class PointsToCuntzMST(Transform[npt.NDArray[np.float32], Tree]):
             Position of soma. If none, use the first point as soma.
         names : SWCNames, optional
         """
-        names = get_names(names)
+        if names is None:
+            names = self.names
+        else:
+            warnings.warn(
+                "`PointsToCuntzMST(...)(names=...)` has been "
+                "replaced by `PointsToCuntzMST(...,names=...)` since "
+                "v0.12.0, and will be removed in next version",
+                DeprecationWarning,
+            )
+            names = get_names(names)  # TODO: remove it
+
         if soma is not None:
             soma = np.array(soma)
             assert soma.shape == (3,)
@@ -103,16 +126,19 @@ class PointsToCuntzMST(Transform[npt.NDArray[np.float32], Tree]):
 
         dic = {
             names.id: np.arange(n),
-            names.type: np.full(n, fill_value=7),  # TODO
+            names.type: np.full(n, fill_value=self.types.glia_processes),
             names.x: points[:, 0],
             names.y: points[:, 1],
             names.z: points[:, 2],
             names.r: 1,
             names.pid: pid,
         }
-        dic[names.type][0] = 1
+        dic[names.type][0] = self.types.soma
         df = pd.DataFrame.from_dict(dic)
-        return Tree.from_data_frame(df, names=names)
+        t = Tree.from_data_frame(df, names=names)
+        if self.sort:
+            t = sort_tree(t)
+        return t
 
     def __repr__(self) -> str:
         return (
@@ -120,21 +146,50 @@ class PointsToCuntzMST(Transform[npt.NDArray[np.float32], Tree]):
             f"-bf-{self.bf}"
             f"-furcations-{self.furcations}"
             f"-{'exclude-soma' if self.exclude_soma else 'include-soma'}"
-        )
+        )  # TODO: names, types
 
 
 class PointsToMST(PointsToCuntzMST):  # pylint: disable=too-few-public-methods
     """Create minimum spanning tree from points."""
 
-    def __init__(self, k_furcations: int = 2) -> None:
+    def __init__(
+        self,
+        furcations: int = 2,
+        *,
+        k_furcations: Optional[int] = None,
+        exclude_soma: bool = True,
+        names: Optional[SWCNames] = None,
+        types: Optional[SWCTypes] = None,
+        **kwargs,
+    ) -> None:
         """
         Parameters
         ----------
-        k_furcations : int, default `2`
+        furcations : int, default `2`
             Suppress multifurcations which more than k. If set to -1,
             no suppression.
+        exclude_soma : bool, default `True`
+            Suppress multi-furcations exclude soma.
+        names : SWCNames, optional
+        types : SWCTypes, optional
         """
-        super().__init__(bf=0, furcations=k_furcations)
+        if k_furcations is not None:
+            warnings.warn(
+                "`PointsToMST(k_furcations=...)` has been renamed to "
+                "`PointsToMST(furcations=...)` since v0.12.0, and will "
+                "be removed in next version",
+                DeprecationWarning,
+            )
+            furcations = k_furcations
+
+        super().__init__(
+            bf=0,
+            furcations=furcations,
+            exclude_soma=exclude_soma,
+            names=names,
+            types=types,
+            **kwargs,
+        )
 
     def __repr__(self) -> str:
         return (

swcgeom/transforms/path.py

@@ -0,0 +1,48 @@
+"""Transformation in path."""
+
+from swcgeom.core import Path, Tree, redirect_tree
+from swcgeom.transforms.base import Transform
+
+__all__ = ["PathToTree", "PathReverser"]
+
+
+class PathToTree(Transform[Path, Tree]):
+    """Transform path to tree."""
+
+    def __call__(self, x: Path) -> Tree:
+        t = Tree(
+            x.number_of_nodes(),
+            type=x.type(),
+            id=x.id(),
+            x=x.x(),
+            y=x.y(),
+            z=x.z(),
+            r=x.r(),
+            pid=x.pid(),
+            source=x.source,
+            comments=x.comments.copy(),
+            names=x.names,
+        )
+        return t
+
+
+class PathReverser(Transform[Path, Path]):
+    r"""Reverse path.
+
+    ```text
+    a -> b -> ... -> y -> z
+    // to
+    a <- b <- ... <- y <- z
+    ```
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.to_tree = PathToTree()
+
+    def __call__(self, x: Path) -> Path:
+        x[0].type, x[-1].type = x[-1].type, x[0].type
+        t = self.to_tree(x)
+        t = redirect_tree(t, x[-1].id)
+        p = t.get_paths()[0]
+        return p

swcgeom/transforms/population.py

@@ -2,8 +2,8 @@
 
 from typing import List
 
-from ..core import Population, Tree
-from .base import Transform
+from swcgeom.core import Population, Tree
+from swcgeom.transforms.base import Transform
 
 __all__ = ["PopulationTransform"]
 

swcgeom/transforms/tree.py

@@ -5,10 +5,11 @@ from typing import Callable, List, Optional, Tuple
 
 import numpy as np
 
-from ..core import BranchTree, DictSWC, Path, Tree, cut_tree, to_subtree
-from .base import Transform
-from .branch import BranchConvSmoother
-from .geometry import Normalizer
+from swcgeom.core import BranchTree, DictSWC, Path, Tree, cut_tree, to_subtree
+from swcgeom.core.swc_utils import SWCTypes, get_types
+from swcgeom.transforms.base import Transform
+from swcgeom.transforms.branch import BranchConvSmoother
+from swcgeom.transforms.geometry import Normalizer
 
 __all__ = [
     "ToBranchTree",
@@ -34,10 +35,16 @@ class ToBranchTree(Transform[Tree, BranchTree]):
 class ToLongestPath(Transform[Tree, Path[DictSWC]]):
     """Transform tree to longest path."""
 
+    def __init__(self, *, detach: bool = True) -> None:
+        self.detach = detach
+
     def __call__(self, x: Tree) -> Path[DictSWC]:
         paths = x.get_paths()
         idx = np.argmax([p.length() for p in paths])
-        return paths[idx].detach()
+        path = paths[idx]
+        if self.detach:
+            path = path.detach()
+        return path  # type: ignore
 
 
 class TreeSmoother(Transform[Tree, Tree]):  # pylint: disable=missing-class-docstring
@@ -107,8 +114,9 @@ class CutByType(Transform[Tree, Tree]):
 class CutAxonTree(CutByType):
     """Cut axon tree."""
 
-    def __init__(self) -> None:
-        super().__init__(type=2)
+    def __init__(self, types: Optional[SWCTypes] = None) -> None:
+        types = get_types(types)
+        super().__init__(type=types.axon)
 
     def __repr__(self) -> str:
         return "CutAxonTree"
@@ -117,8 +125,9 @@ class CutAxonTree(CutByType):
 class CutDendriteTree(CutByType):
     """Cut dendrite tree."""
 
-    def __init__(self) -> None:
-        super().__init__(type=3)
+    def __init__(self, types: Optional[SWCTypes] = None) -> None:
+        types = get_types(types)
+        super().__init__(type=types.basal_dendrite)  # TODO: apical dendrite
 
     def __repr__(self) -> str:
         return "CutDenriteTree"

swcgeom/transforms/tree_assembler.py

@@ -4,10 +4,13 @@ from typing import Iterable, List, Optional, Tuple
 
 import pandas as pd
 
-from ..core import Tree
-from ..core.swc_utils import SWCNames
-from ..core.swc_utils.assembler import assemble_lines_impl, try_assemble_lines_impl
-from .base import Transform
+from swcgeom.core import Tree
+from swcgeom.core.swc_utils import SWCNames
+from swcgeom.core.swc_utils.assembler import (
+    assemble_lines_impl,
+    try_assemble_lines_impl,
+)
+from swcgeom.transforms.base import Transform
 
 
 class LinesToTree(Transform[List[pd.DataFrame], Tree]):

swcgeom/utils/__init__.py

@@ -1,9 +1,12 @@
 """Utils."""
 
-from .debug import *
-from .ellipse import *
-from .neuromorpho import *
-from .numpy import *
-from .renderer import *
-from .sdf import *
-from .transforms import *
+from swcgeom.utils.debug import *
+from swcgeom.utils.dsu import *
+from swcgeom.utils.ellipse import *
+from swcgeom.utils.file import *
+from swcgeom.utils.geometry_object import *
+from swcgeom.utils.neuromorpho import *
+from swcgeom.utils.numpy_helper import *
+from swcgeom.utils.renderer import *
+from swcgeom.utils.sdf import *
+from swcgeom.utils.transforms import *

swcgeom/utils/dsu.py

@@ -0,0 +1,42 @@
+"""Disjoint Set Union Impl."""
+
+__all__ = ["DisjointSetUnion"]
+
+
+class DisjointSetUnion:
+    """Disjoint Set Union.
+
+    DSU with path compression and union by rank.
+    """
+
+    def __init__(self, node_number: int):
+        self.element_parent = [i for i in range(node_number)]
+        self.rank = [0 for _ in range(node_number)]
+
+    def find_parent(self, node_id: int) -> int:
+        if node_id != self.element_parent[node_id]:
+            self.element_parent[node_id] = self.find_parent(
+                self.element_parent[node_id]
+            )
+        return self.element_parent[node_id]
+
+    def union_sets(self, node_a: int, node_b: int) -> None:
+        assert self.validate_node(node_a) and self.validate_node(node_b)
+
+        root_a = self.find_parent(node_a)
+        root_b = self.find_parent(node_b)
+        if root_a != root_b:
+            # union by rank
+            if self.rank[root_a] < self.rank[root_b]:
+                self.element_parent[root_a] = root_b
+            elif self.rank[root_a] > self.rank[root_b]:
+                self.element_parent[root_b] = root_a
+            else:
+                self.element_parent[root_b] = root_a
+                self.rank[root_a] += 1
+
+    def is_same_set(self, node_a: int, node_b: int) -> bool:
+        return self.find_parent(node_a) == self.find_parent(node_b)
+
+    def validate_node(self, node_id: int) -> bool:
+        return 0 <= node_id < len(self.element_parent)

swcgeom/utils/file.py

@@ -0,0 +1,91 @@
+"""File related utils.
+
+Notes
+-----
+If character coding is enabled, all denpendencies need to be installed,
+try:
+
+```sh
+pip install swcgeom[all]
+```
+"""
+
+import warnings
+from io import BytesIO, TextIOBase, TextIOWrapper
+from typing import Literal
+
+__all__ = ["FileReader", "PathOrIO"]
+
+PathOrIO = int | str | bytes | BytesIO | TextIOBase
+
+
+class FileReader:
+    def __init__(
+        self,
+        fname: PathOrIO,
+        *,
+        encoding: Literal["detect"] | str = "utf-8",
+        low_confidence: float = 0.9,
+        **kwargs,
+    ) -> None:
+        """Read file.
+
+        Parameters
+        ----------
+        fname : PathOrIO
+        encoding : str | 'detect', default `utf-8`
+            The name of the encoding used to decode the file. If is
+            `detect`, we will try to detect the character encoding.
+        low_confidence : float, default to 0.9
+            Used for detect character endocing, raising warning when
+            parsing with low confidence.
+        """
+        # TODO: support StringIO
+        self.fname, self.fb, self.f = "", None, None
+        if isinstance(fname, TextIOBase):
+            self.f = fname
+            encoding = fname.encoding  # skip detect
+        elif isinstance(fname, BytesIO):
+            self.fb = fname
+        else:
+            self.fname = fname
+
+        if encoding == "detect":
+            encoding = detect_encoding(fname, low_confidence=low_confidence)
+        self.encoding = encoding
+        self.kwargs = kwargs
+
+    def __enter__(self) -> TextIOBase:
+        if isinstance(self.fb, BytesIO):
+            self.f = TextIOWrapper(self.fb, encoding=self.encoding)
+        elif self.f is None:
+            self.f = open(self.fname, "r", encoding=self.encoding, **self.kwargs)
+
+        return self.f
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
+        if self.f:
+            self.f.close()
+        return True
+
+
+def detect_encoding(fname: PathOrIO, *, low_confidence: float = 0.9) -> str:
+    import chardet
+
+    if isinstance(fname, TextIOBase):
+        return fname.encoding
+    elif isinstance(fname, BytesIO):
+        data = fname.read()
+        fname.seek(0, 0)
+    else:
+        with open(fname, "rb") as f:
+            data = f.read()
+
+    result = chardet.detect(data)
+    encoding = result["encoding"] or "utf-8"
+    if result["confidence"] < low_confidence:
+        warnings.warn(
+            f"parse as `{encoding}` with low confidence "
+            f"{result['confidence']} in `{fname}`"
+        )
+    return encoding