pysurgery 2.2.2__tar.gz → 2.2.3__tar.gz

{pysurgery-2.2.2/pysurgery.egg-info → pysurgery-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysurgery
-Version: 2.2.2
+Version: 2.2.3
 Summary: A high-performance Python library for Computational Surgery Theory.
 Author-email: Gabriel Ribeiro <gabriel.ribeiro@dcc.ufmg.br>
 Requires-Python: >=3.11

{pysurgery-2.2.2 → pysurgery-2.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pysurgery"
-version = "2.2.2"
+version = "2.2.3"
 description = "A high-performance Python library for Computational Surgery Theory."
 dependencies = [
     "numpy>=2.4.4",
@@ -83,7 +83,7 @@ python_files = ["test_*.py"]
 "*" = ["*.jl", "*.yaml", "*.json"]
 
 [tool.bumpversion]
-current_version = "2.2.2"
+current_version = "2.2.3"
 commit = true
 tag = true
 

{pysurgery-2.2.2 → pysurgery-2.2.3}/pysurgery/__init__.py

@@ -316,7 +316,7 @@ from .auto_surgery import (
 
 from . import integrations
 
-__version__ = "2.2.2"
+__version__ = "2.2.3"
                                 
 def __getattr__(name):
     if name == "JuliaBridge":

{pysurgery-2.2.2 → pysurgery-2.2.3}/pysurgery/geometry/point_cloud.py

@@ -635,6 +635,90 @@ class PointCloud:
         self._update_parent(new_points)
         return PointCloud(new_points, parent=self._parent)
 
+    def unbend(
+        self,
+        curvature: float,
+        axis: int,
+        control_axis: int,
+        anchor: Optional[Any] = None
+    ) -> "PointCloud":
+        """Reverses a bending transformation along a specified axis.
+        
+        Mathematical Formulation:
+            Let c be the curvature (c = 1/R, where R is the bending radius).
+            For bend axis d_1 and control axis d_2, and anchor point 'a':
+            For each point P_i, let:
+                X = P_{i, d_1} - a_{d_1}
+                Y = P_{i, d_2} - a_{d_2}
+                
+            If curvature is non-zero (or very small):
+                r = 1/c
+                theta = atan2(X * sign(c), (r - Y) * sign(c))
+                d = sqrt(X^2 + (r - Y)^2)
+                x = theta / c
+                y = r - sign(c) * d
+                
+                P'_{i, d_1} = a_{d_1} + x
+                P'_{i, d_2} = a_{d_2} + y
+            If curvature is zero (or near zero), we use first-order Taylor expansion:
+                P'_{i, d_1} = a_{d_1} + X + c * X * Y
+                P'_{i, d_2} = a_{d_2} + Y - 0.5 * c * X^2
+                
+            For all other coordinate axes j not in {d_1, d_2}:
+                P'_{i, j} = P_{i, j}
+                
+        Args:
+            curvature: Bending curvature to undo.
+            axis: The primary axis along which the unbent points will be aligned.
+            control_axis: The axis perpendicular to the bend axis in which bending occurred.
+            anchor: The anchor point marking the origin of the bend. Can be:
+                    - None / "center": Defaults to the center of mass.
+                    - "min" / "max": Extreme point along the bend axis.
+                    - np.ndarray: Custom coordinates array.
+                    
+        Returns:
+            A new PointCloud instance with unbent points.
+        """
+        if axis < 0 or axis >= self.dimension or control_axis < 0 or control_axis >= self.dimension:
+            raise ValueError("Axis indices are out of bounds.")
+        if axis == control_axis:
+            raise ValueError("Bend axis and control axis must be distinct.")
+
+        # Determine anchor point coordinates
+        if anchor is None or (isinstance(anchor, str) and anchor == "center"):
+            anchor_pt = self.center_of_mass
+        elif isinstance(anchor, str) and anchor in ("min", "max"):
+            anchor_pt = self.get_extreme_points(axis=axis, extreme=anchor)
+        elif isinstance(anchor, np.ndarray):
+            if anchor.shape != (self.dimension,):
+                raise ValueError("Anchor shape must match dimension.")
+            anchor_pt = anchor
+        else:
+            raise ValueError(f"Invalid anchor: {anchor}")
+
+        X = self.points[:, axis] - anchor_pt[axis]
+        Y = self.points[:, control_axis] - anchor_pt[control_axis]
+
+        new_points = self.points.copy()
+
+        # Handle very small curvature using first-order approximation
+        if np.abs(curvature) < 1e-8:
+            new_points[:, axis] = anchor_pt[axis] + X + curvature * X * Y
+            new_points[:, control_axis] = anchor_pt[control_axis] + Y - 0.5 * curvature * (X**2)
+        else:
+            r = 1.0 / curvature
+            sign_c = np.sign(curvature)
+            theta = np.arctan2(X * sign_c, (r - Y) * sign_c)
+            d = np.sqrt(X**2 + (r - Y)**2)
+            x = theta / curvature
+            y = r - sign_c * d
+            
+            new_points[:, axis] = anchor_pt[axis] + x
+            new_points[:, control_axis] = anchor_pt[control_axis] + y
+
+        self._update_parent(new_points)
+        return PointCloud(new_points, parent=self._parent)
+
     def taper(
         self,
         factor: float,

{pysurgery-2.2.2 → pysurgery-2.2.3}/pysurgery/homology/homology_generators.py

@@ -35,6 +35,7 @@ from typing import TYPE_CHECKING, Dict, Iterable, List, Literal, Optional, Tuple
 
 if TYPE_CHECKING:
     from pysurgery.topology.complexes import SimplicialComplex, ChainComplex
+    from pysurgery.geometry.point_cloud import PointCloud
 
 import numpy as np
 import scipy.sparse as sp
@@ -273,7 +274,7 @@ def _rank_mod2(A: np.ndarray) -> int:
 def _components_h0_generators(
     edges: list[Edge],
     num_vertices: int,
-    point_cloud: Optional[np.ndarray] = None,
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]] = None,
 ) -> HomologyBasisResult:
     """Compute H0 generators as one representative per connected component.
 
@@ -357,7 +358,7 @@ def _components_h0_generators(
 def _weight_k_chain(
     chain: np.ndarray,
     k_simplices: list[tuple[int, ...]],
-    point_cloud: Optional[np.ndarray],
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]],
 ) -> float:
     """Compute a geometric/algebraic proxy weight for an active k-chain.
 
@@ -411,7 +412,7 @@ def _hk_generators_mod2(
     simplices: Iterable[Tuple[int, ...]],
     num_vertices: int,
     dimension: int,
-    point_cloud: Optional[np.ndarray],
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]],
     mode: Literal["valid", "optimal"],
 ) -> HomologyBasisResult:
     """Compute H_k representatives over Z/2 via kernel/image quotient.
@@ -520,7 +521,7 @@ def _hk_generators_mod2(
     )
 
 
-def _edge_weight(u: int, v: int, points: Optional[np.ndarray]) -> float:
+def _edge_weight(u: int, v: int, points: Optional[Union[np.ndarray, "PointCloud"]]) -> float:
     """Return edge length weight (or unit weight when no geometry is provided).
 
     Args:
@@ -766,7 +767,7 @@ def _path_edges(path_vertices: List[int]) -> List[Edge]:
 
 
 def _cycle_weight(
-    cycle: Cycle, edge_weights: Dict[Edge, float], point_cloud: Optional[np.ndarray]
+    cycle: Cycle, edge_weights: Dict[Edge, float], point_cloud: Optional[Union[np.ndarray, "PointCloud"]]
 ) -> float:
     """Compute cycle weight using supplied edge weights or geometric fallback.
 
@@ -791,7 +792,7 @@ def _cycle_weight(
 def generator_cycles_from_simplices(
     simplices: Iterable[Tuple[int, ...]],
     num_vertices: int,
-    point_cloud: Optional[np.ndarray] = None,
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]] = None,
     *,
     max_roots: Optional[int] = None,
     root_stride: int = 1,
@@ -844,7 +845,7 @@ def _generator_cycles_from_normalized_edges(
     edges: list[Edge],
     vertex_ids: set[int],
     num_vertices: int,
-    point_cloud: Optional[np.ndarray] = None,
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]] = None,
     *,
     max_roots: Optional[int] = None,
     root_stride: int = 1,
@@ -998,7 +999,7 @@ def greedy_h1_basis(
     cycles: List[Cycle],
     simplices: Iterable[Tuple[int, ...]],
     num_vertices: int,
-    point_cloud: Optional[np.ndarray] = None,
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]] = None,
     backend: str = "auto",
 ) -> List[Cycle]:
     """Select a greedy independent H1 basis from cycle candidates.
@@ -1052,7 +1053,7 @@ def _greedy_h1_basis_from_normalized(
     triangles: list[Triangle],
     vertex_ids: set[int],
     num_vertices: int,
-    point_cloud: Optional[np.ndarray] = None,
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]] = None,
 ) -> List[Cycle]:
     """Internal greedy H1 basis selection on normalized complexes.
 
@@ -1112,7 +1113,7 @@ def _greedy_h1_basis_from_normalized(
 def compute_optimal_h1_basis_from_simplices(
     simplices: Iterable[Tuple[int, ...]],
     num_vertices: int,
-    point_cloud: Optional[np.ndarray] = None,
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]] = None,
     *,
     max_roots: Optional[int] = None,
     root_stride: int = 1,
@@ -1237,7 +1238,7 @@ def compute_homology_basis_from_simplices(
     simplices: Iterable[Tuple[int, ...]],
     num_vertices: int,
     dimension: int,
-    point_cloud: Optional[np.ndarray] = None,
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]] = None,
     *,
     mode: Literal["valid", "optimal"] = "valid",
     max_roots: Optional[int] = None,
@@ -1369,7 +1370,7 @@ def compute_homology_basis_from_simplices(
 def compute_homology_basis_from_complex(
     complex: "SimplicialComplex",
     dimension: int,
-    point_cloud: Optional[np.ndarray] = None,
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]] = None,
     *,
     mode: Literal["valid", "optimal"] = "valid",
     max_roots: Optional[int] = None,
@@ -1439,7 +1440,7 @@ def compute_homology_basis_from_complex(
 
 def compute_optimal_h1_basis_from_complex(
     complex: "SimplicialComplex",
-    point_cloud: Optional[np.ndarray] = None,
+    point_cloud: Optional[Union[np.ndarray, "PointCloud"]] = None,
     *,
     max_roots: Optional[int] = None,
     root_stride: int = 1,

{pysurgery-2.2.2 → pysurgery-2.2.3}/pysurgery/topology/complexes.py

@@ -2478,6 +2478,7 @@ class SimplicialComplex(ChainComplex):
         """
         from ..bridge.julia_bridge import julia_engine
 
