coordinate-system 2.5.4__cp313-cp313-win_amd64.whl → 2.5.5__cp313-cp313-win_amd64.whl

coordinate_system/curvature.py

@@ -18,26 +18,17 @@ Methods Available:
 1. Classical Method: First/Second Fundamental Forms + 5-point finite differences
    - Precision: O(h⁴) convergence, typical error < 0.001%
 
-2. Intrinsic Gradient Operator Method: G_μ = (c(u+h) - c(u))/h
+2. Intrinsic Gradient Operator Method: G_μ = (c(u+h) - c(u-h)) / (2h)
    - Based on coordinate system changes analysis
    - Numerically stable and geometrically intuitive
 
 Author: PanGuoJun
-Version: 2.4.0
-Date: 2025-10-30
 """
 
 import numpy as np
 from typing import Tuple, Optional, Dict, List, Callable, Union
-from .differential_geometry import Surface
+from .differential_geometry import Surface, MetricTensor, IntrinsicGradientOperator, IntrinsicGradientCurvatureCalculator
 from .coordinate_system import coord3, vec3
-from .differential_geometry import (
-    MetricTensor,
-    IntrinsicGradientOperator,
-    IntrinsicGradientCurvatureCalculator,
-    compute_curvature_tensor as compute_curvature_tensor_lie,
-    compute_all_curvatures as compute_all_curvatures_intrinsic
-)
 
 
 # ========== High-Order Finite Difference Operators ==========
@@ -508,186 +499,75 @@ def all_curvatures(
     return calc.compute_all_curvatures(u, v)
 
 
-# ========== Lie Group Method ==========
+# ========== Intrinsic Gradient Operator Method ==========
 
-class LieGroupCurvatureCalculator:
+class IntrinsicGradientCurvatureCalculator:
     """
-    Curvature calculator using Lie group frame field method
-
-    This method uses coord3 Lie group operations to compute curvature
-    through connection operators (frame derivatives) and Cartan structure equations.
-
-    Theory:
-    1. Construct intrinsic frame c(u,v) ∈ SO(3) (orthonormalized)
-    2. Construct embedding frame C(u,v) (preserving metric with scale vector)
-    3. Compute connection operator: G' = (c₂·c₁⁻¹)/C₂ - I/C₁
-    4. Apply corrections: G = scale × G' / √det(g)
-    5. Compute curvature tensor: Θ = [G_u, G_v] - G_{[u,v]}
-    6. Extract Gaussian curvature: K = Θ₁₂ / det(g)
-
-    Advantages:
-    - Eliminates parametrization dependence through intrinsic frames
-    - Natural handling of scale through coord3 Lie group structure
-    - Compatible with C++ optimized implementations
-
-    Comparison with Classical Method:
-    - Classical: Uses first/second fundamental forms directly
-    - Lie Group: Uses frame field derivatives (connection operators)
-    - Both methods converge to same result with proper corrections
+    Curvature calculator using the CORRECTED intrinsic gradient operator method
+    
+    This uses the proven algorithm: G_μ = (c(u+h) - c(u-h)) / (2h) then extract .VZ()
     """
-
-    def __init__(
-        self,
-        surface: Surface,
-        step_size: float = 1e-3,
-        scale_factor: float = 2.0,
-        use_metric_correction: bool = True,
-        use_lie_derivative: bool = True
-    ):
+    
+    def __init__(self, surface: Surface, step_size: float = 1e-3):
         """
-        Initialize Lie group curvature calculator
+        Initialize intrinsic gradient curvature calculator
 
         Args:
             surface: Surface object
-            step_size: Finite difference step size (default: 1e-3, optimal for O(h²) convergence)
-            scale_factor: Scaling factor for connection correction (default: 2.0, precomputed correction for self-referencing terms)
-            use_metric_correction: Whether to apply metric correction (default: True)
-            use_lie_derivative: Whether to include Lie derivative term (default: True)
-                              Highly recommended for accuracy!
+            step_size: Step size for gradient computation (default 0.001)
         """
         self.surface = surface
         self.h = step_size
-        self.scale_factor = scale_factor
-        self.use_metric_correction = use_metric_correction
-        self.use_lie_derivative = use_lie_derivative
+        self.grad_op = IntrinsicGradientOperator(surface, step_size)
 
     def compute_gaussian_curvature(self, u: float, v: float) -> float:
         """
