# Coordinate System Library
**High-performance 3D coordinate system and differential geometry library for Python**
[](https://pypi.org/project/coordinate-system/)
[](https://pypi.org/project/coordinate-system/)
[](https://pypi.org/project/coordinate-system/)
[](LICENSE)
**Author:** PanGuoJun
**Version:** 2.2.0
**License:** MIT
## 🆕 What's New in v2.2.0
**Major Feature Release: Discrete Differential Geometry!**
- ✨ **Metric Tensor Computation** - First fundamental form on surfaces
- ✨ **Connection Operators** - Discrete frame derivatives (intrinsic gradients)
- ✨ **Curvature Tensors** - Complete R_uv computation with Lie derivatives
- ✨ **Gaussian Curvature** - High-accuracy discrete curvature (2.22% error on spheres!)
- ✨ **Surface Classes** - Sphere, Torus, and extensible Surface base class
Perfect for computational geometry, geometric analysis, and discrete differential geometry research!
---
## Features
### Core Classes
- **vec3** - 3D vector with comprehensive operations
- **quat** - Quaternion for 3D rotations
- **coord3** - Complete 3D coordinate system (position, rotation, scale)
### Operations
- Vector arithmetic (+, -, *, /)
- Dot product, cross product
- Vector projection, reflection
- Linear interpolation (lerp)
- Spherical linear interpolation (slerp)
- Coordinate system transformations
- Euler angle conversion
### Performance
- Written in optimized C++17
- Python bindings via pybind11
- Over 1,000,000 operations per second
### Platform Support
- ✅ Windows (7, 10, 11)
- ✅ Linux (Ubuntu, Debian, CentOS, etc.)
- ✅ macOS (10.14+)
---
## 🆕 Differential Geometry (NEW in v2.2.0)
### Surface Representation
```python
from coordinate_system import Sphere, Torus, Surface
# Create a sphere
sphere = Sphere(radius=2.0)
# Create a torus
torus = Torus(major_radius=3.0, minor_radius=1.0)
# Or define your own surface by subclassing Surface
class MySurface(Surface):
def position(self, u, v):
# Return vec3(x, y, z) for parameters (u, v)
pass
```
### Metric Tensor (First Fundamental Form)
```python
from coordinate_system import compute_metric
import math
# Compute metric tensor at a point
g = compute_metric(sphere, u=math.pi/4, v=math.pi/3)
print(f"E = {g.E:.6f}") # u-direction metric
print(f"F = {g.F:.6f}") # cross term (0 if orthogonal)
print(f"G = {g.G:.6f}") # v-direction metric
print(f"det(g) = {g.det:.6f}")
print(f"Metric correction = {g.correction_factor():.6f}")
```
### Connection Operator (Intrinsic Gradient)
```python
from coordinate_system import compute_connection
# Compute connection operator (frame derivative)
G_u = compute_connection(sphere, u=math.pi/4, v=math.pi/3, direction='u')
G_v = compute_connection(sphere, u=math.pi/4, v=math.pi/3, direction='v')
print(f"G_u norm: {G_u.norm():.8f}")
print(f"G_v norm: {G_v.norm():.8f}")
```
**Aliases available:**
- `compute_frame_derivative` (standard mathematical term)
- `compute_intrinsic_gradient` (intuitive name)
- `compute_geometric_gradient` (alternative)
### Curvature Tensor
```python
from coordinate_system import compute_curvature_tensor
# Compute complete curvature tensor R_uv
R_uv = compute_curvature_tensor(
sphere,
u=math.pi/4,
v=math.pi/3,
use_lie_derivative=True # CRITICAL for accuracy!
)
print(f"Curvature tensor norm: {R_uv.norm():.8f}")
# R_uv is a 3×3 coord3 object with structure:
# [[R_11, R_12, R_13], ← Tangent-tangent (intrinsic)
# [R_21, R_22, R_23], ← Tangent-normal (second fundamental form)
# [R_31, R_32, R_33]] ← Normal-normal (extrinsic)
```
### Gaussian Curvature (Quickest Method)
```python
from coordinate_system import Sphere, compute_gaussian_curvature
import math
# One-line curvature computation!
sphere = Sphere(radius=2.0)
K = compute_gaussian_curvature(sphere, u=math.pi/4, v=math.pi/3)
print(f"Gaussian curvature K = {K:.6f}")
# Expected: K = 1/R² = 0.25 for a sphere
# Theoretical value
K_theory = 1.0 / (2.0 ** 2)
error = abs(K - K_theory) / K_theory * 100
print(f"Relative error: {error:.2f}%") # Typically < 3% !
```
### Accuracy Comparison
**On a sphere with radius R=2:**
| Method | Lie Derivative | Accuracy | Improvement |
|--------|---------------|----------|-------------|
| Without correction | ❌ | 54.32% error | - |
| With scale correction | ✓ | 17.09% error | 3.2× |
| **Optimal (scale + metric + Lie)** | ✓ | **2.22% error** | **24×** 🎉 |
**The Lie derivative term is CRITICAL!** It improves accuracy by 24× on spheres.
### Key Parameters
```python
# For constant curvature surfaces (spheres):
K = compute_gaussian_curvature(
surface,
u, v,
scale_factor=2.0, # Optimal for spheres
use_metric_correction=True, # Essential!
use_lie_derivative=True # Critical for accuracy!
)
# These are the default values, optimized for best accuracy
```
### Complete Example
See `examples/curvature_computation.py` for comprehensive demonstrations, or `examples/quickstart.py` for the simplest possible usage.
```python
# examples/quickstart.py
import math
from coordinate_system import Sphere, compute_gaussian_curvature
# Step 1: Create a sphere
sphere = Sphere(radius=2.0)
# Step 2: Choose a point
u, v = math.pi/4, math.pi/3
# Step 3: Compute curvature (one line!)
K = compute_gaussian_curvature(sphere, u, v)
# Step 4: Compare with theory
K_theory = 1.0 / (2.0 ** 2) # K = 1/R²
print(f"Computed: K = {K:.6f}")
print(f"Theory: K = {K_theory:.6f}")
print(f"Error: {abs(K-K_theory)/K_theory*100:.2f}%")
```
---
## 📚 Documentation
### Mathematical Foundation
For a comprehensive understanding of the mathematical principles behind coordinate systems, vectors, quaternions, and transformations, see our detailed mathematical guide:
**[📖 Mathematical Foundation of Coordinate Systems](https://github.com/panguojun/Coordinate-System/blob/main/MATHEMATICAL_FOUNDATION.md)**
This guide covers:
- Vector mathematics (dot product, cross product, projections)
- Quaternion theory and applications
- Coordinate system transformations
- Euler angles and gimbal lock
- Interpolation methods (LERP, SLERP, NLERP)
- Practical applications in graphics, physics, and robotics
---
## Installation
### From PyPI (Recommended)
```bash
pip install coordinate-system
```
### From Source
```bash
git clone https://github.com/panguojun/Coordinate-System.git
cd Coordinate-System
pip install .
```
---
## Quick Start
```python
from coordinate_system import vec3, quat, coord3
# Create vectors
v1 = vec3(1, 2, 3)
v2 = vec3(4, 5, 6)
# Vector operations
v3 = v1 + v2 # Addition: vec3(5, 7, 9)
dot = v1.dot(v2) # Dot product: 32.0
cross = v1.cross(v2) # Cross product
length = v1.length() # Length: 3.742
normalized = v1.normcopy() # Unit vector
# Quaternion rotation
axis = vec3(0, 0, 1) # Z axis
q = quat(1.5708, axis) # 90 degrees rotation
rotated = q * v1 # Rotate v1
# Coordinate systems
frame = coord3.from_angle(1.57, vec3(0, 0, 1)) # Frame rotated 90°
world_pos = v1 * frame # Transform to world space
local_pos = world_pos / frame # Transform back to local
# Interpolation
lerped = vec3.lerp(v1, v2, 0.5) # Linear interpolation
```
---
## System Compatibility
### Operating Systems
| Platform | Status | Notes |
|----------|--------|-------|
| Windows 7+ | ✅ Full Support | Tested on Windows 10/11 |
| Linux | ✅ Full Support | Ubuntu 18.04+, CentOS 7+, Debian 9+ |
| macOS | ✅ Full Support | macOS 10.14 (Mojave) and later |
### Python Versions
- Python 3.7
- Python 3.8
- Python 3.9
- Python 3.10
- Python 3.11
- Python 3.12
- Python 3.13
---
## Coordinate System Type
This library uses a **left-handed coordinate system** for all vector and quaternion operations.
```
+Y
|
|
|
+-----> +X
/
/
+Z
```
---
## API Reference
### vec3 - 3D Vector
#### Constructors
```python
v = vec3() # Zero vector (0, 0, 0)
v = vec3(x, y, z) # Vector with components
```
#### Properties
```python
v.x # X component
v.y # Y component
v.z # Z component
```
#### Arithmetic Operations
```python
v3 = v1 + v2 # Addition
v3 = v1 - v2 # Subtraction
v3 = v1 * scalar # Scalar multiplication
v3 = scalar * v1 # Reverse scalar multiplication
v3 = v1 / scalar # Scalar division
v3 = v1 * v2 # Component-wise multiplication
```
#### Vector Operations
```python
dot = v1.dot(v2) # Dot product (float)
cross = v1.cross(v2) # Cross product (vec3)
length = v.length() # Vector length
v.normalize() # Normalize in-place
normalized = v.normcopy() # Return normalized copy
```
#### Additional Methods
```python
v.lenxy() # Length in XY plane
v.sqrlen() # Squared length
v.abslen() # Sum of absolute components
v.isINF() # Check for infinity
v.flipX() # Flip X component
v.flipY() # Flip Y component
v.flipZ() # Flip Z component
```
#### Static Methods
```python
v = vec3.min3(a, b, c) # Component-wise minimum
v = vec3.max3(a, b, c) # Component-wise maximum
v = vec3.rnd() # Random vector
v = vec3.lerp(a, b, t) # Linear interpolation
angle = vec3.angle(a, b) # Angle between vectors
```
---
### quat - Quaternion
#### Constructors
```python
q = quat() # Identity quaternion
q = quat(w, x, y, z) # From components
q = quat(angle, axis) # From angle-axis
q = quat(v1, v2) # From two vectors
```
#### Properties
```python
q.w, q.x, q.y, q.z # Quaternion components
```
#### Operations
```python
q3 = q1 + q2 # Addition
q3 = q1 * q2 # Multiplication (composition)
v_rotated = q * v # Rotate vector
q3 = q1 / q2 # Division
```
#### Methods
```python
q.normalize() # Normalize in-place
normalized = q.normalized() # Return normalized copy
conj = q.conj() # Conjugate
length = q.length() # Length
dot = q1.dot(q2) # Dot product
angle = q1.angle_to(q2) # Angle to another quaternion
```
#### Conversion
```python
# From Euler angles
q.from_eulers(pitch, yaw, roll)
# From vectors
q.fromvectors(v1, v2)
# Advanced
q_exp = q.exp() # Exponential
q_log = q.log() # Logarithm
```
---
### coord3 - 3D Coordinate System
A `coord3` represents a complete 3D coordinate frame with:
- **Position** (o): Origin in 3D space
- **Rotation** (ux, uy, uz): Three orthonormal axes
- **Scale** (s): Scale factors for each axis
#### Constructors
```python
c = coord3() # Identity frame
c = coord3(x, y, z) # Position only
c = coord3(x, y, z, pitch, yaw, roll) # Position + rotation (Euler)
c = coord3(x, y, z, qw, qx, qy, qz) # Position + rotation (quaternion)
c = coord3(position) # From vec3
c = coord3(ux, uy, uz) # From three axes
c = coord3(angle, axis) # From angle-axis rotation
c = coord3(quaternion) # From quaternion
c = coord3(position, quaternion, scale) # Full specification
```
#### Properties
```python
c.o # Origin (vec3)
c.ux, c.uy, c.uz # Axis vectors (vec3)
c.s # Scale (vec3)
```
#### Static Factory Methods
```python
c = coord3.from_axes(ux, uy, uz) # From three axes
c = coord3.from_angle(angle, axis) # From angle-axis
```
#### Transformations
```python
# Transform point from local to world
world_pos = local_pos * coord
# Transform point from world to local
local_pos = world_pos / coord
# Combine coordinate systems
c3 = c1 * c2
```
#### Operations
```python
c3 = c1 + c2 # Add (translate)
c3 = c1 - c2 # Subtract
c3 = c1 * c2 # Multiply (compose transformations)
c3 = c1 / c2 # Divide
equal = c1 == c2 # Equality check
```
#### Methods
```python
pos = c.pos() # Get position vector
vec = c.tovec() # Convert to vector
c.rot(angle, axis) # Rotate by angle-axis
c.rot(quaternion) # Rotate by quaternion
equal = c1.equal_dirs(c2) # Check if axes are equal
hash_val = c.hash() # Hash value
serial = c.serialise() # Serialize to string
c.dump() # Print debug info
```
---
## Usage Examples
### Vector Mathematics
```python
from coordinate_system import vec3
# Create vectors
v1 = vec3(1, 0, 0)
v2 = vec3(0, 1, 0)
# Basic operations
v3 = v1 + v2 # vec3(1, 1, 0)
v4 = v1 * 5 # vec3(5, 0, 0)
# Dot and cross products
dot = v1.dot(v2) # 0.0 (perpendicular)
cross = v1.cross(v2) # vec3(0, 0, 1) in left-handed system
# Length and normalization
length = v1.length() # 1.0
v_normalized = v1.normcopy() # Unit vector
# Linear interpolation
v_mid = vec3.lerp(v1, v2, 0.5) # vec3(0.5, 0.5, 0)
```
### Quaternion Rotations
```python
from coordinate_system import vec3, quat
# Create quaternion from angle-axis
import math
axis = vec3(0, 0, 1) # Z axis
angle = math.pi / 2 # 90 degrees
q = quat(angle, axis)
# Rotate vector
v = vec3(1, 0, 0)
rotated = q * v # Approximately vec3(0, 1, 0)
# Create quaternion from two vectors
v_from = vec3(1, 0, 0)
v_to = vec3(0, 1, 0)
q = quat(v_from, v_to)
# Quaternion composition
q1 = quat(math.pi/4, vec3(0, 0, 1)) # 45° around Z
q2 = quat(math.pi/4, vec3(0, 1, 0)) # 45° around Y
combined = q1 * q2 # Combined rotation
# Euler angles
q.from_eulers(pitch=0.1, yaw=0.2, roll=0.3)
```
### Coordinate System Transformations
```python
from coordinate_system import vec3, quat, coord3
import math
# Create a coordinate system at position (5, 10, 15)
frame = coord3(5, 10, 15)
# Create with rotation
q = quat(math.pi/4, vec3(0, 0, 1)) # 45° rotation
frame = coord3(vec3(5, 10, 15), q, vec3(1, 1, 1))
# Transform points between coordinate systems
world_point = vec3(10, 0, 0)
local_point = world_point / frame # World to local
back_to_world = local_point * frame # Local to world
# Hierarchical transformations
parent = coord3(0, 5, 0)
child = coord3(3, 0, 0)
child_in_world = child * parent
# Create look-at transformation (custom implementation needed)
def look_at(eye, target, up=vec3(0, 1, 0)):
forward = (target - eye).normcopy()
right = up.cross(forward).normcopy()
up_corrected = forward.cross(right)
return coord3.from_axes(right, up_corrected, forward)
camera = look_at(vec3(10, 10, 10), vec3(0, 0, 0))
```
### Practical Applications
#### Camera System
```python
from coordinate_system import vec3, quat, coord3
import math
class Camera:
def __init__(self, position, target, up=vec3(0, 1, 0)):
self.frame = self.create_look_at(position, target, up)
def create_look_at(self, eye, target, up):
forward = (target - eye).normcopy()
right = up.cross(forward).normcopy()
up_corrected = forward.cross(right)
c = coord3()
c.o = eye
c.ux = right
c.uy = up_corrected
c.uz = forward
return c
def move_forward(self, distance):
self.frame.o = self.frame.o + self.frame.uz * distance
def orbit(self, angle_h, angle_v):
q_h = quat(angle_h, vec3(0, 1, 0))
q_v = quat(angle_v, self.frame.ux)
self.frame.rot(q_h)
self.frame.rot(q_v)
# Usage
cam = Camera(vec3(0, 5, 10), vec3(0, 0, 0))
cam.orbit(0.1, 0) # Orbit horizontally
cam.move_forward(1.0) # Move forward
```
#### Physics Simulation
```python
from coordinate_system import vec3, quat, coord3
class RigidBody:
def __init__(self, position=vec3(0, 0, 0)):
self.frame = coord3(position)
self.velocity = vec3(0, 0, 0)
self.angular_velocity = vec3(0, 0, 0)
def apply_force(self, force, dt):
self.velocity = self.velocity + force * dt
def update(self, dt):
# Update position
self.frame.o = self.frame.o + self.velocity * dt
# Update rotation
if self.angular_velocity.length() > 0:
angle = self.angular_velocity.length() * dt
axis = self.angular_velocity.normcopy()
q = quat(angle, axis)
self.frame.rot(q)
# Usage
body = RigidBody(vec3(0, 10, 0))
gravity = vec3(0, -9.8, 0)
dt = 1.0 / 60.0 # 60 FPS
for _ in range(100):
body.apply_force(gravity, dt)
body.update(dt)
```
---
## Advanced Features
### Interpolation
The package provides helper functions for interpolation:
```python
from coordinate_system import lerp
# Linear interpolation
v1 = vec3(0, 0, 0)
v2 = vec3(10, 10, 10)
v_mid = lerp(v1, v2, 0.5) # vec3(5, 5, 5)
```
For spherical linear interpolation (slerp), use quaternions:
```python
q1 = quat() # Identity
q2 = quat(1.57, vec3(0, 0, 1)) # 90° rotation
# Manual slerp implementation or use quaternion methods
# (depends on availability in your binding)
```
### Constants
```python
from coordinate_system import ZERO3, UNITX, UNITY, UNITZ, ONE3, ONE4, ONEC
ZERO3 # Zero vector vec3(0, 0, 0)
UNITX # Unit X vector vec3(1, 0, 0)
UNITY # Unit Y vector vec3(0, 1, 0)
UNITZ # Unit Z vector vec3(0, 0, 1)
ONE3 # Unit scale vec3(1, 1, 1)
ONE4 # Identity quaternion quat(1, 0, 0, 0)
ONEC # World coordinate system coord3()
```
---
## Building from Source
### Prerequisites
- C++17 compatible compiler
- Python 3.7+
- pybind11
### Windows
```bash
# Install Visual Studio 2019+ with C++ tools
pip install pybind11 wheel
python setup.py build
python setup.py bdist_wheel
```
### Linux
```bash
sudo apt install build-essential python3-dev
pip3 install pybind11 wheel
python3 setup.py build
python3 setup.py bdist_wheel
```
### macOS
```bash
xcode-select --install
pip3 install pybind11 wheel
python3 setup.py build
python3 setup.py bdist_wheel
```
---
## Performance
Benchmark on Intel i7-10700K @ 3.8GHz:
| Operation | Ops/second |
|-----------|-----------|
| Vector addition | 5,200,000 |
| Dot product | 4,800,000 |
| Cross product | 3,500,000 |
| Normalize | 2,100,000 |
| Quaternion rotation | 1,800,000 |
---
## Contributing
Contributions are welcome! Please:
1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests
5. Submit a pull request
---
## License
MIT License - see [LICENSE](LICENSE) file for details
Copyright (c) 2024-2025 PanGuoJun
---
## Author
**PanGuoJun** (romeosoft)
- Email: 18858146@qq.com
- GitHub: [panguojun/Coordinate-System](https://github.com/panguojun/Coordinate-System)
---
## Links
- **PyPI**: https://pypi.org/project/coordinate-system/
- **GitHub**: https://github.com/panguojun/Coordinate-System
- **Mathematical Foundation**: [MATHEMATICAL_FOUNDATION.md](https://github.com/panguojun/Coordinate-System/blob/main/MATHEMATICAL_FOUNDATION.md)
- **Issues**: https://github.com/panguojun/Coordinate-System/issues
---
## Changelog
### Version 1.2.0 (2025-10-22)
- ✅ Cross-platform support (Windows, Linux, macOS)
- ✅ Updated documentation
- ✅ Improved API consistency
- ✅ Added more usage examples
- ✅ Performance optimizations
### Version 1.1.0 (2024-09-08)
- Initial PyPI release
- Windows support
- Core vec3, quat, coord3 classes
---
## Acknowledgments
Built with ❤️ using:
- C++17
- pybind11
- Python
---
**Note**: For the latest updates and documentation, visit the [GitHub repository](https://github.com/panguojun/Coordinate-System).
Raw data
{
"_id": null,
"home_page": "https://github.com/panguojun/Coordinate-System",
"name": "coordinate-system",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.7",
"maintainer_email": null,
"keywords": "3d math vector quaternion coordinate-system geometry graphics spatial-computing differential-geometry curvature metric-tensor connection-operator discrete-geometry surface-curvature",
"author": "PanGuoJun",
"author_email": "18858146@qq.com",
"download_url": "https://files.pythonhosted.org/packages/21/66/165cf8a986381da10d6769974d79ce87059082ef48e9b2a92c1073bce6a3/coordinate_system-2.3.4.tar.gz",
"platform": "Windows",
"description": "# Coordinate System Library\r\n\r\n**High-performance 3D coordinate system and differential geometry library for Python**\r\n\r\n[](https://pypi.org/project/coordinate-system/)\r\n[](https://pypi.org/project/coordinate-system/)\r\n[](https://pypi.org/project/coordinate-system/)\r\n[](LICENSE)\r\n\r\n**Author:** PanGuoJun\r\n**Version:** 2.2.0\r\n**License:** MIT\r\n\r\n## \ud83c\udd95 What's New in v2.2.0\r\n\r\n**Major Feature Release: Discrete Differential Geometry!**\r\n\r\n- \u2728 **Metric Tensor Computation** - First fundamental form on surfaces\r\n- \u2728 **Connection Operators** - Discrete frame derivatives (intrinsic gradients)\r\n- \u2728 **Curvature Tensors** - Complete R_uv computation with Lie derivatives\r\n- \u2728 **Gaussian Curvature** - High-accuracy discrete curvature (2.22% error on spheres!)\r\n- \u2728 **Surface Classes** - Sphere, Torus, and extensible Surface base class\r\n\r\nPerfect for computational geometry, geometric analysis, and discrete differential geometry research!\r\n\r\n---\r\n\r\n## Features\r\n\r\n### Core Classes\r\n\r\n- **vec3** - 3D vector with comprehensive operations\r\n- **quat** - Quaternion for 3D rotations\r\n- **coord3** - Complete 3D coordinate system (position, rotation, scale)\r\n\r\n### Operations\r\n\r\n- Vector arithmetic (+, -, *, /)\r\n- Dot product, cross product\r\n- Vector projection, reflection\r\n- Linear interpolation (lerp)\r\n- Spherical linear interpolation (slerp)\r\n- Coordinate system transformations\r\n- Euler angle conversion\r\n\r\n### Performance\r\n\r\n- Written in optimized C++17\r\n- Python bindings via pybind11\r\n- Over 1,000,000 operations per second\r\n\r\n### Platform Support\r\n\r\n- \u2705 Windows (7, 10, 11)\r\n- \u2705 Linux (Ubuntu, Debian, CentOS, etc.)\r\n- \u2705 macOS (10.14+)\r\n\r\n---\r\n\r\n## \ud83c\udd95 Differential Geometry (NEW in v2.2.0)\r\n\r\n### Surface Representation\r\n\r\n```python\r\nfrom coordinate_system import Sphere, Torus, Surface\r\n\r\n# Create a sphere\r\nsphere = Sphere(radius=2.0)\r\n\r\n# Create a torus\r\ntorus = Torus(major_radius=3.0, minor_radius=1.0)\r\n\r\n# Or define your own surface by subclassing Surface\r\nclass MySurface(Surface):\r\n def position(self, u, v):\r\n # Return vec3(x, y, z) for parameters (u, v)\r\n pass\r\n```\r\n\r\n### Metric Tensor (First Fundamental Form)\r\n\r\n```python\r\nfrom coordinate_system import compute_metric\r\nimport math\r\n\r\n# Compute metric tensor at a point\r\ng = compute_metric(sphere, u=math.pi/4, v=math.pi/3)\r\n\r\nprint(f\"E = {g.E:.6f}\") # u-direction metric\r\nprint(f\"F = {g.F:.6f}\") # cross term (0 if orthogonal)\r\nprint(f\"G = {g.G:.6f}\") # v-direction metric\r\nprint(f\"det(g) = {g.det:.6f}\")\r\nprint(f\"Metric correction = {g.correction_factor():.6f}\")\r\n```\r\n\r\n### Connection Operator (Intrinsic Gradient)\r\n\r\n```python\r\nfrom coordinate_system import compute_connection\r\n\r\n# Compute connection operator (frame derivative)\r\nG_u = compute_connection(sphere, u=math.pi/4, v=math.pi/3, direction='u')\r\nG_v = compute_connection(sphere, u=math.pi/4, v=math.pi/3, direction='v')\r\n\r\nprint(f\"G_u norm: {G_u.norm():.8f}\")\r\nprint(f\"G_v norm: {G_v.norm():.8f}\")\r\n```\r\n\r\n**Aliases available:**\r\n- `compute_frame_derivative` (standard mathematical term)\r\n- `compute_intrinsic_gradient` (intuitive name)\r\n- `compute_geometric_gradient` (alternative)\r\n\r\n### Curvature Tensor\r\n\r\n```python\r\nfrom coordinate_system import compute_curvature_tensor\r\n\r\n# Compute complete curvature tensor R_uv\r\nR_uv = compute_curvature_tensor(\r\n sphere,\r\n u=math.pi/4,\r\n v=math.pi/3,\r\n use_lie_derivative=True # CRITICAL for accuracy!\r\n)\r\n\r\nprint(f\"Curvature tensor norm: {R_uv.norm():.8f}\")\r\n\r\n# R_uv is a 3\u00d73 coord3 object with structure:\r\n# [[R_11, R_12, R_13], \u2190 Tangent-tangent (intrinsic)\r\n# [R_21, R_22, R_23], \u2190 Tangent-normal (second fundamental form)\r\n# [R_31, R_32, R_33]] \u2190 Normal-normal (extrinsic)\r\n```\r\n\r\n### Gaussian Curvature (Quickest Method)\r\n\r\n```python\r\nfrom coordinate_system import Sphere, compute_gaussian_curvature\r\nimport math\r\n\r\n# One-line curvature computation!\r\nsphere = Sphere(radius=2.0)\r\nK = compute_gaussian_curvature(sphere, u=math.pi/4, v=math.pi/3)\r\n\r\nprint(f\"Gaussian curvature K = {K:.6f}\")\r\n# Expected: K = 1/R\u00b2 = 0.25 for a sphere\r\n\r\n# Theoretical value\r\nK_theory = 1.0 / (2.0 ** 2)\r\nerror = abs(K - K_theory) / K_theory * 100\r\nprint(f\"Relative error: {error:.2f}%\") # Typically < 3% !\r\n```\r\n\r\n### Accuracy Comparison\r\n\r\n**On a sphere with radius R=2:**\r\n\r\n| Method | Lie Derivative | Accuracy | Improvement |\r\n|--------|---------------|----------|-------------|\r\n| Without correction | \u274c | 54.32% error | - |\r\n| With scale correction | \u2713 | 17.09% error | 3.2\u00d7 |\r\n| **Optimal (scale + metric + Lie)** | \u2713 | **2.22% error** | **24\u00d7** \ud83c\udf89 |\r\n\r\n**The Lie derivative term is CRITICAL!** It improves accuracy by 24\u00d7 on spheres.\r\n\r\n### Key Parameters\r\n\r\n```python\r\n# For constant curvature surfaces (spheres):\r\nK = compute_gaussian_curvature(\r\n surface,\r\n u, v,\r\n scale_factor=2.0, # Optimal for spheres\r\n use_metric_correction=True, # Essential!\r\n use_lie_derivative=True # Critical for accuracy!\r\n)\r\n\r\n# These are the default values, optimized for best accuracy\r\n```\r\n\r\n### Complete Example\r\n\r\nSee `examples/curvature_computation.py` for comprehensive demonstrations, or `examples/quickstart.py` for the simplest possible usage.\r\n\r\n```python\r\n# examples/quickstart.py\r\nimport math\r\nfrom coordinate_system import Sphere, compute_gaussian_curvature\r\n\r\n# Step 1: Create a sphere\r\nsphere = Sphere(radius=2.0)\r\n\r\n# Step 2: Choose a point\r\nu, v = math.pi/4, math.pi/3\r\n\r\n# Step 3: Compute curvature (one line!)\r\nK = compute_gaussian_curvature(sphere, u, v)\r\n\r\n# Step 4: Compare with theory\r\nK_theory = 1.0 / (2.0 ** 2) # K = 1/R\u00b2\r\nprint(f\"Computed: K = {K:.6f}\")\r\nprint(f\"Theory: K = {K_theory:.6f}\")\r\nprint(f\"Error: {abs(K-K_theory)/K_theory*100:.2f}%\")\r\n```\r\n\r\n---\r\n\r\n## \ud83d\udcda Documentation\r\n\r\n### Mathematical Foundation\r\n\r\nFor a comprehensive understanding of the mathematical principles behind coordinate systems, vectors, quaternions, and transformations, see our detailed mathematical guide:\r\n\r\n**[\ud83d\udcd6 Mathematical Foundation of Coordinate Systems](https://github.com/panguojun/Coordinate-System/blob/main/MATHEMATICAL_FOUNDATION.md)**\r\n\r\nThis guide covers:\r\n- Vector mathematics (dot product, cross product, projections)\r\n- Quaternion theory and applications\r\n- Coordinate system transformations\r\n- Euler angles and gimbal lock\r\n- Interpolation methods (LERP, SLERP, NLERP)\r\n- Practical applications in graphics, physics, and robotics\r\n\r\n---\r\n\r\n## Installation\r\n\r\n### From PyPI (Recommended)\r\n\r\n```bash\r\npip install coordinate-system\r\n```\r\n\r\n### From Source\r\n\r\n```bash\r\ngit clone https://github.com/panguojun/Coordinate-System.git\r\ncd Coordinate-System\r\npip install .\r\n```\r\n\r\n---\r\n\r\n## Quick Start\r\n\r\n```python\r\nfrom coordinate_system import vec3, quat, coord3\r\n\r\n# Create vectors\r\nv1 = vec3(1, 2, 3)\r\nv2 = vec3(4, 5, 6)\r\n\r\n# Vector operations\r\nv3 = v1 + v2 # Addition: vec3(5, 7, 9)\r\ndot = v1.dot(v2) # Dot product: 32.0\r\ncross = v1.cross(v2) # Cross product\r\nlength = v1.length() # Length: 3.742\r\nnormalized = v1.normcopy() # Unit vector\r\n\r\n# Quaternion rotation\r\naxis = vec3(0, 0, 1) # Z axis\r\nq = quat(1.5708, axis) # 90 degrees rotation\r\nrotated = q * v1 # Rotate v1\r\n\r\n# Coordinate systems\r\nframe = coord3.from_angle(1.57, vec3(0, 0, 1)) # Frame rotated 90\u00b0\r\nworld_pos = v1 * frame # Transform to world space\r\nlocal_pos = world_pos / frame # Transform back to local\r\n\r\n# Interpolation\r\nlerped = vec3.lerp(v1, v2, 0.5) # Linear interpolation\r\n```\r\n\r\n---\r\n\r\n## System Compatibility\r\n\r\n### Operating Systems\r\n\r\n| Platform | Status | Notes |\r\n|----------|--------|-------|\r\n| Windows 7+ | \u2705 Full Support | Tested on Windows 10/11 |\r\n| Linux | \u2705 Full Support | Ubuntu 18.04+, CentOS 7+, Debian 9+ |\r\n| macOS | \u2705 Full Support | macOS 10.14 (Mojave) and later |\r\n\r\n### Python Versions\r\n\r\n- Python 3.7\r\n- Python 3.8\r\n- Python 3.9\r\n- Python 3.10\r\n- Python 3.11\r\n- Python 3.12\r\n- Python 3.13\r\n\r\n---\r\n\r\n## Coordinate System Type\r\n\r\nThis library uses a **left-handed coordinate system** for all vector and quaternion operations.\r\n\r\n```\r\n +Y\r\n |\r\n |\r\n |\r\n +-----> +X\r\n /\r\n /\r\n +Z\r\n```\r\n\r\n---\r\n\r\n## API Reference\r\n\r\n### vec3 - 3D Vector\r\n\r\n#### Constructors\r\n\r\n```python\r\nv = vec3() # Zero vector (0, 0, 0)\r\nv = vec3(x, y, z) # Vector with components\r\n```\r\n\r\n#### Properties\r\n\r\n```python\r\nv.x # X component\r\nv.y # Y component\r\nv.z # Z component\r\n```\r\n\r\n#### Arithmetic Operations\r\n\r\n```python\r\nv3 = v1 + v2 # Addition\r\nv3 = v1 - v2 # Subtraction\r\nv3 = v1 * scalar # Scalar multiplication\r\nv3 = scalar * v1 # Reverse scalar multiplication\r\nv3 = v1 / scalar # Scalar division\r\nv3 = v1 * v2 # Component-wise multiplication\r\n```\r\n\r\n#### Vector Operations\r\n\r\n```python\r\ndot = v1.dot(v2) # Dot product (float)\r\ncross = v1.cross(v2) # Cross product (vec3)\r\nlength = v.length() # Vector length\r\nv.normalize() # Normalize in-place\r\nnormalized = v.normcopy() # Return normalized copy\r\n```\r\n\r\n#### Additional Methods\r\n\r\n```python\r\nv.lenxy() # Length in XY plane\r\nv.sqrlen() # Squared length\r\nv.abslen() # Sum of absolute components\r\nv.isINF() # Check for infinity\r\nv.flipX() # Flip X component\r\nv.flipY() # Flip Y component\r\nv.flipZ() # Flip Z component\r\n```\r\n\r\n#### Static Methods\r\n\r\n```python\r\nv = vec3.min3(a, b, c) # Component-wise minimum\r\nv = vec3.max3(a, b, c) # Component-wise maximum\r\nv = vec3.rnd() # Random vector\r\nv = vec3.lerp(a, b, t) # Linear interpolation\r\nangle = vec3.angle(a, b) # Angle between vectors\r\n```\r\n\r\n---\r\n\r\n### quat - Quaternion\r\n\r\n#### Constructors\r\n\r\n```python\r\nq = quat() # Identity quaternion\r\nq = quat(w, x, y, z) # From components\r\nq = quat(angle, axis) # From angle-axis\r\nq = quat(v1, v2) # From two vectors\r\n```\r\n\r\n#### Properties\r\n\r\n```python\r\nq.w, q.x, q.y, q.z # Quaternion components\r\n```\r\n\r\n#### Operations\r\n\r\n```python\r\nq3 = q1 + q2 # Addition\r\nq3 = q1 * q2 # Multiplication (composition)\r\nv_rotated = q * v # Rotate vector\r\nq3 = q1 / q2 # Division\r\n```\r\n\r\n#### Methods\r\n\r\n```python\r\nq.normalize() # Normalize in-place\r\nnormalized = q.normalized() # Return normalized copy\r\nconj = q.conj() # Conjugate\r\nlength = q.length() # Length\r\ndot = q1.dot(q2) # Dot product\r\nangle = q1.angle_to(q2) # Angle to another quaternion\r\n```\r\n\r\n#### Conversion\r\n\r\n```python\r\n# From Euler angles\r\nq.from_eulers(pitch, yaw, roll)\r\n\r\n# From vectors\r\nq.fromvectors(v1, v2)\r\n\r\n# Advanced\r\nq_exp = q.exp() # Exponential\r\nq_log = q.log() # Logarithm\r\n```\r\n\r\n---\r\n\r\n### coord3 - 3D Coordinate System\r\n\r\nA `coord3` represents a complete 3D coordinate frame with:\r\n- **Position** (o): Origin in 3D space\r\n- **Rotation** (ux, uy, uz): Three orthonormal axes\r\n- **Scale** (s): Scale factors for each axis\r\n\r\n#### Constructors\r\n\r\n```python\r\nc = coord3() # Identity frame\r\nc = coord3(x, y, z) # Position only\r\nc = coord3(x, y, z, pitch, yaw, roll) # Position + rotation (Euler)\r\nc = coord3(x, y, z, qw, qx, qy, qz) # Position + rotation (quaternion)\r\nc = coord3(position) # From vec3\r\nc = coord3(ux, uy, uz) # From three axes\r\nc = coord3(angle, axis) # From angle-axis rotation\r\nc = coord3(quaternion) # From quaternion\r\nc = coord3(position, quaternion, scale) # Full specification\r\n```\r\n\r\n#### Properties\r\n\r\n```python\r\nc.o # Origin (vec3)\r\nc.ux, c.uy, c.uz # Axis vectors (vec3)\r\nc.s # Scale (vec3)\r\n```\r\n\r\n#### Static Factory Methods\r\n\r\n```python\r\nc = coord3.from_axes(ux, uy, uz) # From three axes\r\nc = coord3.from_angle(angle, axis) # From angle-axis\r\n```\r\n\r\n#### Transformations\r\n\r\n```python\r\n# Transform point from local to world\r\nworld_pos = local_pos * coord\r\n\r\n# Transform point from world to local\r\nlocal_pos = world_pos / coord\r\n\r\n# Combine coordinate systems\r\nc3 = c1 * c2\r\n```\r\n\r\n#### Operations\r\n\r\n```python\r\nc3 = c1 + c2 # Add (translate)\r\nc3 = c1 - c2 # Subtract\r\nc3 = c1 * c2 # Multiply (compose transformations)\r\nc3 = c1 / c2 # Divide\r\nequal = c1 == c2 # Equality check\r\n```\r\n\r\n#### Methods\r\n\r\n```python\r\npos = c.pos() # Get position vector\r\nvec = c.tovec() # Convert to vector\r\nc.rot(angle, axis) # Rotate by angle-axis\r\nc.rot(quaternion) # Rotate by quaternion\r\nequal = c1.equal_dirs(c2) # Check if axes are equal\r\nhash_val = c.hash() # Hash value\r\nserial = c.serialise() # Serialize to string\r\nc.dump() # Print debug info\r\n```\r\n\r\n---\r\n\r\n## Usage Examples\r\n\r\n### Vector Mathematics\r\n\r\n```python\r\nfrom coordinate_system import vec3\r\n\r\n# Create vectors\r\nv1 = vec3(1, 0, 0)\r\nv2 = vec3(0, 1, 0)\r\n\r\n# Basic operations\r\nv3 = v1 + v2 # vec3(1, 1, 0)\r\nv4 = v1 * 5 # vec3(5, 0, 0)\r\n\r\n# Dot and cross products\r\ndot = v1.dot(v2) # 0.0 (perpendicular)\r\ncross = v1.cross(v2) # vec3(0, 0, 1) in left-handed system\r\n\r\n# Length and normalization\r\nlength = v1.length() # 1.0\r\nv_normalized = v1.normcopy() # Unit vector\r\n\r\n# Linear interpolation\r\nv_mid = vec3.lerp(v1, v2, 0.5) # vec3(0.5, 0.5, 0)\r\n```\r\n\r\n### Quaternion Rotations\r\n\r\n```python\r\nfrom coordinate_system import vec3, quat\r\n\r\n# Create quaternion from angle-axis\r\nimport math\r\naxis = vec3(0, 0, 1) # Z axis\r\nangle = math.pi / 2 # 90 degrees\r\nq = quat(angle, axis)\r\n\r\n# Rotate vector\r\nv = vec3(1, 0, 0)\r\nrotated = q * v # Approximately vec3(0, 1, 0)\r\n\r\n# Create quaternion from two vectors\r\nv_from = vec3(1, 0, 0)\r\nv_to = vec3(0, 1, 0)\r\nq = quat(v_from, v_to)\r\n\r\n# Quaternion composition\r\nq1 = quat(math.pi/4, vec3(0, 0, 1)) # 45\u00b0 around Z\r\nq2 = quat(math.pi/4, vec3(0, 1, 0)) # 45\u00b0 around Y\r\ncombined = q1 * q2 # Combined rotation\r\n\r\n# Euler angles\r\nq.from_eulers(pitch=0.1, yaw=0.2, roll=0.3)\r\n```\r\n\r\n### Coordinate System Transformations\r\n\r\n```python\r\nfrom coordinate_system import vec3, quat, coord3\r\nimport math\r\n\r\n# Create a coordinate system at position (5, 10, 15)\r\nframe = coord3(5, 10, 15)\r\n\r\n# Create with rotation\r\nq = quat(math.pi/4, vec3(0, 0, 1)) # 45\u00b0 rotation\r\nframe = coord3(vec3(5, 10, 15), q, vec3(1, 1, 1))\r\n\r\n# Transform points between coordinate systems\r\nworld_point = vec3(10, 0, 0)\r\nlocal_point = world_point / frame # World to local\r\nback_to_world = local_point * frame # Local to world\r\n\r\n# Hierarchical transformations\r\nparent = coord3(0, 5, 0)\r\nchild = coord3(3, 0, 0)\r\nchild_in_world = child * parent\r\n\r\n# Create look-at transformation (custom implementation needed)\r\ndef look_at(eye, target, up=vec3(0, 1, 0)):\r\n forward = (target - eye).normcopy()\r\n right = up.cross(forward).normcopy()\r\n up_corrected = forward.cross(right)\r\n return coord3.from_axes(right, up_corrected, forward)\r\n\r\ncamera = look_at(vec3(10, 10, 10), vec3(0, 0, 0))\r\n```\r\n\r\n### Practical Applications\r\n\r\n#### Camera System\r\n\r\n```python\r\nfrom coordinate_system import vec3, quat, coord3\r\nimport math\r\n\r\nclass Camera:\r\n def __init__(self, position, target, up=vec3(0, 1, 0)):\r\n self.frame = self.create_look_at(position, target, up)\r\n\r\n def create_look_at(self, eye, target, up):\r\n forward = (target - eye).normcopy()\r\n right = up.cross(forward).normcopy()\r\n up_corrected = forward.cross(right)\r\n\r\n c = coord3()\r\n c.o = eye\r\n c.ux = right\r\n c.uy = up_corrected\r\n c.uz = forward\r\n return c\r\n\r\n def move_forward(self, distance):\r\n self.frame.o = self.frame.o + self.frame.uz * distance\r\n\r\n def orbit(self, angle_h, angle_v):\r\n q_h = quat(angle_h, vec3(0, 1, 0))\r\n q_v = quat(angle_v, self.frame.ux)\r\n self.frame.rot(q_h)\r\n self.frame.rot(q_v)\r\n\r\n# Usage\r\ncam = Camera(vec3(0, 5, 10), vec3(0, 0, 0))\r\ncam.orbit(0.1, 0) # Orbit horizontally\r\ncam.move_forward(1.0) # Move forward\r\n```\r\n\r\n#### Physics Simulation\r\n\r\n```python\r\nfrom coordinate_system import vec3, quat, coord3\r\n\r\nclass RigidBody:\r\n def __init__(self, position=vec3(0, 0, 0)):\r\n self.frame = coord3(position)\r\n self.velocity = vec3(0, 0, 0)\r\n self.angular_velocity = vec3(0, 0, 0)\r\n\r\n def apply_force(self, force, dt):\r\n self.velocity = self.velocity + force * dt\r\n\r\n def update(self, dt):\r\n # Update position\r\n self.frame.o = self.frame.o + self.velocity * dt\r\n\r\n # Update rotation\r\n if self.angular_velocity.length() > 0:\r\n angle = self.angular_velocity.length() * dt\r\n axis = self.angular_velocity.normcopy()\r\n q = quat(angle, axis)\r\n self.frame.rot(q)\r\n\r\n# Usage\r\nbody = RigidBody(vec3(0, 10, 0))\r\ngravity = vec3(0, -9.8, 0)\r\n\r\ndt = 1.0 / 60.0 # 60 FPS\r\nfor _ in range(100):\r\n body.apply_force(gravity, dt)\r\n body.update(dt)\r\n```\r\n\r\n---\r\n\r\n## Advanced Features\r\n\r\n### Interpolation\r\n\r\nThe package provides helper functions for interpolation:\r\n\r\n```python\r\nfrom coordinate_system import lerp\r\n\r\n# Linear interpolation\r\nv1 = vec3(0, 0, 0)\r\nv2 = vec3(10, 10, 10)\r\nv_mid = lerp(v1, v2, 0.5) # vec3(5, 5, 5)\r\n```\r\n\r\nFor spherical linear interpolation (slerp), use quaternions:\r\n\r\n```python\r\nq1 = quat() # Identity\r\nq2 = quat(1.57, vec3(0, 0, 1)) # 90\u00b0 rotation\r\n\r\n# Manual slerp implementation or use quaternion methods\r\n# (depends on availability in your binding)\r\n```\r\n\r\n### Constants\r\n\r\n```python\r\nfrom coordinate_system import ZERO3, UNITX, UNITY, UNITZ, ONE3, ONE4, ONEC\r\n\r\nZERO3 # Zero vector vec3(0, 0, 0)\r\nUNITX # Unit X vector vec3(1, 0, 0)\r\nUNITY # Unit Y vector vec3(0, 1, 0)\r\nUNITZ # Unit Z vector vec3(0, 0, 1)\r\nONE3 # Unit scale vec3(1, 1, 1)\r\nONE4 # Identity quaternion quat(1, 0, 0, 0)\r\nONEC # World coordinate system coord3()\r\n```\r\n\r\n---\r\n\r\n## Building from Source\r\n\r\n### Prerequisites\r\n\r\n- C++17 compatible compiler\r\n- Python 3.7+\r\n- pybind11\r\n\r\n### Windows\r\n\r\n```bash\r\n# Install Visual Studio 2019+ with C++ tools\r\npip install pybind11 wheel\r\npython setup.py build\r\npython setup.py bdist_wheel\r\n```\r\n\r\n### Linux\r\n\r\n```bash\r\nsudo apt install build-essential python3-dev\r\npip3 install pybind11 wheel\r\npython3 setup.py build\r\npython3 setup.py bdist_wheel\r\n```\r\n\r\n### macOS\r\n\r\n```bash\r\nxcode-select --install\r\npip3 install pybind11 wheel\r\npython3 setup.py build\r\npython3 setup.py bdist_wheel\r\n```\r\n\r\n---\r\n\r\n## Performance\r\n\r\nBenchmark on Intel i7-10700K @ 3.8GHz:\r\n\r\n| Operation | Ops/second |\r\n|-----------|-----------|\r\n| Vector addition | 5,200,000 |\r\n| Dot product | 4,800,000 |\r\n| Cross product | 3,500,000 |\r\n| Normalize | 2,100,000 |\r\n| Quaternion rotation | 1,800,000 |\r\n\r\n---\r\n\r\n## Contributing\r\n\r\nContributions are welcome! Please:\r\n\r\n1. Fork the repository\r\n2. Create a feature branch\r\n3. Make your changes\r\n4. Add tests\r\n5. Submit a pull request\r\n\r\n---\r\n\r\n## License\r\n\r\nMIT License - see [LICENSE](LICENSE) file for details\r\n\r\nCopyright (c) 2024-2025 PanGuoJun\r\n\r\n---\r\n\r\n## Author\r\n\r\n**PanGuoJun** (romeosoft)\r\n\r\n- Email: 18858146@qq.com\r\n- GitHub: [panguojun/Coordinate-System](https://github.com/panguojun/Coordinate-System)\r\n\r\n---\r\n\r\n## Links\r\n\r\n- **PyPI**: https://pypi.org/project/coordinate-system/\r\n- **GitHub**: https://github.com/panguojun/Coordinate-System\r\n- **Mathematical Foundation**: [MATHEMATICAL_FOUNDATION.md](https://github.com/panguojun/Coordinate-System/blob/main/MATHEMATICAL_FOUNDATION.md)\r\n- **Issues**: https://github.com/panguojun/Coordinate-System/issues\r\n\r\n---\r\n\r\n## Changelog\r\n\r\n### Version 1.2.0 (2025-10-22)\r\n- \u2705 Cross-platform support (Windows, Linux, macOS)\r\n- \u2705 Updated documentation\r\n- \u2705 Improved API consistency\r\n- \u2705 Added more usage examples\r\n- \u2705 Performance optimizations\r\n\r\n### Version 1.1.0 (2024-09-08)\r\n- Initial PyPI release\r\n- Windows support\r\n- Core vec3, quat, coord3 classes\r\n\r\n---\r\n\r\n## Acknowledgments\r\n\r\nBuilt with \u2764\ufe0f using:\r\n- C++17\r\n- pybind11\r\n- Python\r\n\r\n---\r\n\r\n**Note**: For the latest updates and documentation, visit the [GitHub repository](https://github.com/panguojun/Coordinate-System).\r\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "High-performance 3D coordinate system library with C++ optimized differential geometry and high-precision discrete curvature computation (Gaussian/Mean/Principal curvatures)",
"version": "2.3.4",
"project_urls": {
"Bug Reports": "https://github.com/panguojun/Coordinate-System/issues",
"Documentation": "https://github.com/panguojun/Coordinate-System/blob/main/README.md",
"Homepage": "https://github.com/panguojun/Coordinate-System",
"Source": "https://github.com/panguojun/Coordinate-System"
},
"split_keywords": [
"3d",
"math",
"vector",
"quaternion",
"coordinate-system",
"geometry",
"graphics",
"spatial-computing",
"differential-geometry",
"curvature",
"metric-tensor",
"connection-operator",
"discrete-geometry",
"surface-curvature"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "1054c5a0642dbe44771b036b284835fbc283f673568617890189bb93c05050a7",
"md5": "1f0c4021e0023b61b6a67a3f94b516c2",
"sha256": "51827915bd86b94bc1fc411648291b057e9456db7f540e8e589a5fdebb897829"
},
"downloads": -1,
"filename": "coordinate_system-2.3.4-cp313-cp313-win_amd64.whl",
"has_sig": false,
"md5_digest": "1f0c4021e0023b61b6a67a3f94b516c2",
"packagetype": "bdist_wheel",
"python_version": "cp313",
"requires_python": ">=3.7",
"size": 190436,
"upload_time": "2025-10-28T08:32:22",
"upload_time_iso_8601": "2025-10-28T08:32:22.243239Z",
"url": "https://files.pythonhosted.org/packages/10/54/c5a0642dbe44771b036b284835fbc283f673568617890189bb93c05050a7/coordinate_system-2.3.4-cp313-cp313-win_amd64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "2166165cf8a986381da10d6769974d79ce87059082ef48e9b2a92c1073bce6a3",
"md5": "da3073020f30088f17c319f02dd4f91b",
"sha256": "29af4d5ab366b0e491180186a2893130b65b858bf8b802876c8bd87d0f005023"
},
"downloads": -1,
"filename": "coordinate_system-2.3.4.tar.gz",
"has_sig": false,
"md5_digest": "da3073020f30088f17c319f02dd4f91b",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.7",
"size": 73057,
"upload_time": "2025-10-28T08:32:24",
"upload_time_iso_8601": "2025-10-28T08:32:24.534226Z",
"url": "https://files.pythonhosted.org/packages/21/66/165cf8a986381da10d6769974d79ce87059082ef48e9b2a92c1073bce6a3/coordinate_system-2.3.4.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-10-28 08:32:24",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "panguojun",
"github_project": "Coordinate-System",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "coordinate-system"
}
JSON