+        original_pc = points
         points = np.asarray(points, dtype=np.float64)
         n_pts = points.shape[0]
 
@@ -2489,6 +2490,7 @@ class SimplicialComplex(ChainComplex):
                 )
                 sc._coordinates = points
                 sc._generate_point_cloud_mappings(points)
+                sc._link_point_cloud(original_pc)
                 return sc
             except Exception as e:
                 warnings.warn(f"Julia Vietoris-Rips failed: {e!r}. Falling back to Python.")
@@ -2509,6 +2511,7 @@ class SimplicialComplex(ChainComplex):
             sc._coordinates = points
         
         sc._generate_point_cloud_mappings(points)
+        sc._link_point_cloud(original_pc)
         return sc
 
     @classmethod
@@ -2692,6 +2695,7 @@ class SimplicialComplex(ChainComplex):
             sc = cls.from_simplices([], coefficient_ring=coefficient_ring)
             sc._coordinates = pts
             sc._generate_point_cloud_mappings(pts)
+            sc._link_point_cloud(points)
             return sc
         if k >= n:
             k = n - 1
@@ -2699,6 +2703,7 @@ class SimplicialComplex(ChainComplex):
             sc = cls.from_simplices([(i,) for i in range(n)], coefficient_ring=coefficient_ring)
             sc._coordinates = pts
             sc._generate_point_cloud_mappings(pts)