-        Compute Gaussian curvature using Lie group method
-
-        Args:
-            u, v: Parameter coordinates
-
-        Returns:
-            Gaussian curvature K
-
-        Example:
-            >>> from coordinate_system import Sphere
-            >>> from coordinate_system.curvature import LieGroupCurvatureCalculator
-            >>> import math
-            >>>
-            >>> sphere = Sphere(radius=2.0)
-            >>> calc = LieGroupCurvatureCalculator(sphere)
-            >>> K = calc.compute_gaussian_curvature(math.pi/4, math.pi/6)
-            >>> print(f"K = {K:.6f}, Expected = 0.250000")
-        """
-        # Temporarily set surface.h to match calculator's step size
-        original_h = self.surface.h
-        self.surface.h = self.h
-
-        try:
-            # Compute curvature tensor using connection operators
-            R_uv = compute_curvature_tensor_lie(
-                self.surface, u, v,
-                scale_factor=self.scale_factor,
-                use_metric_correction=self.use_metric_correction,
-                use_lie_derivative=self.use_lie_derivative
-            )
-
-            # Compute metric tensor
-            g = MetricTensor.from_surface(self.surface, u, v)
-
-            # Extract Gaussian curvature using antisymmetric part
-            # K = R_{12}^{antisym} / det(g) = (R_01 - R_10)/2 / det(g)
-            #
-            # R_uv is a coord3 representing the curvature tensor as a 3×3 matrix:
-            # R_uv.ux = [R_00, R_01, R_02]  (first row)
-            # R_uv.uy = [R_10, R_11, R_12]  (second row)
-            # R_uv.uz = [R_20, R_21, R_22]  (third row)
-            #
-            # We need:
-            # R_01 = R_uv.ux.y (first row, second column)
-            # R_10 = R_uv.uy.x (second row, first column)
-            R_01 = R_uv.ux.y
-            R_10 = R_uv.uy.x
-
-            # Antisymmetric part extracts pure curvature (eliminates metric influence)
-            R_12_antisym = (R_01 - R_10) / 2.0
-
-            if abs(g.det) > 1e-14:
-                K = R_12_antisym / g.det
-            else:
-                K = 0.0
-
-            return K
-        finally:
-            # Restore original step size
-            self.surface.h = original_h
-
-    def compute_all_curvatures(self, u: float, v: float) -> Dict[str, Union[float, np.ndarray, coord3]]:
+        Compute Gaussian curvature using corrected intrinsic gradient method
         """
-        Compute curvature and related quantities using Lie group method
-
-        Args:
-            u, v: Parameter coordinates
+        # Compute gradient operators using the proven central difference algorithm
+        G_u, G_v, _ = self.grad_op.compute_both(u, v)
+
+        # Compute tangent vectors
+        r_u = self.surface.tangent_u(u, v)
+        r_v = self.surface.tangent_v(u, v)
+
+        # Extract normal derivatives (already computed using correct algorithm)
+        dn_du = G_u.dn
+        dn_dv = G_v.dn
+
+        # Compute metric tensor
+        E = r_u.dot(r_u)
+        F = r_u.dot(r_v)
+        G = r_v.dot(r_v)
+        metric_det = E * G - F * F
+
+        # Compute second fundamental form
+        L = -dn_du.dot(r_u)
+        M1 = -dn_du.dot(r_v)
+        M2 = -dn_dv.dot(r_u)
+        N = -dn_dv.dot(r_v)
+        M = (M1 + M2) / 2.0
+
+        # Gaussian curvature
+        if abs(metric_det) > 1e-14:
+            K = (L * N - M * M) / metric_det
+        else:
+            K = 0.0
 
-        Returns:
-            Dictionary containing:
-            - 'K': Gaussian curvature
-            - 'R_uv': Curvature tensor (coord3 object)
-            - 'G_u': Connection operator in u direction (coord3)
-            - 'G_v': Connection operator in v direction (coord3)
-            - 'g': Metric tensor (MetricTensor object)
-            - 'det_g': Metric determinant
+        return K
 
