swcgeom 0.19.4__cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.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=zPXrhc9_V2_xxYsEV5VBNfDNk7DbNhckUQwWmmCBLSo,465
+swcgeom/analysis/__init__.py,sha256=bSA9kr2vUysCiKqJuCGNJcEZQx086QGysIJaNDbp6oI,471
+swcgeom/analysis/feature_extractor.py,sha256=z5a6Ol7H60BwGli11A_2z8lpvSNa2kvkkpqKMaflQdY,14312
+swcgeom/analysis/features.py,sha256=Q1zwGevjyMWbTuOOSB5is_6s6yhXgguqZi4G_zZ3-QI,6111
+swcgeom/analysis/lmeasure.py,sha256=ZCr2Jh2dOCgat_wMJrNaDTp2eaeWLWdEUnGSIfTB8-M,27365
+swcgeom/analysis/sholl.py,sha256=qq7HftiYW7P_lhdHJrCj-HG_0I0C5ZXjKbTmV-c3V3E,6569
+swcgeom/analysis/trunk.py,sha256=IlOZ9FGi7D-_k0FpYNaP61uBlgPgVlLDdEno87SmpNQ,5470
+swcgeom/analysis/visualization.py,sha256=7V3puXfz8YlJTe_m-3dlvherbVzeWxkuLpHu_cEbRpQ,6102
+swcgeom/analysis/visualization3d.py,sha256=qEN94EYaokKoi1O17mTBQJ3ahzRXoM1xyZtcRiLFA_k,2458
+swcgeom/analysis/volume.py,sha256=vDa5VlfxNGrJ7Zu0Q677LY3T_GkEFAiThhJind_k3Q8,4600
+swcgeom/core/__init__.py,sha256=CSONS2N1VOa-mGtsDqEoHe23DcrUF0gjMriN4UE_sSY,678
+swcgeom/core/branch.py,sha256=zUHU6thButZb5qVSAGVGxNBi1DSm2sy9BRfIYHfvKyM,4177
+swcgeom/core/branch_tree.py,sha256=B2_qfhXsVl6dY3127pDlBjU-iSTmBzE86cFmK_xgKiY,1969
+swcgeom/core/compartment.py,sha256=i2qg3O8_TjlUBdTEthNQX14PVv47G_C1Awg3zhZiZzs,3377
+swcgeom/core/node.py,sha256=0nYAzKPrLpPlQ0mJwTE_jyNycDhiGMr8gO9NRXuk6LU,3828
+swcgeom/core/path.py,sha256=jVS-PNCZ3ByVJQwNZn0Lm_Z46M1HOSXfjDT7aSlYEnU,4549
+swcgeom/core/population.py,sha256=bOTU0eeS_5qJAmfzV3UfqP60go8s2hpRxnHVK8rt1L8,10222
+swcgeom/core/swc.py,sha256=Z2Nyqu67_jJv8JHEHlbReG5saIBSSrZDINDmDXf62fc,6942
+swcgeom/core/tree.py,sha256=0CTr4fs49q6jVqLPGVMZyrswI_WCWzkGGgQBGGDCJnA,12684
+swcgeom/core/tree_utils.py,sha256=r6qXdkwrGK1lri2F8o-uVfVDbb147NQ_46ir835JPs8,7385
+swcgeom/core/tree_utils_impl.py,sha256=Bl-dWYXUGC6s2E4rYpr2Wv6Dd1piKSs5MFKE62Q96WY,1682
+swcgeom/core/swc_utils/__init__.py,sha256=cCeisMAWnsTZNja09a5ExMAEf0TYTe90L_2MX2hTEBU,759
+swcgeom/core/swc_utils/assembler.py,sha256=tpCyArdz2CHHrsdPqxF6QVq_I7EnU89g3i1Fj9QNVi8,966
+swcgeom/core/swc_utils/base.py,sha256=fXd5tyQqa19NEECY7rT7_TOdgYjgSCwTuA7b6FxbGFY,4799
+swcgeom/core/swc_utils/checker.py,sha256=HXkaqG8RITovk1EwR2pjuse_Xxkwd_UMVXHSLOU79gQ,2667
+swcgeom/core/swc_utils/io.py,sha256=feQu756Mb4KRzLPxoZVaztrvomEbLoU70QkqQobOgbk,6217
+swcgeom/core/swc_utils/normalizer.py,sha256=TC65MNht7HDltg-b9d-nC4INZljBwSb25GNhj0Fciao,5102
+swcgeom/core/swc_utils/subtree.py,sha256=w6SPdggfgroxf08cf57xMwLhWzBakl34Bq05gC61gyw,2056
+swcgeom/images/__init__.py,sha256=fY_KL2wHZjAGfo5FjPNRMt2LMlb5Qv0zZBWDj7EWi4E,231
+swcgeom/images/augmentation.py,sha256=0SZFjr_iZhTZrt4tsXfJr9PAXROgo4Prk78KnV2xiqI,4112
+swcgeom/images/contrast.py,sha256=8KjTEmG_S5TfmT4piASYLjcPOABnhuKoRU4tqfwWAvs,1987
+swcgeom/images/folder.py,sha256=Z_PnGbk7kYbz4OV8IKW_aNfAUCls6vmKq5kxbbqezh4,6373
+swcgeom/images/io.py,sha256=0qqDBf-g7mHQWciTqCSKScejsVg-p7b3u78OugAPsMI,19846
+swcgeom/images/loaders/__init__.py,sha256=jLV_UaTtz6e9zUCYSRPjsZL7cbFP_a4h2Qx5n_BoLg8,246
+swcgeom/images/loaders/pbd.cpython-311-x86_64-linux-gnu.so,sha256=65M7mQDR1cP-p5AcFI9oujOUKBdXHy1ofwj-O8ewvfo,2209792
+swcgeom/images/loaders/pbd.pyx,sha256=xsvkNpfh27gJQPcOmVAOjPlwRVjYVs3acPAK3GKFDbg,22569
+swcgeom/images/loaders/raw.cpython-311-x86_64-linux-gnu.so,sha256=zAD0TRsGMJSoyrHDjbRsZfYcXYVmpB9Q7u74wHojlpg,1001776
+swcgeom/images/loaders/raw.pyx,sha256=KqorpMY6VSanqjBAdxfzy8WE0Lpt-3vnktTqZdwaP0k,6764
+swcgeom/transforms/__init__.py,sha256=JkH8kt9KwUo0RFc4QmpoHZWlB2qw97snXmU6j4VFibw,896
+swcgeom/transforms/base.py,sha256=BxG5-1spPGeTpq2-lXcy0Z_Q8dQwNeaWhZcT9-j3sXM,4476
+swcgeom/transforms/branch.py,sha256=ZyMWXg_uc2AyjavbZVsGb_DS58UmbvK7Tt3FQgix7VY,7086
+swcgeom/transforms/branch_tree.py,sha256=kWUB3B3YoKaQUX_FtN7lPYNy9LakxecdgMKMrmtGg3A,2408
+swcgeom/transforms/geometry.py,sha256=Zltl7UugZdPR1ZSkVKU9ccPvYAZccFW-VHWDm12vBds,7666
+swcgeom/transforms/image_preprocess.py,sha256=YW684hgtIETSBNIjM6BZgWhJCs5XbyHyi9YHLpD6Lhg,3822
+swcgeom/transforms/image_stack.py,sha256=jcIEaGGOJqZ2Joobjv4yX3HJgScfFVEHtoUjLKQKFU0,6879
+swcgeom/transforms/images.py,sha256=BLALtcj2AKK96GzDK-IG9Sz0KoM-K4D0T6xnq-MP3q0,5790
+swcgeom/transforms/mst.py,sha256=YUkLRkQn3UWAdPDkkluONWRxsCsEpsxCtVFzrAagwBc,5921
+swcgeom/transforms/neurolucida_asc.py,sha256=bwMiXn-rHcaTQCE4YVfi12CR9x9VQAa2uXI9EQz-ZqU,14201
+swcgeom/transforms/path.py,sha256=k8T8YEfitHC-jS3HYWW5mQiwCcHPY9bTXPF4FkS3EYk,1263
+swcgeom/transforms/population.py,sha256=5QHaAl7hxvaDEAgRrPgW7gVhRd7glVHtIZ7avSoy4CQ,983
+swcgeom/transforms/tree.py,sha256=JzbcKbTES3B7HO7_2DeiW61vSeL9vr_itcR3RriR6i4,7763
+swcgeom/transforms/tree_assembler.py,sha256=AlLM-4rnIq1sEnkoie19gcWHZz2ZhTW8fk0h-_lC8Tc,4899
+swcgeom/utils/__init__.py,sha256=ZqR6xtp6o_4mmyogi0YSVkRyXZEcvhT-O5T-DaSsO_k,740
+swcgeom/utils/debug.py,sha256=C7hX4lFLATcBu07d-l40wopgYPUjuy3-wS3qIdM30uI,571
+swcgeom/utils/download.py,sha256=bAMyLjlmllaspl6WVj6cULYeOtmq7ECv5wqhhq5mqhI,3670
+swcgeom/utils/dsu.py,sha256=Gi6GLxghd-kH9_M0T_SfsceNLzjICVZ_9PsB8IJe9BA,1792
+swcgeom/utils/ellipse.py,sha256=SXa6v1VXZO4WiQUPhKP_wjG_ExmG3WJKsxE078_UdTk,3752
+swcgeom/utils/file.py,sha256=4dtf2fsDA5LO1g5GxE2WE3RiSyQUsjFf9T4fmoXn4IU,2605
+swcgeom/utils/neuromorpho.py,sha256=7YfKmmAjhlXiGh_83mU-85BuwSKOOD070SpdR9Si5kI,18819
+swcgeom/utils/numpy_helper.py,sha256=QuNL2sTWim2LhNZpnDfaf8EO_xKNJuQpZ4oAKQ6u7i4,1708
+swcgeom/utils/plotter_2d.py,sha256=dRSBZYz_1JEc2VDbou5YT5N4Sr4KoD3r7V3YsvLwbT4,3884
+swcgeom/utils/plotter_3d.py,sha256=BhduXReVtaiMMacCM_aKGW5JHcPClXvvaKdVlOi3D1M,930
+swcgeom/utils/renderer.py,sha256=EzpM0RQKqrpa7Z6IIqQwzCk5zITbEjDe85g77M61LKQ,4324
+swcgeom/utils/sdf.py,sha256=OI9zhKpvjti25MsUGFwvSEmGC09JHqSSXWnXmp1mvRw,10492
+swcgeom/utils/solid_geometry.py,sha256=GcQDZH7PLQ9JSJaSXfsgJYLsvG9y8A8NH256PX_z8mI,4103
+swcgeom/utils/transforms.py,sha256=0YxkIiBM9LFpClclQ-v-Qj1cE8GBSDYwY885uhcy7vI,9102
+swcgeom/utils/volumetric_object.py,sha256=vAehsb-8QUjmGkOh2xw5Zr2_ftJOcJCPo7WTH_zepaM,14833
+swcgeom-0.19.4.dist-info/METADATA,sha256=v1gleV2ndiBgyJY84di5u_YAvWcHO20BQ0P1GsG0XsU,2865
+swcgeom-0.19.4.dist-info/WHEEL,sha256=YUTg7P1AA-xx_c2hOmP6nO8BydKCwT5S53P7NlWYKxw,151
+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/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357

swcgeom-0.19.4.dist-info/WHEEL

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