+            sc._link_point_cloud(points)
             return sc
 
         simplices = [(i,) for i in range(n)]
@@ -2744,6 +2749,7 @@ class SimplicialComplex(ChainComplex):
             sc = sc.expand(max_dimension)
         sc._coordinates = pts
         sc._generate_point_cloud_mappings(pts)
+        sc._link_point_cloud(points)
         return sc
     @classmethod
     def from_alpha_complex(
@@ -2780,6 +2786,7 @@ class SimplicialComplex(ChainComplex):
             sc = cls.from_simplices([[i] for i in range(n_pts)], coefficient_ring=coefficient_ring)
             sc._coordinates = pts
             sc._generate_point_cloud_mappings(pts)
+            sc._link_point_cloud(points)
             return sc
 
         dt = Delaunay(pts, qhull_options="QJ")
@@ -2835,6 +2842,7 @@ class SimplicialComplex(ChainComplex):
                 sc = cls.from_simplices(valid_simplices_list, coefficient_ring=coefficient_ring, close_under_faces=True)
                 sc._coordinates = pts
                 sc._generate_point_cloud_mappings(pts)
+                sc._link_point_cloud(points)
                 return sc
             except Exception as e:
                 if backend_norm == "julia":
@@ -2852,6 +2860,7 @@ class SimplicialComplex(ChainComplex):
         sc = cls.from_simplices(valid_simplices_final, coefficient_ring=coefficient_ring, close_under_faces=True)
         sc._coordinates = pts
         sc._generate_point_cloud_mappings(pts)
+        sc._link_point_cloud(points)
         return sc
 
     @classmethod
@@ -2884,6 +2893,7 @@ class SimplicialComplex(ChainComplex):
             sc = cls.from_simplices([[i] for i in range(n_pts)], coefficient_ring=coefficient_ring)
             sc._coordinates = pts
             sc._generate_point_cloud_mappings(pts)
+            sc._link_point_cloud(points)
             return sc
         
         # 1. Compute Voronoi diagram to get poles (Voronoi vertices)
@@ -2912,6 +2922,7 @@ class SimplicialComplex(ChainComplex):
         sc = cls.from_simplices(valid_simplices, coefficient_ring=coefficient_ring, close_under_faces=True)
         sc._coordinates = pts
         sc._generate_point_cloud_mappings(pts)
+        sc._link_point_cloud(points)
         return sc
 
     @classmethod
@@ -2941,6 +2952,7 @@ class SimplicialComplex(ChainComplex):
             sc = cls.from_simplices([], coefficient_ring=coefficient_ring)
             sc._coordinates = pts
             sc.filtration = {}
+            sc._link_point_cloud(points)
             return sc
         dim = pts.shape[1]
         if n < dim + 1:
@@ -2949,6 +2961,7 @@ class SimplicialComplex(ChainComplex):
             sc._coordinates = pts
             sc.filtration = {(i,): 0.0 for i in range(n)}
             sc._generate_point_cloud_mappings(pts)
+            sc._link_point_cloud(points)
             return sc
 
         from scipy.spatial import Delaunay
@@ -2977,6 +2990,7 @@ class SimplicialComplex(ChainComplex):
 
         sc.filtration = vals
         sc._generate_point_cloud_mappings(pts)
+        sc._link_point_cloud(points)
         return sc
 
     @classmethod
@@ -3154,6 +3168,7 @@ class SimplicialComplex(ChainComplex):
                 pts = np.asarray(pc, dtype=np.float64)
             self._coordinates = pts
             self._generate_point_cloud_mappings(pts)
+            self._link_point_cloud(pc)
 
     @property
     def point_cloud_to_simplices(self) -> Dict[int, List[Tuple[int, ...]]]:
@@ -3181,6 +3196,12 @@ class SimplicialComplex(ChainComplex):
                 if vertex in self._point_cloud_to_simplices:
                     self._point_cloud_to_simplices[vertex].append(simplex)
 
+    def _link_point_cloud(self, points: Any) -> None:
+        """Link a PointCloud back to this complex as its parent."""
+        from ..geometry.point_cloud import PointCloud
+        if isinstance(points, PointCloud):
+            points._parent = self
+
     @classmethod
     def concatenate(cls, complexes: Iterable["SimplicialComplex"]) -> "SimplicialComplex":
         """Concatenate multiple simplicial complexes (simplex trees) into a single larger complex.
@@ -5640,7 +5661,7 @@ class SimplicialComplex(ChainComplex):
 
     def compute_optimal_h1_basis(
         self,
-        point_cloud: Optional[np.ndarray] = None,
+        point_cloud: Optional[Union[np.ndarray, "PointCloud"]] = None,
         *,
         max_roots: Optional[int] = None,
         root_stride: int = 1,

{pysurgery-2.2.2 → pysurgery-2.2.3/pysurgery.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysurgery
-Version: 2.2.2
+Version: 2.2.3
 Summary: A high-performance Python library for Computational Surgery Theory.
 Author-email: Gabriel Ribeiro <gabriel.ribeiro@dcc.ufmg.br>
 Requires-Python: >=3.11

{pysurgery-2.2.2 → pysurgery-2.2.3}/tests/test_point_cloud.py

@@ -296,6 +296,33 @@ def test_bend():
     pc_flat = pc.bend(curvature=0.0, axis=0, control_axis=1, anchor="min")
     np.testing.assert_allclose(pc_flat.points, pts)
 
+def test_unbend():
+    # 1. Test unbending a bent point cloud
+    pts = np.array([
+        [0.0, 0.0],
+        [np.pi / 2, 0.5],
+        [np.pi, -0.2]
+    ])
+    pc = PointCloud(pts)
+    
+    # Bend with curvature 0.5
+    pc_bent = pc.bend(curvature=0.5, axis=0, control_axis=1, anchor="min")
+    
+    # Unbend with curvature 0.5
+    pc_unbent = pc_bent.unbend(curvature=0.5, axis=0, control_axis=1, anchor="min")
+    np.testing.assert_allclose(pc_unbent.points, pts, atol=1e-7)
+
+    # 2. Test negative curvature
+    pc_bent_neg = pc.bend(curvature=-0.5, axis=0, control_axis=1, anchor="min")
+    pc_unbent_neg = pc_bent_neg.unbend(curvature=-0.5, axis=0, control_axis=1, anchor="min")
+    np.testing.assert_allclose(pc_unbent_neg.points, pts, atol=1e-7)
+
+    # 3. Test near-zero curvature (Taylor series)
+    pc_bent_zero = pc.bend(curvature=1e-9, axis=0, control_axis=1, anchor="min")
+    pc_unbent_zero = pc_bent_zero.unbend(curvature=1e-9, axis=0, control_axis=1, anchor="min")
+    np.testing.assert_allclose(pc_unbent_zero.points, pts, atol=1e-7)
+
+
 def test_taper():
     pts_offset = np.array([
         [2.0, 3.0, 0.0],

{pysurgery-2.2.2 → pysurgery-2.2.3}/tests/test_point_cloud_mappings.py

@@ -120,3 +120,38 @@ def test_simplicial_complex_concatenation():
     assert sc_concat.filtration[(0, 1)] == 0.5
     assert sc_concat.filtration[(3,)] == 0.2
     assert sc_concat.filtration[(3, 4)] == 0.6
+
+def test_point_cloud_parent_linkage():
+    from pysurgery.geometry import PointCloud
+    pts = np.array([
+        [0.0, 0.0],
+        [1.0, 0.0],
+        [0.0, 1.0],
+        [1.0, 1.0]
+    ])
+    pc = PointCloud(pts)
+    assert pc._parent is None
+
+    # 1. Test from_vietoris_rips links pc
+    sc_rips = SimplicialComplex.from_vietoris_rips(pc, epsilon=1.5, max_dimension=1)
+    assert pc._parent is sc_rips
+    
+    # Rotate pc, check that coordinates of sc_rips are updated!
+    pc_rot = pc.rotate(90.0, plane="xy", center=np.zeros(2))
+    np.testing.assert_allclose(sc_rips._coordinates, pc_rot.points)
+
+    # 2. Test from_alpha_complex links pc
+    pc2 = PointCloud(pts)
+    sc_alpha = SimplicialComplex.from_alpha_complex(pc2, alpha=2.0)
+    assert pc2._parent is sc_alpha
+    pc2_trans = pc2.translate([10.0, 10.0])
+    np.testing.assert_allclose(sc_alpha._coordinates, pc2_trans.points)
+
+    # 3. Test setter
+    pc3 = PointCloud(pts)
+    sc_empty = SimplicialComplex.from_simplices([[0], [1], [2]])
+    sc_empty.point_cloud = pc3
+    assert pc3._parent is sc_empty
+    pc3_trans = pc3.translate([-5.0, 0.0])
+    np.testing.assert_allclose(sc_empty._coordinates, pc3_trans.points)
+