swcgeom 0.19.4__cp311-cp311-win_amd64.whl

swcgeom/utils/volumetric_object.py

@@ -0,0 +1,483 @@
+
+# SPDX-FileCopyrightText: 2022 - 2025 Zexin Yuan <pypi@yzx9.xyz>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Volumetric object.
+
+This library implements the calculation of volumes for any shape
+generated through boolean operations, employing Signed Distance
+Function (SDF) and Monte Carlo algorithms.
+
+However, this approach is computationally demanding. To address this,
+we have specialized certain operations to accelerate the computation
+process.
+
+If you wish to use these methods, please review our implementation.
+Additionally, consider specializing some subclasses that can utilize
+formula-based calculations for further optimization of your
+computations.
+"""
+
+import warnings
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+import numpy as np
+import numpy.typing as npt
+from sdflit import SDF, FrustumCone, Sphere, intersect, merge, subtract
+
+from swcgeom.utils.solid_geometry import (
+    find_sphere_line_intersection,
+    find_unit_vector_on_plane,
+    project_point_on_line,
+)
+
+__all__ = ["VolObject", "VolMCObject", "VolSDFObject", "VolSphere", "VolFrustumCone"]
+
+eps = 1e-6
+
+
+class VolObject(ABC):
+    """Volumetric object."""
+
+    volume = None
+
+    def get_volume(self, **kwargs) -> float:
+        """Get volume."""
+        if len(kwargs) != 0:
+            # not cached
+            return self._get_volume(**kwargs)
+
+        if self.volume is None:
+            self.volume = self._get_volume()
+        return self.volume
+
+    @abstractmethod
+    def _get_volume(self) -> float:
+        """Get volume."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def union(self, obj: "VolObject") -> "VolObject":
+        """Union with another volume object."""
+        classname = obj.__class__.__name__
+        raise NotImplementedError(f"unable to union with {classname}")
+
+    @abstractmethod
+    def intersect(self, obj: "VolObject") -> "VolObject":
+        """Intersect with another volume object."""
+        classname = obj.__class__.__name__
+        raise NotImplementedError(f"unable to intersect with {classname}")
+
+    @abstractmethod
+    def subtract(self, obj: "VolObject") -> "VolObject":
+        """Subtract another volume object."""
+        classname = obj.__class__.__name__
+        raise NotImplementedError(f"unable to diff with {classname}")
+
+
+class VolMCObject(VolObject, ABC):
+    """Volumetric Monte Carlo Object.
+
+    The volume of the object is calculated by Monte Carlo integration.
+    """
+
+    n_samples: int | None = None
+
+    cache_volume: float | None = None
+    cache_volume_n_samples: int = 0
+
+    def __init__(self, *, n_samples: int | None = None) -> None:
+        super().__init__()
+        if n_samples is not None:
+            warnings.warn(
+                "`VolMCObject(n_samples=...)` has been move to since "
+                "v0.14.0 and will be removed in next version, use "
+                "`VolMCObject().get_volume(n_samples=...)` instead",
+                DeprecationWarning,
+            )
+            self.n_samples = n_samples
+
+    @abstractmethod
+    def sample(self, n: int) -> tuple[npt.NDArray[np.float32], float]:
+        """Sample points.
+
+        Args:
+            n: Number of points to sample.
+
+        Returns:
+            points: Sampled points.
+            volume: Volume of the sample range.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def inside(self, p: npt.NDArray[np.float32]) -> bool:
+        """Is p in the object."""
+        raise NotImplementedError()
+
+    def is_in(self, p: npt.NDArray[np.float32]) -> npt.NDArray[np.bool_]:
+        """Is p in the object.
+
+        Returns:
+            is_in: Array of shape (N,).
+                If bounding box is `None`, `True` will be returned.
+        """
+        return np.array([self.inside(pp) for pp in p])
+
+    def _get_volume(self, *, n_samples: int | None = None) -> float:
+        """Get volume by Monte Carlo integration.
+
+        Args:
+            n_samples: Number of samples, default 1_000_000
+        """
+
+        # legacy
+        DEFAULT_N_SAMPLES = 1_000_000
+        if n_samples is None:
+            n_samples = self.n_samples or DEFAULT_N_SAMPLES
+
+        # cache volume
+        if self.cache_volume is not None and n_samples <= self.cache_volume_n_samples:
+            return self.cache_volume
+
+        p, v = self.sample(n_samples)
+        hits = sum(self.inside(pp) for pp in p)
+        volume = hits / n_samples * v
+
+        # update cache
+        self.cache_volume = volume
+        self.cache_volume_n_samples = n_samples
+
+        return volume
+
+
+# Volumetric SDF Objects
+
+
+class VolSDFObject(VolMCObject):
+    """Volumetric SDF Object.
+
+    NOTE: SDF must has a bounding box.
+    """
+
+    def __init__(self, sdf: SDF, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.sdf = sdf
+
+    def sample(self, n: int) -> tuple[npt.NDArray[np.float32], float]:
+        (min_x, min_y, min_z), (max_x, max_y, max_z) = self.sdf.bounding_box()
+        samples = np.random.uniform(
+            (min_x, min_y, min_z), (max_x, max_y, max_z), size=(n, 3)
+        ).astype(np.float32)
+        v = (max_x - min_x) * (max_y - min_y) * (max_z - min_z)
+        return samples, v
+
+    def inside(self, p: npt.NDArray[np.float32]) -> bool:
+        return self.sdf.inside(_tp3f(p))
+
+    def union(self, obj: VolObject) -> VolObject:
+        if isinstance(obj, VolSDFObject):
+            return VolSDFUnion(self, obj)
+        raise NotImplementedError()
+
+    def intersect(self, obj: VolObject) -> VolObject:
+        if isinstance(obj, VolSDFObject):
+            return VolSDFIntersection(self, obj)
+        raise NotImplementedError()
+
+    def subtract(self, obj: VolObject) -> VolObject:
+        if isinstance(obj, VolSDFObject):
+            return VolSDFDifference(self, obj)
+        raise NotImplementedError()
+
+
+T = TypeVar("T", bound=VolSDFObject)
+K = TypeVar("K", bound=VolSDFObject)
+
+
+class VolSDFIntersection(VolSDFObject, ABC, Generic[T, K]):
+    """Intersection of two volumetric sdf objects."""
+
+    def __init__(self, obj1: T, obj2: K, **kwargs) -> None:
+        obj = intersect(obj1.sdf, obj2.sdf)
+        super().__init__(obj, **kwargs)
+        self.obj1 = obj1
+        self.obj2 = obj2
+
+
+class VolSDFUnion(VolSDFObject, ABC, Generic[T, K]):
+    """Union of two volumetric sdf objects."""
+
+    def __init__(self, obj1: T, obj2: K, **kwargs) -> None:
+        obj = merge(obj1.sdf, obj2.sdf)
+        super().__init__(obj, **kwargs)
+        self.obj1 = obj1
+        self.obj2 = obj2
+
+
+class VolSDFDifference(VolSDFObject, ABC, Generic[T, K]):
+    """Difference of volumetric sdf object and another object."""
+
+    def __init__(self, obj1: T, obj2: K, **kwargs) -> None:
+        obj = subtract(obj1.sdf, obj2.sdf)
+        super().__init__(obj, **kwargs)
+        self.obj1 = obj1
+        self.obj2 = obj2
+
+
+# Primitive Volumetric Objects
+
+
+class VolSphere(VolSDFObject):
+    """Volumetric Sphere."""
+
+    def __init__(self, center: npt.ArrayLike, radius: float):
+        center = np.array(center)
+        sdf = Sphere(_tp3f(center), radius)
+        super().__init__(sdf.into())
+
+        self.center = center
+        self.radius = radius
+
+    def _get_volume(self) -> float:
+        return self.calc_volume(self.radius)
+
+    def get_volume_spherical_cap(self, h: float) -> float:
+        return self.calc_volume_spherical_cap(self.radius, h)
+
+    def union(self, obj: VolObject) -> VolObject:
+        if isinstance(obj, VolSphere):
+            return VolSphere2Union(self, obj)
+
+        if isinstance(obj, VolFrustumCone):
+            return VolSphereFrustumConeUnion(self, obj)
+
+        return super().union(obj)
+
+    def intersect(self, obj: VolObject) -> VolObject:
+        if isinstance(obj, VolSphere):
+            return VolSphere2Intersection(self, obj)
+
+        if isinstance(obj, VolFrustumCone):
+            return VolSphereFrustumConeIntersection(self, obj)
+
+        return super().intersect(obj)
+
+    @staticmethod
+    def calc_volume(radius: float) -> float:
+        r"""Calculate volume of sphere.
+
+        \being{equation}
+        V = \frac{4}{3} * π * r^3
+        \end{equation}
+
+        Returns:
+            volume: volume of sphere.
+        """
+        return 4 / 3 * np.pi * radius**3
+
+    @staticmethod
+    def calc_volume_spherical_cap(r: float, h: float) -> float:
+        r"""Calculate the volume of a spherical cap.
+
+        \being{equation}
+        V = π * h^2 * (3r - h) / 3
+        \end{equation}
+
+        Args:
+            r: radius of the sphere
+            h: height of the spherical cap
+
+        Returns:
+            volume: volume of the spherical cap
+        """
+        return np.pi * h**2 * (3 * r - h) / 3
+
+
+class VolFrustumCone(VolSDFObject):
+    """Volumetric Frustum."""
+
+    def __init__(self, c1: npt.ArrayLike, r1: float, c2: npt.ArrayLike, r2: float):
+        c1, c2 = np.array(c1), np.array(c2)
+        sdf = FrustumCone(_tp3f(c1), _tp3f(c2), r1, r2)
+        super().__init__(sdf.into())
+
+        self.c1 = c1
+        self.c2 = c2
+        self.r1 = r1
+        self.r2 = r2
+
+    def height(self) -> float:
+        """Get height of frustum."""
+        return np.linalg.norm(self.c1 - self.c2).item()
+
+    def _get_volume(self) -> float:
+        return self.calc_volume(self.r1, self.r2, self.height())
+
+    def union(self, obj: VolObject) -> VolObject:
+        if isinstance(obj, VolSphere):
+            return VolSphereFrustumConeUnion(obj, self)
+
+        return super().union(obj)
+
+    def intersect(self, obj: VolObject) -> VolObject:
+        return super().intersect(obj)
+
+    @staticmethod
+    def calc_volume(r1: float, r2: float, height: float) -> float:
+        r"""Calculate volume of frustum.
+
+        \being{equation}
+        V = \frac{1}{3} * π * h * (r^2 + r * R + R^2)
+        \end{equation}
+
+        Returns:
+            volume: volume of frustum.
+        """
+        return (1 / 3) * np.pi * height * (r1**2 + r1 * r2 + r2**2)
+
+
+# Composite sphere and sphere
+
+
+class VolSphere2Intersection(VolSDFIntersection[VolSphere, VolSphere]):
+    """Intersection of two spheres."""
+
+    def _get_volume(self) -> float:
+        return self.calc_intersect_volume(self.obj1, self.obj2)
+
+    @staticmethod
+    def calc_intersect_volume(obj1: VolSphere, obj2: VolSphere) -> float:
+        r"""Calculate intersect volume of two spheres.
+
+        \being{equation}
+        V = \frac{\pi}{12d} * (r_1 + r_2 - d)^2 (d^2 + 2d r_1 - 3r_1^2 + 2d r_2 - 3r_2^2 + 6 r_1r_2)
+        \end{equation}
+
+        Returns:
+            volume: Intersect volume.
+        """
+
+        r1, r2 = obj1.radius, obj2.radius
+        d = np.linalg.norm(obj1.center - obj2.center).item()
+        if d > r1 + r2:
+            return 0
+
+        if d <= abs(r1 - r2):
+            return VolSphere.calc_volume(min(r1, r2))
+
+        part1 = (np.pi / (12 * d)) * (r1 + r2 - d) ** 2
+        part2 = d**2 + 2 * d * r1 - 3 * r1**2 + 2 * d * r2 - 3 * r2**2 + 6 * r1 * r2
+        return part1 * part2
+
+
+class VolSphere2Union(VolSDFUnion[VolSphere, VolSphere]):
+    """Union of two spheres."""
+
+    def _get_volume(self) -> float:
+        return (
+            self.obj1.get_volume()
+            + self.obj2.get_volume()
+            - VolSphere2Intersection.calc_intersect_volume(self.obj1, self.obj2)
+        )
+
+
+# Composite sphere and frustum cone
+
+
+class VolSphereFrustumConeIntersection(VolSDFIntersection[VolSphere, VolFrustumCone]):
+    """Intersection of sphere and frustum cone."""
+
+    def _get_volume(self) -> float:
+        if (
+            np.allclose(self.obj1.center, self.obj2.c1)
+            and np.allclose(self.obj1.radius, self.obj2.r1)
+        ) or (
+            np.allclose(self.obj1.center, self.obj2.c2)
+            and np.allclose(self.obj1.radius, self.obj2.r2)
+        ):
+            return self.calc_concentric_intersect_volume(self.obj1, self.obj2)
+
+        return super()._get_volume()
+
+    @staticmethod
+    def calc_concentric_intersect_volume(
+        sphere: VolSphere, frustum_cone: VolFrustumCone
+    ) -> float:
+        r"""Calculate intersect volume of sphere and frustum cone.
+
+        Returns:
+            volume: Intersect volume.
+        """
+
+        h = frustum_cone.height()
+        c1, r1 = sphere.center, sphere.radius
+        if np.allclose(c1, frustum_cone.c1) and np.allclose(r1, frustum_cone.r1):
+            c2, r2 = frustum_cone.c2, frustum_cone.r2
+        elif np.allclose(c1, frustum_cone.c2) and np.allclose(r1, frustum_cone.r2):
+            c2, r2 = frustum_cone.c1, frustum_cone.r1
+        else:
+            raise ValueError("sphere and frustum cone is not concentric")
+
+        # Fast-Path: The surface of the frustum concentric with the sphere
+        # is the surface with smaller radius
+        if r2 - r1 >= -eps:  # r2 >= r1:
+            v_himisphere = VolSphere.calc_volume_spherical_cap(r1, r1)
+            if h >= r1:
+                # The hemisphere is completely inside the frustum cone
+                return v_himisphere
+
+            # The frustum cone is lower than the hemisphere
+            v_cap = VolSphere.calc_volume_spherical_cap(r1, r1 - h)
+            return v_himisphere - v_cap
+
+        up = (c2 - c1) / np.linalg.norm(c2 - c1)
+        v = find_unit_vector_on_plane(up)
+
+        intersections = find_sphere_line_intersection(c1, r1, c1 + r1 * v, c2 + r2 * v)
+        if len(intersections) == 0:
+            # Tricky case: Since the intersection point not found with
+            # numerical precision, we can simply assume that there are two
+            # intersection points and at the same position
+            intersections = [(0, c1 + r1 * v), (0, c1 + r1 * v)]
+        assert len(intersections) == 2
+        t, p = max(intersections, key=lambda x: x[0])
+
+        # Fast-Path: The frustum cone is completely inside the sphere
+        if t > 1 + eps:
+            return frustum_cone.get_volume()
+
+        M = project_point_on_line(c1, up, p)
+        h1 = np.linalg.norm(M - c1).item()
+        r3 = np.linalg.norm(M - p).item()
+        v_cap1 = VolSphere.calc_volume_spherical_cap(r1, r1 - h1)
+        v_frustum = VolFrustumCone.calc_volume(r1, r3, h1)
+
+        # Fast-Path: The frustum cone is higher than the sphere
+        if h >= r1:
+            return v_cap1 + v_frustum
+
+        v_cap2 = VolSphere.calc_volume_spherical_cap(r1, r1 - h)
+        return v_cap1 + v_frustum - v_cap2
+
+
+class VolSphereFrustumConeUnion(VolSDFUnion[VolSphere, VolFrustumCone]):
+    """Union of sphere and frustum cone."""
+
+    def _get_volume(self) -> float:
+        return (
+            self.obj1.get_volume()
+            + self.obj2.get_volume()
+            - VolSphereFrustumConeIntersection.calc_concentric_intersect_volume(
+                self.obj1, self.obj2
+            )
+        )
+
+
+def _tp3f(x: npt.NDArray) -> tuple[float, float, float]:
+    """Convert to tuple of 3 floats."""
+
+    assert len(x) == 3
+    return (float(x[0]), float(x[1]), float(x[2]))

swcgeom-0.19.4.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: swcgeom
+Version: 0.19.4
+Summary: Neuron geometry library for swc format
+Author-email: yzx9 <pypi@yzx9.xyz>
+License-Expression: Apache-2.0
+Project-URL: repository, https://github.com/yzx9/swcgeom
+Keywords: neuroscience,neuron,neuroanatomy,neuron-morphology
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: imagecodecs>=2023.3.16
+Requires-Dist: matplotlib>=3.5.2
+Requires-Dist: numpy>=1.22.3
+Requires-Dist: pandas>=1.4.2
+Requires-Dist: pynrrd>=1.1.0
+Requires-Dist: scipy>=1.9.1
+Requires-Dist: sdflit>=0.2.6
+Requires-Dist: seaborn>=0.12.0
+Requires-Dist: tifffile>=2022.8.12
+Requires-Dist: typing-extensions>=4.4.0
+Requires-Dist: tqdm>=4.46.1
+Provides-Extra: all
+Requires-Dist: beautifulsoup4>=4.11.1; extra == "all"
+Requires-Dist: certifi>=2023.5.7; extra == "all"
+Requires-Dist: chardet>=5.2.0; extra == "all"
+Requires-Dist: lmdb>=1.4.1; extra == "all"
+Requires-Dist: requests>=2.0.0; extra == "all"
+Requires-Dist: urllib3>=1.26.0; extra == "all"
+Dynamic: license-file
+
+# SWCGEOM
+
+[![Run tests](https://github.com/yzx9/swcgeom/actions/workflows/test.yml/badge.svg)](https://github.com/yzx9/swcgeom/actions/workflows/test.yml)
+[![Release to GitHub](https://github.com/yzx9/swcgeom/actions/workflows/github-publish.yml/badge.svg)](https://github.com/yzx9/swcgeom/releases)
+[![Release to PyPI](https://github.com/yzx9/swcgeom/actions/workflows/pypi-publish.yml/badge.svg)](https://pypi.org/project/swcgeom/)
+
+A neuron geometry library for swc format.
+
+## Usage
+
+See examples for details.
+
+## Development
+
+```bash
+# clone repo
+git clone git@github.com:yzx9/swcgeom.git
+cd swcgeom
+
+# install dependencies
+python -m pip install --upgrade pip
+pip install build
+
+# install editable version
+pip install --editable .
+```
+
+Static analysis don't support import hook used in editable install for
+[PEP660](https://peps.python.org/pep-0660/) since upgrade to setuptools v64+,
+detail information at [setuptools#3518](https://github.com/pypa/setuptools/issues/3518),
+a workaround for vscode with pylance:
+
+```json
+{
+  "python.analysis.extraPaths": ["/path/to/this/project"]
+}
+```
+
+## LICENSE
+
+This work is licensed under a
+<a rel="license" href="https://www.apache.org/licenses/">Apache-2.0</a>.
+
+Copyright (c) 2022-present, Zexin Yuan

swcgeom-0.19.4.dist-info/RECORD

@@ -0,0 +1,72 @@
+swcgeom/__init__.py,sha256=kqxv-GpypsmuViVtQ2zmVihoEMVUEFR031F4E1KB_rE,486
+swcgeom/analysis/__init__.py,sha256=OxF3lbhbX-S7jvvxpIV2ioi539e6WnWE2NbogVxpmmo,484
+swcgeom/analysis/feature_extractor.py,sha256=SR72042CGCGfAwRp78AFlbJaTBXHN_mSFceiRCupxCM,14766
+swcgeom/analysis/features.py,sha256=v9dC4ejXBR9MJV5KYuv6qMVo0DjxpJjOJchG4c5cMYc,6329
+swcgeom/analysis/lmeasure.py,sha256=NiDPrq6ke5gWSKJtZqwaPYlN0aKNN4UWWid-yjxNp6g,28115
+swcgeom/analysis/sholl.py,sha256=D_becIODn_T3gzZZLI4c0d6h3juEov0qHFvS0yksmUQ,6770
+swcgeom/analysis/trunk.py,sha256=7XcGhUc8QmFMzZ_kMuoGPuKu7BlAe9cCCODbnfqo81o,5653
+swcgeom/analysis/visualization.py,sha256=jeW9YVVgCI-Qs4w6Ds1n-AjwDEDBc8um5OWPCtYxkig,6293
+swcgeom/analysis/visualization3d.py,sha256=5f7QK2kkHGgnT8URyE6Dy9FDRVtJkaWFWmmOKZRo7js,2539
+swcgeom/analysis/volume.py,sha256=SN7VBTXTXxCkNYZ-9KGxak_jnPDpg4Eo_GC3WFAGQg0,4743
+swcgeom/core/__init__.py,sha256=CkJIzhQC9VzFvMa8JQ6g7WwNE_edwNt6xDYieQMB_YI,697
+swcgeom/core/branch.py,sha256=HUe_Yo4YZBYuKMr8jFU4kJ8nosrbhCzuph7eRPQLBE0,4306
+swcgeom/core/branch_tree.py,sha256=6doQaarCB-nEcrMuNElwmPqgvE15yn5fxy3JePBcaTs,2034
+swcgeom/core/compartment.py,sha256=gWzklvRH9nXBPezr8QnIEKxta3uZHk3Um9hLC7DT_2I,3484
+swcgeom/core/node.py,sha256=XkMjlQ-1E_WaCCK6ghArQ9lXKuxPvzylLJyf6hnSzAE,3958
+swcgeom/core/path.py,sha256=5ZARke8KAnM2bO99OgDTvYDdsqxdJ6Oa2lZlfSI4Mco,4704
+swcgeom/core/population.py,sha256=rRkWh0Aik24EGBCo3jAOrvF-x2chpdJJCSA82caU4no,10563
+swcgeom/core/swc.py,sha256=Wlz4kV44dJpsYgiOEGTi8mL56KjvLAVuz_F_ip_JtaU,7189
+swcgeom/core/tree.py,sha256=TdApE-ZANdyh6U8YoYmI-LsoaMzsyDQMvcKrHR6yuSE,13068
+swcgeom/core/tree_utils.py,sha256=4eFHQ8EajJG4fGO3_in6LKLYW1e-dw1cP8ZhqBJA0b8,7662
+swcgeom/core/tree_utils_impl.py,sha256=mhgQqrtnGwei8B2jY2JvVgPLM-KU6PsKy8t-thdxxh8,1740
+swcgeom/core/swc_utils/__init__.py,sha256=afVBWtkRFqnZUZeHf194JiycdbvGi1TLP_jf6FN7XLw,778
+swcgeom/core/swc_utils/assembler.py,sha256=_VlOPnJvmveB8jSnnOhqY0MchnYq7F1dXCWJdvbC44c,1001
+swcgeom/core/swc_utils/base.py,sha256=TVT4e6XoKuyBWbu2sFyzslnTobIXSXLqAiHEbOILi_I,4979
+swcgeom/core/swc_utils/checker.py,sha256=RBFFgzw_LtwK_o2oXzrg54DClf0m3POn27lFwM5Wans,2774
+swcgeom/core/swc_utils/io.py,sha256=pI0NbD4b9KCv9btYiP4OCtMJchcp_GVZobVOlEMSmqY,6421
+swcgeom/core/swc_utils/normalizer.py,sha256=b0RxQroVyPmfKvV4x8FneEGgce8G4MI2xTsv34FADZA,5265
+swcgeom/core/swc_utils/subtree.py,sha256=ri3Sh_uTi1mrfcA-rqTD88rW_L0cxZPRuON4zzADwNA,2126
+swcgeom/images/__init__.py,sha256=3BLzhVKRbVtdsjaPTXX0SMO8JVxGwGvwVc4D0uyZ2nA,240
+swcgeom/images/augmentation.py,sha256=vjUC9v6QC7SyVot4D7ErH00og_S9I2A_SW2syRuMgCM,4261
+swcgeom/images/contrast.py,sha256=2Z38wV2laTCFAjZ3mT4vQlDtwHIZ-GmQQi81JDEzgO0,2074
+swcgeom/images/folder.py,sha256=veQnUP5W9eXtOsBB0YtwEs3GlsylREJt9yth1FMTyAA,6590
+swcgeom/images/io.py,sha256=mY6rklHn3xuSNvd_g4YGwLHP8Y3u-hEb6bV2jFVraso,20424
+swcgeom/images/loaders/__init__.py,sha256=a4XSH2Bn6v5YUGb_lKwdjAGD1i4SXBTXGVh08mct7pg,254
+swcgeom/images/loaders/pbd.cp311-win_amd64.pyd,sha256=9L-R4uAosyXzR4_HcukpAVbmKBvBUfB0Vw-yC4ykJXU,194560
+swcgeom/images/loaders/pbd.pyx,sha256=14uWjLpdxLhdPVUoAjthEnRVbhV0AdKGBipXY_BZeWU,23092
+swcgeom/images/loaders/raw.cp311-win_amd64.pyd,sha256=t3ZpbD3jwGXd7IZdqW_ogw_EKpi6fWElNKNoTb3NgCo,93184
+swcgeom/images/loaders/raw.pyx,sha256=Zd6CIoy97aaGs6bxi9CzoraPp261dpuWMK_ZujElfYU,6947
+swcgeom/transforms/__init__.py,sha256=DSE21HbgD6WczilWtONVq_m3zUgZXP-nsJjOCE_vKKU,916
+swcgeom/transforms/base.py,sha256=oaOSZGrZKVbauypp9G-3G2f_WIx2gEJIft60jMg5rBc,4612
+swcgeom/transforms/branch.py,sha256=OPx8D36neNmgePXPTw9qOXTzGfskCL5Og-k_s5GXV5g,7309
+swcgeom/transforms/branch_tree.py,sha256=ZhV5KNPprtcOc_jbqO36sNaQaPibyTKkblcyFYKAOgs,2482
+swcgeom/transforms/geometry.py,sha256=j6IXyM88W64FDEosdiN1KY1A793vCJrvibk4gZWWF8U,7936
+swcgeom/transforms/image_preprocess.py,sha256=UDHzXPeGhVpQ7yTAUGMJb8P0tFHZoRAY3JI5IYNEoKU,3929
+swcgeom/transforms/image_stack.py,sha256=pFisQ2x_H-3Bn-slVwlsiterv8p9E05zWv6-jm5x3_4,7098
+swcgeom/transforms/images.py,sha256=Xg7nAnAuDbjxCwmXJqshGDi4EDxO8MlNBOCNQsdiEBk,5996
+swcgeom/transforms/mst.py,sha256=QS2yO40thu-FfGkjY7yYZqnK1QOF7mkgSex6QQSZHcY,6104
+swcgeom/transforms/neurolucida_asc.py,sha256=QV9K6Q0lUandF0r2Fyd999VyiI8zdS4rYNZ94vIMl4g,14699
+swcgeom/transforms/path.py,sha256=JMjPKm3eYB_nr6j2-BBF-zUqPRTTIDMInM8TkCoSafE,1319
+swcgeom/transforms/population.py,sha256=305NHfplPu_VJvVNUm1_8-me0Cd6TsGXAQTi9AYfSTE,1019
+swcgeom/transforms/tree.py,sha256=ykmEP9626z4SBAwl0Vgw3Z7VZwRqiO2GxPsWtTha5wQ,8028
+swcgeom/transforms/tree_assembler.py,sha256=42bAOBzzSlMMYdqlFu8ZoNQrS2Qi-MJje5_kAkWqdmA,5060
+swcgeom/utils/__init__.py,sha256=k74fxbYGZfizmqHbWTqavtONOiqs5mndrBSC8SzDMQE,758
+swcgeom/utils/debug.py,sha256=vURuhDf1Mx67-p8EMSoOTQbzZRAQd1Q5OQzD4OR6PaA,594
+swcgeom/utils/download.py,sha256=bU2Be9fX_zNLaIe04fCaZFDHaLd_KoJMwnUvyUG_qUI,3789
+swcgeom/utils/dsu.py,sha256=hNEsAO0HtlyI-SeLqx0F7sEE4YVCSuR9nZda6gwo_9E,1850
+swcgeom/utils/ellipse.py,sha256=xTw1y6fNVcHIbY5c_MN2YLBju5DfHH3j7OP4m0zhGro,3883
+swcgeom/utils/file.py,sha256=aPGv7peQUDqbQPdBvo7OW6G8_wqHCQhaQPx4P7b3yDI,2695
+swcgeom/utils/neuromorpho.py,sha256=ANAsp7sIGOwjYu52WNaGHMmd7Wjgj5o_wzfEecF0FOg,19400
+swcgeom/utils/numpy_helper.py,sha256=iNf4-mbv22l21VuaA2ulUC4vFRlx4827OSKP0_TkFvc,1778
+swcgeom/utils/plotter_2d.py,sha256=9FG-b3Hj85tYKEBbjCldXRQ45-7odglMQsfaejt42D8,4018
+swcgeom/utils/plotter_3d.py,sha256=x2U6ogarUNHMbqiVEShe4SABVimXqhvWrKHvyeBGWVM,965
+swcgeom/utils/renderer.py,sha256=iFeKJIVAQfqehloRZHtb5vIf4e6zDMIdXazsIkyFxGI,4469
+swcgeom/utils/sdf.py,sha256=WxPwGd4DJRM8sIA2t8RP5_6fypom3PxMtg03sSNqKrM,10816
+swcgeom/utils/solid_geometry.py,sha256=ma30775813e8bFC6ycGLNdY1N2v96iPmECeHZc2YnPA,4257
+swcgeom/utils/transforms.py,sha256=hX6QgHKcaWmRwc5RlbKwVBGqCdXJbuQh-CPr02Lme0Q,9469
+swcgeom/utils/volumetric_object.py,sha256=C6k73avzKJUIsvaP6Bb43K2oENjv0mRub2caNHz4qGI,15316
+swcgeom-0.19.4.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+swcgeom-0.19.4.dist-info/METADATA,sha256=fG08-VedmB_7VuWAAt_sxQXK9D9pBOinkr7nXWfSVvs,2951
+swcgeom-0.19.4.dist-info/WHEEL,sha256=ge07nwgZNrHM7F-h6ntB4NDhu5ar8XLYRt0vb6q09YM,101
+swcgeom-0.19.4.dist-info/top_level.txt,sha256=hmLyUXWS61Gxl07haswFEKKefYPBVJYlUlol8ghNkjY,8
+swcgeom-0.19.4.dist-info/RECORD,,

swcgeom-0.19.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.0.1)
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+