-        Example:
-            >>> calc = LieGroupCurvatureCalculator(sphere)
-            >>> result = calc.compute_all_curvatures(math.pi/4, math.pi/6)
-            >>> print(f"K = {result['K']:.6f}")
-            >>> print(f"det(g) = {result['det_g']:.6f}")
+    def compute_all_curvatures(self, u: float, v: float) -> dict:
         """
-        # Temporarily set surface.h to match calculator's step size
-        original_h = self.surface.h
-        self.surface.h = self.h
-
-        try:
-            # Compute intrinsic gradient operators
-            intrinsic_op = IntrinsicGradientOperator(
-                self.surface,
-                self.h
-            )
-            G_u, G_v = intrinsic_op.compute_both(u, v)
-
-            # Compute curvature tensor
-            R_uv = compute_curvature_tensor_lie(
-                self.surface, u, v,
-                scale_factor=self.scale_factor,
-                use_metric_correction=self.use_metric_correction,
-                use_lie_derivative=self.use_lie_derivative
-            )
-
-            # Compute metric
-            g = MetricTensor.from_surface(self.surface, u, v)
-
-            # Extract Gaussian curvature using antisymmetric part
-            # K = (R_01 - R_10)/2 / det(g)
-            R_01 = R_uv.ux.y
-            R_10 = R_uv.uy.x
-            R_12_antisym = (R_01 - R_10) / 2.0
-            K = R_12_antisym / g.det if abs(g.det) > 1e-14 else 0.0
-
-            return {
-                'K': K,
-                'R_uv': R_uv,
-                'G_u': G_u,
-                'G_v': G_v,
-                'g': g,
-                'det_g': g.det,
-                'R_12_antisym': R_12_antisym
-            }
-        finally:
-            # Restore original step size
-            self.surface.h = original_h
+        Compute all curvature quantities using intrinsic gradient method
+        """
+        K = self.compute_gaussian_curvature(u, v)
+        
+        # For other curvatures, use the existing implementation
+        calc = IntrinsicGradientCurvatureCalculator(self.surface, self.h)
+        result = calc.compute_all_curvatures(u, v)
+        result['gaussian_curvature'] = K  # Ensure our corrected K is used
+        
+        return result
 
 
 def compare_methods(
@@ -695,21 +575,21 @@ def compare_methods(
     u: float,
     v: float,
     step_size_classical: float = 1e-3,
-    step_size_lie: float = 1e-5
+    step_size_intrinsic: float = 1e-3
 ) -> Dict[str, float]:
     """
-    Compare classical and Lie group curvature methods
+    Compare classical and intrinsic gradient curvature methods
 
     Args:
         surface: Surface object
         u, v: Parameter coordinates
         step_size_classical: Step size for classical method
-        step_size_lie: Step size for Lie group method
+        step_size_intrinsic: Step size for intrinsic gradient method
 
     Returns:
         Dictionary with comparison results:
         - 'K_classical': Gaussian curvature from classical method
-        - 'K_lie': Gaussian curvature from Lie group method
+        - 'K_intrinsic': Gaussian curvature from intrinsic gradient method
         - 'difference': Absolute difference
         - 'relative_error': Relative error (if K_classical != 0)
 
@@ -721,93 +601,53 @@ def compare_methods(
         >>> sphere = Sphere(radius=2.0)
         >>> result = compare_methods(sphere, math.pi/4, math.pi/6)
         >>> print(f"Classical: K = {result['K_classical']:.8f}")
-        >>> print(f"Lie Group: K = {result['K_lie']:.8f}")
+        >>> print(f"Intrinsic: K = {result['K_intrinsic']:.8f}")
         >>> print(f"Difference: {result['difference']:.2e}")
     """
     # Classical method
     calc_classical = CurvatureCalculator(surface, step_size_classical)
     K_classical = calc_classical.compute_gaussian_curvature(u, v)
 
-    # Lie group method
-    calc_lie = LieGroupCurvatureCalculator(surface, step_size_lie)
-    K_lie = calc_lie.compute_gaussian_curvature(u, v)
+    # Intrinsic gradient method
+    calc_intrinsic = IntrinsicGradientCurvatureCalculator(surface, step_size_intrinsic)
+    K_intrinsic = calc_intrinsic.compute_gaussian_curvature(u, v)
 
     # Comparison
-    difference = abs(K_classical - K_lie)
+    difference = abs(K_classical - K_intrinsic)
     relative_error = difference / abs(K_classical) if abs(K_classical) > 1e-14 else 0.0
 
     return {
         'K_classical': K_classical,
-        'K_lie': K_lie,
+        'K_intrinsic': K_intrinsic,
         'difference': difference,
         'relative_error': relative_error
     }
 
 
-def gaussian_curvature_lie(
-    surface: Surface,
-    u: float,
-    v: float,
-    step_size: float = 1e-5,
-    scale_factor: float = 2.0,
-    use_metric_correction: bool = True,
-    use_lie_derivative: bool = True
-) -> float:
-    """
-    Compute Gaussian curvature using Lie group method (simplified interface)
-
-    Args:
-        surface: Surface object
-        u, v: Parameter coordinates
-        step_size: Finite difference step size (default: 1e-5)
-        scale_factor: Scaling factor for correction (default: 2.0)
-        use_metric_correction: Whether to apply metric correction
-        use_lie_derivative: Whether to include Lie derivative term
-
-    Returns:
-        Gaussian curvature K
-
-    Example:
-        >>> from coordinate_system import Sphere
-        >>> from coordinate_system.curvature import gaussian_curvature_lie
-        >>> import math
-        >>>
-        >>> sphere = Sphere(radius=2.0)
-        >>> K = gaussian_curvature_lie(sphere, math.pi/4, math.pi/6)
-        >>> print(f"K = {K:.6f}")
-    """
-    calc = LieGroupCurvatureCalculator(
-        surface, step_size, scale_factor,
-        use_metric_correction, use_lie_derivative
-    )
-    return calc.compute_gaussian_curvature(u, v)
-
-
-# ========== Intrinsic Gradient Operator Method ==========
-# Now imported from differential_geometry module
-from .differential_geometry import (
-    IntrinsicGradientOperator,
-    IntrinsicGradientCurvatureCalculator,
-)
+# ========== Convenience Functions for Intrinsic Gradient Method ==========
 
-# Define convenience functions for backward compatibility
 def intrinsic_gradient_gaussian_curvature(surface, u, v, step_size=1e-3):
+    """Compute Gaussian curvature using intrinsic gradient method"""
     calc = IntrinsicGradientCurvatureCalculator(surface, step_size)
     return calc.compute_gaussian_curvature(u, v)
 
 def intrinsic_gradient_mean_curvature(surface, u, v, step_size=1e-3):
+    """Compute mean curvature using intrinsic gradient method"""
     calc = IntrinsicGradientCurvatureCalculator(surface, step_size)
     return calc.compute_mean_curvature(u, v)
 
 def intrinsic_gradient_principal_curvatures(surface, u, v, step_size=1e-3):
+    """Compute principal curvatures using intrinsic gradient method"""
     calc = IntrinsicGradientCurvatureCalculator(surface, step_size)
     result = calc.compute_all_curvatures(u, v)
     return result['principal_curvatures']
 
 def intrinsic_gradient_all_curvatures(surface, u, v, step_size=1e-3):
+    """Compute all curvatures using intrinsic gradient method"""
     calc = IntrinsicGradientCurvatureCalculator(surface, step_size)
     return calc.compute_all_curvatures(u, v)
 
+
 # ========== Export ==========
 
 __all__ = [
@@ -818,21 +658,16 @@ __all__ = [
     'principal_curvatures',
     'all_curvatures',
 
-    # Lie group method
-    'LieGroupCurvatureCalculator',
-    'gaussian_curvature_lie',
-    'compare_methods',
-
     # Intrinsic Gradient Operator method
-    'IntrinsicGradientOperator',
     'IntrinsicGradientCurvatureCalculator',
     'intrinsic_gradient_gaussian_curvature',
     'intrinsic_gradient_mean_curvature',
     'intrinsic_gradient_principal_curvatures',
     'intrinsic_gradient_all_curvatures',
+    'compare_methods',
 
     # Utility functions
     'derivative_5pt',
     'derivative_2nd_5pt',
     'richardson_extrapolation',
-]
+]

coordinate_system/differential_geometry.py

@@ -6,11 +6,10 @@ This module provides tools for discrete differential geometry computations on su
 using the CORRECT Intrinsic Gradient Operator framework based on the proven algorithm.
 
 Key Formula:
-    G_μ = (c(u+h) - c(u)) / h
-    where c is the embedding frame (NOT pure intrinsic frame)
+    G_μ = (c(u+h) - c(u-h)) / (2h)  then extract normal derivative using .VZ()
 
 Author: PanGuoJun
-Version: 3.2.0 (Fixed)
+Version: 3.3.0 (Corrected Intrinsic Gradient)
 Date: 2025-10-31
 """
 
@@ -145,45 +144,14 @@ class MetricTensor:
         return f"MetricTensor(E={self.E:.6f}, F={self.F:.6f}, G={self.G:.6f}, det={self.det:.6f})"
 
 
-# ========== Helper Class for Embedding Frame ==========
-
-class EmbeddingFrame:
-    """
-    Helper class to represent embedding frame with metric information
-    This replaces complex coord3 operations for clarity
-    """
-
-    def __init__(self, origin: vec3, e1: vec3, e2: vec3, n: vec3, s1: float, s2: float):
-        """
-        Initialize embedding frame
-
-        Args:
-            origin: Position on surface
-            e1, e2: Orthonormal tangent vectors
-            n: Unit normal vector
-            s1, s2: Scale factors (lengths of original tangent vectors)
-        """
-        self.origin = origin
-        self.e1 = e1
-        self.e2 = e2
-        self.n = n
-        self.s1 = s1
-        self.s2 = s2
-
-    def metric_det(self) -> float:
-        """Compute metric determinant from scale factors"""
-        return self.s1 * self.s1 * self.s2 * self.s2
-
-
 # ========== CORRECT Intrinsic Gradient Operator ==========
 
 class IntrinsicGradientOperator:
     """
     CORRECT Implementation of Intrinsic Gradient Operator
-    Based on proven formula: G_μ = (c(u+h) - c(u)) / h
+    Based on proven formula: G_μ = (c(u+h) - c(u-h)) / (2h) then extract .VZ()
 
-    Key insight: Use coord3's normalize() to separate rotation and scaling,
-    which is the core advantage of our coordinate system design.
+    This matches the validated algorithm from the working test code.
     """
 
     def __init__(self, surface: Surface, step_size: float = 1e-3):
@@ -197,78 +165,89 @@ class IntrinsicGradientOperator:
         self.surface = surface
         self.h = step_size
 
-    def calc_embedding_frame(self, u: float, v: float) -> EmbeddingFrame:
+    def calc_intrinsic_frame(self, u: float, v: float) -> coord3:
         """
-        Calculate embedding frame at point (u, v) using coord3's normalize
-        CRITICAL: Leverages coord3's ability to separate rotation and scaling
+        Calculate intrinsic frame at point (u, v)
+        
+        This matches the algorithm from the working test code:
+        - Compute position and tangent vectors
+        - Create orthonormal frame with unit vectors
+        - Return coord3 object for vector operations
         """
-        # Get tangent vectors
+        # Position vector
+        pos = self.surface.position(u, v)
+        
+        # Tangent vectors
         r_u = self.surface.tangent_u(u, v)
         r_v = self.surface.tangent_v(u, v)
-
-        # Create coord3 frame with tangent vectors (not normalized yet)
-        c = coord3()
-        c.o = self.surface.position(u, v)
-        c.ux = r_u
-        c.uy = r_v
-        c.uz = r_u.cross(r_v)
-
-        # Use coord3's normalize to separate rotation and scale
-        # This is the KEY operation that separates our design from matrices!
-        c.normalize(False)  # False = don't normalize scale factors
-
-        # Now c.ux, c.uy, c.uz are unit vectors
-        # and c.s contains the original scales
-
-        # Apply Gram-Schmidt for orthogonality while preserving scales
-        e1 = c.ux
-        e2_temp = c.uy - e1 * c.uy.dot(e1)
-        e2 = e2_temp.normcopy()
-        n = e1.cross(e2).normcopy()
-
-        # Get the scale factors (metric information)
-        s1 = c.s.x  # Scale from r_u
-        s2 = (r_v - e1 * r_v.dot(e1)).len()  # Scale from r_v orthogonal component
-
-        return EmbeddingFrame(c.o, e1, e2, n, s1, s2)
-
-    def compute_both(self, u: float, v: float) -> Tuple['GradientResult', 'GradientResult']:
+        
+        # Unit normal vector
+        n = r_u.cross(r_v).normalized()
+        
+        # Unit tangent vectors
+        e1 = r_u.normalized()
+        e2 = r_v.normalized()
+        
+        # Ensure orthonormality
+        e2_corrected = (e2 - e1 * e2.dot(e1)).normalized()
+        n_corrected = e1.cross(e2_corrected).normalized()
+        
+        # Create intrinsic frame
+        frame = coord3()
+        frame.o = pos
+        frame.ux = e1
+        frame.uy = e2_corrected
+        frame.uz = n_corrected
+        
+        return frame
+
+    def compute_both(self, u: float, v: float) -> Tuple['GradientResult', 'GradientResult', coord3]:
         """
-        Compute intrinsic gradient operators in both directions
-        Returns simplified gradient results containing only necessary information
+        Compute intrinsic gradient operators in both directions using CENTRAL DIFFERENCES
+        
+        This implements the proven algorithm:
+        dn_du = ((c(u+h) - c(u-h)) / (2h)).VZ()
         """
-        # Compute frames
-        c_center = self.calc_embedding_frame(u, v)
-        c_u_plus = self.calc_embedding_frame(u + self.h, v)
-        c_v_plus = self.calc_embedding_frame(u, v + self.h)
-
-        # Compute gradient operators: G_μ = (c(u+h) - c(u)) / h
-        G_u = GradientResult(c_center, c_u_plus, self.h)
-        G_v = GradientResult(c_center, c_v_plus, self.h)
-
+        # Compute frames using central differences (like the working test code)
+        c_center = self.calc_intrinsic_frame(u, v)
+        
+        # u-direction: central difference
+        c_u_plus = self.calc_intrinsic_frame(u + self.h, v)
+        c_u_minus = self.calc_intrinsic_frame(u - self.h, v)
+        dn_du = ((c_u_plus - c_u_minus) / (2 * self.h)).VZ()
+        
+        # v-direction: central difference  
+        c_v_plus = self.calc_intrinsic_frame(u, v + self.h)
+        c_v_minus = self.calc_intrinsic_frame(u, v - self.h)
+        dn_dv = ((c_v_plus - c_v_minus) / (2 * self.h)).VZ()
+        
+        # Create gradient results
+        G_u = GradientResult(dn_du, "u")
+        G_v = GradientResult(dn_dv, "v")
+        
         return G_u, G_v, c_center
 
 
 class GradientResult:
     """
-    Simplified gradient result containing normal vector derivative
+    Gradient result containing normal vector derivative
+    
+    Simplified version that directly stores the computed derivative
     """
 
-    def __init__(self, c_center: EmbeddingFrame, c_shifted: EmbeddingFrame, h: float):
+    def __init__(self, dn: vec3, direction: str):
         """
-        Compute gradient from two frames
+        Initialize gradient result
 
         Args:
-            c_center: Frame at center point
-            c_shifted: Frame at shifted point
-            h: Step size
+            dn: Normal vector derivative (computed using proven algorithm)
+            direction: Parameter direction ('u' or 'v')
         """
-        # Compute normal vector derivative (the key information we need)
-        self.dn = vec3(
-            (c_shifted.n.x - c_center.n.x) / h,
-            (c_shifted.n.y - c_center.n.y) / h,
-            (c_shifted.n.z - c_center.n.z) / h
-        )
+        self.dn = dn
+        self.direction = direction
+
+    def __repr__(self) -> str:
+        return f"GradientResult({self.direction}: [{self.dn.x:.6f}, {self.dn.y:.6f}, {self.dn.z:.6f}])"
 
 
 # ========== Curvature Calculator ==========
@@ -296,26 +275,28 @@ class IntrinsicGradientCurvatureCalculator:
 
         Formula: K = (LN - M²) / det(g)
         """
-        # Compute gradient operators and embedding frame
-        G_u, G_v, c_center = self.grad_op.compute_both(u, v)
-
-        # Get metric determinant
-        metric_det = c_center.metric_det()
+        # Compute gradient operators using the proven algorithm
+        G_u, G_v, _ = self.grad_op.compute_both(u, v)
 
         # Compute tangent vectors
         r_u = self.surface.tangent_u(u, v)
         r_v = self.surface.tangent_v(u, v)
 
-        # Extract normal derivatives
+        # Extract normal derivatives (already computed using correct algorithm)
         dn_du = G_u.dn
         dn_dv = G_v.dn
 
+        # Compute metric tensor
+        E = r_u.dot(r_u)
+        F = r_u.dot(r_v)
+        G = r_v.dot(r_v)
+        metric_det = E * G - F * F
+
         # Compute second fundamental form
         L = -dn_du.dot(r_u)  # -<dn/du, r_u>
         M1 = -dn_du.dot(r_v)  # -<dn/du, r_v>
         M2 = -dn_dv.dot(r_u)  # -<dn/dv, r_u>
         N = -dn_dv.dot(r_v)   # -<dn/dv, r_v>
-
         M = (M1 + M2) / 2.0  # Symmetrize
 
         # Gaussian curvature
@@ -335,7 +316,7 @@ class IntrinsicGradientCurvatureCalculator:
         # Compute gradient operators
         G_u, G_v, _ = self.grad_op.compute_both(u, v)
 
-        # Compute metric tensor
+        # Compute tangent vectors and metric
         r_u = self.surface.tangent_u(u, v)
         r_v = self.surface.tangent_v(u, v)
         E = r_u.dot(r_u)
@@ -489,17 +470,21 @@ def compute_intrinsic_gradient(
         GradientResult object
     """
     grad_op = IntrinsicGradientOperator(surface, step_size)
-
-    c_center = grad_op.calc_embedding_frame(u, v)
-
+    
     if direction == 'u':
-        c_shifted = grad_op.calc_embedding_frame(u + step_size, v)
+        # Compute central difference for u direction
+        c_plus = grad_op.calc_intrinsic_frame(u + step_size, v)
+        c_minus = grad_op.calc_intrinsic_frame(u - step_size, v)
+        dn = ((c_plus - c_minus) / (2 * step_size)).VZ()
     elif direction == 'v':
-        c_shifted = grad_op.calc_embedding_frame(u, v + step_size)
+        # Compute central difference for v direction
+        c_plus = grad_op.calc_intrinsic_frame(u, v + step_size)
+        c_minus = grad_op.calc_intrinsic_frame(u, v - step_size)
+        dn = ((c_plus - c_minus) / (2 * step_size)).VZ()
     else:
         raise ValueError(f"direction must be 'u' or 'v', got: {direction}")
 
-    return GradientResult(c_center, c_shifted, step_size)
+    return GradientResult(dn, direction)
 
 
 # ========== Backward Compatibility (DEPRECATED) ==========

{coordinate_system-2.5.4.dist-info → coordinate_system-2.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coordinate_system
-Version: 2.5.4
+Version: 2.5.5
 Summary: High-performance 3D coordinate system library with Intrinsic Gradient Operator method for curvature computation, achieving machine-precision accuracy
 Home-page: https://github.com/panguojun/Coordinate-System
 Author: PanGuoJun

coordinate_system-2.5.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+coordinate_system/__init__.py,sha256=wDY6E9q4mzfeLWqhVd7sakzmHXUXIoV8o1BG4THlKHI,7858
+coordinate_system/coordinate_system.cp313-win_amd64.pyd,sha256=5H6KLnWa6TN5Pb8UhwzZZ14dNbVIOrQ8mO4SbU0O3Jw,497152
+coordinate_system/curvature.py,sha256=O1IJBC2TdS38tZ0T9DAuIIugvCqgJjHKNGwsmlQl5Hw,21737
+coordinate_system/differential_geometry.py,sha256=_DtJQ60thyE9eM0tFzmsnoyUbaf6uw8g0UAZeBN3RcM,14981
+coordinate_system-2.5.5.dist-info/LICENSE,sha256=tDnRkJxBYPzWdfh2gArRqrUPJxQZRZHJVs68qqBHIq4,1083
+coordinate_system-2.5.5.dist-info/METADATA,sha256=_04i-WzKPln695kKCPDfY3IrHOx48FBYSshg9uSNJZI,19428
+coordinate_system-2.5.5.dist-info/WHEEL,sha256=4-iQBlRoDdX1wfPofc7KLWa5Cys4eZSgXs6GVU8fKlQ,101
+coordinate_system-2.5.5.dist-info/top_level.txt,sha256=R6LguuPPZ5esrIsDTqPGi9UxCvZPIXwn7KRKX87c79M,18
+coordinate_system-2.5.5.dist-info/RECORD,,

coordinate_system/coord3_wrapper.py

@@ -1,300 +0,0 @@
-"""
-Coord3 Wrapper for Intrinsic Gradient Operator
-===============================================
-
-This module provides a Python wrapper for coord3 that correctly implements
-the mathematical operations needed for the intrinsic gradient operator.
-
-Key insight: Use coord3's normalize() to separate rotation and scaling,
-which is a core advantage of our coordinate system design over matrices.
-
-Solution: Implement subtraction that properly handles the rotation-scale separation.
-"""
-
-import numpy as np
-from .coordinate_system import coord3 as _coord3, vec3
-import math
-
-
-class Coord3Wrapper:
-    """
-    Wrapper for coord3 that implements correct arithmetic for gradient operators
-
-    The intrinsic gradient operator requires:
-    G_μ = (c(u+h) - c(u)) / h
-
-    This implementation leverages coord3's ability to separate rotation and scaling.
-    """
-
-    def __init__(self, coord3_obj=None):
-        """
-        Initialize from a coord3 object or create new
-
-        Args:
-            coord3_obj: Original coord3 object from C++ binding
-        """
-        if coord3_obj is None:
-            self._c3 = _coord3()
-        else:
-            self._c3 = coord3_obj
-            # Ensure normalization to separate rotation and scale
-            self.normalize_axes()
-
-    def normalize_axes(self):
-        """
-        Normalize axes and extract scale factors
-
-        This is the key operation that separates rotation from scaling,
-        which is the core advantage of coord3 over matrix representations.
-        """
-        # Extract scale factors from current axes
-        sx = math.sqrt(self._c3.ux.dot(self._c3.ux))
-        sy = math.sqrt(self._c3.uy.dot(self._c3.uy))
-        sz = math.sqrt(self._c3.uz.dot(self._c3.uz))
-
-        # Normalize axes (pure rotation)
-        if sx > 1e-10:
-            self._c3.ux = self._c3.ux / sx
-        if sy > 1e-10:
-            self._c3.uy = self._c3.uy / sy
-        if sz > 1e-10:
-            self._c3.uz = self._c3.uz / sz
-
-        # Store scale factors separately
-        self._c3.s = vec3(sx, sy, sz)
-
-    @property
-    def o(self):
-        """Origin/position"""
-        return self._c3.o
-
-    @property
-    def ux(self):
-        """X axis direction (unit vector)"""
-        return self._c3.ux
-
-    @property
-    def uy(self):
-        """Y axis direction (unit vector)"""
-        return self._c3.uy
-
-    @property
-    def uz(self):
-        """Z axis direction (unit vector)"""
-        return self._c3.uz
-
-    @property
-    def s(self):
-        """Scale factors"""
-        return self._c3.s
-
-    def VX(self):
-        """Scaled X axis = ux * s.x"""
-        return vec3(
-            self.ux.x * self.s.x,
-            self.ux.y * self.s.x,
-            self.ux.z * self.s.x
-        )
-
-    def VY(self):
-        """Scaled Y axis = uy * s.y"""
-        return vec3(
-            self.uy.x * self.s.y,
-            self.uy.y * self.s.y,
-            self.uy.z * self.s.y
-        )
-
-    def VZ(self):
-        """Scaled Z axis = uz * s.z"""
-        return vec3(
-            self.uz.x * self.s.z,
-            self.uz.y * self.s.z,
-            self.uz.z * self.s.z
-        )
-
-    def __sub__(self, other):
-        """
-        Subtraction for gradient operator with proper rotation-scale separation
-
-        This leverages coord3's design advantage:
-        1. Both frames are normalized (rotation and scale separated)
-        2. Compute differences in rotation (unit vectors)
-        3. Compute differences in scale (scale factors)
-        4. Keep them separated for proper gradient computation
-        """
-        result = Coord3Wrapper()
-
-        # Ensure both frames are normalized
-        self.normalize_axes()
-        if isinstance(other, Coord3Wrapper):
-            other.normalize_axes()
-
-        # Origin difference
-        result._c3.o = self.o - other.o
-
-        # Rotation differences (unit vectors)
-        result._c3.ux = self.ux - other.ux
-        result._c3.uy = self.uy - other.uy
-        result._c3.uz = self.uz - other.uz
-
-        # Scale differences (kept separate)
-        result._c3.s = self.s - other.s
-
-        return result
-
-    def __truediv__(self, scalar):
-        """
-        Division by scalar for gradient operator
-
-        Used in G_μ = (c(u+h) - c(u)) / h
-        """
-        if isinstance(scalar, (int, float)):
-            result = Coord3Wrapper()
-
-            # Divide all components by scalar
-            result._c3.o = self.o / scalar
-            result._c3.ux = self.ux / scalar
-            result._c3.uy = self.uy / scalar
-            result._c3.uz = self.uz / scalar
-            result._c3.s = self.s / scalar
-
-            return result
-        else:
-            raise TypeError(f"Division only supported by scalar, got {type(scalar)}")
-
-    def compute_metric_det(self):
-        """
-        Compute determinant of metric tensor for 2D surface
-
-        For a surface parametrized by (u,v):
-        g = [[E, F], [F, G]]
-        where E = |∂r/∂u|², F = ∂r/∂u · ∂r/∂v, G = |∂r/∂v|²
-
-        Returns:
-            det(g) = E*G - F²
-        """
-        # Get scaled tangent vectors
-        vx = self.VX()  # ∂r/∂u direction
-        vy = self.VY()  # ∂r/∂v direction
-
-        # First fundamental form coefficients
-        E = vx.dot(vx)  # g_uu
-        F = vx.dot(vy)  # g_uv
-        G = vy.dot(vy)  # g_vv
-
-        # Determinant
-        return E * G - F * F
-
-    def to_coord3(self):
-        """Convert back to original coord3"""
-        return self._c3
-
-    @classmethod
-    def from_surface_frame(cls, surface, u, v, compute_frame_func):
-        """
-        Create from surface using frame computation function
-
-        Args:
-            surface: Surface object
-            u, v: Parameters
-            compute_frame_func: Function to compute embedding frame
-
-        Returns:
-            Coord3Wrapper with proper metric information
-        """
-        frame = compute_frame_func(surface, u, v)
-        return cls(frame)
-
-
-def create_embedding_frame_with_normalize(surface, u, v):
-    """
-    Create embedding frame for surface at point (u,v) using coord3's normalize
-
-    This implementation leverages coord3's design advantage:
-    1. Compute tangent vectors r_u, r_v
-    2. Build initial frame with scaled axes
-    3. Use normalize() to separate rotation and scaling
-    4. Apply Gram-Schmidt in the normalized space
-    5. Preserve metric information in scale factors
-
-    Returns:
-        coord3 with proper embedding frame (rotation and scale separated)
-    """
-    # Get position
-    pos = surface.position(u, v)
-
-    # Compute tangent vectors using finite differences
-    h = 1e-6
-    pos_u_plus = surface.position(u + h, v)
-    pos_u_minus = surface.position(u - h, v)
-    r_u = (pos_u_plus - pos_u_minus) / (2 * h)
-
-    pos_v_plus = surface.position(u, v + h)
-    pos_v_minus = surface.position(u, v - h)
-    r_v = (pos_v_plus - pos_v_minus) / (2 * h)
-
-    # Create initial frame with tangent vectors (not normalized)
-    c = _coord3()
-    c.o = pos
-    c.ux = r_u  # Will be normalized later
-    c.uy = r_v  # Will be normalized later
-
-    # Compute initial normal (may not be unit)
-    n = r_u.cross(r_v)
-    c.uz = n
-
-    # Use coord3's normalize to separate rotation and scale
-    # This automatically extracts scale factors and normalizes axes
-    c.normalize()  # This is the key operation!
-
-    # Now apply Gram-Schmidt to ensure orthogonality
-    # (while preserving the extracted scale factors)
-
-    # Get current scale factors (preserved from normalize)
-    s1 = c.s.x
-    s2 = c.s.y
-    s3 = c.s.z
-
-    # Gram-Schmidt on normalized axes
-    e1 = c.ux  # Already normalized
-
-    # Orthogonalize e2 against e1
-    e2_temp = c.uy - e1 * c.uy.dot(e1)
-    e2_len = math.sqrt(e2_temp.dot(e2_temp))
-    if e2_len > 1e-10:
-        e2 = e2_temp / e2_len
-    else:
-        # Degenerate case: create orthogonal vector
-        if abs(e1.x) < 0.9:
-            e2 = vec3(1, 0, 0) - e1 * e1.x
-        else:
-            e2 = vec3(0, 1, 0) - e1 * e1.y
-        e2 = e2.normalized()
-
-    # Compute orthogonal normal
-    e3 = e1.cross(e2)
-    e3_len = math.sqrt(e3.dot(e3))
-    if e3_len > 1e-10:
-        e3 = e3 / e3_len
-    else:
-        e3 = vec3(0, 0, 1)
-
-    # Update frame with orthonormal axes
-    c.ux = e1
-    c.uy = e2
-    c.uz = e3
-
-    # Preserve the original scale factors (metric information)
-    # This is crucial for curvature computation
-    c.s = vec3(s1, s2, 1.0)
-
-    return c
-
-
-def create_embedding_frame(surface, u, v):
-    """
-    Create embedding frame for surface - backward compatibility wrapper
-
-    Calls the new implementation that uses normalize().
-    """
-    return create_embedding_frame_with_normalize(surface, u, v)

coordinate_system-2.5.4.dist-info/RECORD

@@ -1,10 +0,0 @@
-coordinate_system/__init__.py,sha256=wDY6E9q4mzfeLWqhVd7sakzmHXUXIoV8o1BG4THlKHI,7858
-coordinate_system/coord3_wrapper.py,sha256=d7zi-i0MuNqqN0rAIOo8aoVxOB4Xl4OadmMCG_CpemE,8946
-coordinate_system/coordinate_system.cp313-win_amd64.pyd,sha256=NnAuMCQTuk6dGENjeZEK0q8Hnem10kP64RVGovN4_ds,497664
-coordinate_system/curvature.py,sha256=OEZwTKmuDRwLP1k503oURIBmZtdG70EFlu4Mr-pNjlg,27735
-coordinate_system/differential_geometry.py,sha256=3Pe1JgzW7hY8zVOTARhQmA5d2YUdEK3eeKOgpCpsoo4,15306
-coordinate_system-2.5.4.dist-info/LICENSE,sha256=tDnRkJxBYPzWdfh2gArRqrUPJxQZRZHJVs68qqBHIq4,1083
-coordinate_system-2.5.4.dist-info/METADATA,sha256=Fsc22TPnLnqLllhhtyj_H5FnKoY8p62LTYqJs53Omtw,19428
-coordinate_system-2.5.4.dist-info/WHEEL,sha256=4-iQBlRoDdX1wfPofc7KLWa5Cys4eZSgXs6GVU8fKlQ,101
-coordinate_system-2.5.4.dist-info/top_level.txt,sha256=R6LguuPPZ5esrIsDTqPGi9UxCvZPIXwn7KRKX87c79M,18
-coordinate_system-2.5.4.dist-info/RECORD,,