swcgeom 0.16.0__tar.gz → 0.17.0__tar.gz

{swcgeom-0.16.0 → swcgeom-0.17.0}/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## **0.17.0**&emsp;<sub><sup>2024-04-04 ([59257cb...2072139](https://github.com/yzx9/swcgeom/compare/59257cbfb6264afd3ca31fcba002f692bbb69ed0...20721393086e5a890b097b3ae32aaa1e4ad6b898?diff=split))</sup></sub>
+
+### Features
+
+##### &ensp;`images`
+
+- handle raw file in terafly ([67ecd63](https://github.com/yzx9/swcgeom/commit/67ecd63bf4124d49b00e779c2702a7b939ef710b))
+- add image stack dtype support ([7313ead](https://github.com/yzx9/swcgeom/commit/7313ead09ec61970f221b9e0c3691d31c269b591))
+
+##### &ensp;`transforms`
+
+- add new image transformation classes ([7b5d805](https://github.com/yzx9/swcgeom/commit/7b5d805a1aa0deac3f9d7576a9aecab36b59774b))
+- add image flip and notes ([5f2a4d1](https://github.com/yzx9/swcgeom/commit/5f2a4d1a9c2b5fb68e8221c7b024a411b247ab6d))
+
+
+### BREAKING CHANGES
+- `images` remove deprecated \`swap\_xy\` and \`filp\_xy\` flag ([2072139](https://github.com/yzx9/swcgeom/commit/20721393086e5a890b097b3ae32aaa1e4ad6b898))
+<br>
+
+
 ## **0.16.0**&emsp;<sub><sup>2024-03-16 ([bf2bf95...7029483](https://github.com/yzx9/swcgeom/compare/bf2bf95ee9fbfb7eba871db7303292f1dfcc7b8f...70294836643e51ca43d039887bbd71de3a9b561b?diff=split))</sup></sub>
 
 ### Features

{swcgeom-0.16.0/swcgeom.egg-info → swcgeom-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swcgeom
-Version: 0.16.0
+Version: 0.17.0
 Summary: Neuron geometry library for swc format
 Author-email: yzx9 <yuan.zx@outlook.com>
 License: Apache-2.0

{swcgeom-0.16.0 → swcgeom-0.17.0}/swcgeom/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.16.0'
-__version_tuple__ = version_tuple = (0, 16, 0)
+__version__ = version = '0.17.0'
+__version_tuple__ = version_tuple = (0, 17, 0)

{swcgeom-0.16.0 → swcgeom-0.17.0}/swcgeom/analysis/__init__.py

@@ -1,9 +1,7 @@
 """Analysis for neuron trees."""
 
-from swcgeom.analysis.branch_features import *
 from swcgeom.analysis.feature_extractor import *
-from swcgeom.analysis.node_features import *
-from swcgeom.analysis.path_features import *
+from swcgeom.analysis.features import *
 from swcgeom.analysis.sholl import *
 from swcgeom.analysis.trunk import *
 from swcgeom.analysis.visualization import *

{swcgeom-0.16.0 → swcgeom-0.17.0}/swcgeom/analysis/feature_extractor.py

@@ -17,13 +17,13 @@ import numpy.typing as npt
 import seaborn as sns
 from matplotlib.axes import Axes
 
-from swcgeom.analysis.branch_features import BranchFeatures
-from swcgeom.analysis.node_features import (
+from swcgeom.analysis.features import (
     BifurcationFeatures,
+    BranchFeatures,
     NodeFeatures,
+    PathFeatures,
     TipFeatures,
 )
-from swcgeom.analysis.path_features import PathFeatures
 from swcgeom.analysis.sholl import Sholl
 from swcgeom.analysis.volume import get_volume
 from swcgeom.core import Population, Populations, Tree

swcgeom-0.16.0/swcgeom/analysis/node_features.py → swcgeom-0.17.0/swcgeom/analysis/features.py

@@ -1,15 +1,26 @@
-"""Depth distribution of tree."""
+"""Feature anlysis of tree."""
 
 from abc import ABC, abstractmethod
 from functools import cached_property
+from typing import List, TypeVar
 
 import numpy as np
 import numpy.typing as npt
 from typing_extensions import Self
 
-from swcgeom.core import BranchTree, Tree
+from swcgeom.core import Branch, BranchTree, Tree
 
-__all__ = ["NodeFeatures", "BifurcationFeatures", "TipFeatures"]
+__all__ = [
+    "NodeFeatures",
+    "BifurcationFeatures",
+    "TipFeatures",
+    "PathFeatures",
+    "BranchFeatures",
+]
+
+T = TypeVar("T", bound=Branch)
+
+# Node Level
 
 
 class NodeFeatures:
@@ -31,6 +42,7 @@ class NodeFeatures:
         -------
         count : array of shape (1,)
         """
+
         return np.array([self.tree.number_of_nodes()], dtype=np.float32)
 
     def get_radial_distance(self) -> npt.NDArray[np.float32]:
@@ -41,6 +53,7 @@ class NodeFeatures:
         radial_distance : npt.NDArray[np.float32]
             Array of shape (N,).
         """
+
         xyz = self.tree.xyz() - self.tree.soma().xyz()
         radial_distance = np.linalg.norm(xyz, axis=1)
         return radial_distance
@@ -58,6 +71,7 @@ class NodeFeatures:
         order : npt.NDArray[np.int32]
             Array of shape (N,), which k is the number of branchs.
         """
+
         order = np.zeros_like(self._branch_tree.id(), dtype=np.int32)
 
         def assign_depth(n: Tree.Node, pre_depth: int | None) -> int:
@@ -88,6 +102,7 @@ class _SubsetNodesFeatures(ABC):
         count : npt.NDArray[np.float32]
             Array of shape (1,).
         """
+
         return np.array([np.count_nonzero(self.nodes)], dtype=np.float32)
 
     def get_radial_distance(self) -> npt.NDArray[np.float32]:
@@ -98,6 +113,7 @@ class _SubsetNodesFeatures(ABC):
         radial_distance : npt.NDArray[np.float32]
             Array of shape (N,).
         """
+
         return self._features.get_radial_distance()[self.nodes]
 
     @classmethod
@@ -119,3 +135,89 @@ class TipFeatures(_SubsetNodesFeatures):
     @cached_property
     def nodes(self) -> npt.NDArray[np.bool_]:
         return np.array([n.is_tip() for n in self._features.tree])
+
+
+# Path Level
+
+
+class PathFeatures:
+    """Path analysis of tree."""
+
+    tree: Tree
+
+    def __init__(self, tree: Tree) -> None:
+        self.tree = tree
+
+    def get_count(self) -> int:
+        return len(self._paths)
+
+    def get_length(self) -> npt.NDArray[np.float32]:
+        """Get length of paths."""
+
+        length = [path.length() for path in self._paths]
+        return np.array(length, dtype=np.float32)
+
+    def get_tortuosity(self) -> npt.NDArray[np.float32]:
+        """Get tortuosity of path."""
+
+        return np.array([path.tortuosity() for path in self._paths], dtype=np.float32)
+
+    @cached_property
+    def _paths(self) -> List[Tree.Path]:
+        return self.tree.get_paths()
+
+
+class BranchFeatures:
+    """Analysis bransh of tree."""
+
+    tree: Tree
+
+    def __init__(self, tree: Tree) -> None:
+        self.tree = tree
+
+    def get_count(self) -> int:
+        return len(self._branches)
+
+    def get_length(self) -> npt.NDArray[np.float32]:
+        """Get length of branches."""
+
+        length = [br.length() for br in self._branches]
+        return np.array(length, dtype=np.float32)
+
+    def get_tortuosity(self) -> npt.NDArray[np.float32]:
+        """Get tortuosity of path."""
+
+        return np.array([br.tortuosity() for br in self._branches], dtype=np.float32)
+
+    def get_angle(self, eps: float = 1e-7) -> npt.NDArray[np.float32]:
+        """Get agnle between branches.
+
+        Returns
+        -------
+        angle : npt.NDArray[np.float32]
+            An array of shape (N, N), which N is length of branches.
+        """
+
+        return self.calc_angle(self._branches, eps=eps)
+
+    @staticmethod
+    def calc_angle(branches: List[T], eps: float = 1e-7) -> npt.NDArray[np.float32]:
+        """Calc agnle between branches.
+
+        Returns
+        -------
+        angle : npt.NDArray[np.float32]
+            An array of shape (N, N), which N is length of branches.
+        """
+
+        vector = np.array([br[-1].xyz() - br[0].xyz() for br in branches])
+        vector_dot = np.matmul(vector, vector.T)
+        vector_norm = np.linalg.norm(vector, ord=2, axis=1, keepdims=True)
+        vector_norm_dot = np.matmul(vector_norm, vector_norm.T) + eps
+        arccos = np.clip(vector_dot / vector_norm_dot, -1, 1)
+        angle = np.arccos(arccos)
+        return angle
+
+    @cached_property
+    def _branches(self) -> List[Tree.Branch]:
+        return self.tree.get_branches()

{swcgeom-0.16.0 → swcgeom-0.17.0}/swcgeom/images/io.py

@@ -107,26 +107,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."""
-
-    kwargs["dtype"] = dtype or np.float32
-
-    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)
+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.
+    """
+
+    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 +151,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:
@@ -164,17 +179,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 +213,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 +221,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)
@@ -265,15 +252,7 @@ class NDArrayImageStack(ImageStack[ScalarType]):
 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 +264,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
 
 
@@ -384,7 +355,12 @@ class TeraflyImageStack(ImageStack[ScalarType]):
 
         @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
 

swcgeom-0.17.0/swcgeom/transforms/images.py

@@ -0,0 +1,203 @@
+"""Image stack related transform."""
+
+import warnings
+from typing import Tuple
+
+import numpy as np
+import numpy.typing as npt
+
+from swcgeom.transforms.base import Identity, Transform
+
+__all__ = [
+    "ImagesCenterCrop",
+    "ImagesScale",
+    "ImagesClip",
+    "ImagesFlip",
+    "ImagesFlipY",
+    "ImagesNormalizer",
+    "ImagesMeanVarianceAdjustment",
+    "ImagesScaleToUnitRange",
+    "ImagesHistogramEqualization",
+    "Center",  # legacy
+]
+
+
+NDArrayf32 = npt.NDArray[np.float32]
+
+
+class ImagesCenterCrop(Transform[NDArrayf32, NDArrayf32]):
+    """Get image stack center."""
+
+    def __init__(self, shape_out: int | Tuple[int, int, int]):
+        super().__init__()
+        self.shape_out = (
+            shape_out
+            if isinstance(shape_out, tuple)
+            else (shape_out, shape_out, shape_out)
+        )
+
+    def __call__(self, x: NDArrayf32) -> NDArrayf32:
+        diff = np.subtract(x.shape[:3], self.shape_out)
+        s = diff // 2
+        e = np.add(s, self.shape_out)
+        return x[s[0] : e[0], s[1] : e[1], s[2] : e[2], :]
+
+    def extra_repr(self) -> str:
+        return f"shape_out=({','.join(str(a) for a in self.shape_out)})"
+
+
+class Center(ImagesCenterCrop):
+    """Get image stack center.
+
+    .. deprecated:: 0.16.0
+        Use :class:`ImagesCenterCrop` instead.
+    """
+
+    def __init__(self, shape_out: int | Tuple[int, int, int]):
+        warnings.warn(
+            "`Center` is deprecated, use `ImagesCenterCrop` instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(shape_out)
+
+
+class ImagesScale(Transform[NDArrayf32, NDArrayf32]):
+    def __init__(self, scaler: float) -> None:
+        super().__init__()
+        self.scaler = scaler
+
+    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:
+        super().__init__()
+        self.vmin, self.vmax = vmin, vmax
+
+    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."""
+
+    def __call__(self, x: NDArrayf32) -> NDArrayf32:
+        mean = np.mean(x)
+        variance = np.var(x)
+        return (x - mean) / variance
+
+
+class ImagesMeanVarianceAdjustment(Transform[NDArrayf32, NDArrayf32]):
+    """Adjust image stack mean and variance.
+
+    See Also
+    --------
+    ~swcgeom.images.ImageStackFolder.stat
+    """
+
+    def __init__(self, mean: float, variance: float) -> None:
+        super().__init__()
+        self.mean = mean
+        self.variance = variance
+
+    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}"

{swcgeom-0.16.0 → swcgeom-0.17.0/swcgeom.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swcgeom
-Version: 0.16.0
+Version: 0.17.0
 Summary: Neuron geometry library for swc format
 Author-email: yzx9 <yuan.zx@outlook.com>
 License: Apache-2.0

{swcgeom-0.16.0 → swcgeom-0.17.0}/swcgeom.egg-info/SOURCES.txt

@@ -36,11 +36,9 @@ swcgeom.egg-info/dependency_links.txt
 swcgeom.egg-info/requires.txt
 swcgeom.egg-info/top_level.txt
 swcgeom/analysis/__init__.py
-swcgeom/analysis/branch_features.py
 swcgeom/analysis/feature_extractor.py
+swcgeom/analysis/features.py
 swcgeom/analysis/lmeasure.py
-swcgeom/analysis/node_features.py
-swcgeom/analysis/path_features.py
 swcgeom/analysis/sholl.py
 swcgeom/analysis/trunk.py
 swcgeom/analysis/visualization.py

swcgeom-0.16.0/swcgeom/analysis/branch_features.py

@@ -1,67 +0,0 @@
-"""Branch anlysis of tree."""
-
-from functools import cached_property
-from typing import List, TypeVar
-
-import numpy as np
-import numpy.typing as npt
-
-from swcgeom.core import Branch, Tree
-
-__all__ = ["BranchFeatures"]
-
-T = TypeVar("T", bound=Branch)
-
-
-class BranchFeatures:
-    """Analysis bransh of tree."""
-
-    tree: Tree
-
-    def __init__(self, tree: Tree) -> None:
-        self.tree = tree
-
-    def get_count(self) -> int:
-        return len(self._branches)
-
-    def get_length(self) -> npt.NDArray[np.float32]:
-        """Get length of branches."""
-        length = [br.length() for br in self._branches]
-        return np.array(length, dtype=np.float32)
-
-    def get_tortuosity(self) -> npt.NDArray[np.float32]:
-        """Get tortuosity of path."""
-        return np.array([br.tortuosity() for br in self._branches], dtype=np.float32)
-
-    def get_angle(self, eps: float = 1e-7) -> npt.NDArray[np.float32]:
-        """Get agnle between branches.
-
-        Returns
-        -------
-        angle : npt.NDArray[np.float32]
-            An array of shape (N, N), which N is length of branches.
-        """
-
-        return self.calc_angle(self._branches, eps=eps)
-
-    @staticmethod
-    def calc_angle(branches: List[T], eps: float = 1e-7) -> npt.NDArray[np.float32]:
-        """Calc agnle between branches.
-
-        Returns
-        -------
-        angle : npt.NDArray[np.float32]
-            An array of shape (N, N), which N is length of branches.
-        """
-
-        vector = np.array([br[-1].xyz() - br[0].xyz() for br in branches])
-        vector_dot = np.matmul(vector, vector.T)
-        vector_norm = np.linalg.norm(vector, ord=2, axis=1, keepdims=True)
-        vector_norm_dot = np.matmul(vector_norm, vector_norm.T) + eps
-        arccos = np.clip(vector_dot / vector_norm_dot, -1, 1)
-        angle = np.arccos(arccos)
-        return angle
-
-    @cached_property
-    def _branches(self) -> List[Tree.Branch]:
-        return self.tree.get_branches()

swcgeom-0.16.0/swcgeom/analysis/path_features.py

@@ -1,37 +0,0 @@
-"""Depth distribution of tree."""
-
-
-from functools import cached_property
-from typing import List
-
-import numpy as np
-import numpy.typing as npt
-
-from swcgeom.core import Tree
-
-__all__ = ["PathFeatures"]
-
-
-class PathFeatures:
-    """Path analysis of tree."""
-
-    tree: Tree
-
-    def __init__(self, tree: Tree) -> None:
-        self.tree = tree
-
-    def get_count(self) -> int:
-        return len(self._paths)
-
-    def get_length(self) -> npt.NDArray[np.float32]:
-        """Get length of paths."""
-        length = [path.length() for path in self._paths]
-        return np.array(length, dtype=np.float32)
-
-    def get_tortuosity(self) -> npt.NDArray[np.float32]:
-        """Get tortuosity of path."""
-        return np.array([path.tortuosity() for path in self._paths], dtype=np.float32)
-
-    @cached_property
-    def _paths(self) -> List[Tree.Path]:
-        return self.tree.get_paths()

swcgeom-0.16.0/swcgeom/transforms/images.py

@@ -1,102 +0,0 @@
-"""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
-
-__all__ = [
-    "ImagesCenterCrop",
-    "ImagesScale",
-    "ImagesClip",
-    "ImagesNormalizer",
-    "ImagesMeanVarianceAdjustment",
-    "Center",  # legacy
-]
-
-
-NDArrayf32 = npt.NDArray[np.float32]
-
-
-class ImagesCenterCrop(Transform[NDArrayf32, NDArrayf32]):
-    """Get image stack center."""
-
-    def __init__(self, shape_out: int | Tuple[int, int, int]):
-        super().__init__()
-        self.shape_out = (
-            shape_out
-            if isinstance(shape_out, tuple)
-            else (shape_out, shape_out, shape_out)
-        )
-
-    def __call__(self, x: NDArrayf32) -> NDArrayf32:
-        diff = np.subtract(x.shape[:3], self.shape_out)
-        s = diff // 2
-        e = np.add(s, self.shape_out)
-        return x[s[0] : e[0], s[1] : e[1], s[2] : e[2], :]
-
-    def extra_repr(self) -> str:
-        return f"shape_out=({','.join(str(a) for a in self.shape_out)})"
-
-
-class Center(ImagesCenterCrop):
-    """Get image stack center.
-
-    .. deprecated:: 0.5.0
-        Use :class:`ImagesCenterCrop` instead.
-    """
-
-    def __init__(self, shape_out: int | Tuple[int, int, int]):
-        warnings.warn(
-            "`Center` is deprecated, use `ImagesCenterCrop` instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        super().__init__(shape_out)
-
-
-class ImagesScale(Transform[NDArrayf32, NDArrayf32]):
-    def __init__(self, scaler: float) -> None:
-        super().__init__()
-        self.scaler = scaler
-
-    def __call__(self, x: NDArrayf32) -> NDArrayf32:
-        return self.scaler * x
-
-
-class ImagesClip(Transform[NDArrayf32, NDArrayf32]):
-    def __init__(self, vmin: float = 0, vmax: float = 1, /) -> None:
-        super().__init__()
-        self.vmin, self.vmax = vmin, vmax
-
-    def __call__(self, x: NDArrayf32) -> NDArrayf32:
-        return np.clip(x, self.vmin, self.vmax)
-
-
-class ImagesNormalizer(Transform[NDArrayf32, NDArrayf32]):
-    """Normalize image stack."""
-
-    def __call__(self, x: NDArrayf32) -> NDArrayf32:
-        mean = np.mean(x)
-        variance = np.var(x)
-        return (x - mean) / variance
-
-
-class ImagesMeanVarianceAdjustment(Transform[NDArrayf32, NDArrayf32]):
-    """Adjust image stack mean and variance.
-
-    See Also
-    --------
-    ~swcgeom.images.ImageStackFolder.stat
-    """
-
-    def __init__(self, mean: float, variance: float) -> None:
-        super().__init__()
-        self.mean = mean
-        self.variance = variance
-
-    def __call__(self, x: NDArrayf32) -> NDArrayf32:
-        return (x - self.mean) / self.variance