nanomanifold 0.1.1__py3-none-any.whl

nanomanifold/common.py

@@ -0,0 +1,25 @@
+import array_api_compat
+
+
+def get_namespace(array):
+    return array_api_compat.get_namespace(array)
+
+
+def get_namespace_by_name(name: str):
+    if name == "numpy":
+        import numpy as np
+
+        ones = np.ones(1)
+        return get_namespace(ones)
+
+    elif name == "torch":
+        import torch
+
+        ones = torch.ones(1)
+        return get_namespace(ones)
+
+    elif name == "jax":
+        import jax.numpy as jnp
+
+        ones = jnp.ones(1)
+        return get_namespace(ones)

nanomanifold-0.1.1.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: nanomanifold
+Version: 0.1.1
+Summary: SO3/SE3 operations on any backend
+Author-email: Andrea Boscolo Camiletto <abcamiletto@gmail.com>
+Requires-Python: >=3.11
+Requires-Dist: array-api-compat>=1.12.0
+Requires-Dist: jaxtyping>=0.3.2
+Requires-Dist: numpy>=2.3.2
+Description-Content-Type: text/markdown
+
+# nanomanifold
+
+Fast, batched and differentiable SO3/SE3 transforms for any backend (NumPy, PyTorch, JAX, ...)
+Works directly on arrays, defined as:
+
+- **SO3**: unit quaternions `[w, x, y, z]` for 3D rotations, shape `(..., 4)`
+- **SE3**: concatenated `[quat, translation]`, shape `(..., 7)`
+
+```python
+import numpy as np
+from nanomanifold import SO3, SE3
+
+# Rotations stored as quaternion arrays [w,x,y,z]
+q = SO3.from_axis_angle(np.array([0, 0, 1]), np.pi/4)  # 45° around Z
+points = np.array([[1, 0, 0], [0, 1, 0]])
+rotated = SO3.rotate_points(q, points)
+
+# Rigid transforms stored as 7D arrays [quat, translation]
+T = SE3.from_rt(q, np.array([1, 0, 0]))  # rotation + translation
+transformed = SE3.transform_points(T, points)
+```
+
+## Features
+
+**Array-based API** — all functions operate directly on arrays from any backend  
+**Backend agnostic** — works with NumPy, PyTorch, JAX, CuPy, Dask, and more  
+**Batched operations** — process thousands of transforms at once  
+**Differentiable** — automatic gradients where supported (PyTorch/JAX)  
+**Memory efficient** — quaternions instead of matrices  
+**Numerically stable** — handles edge cases and singularities
+
+## Quick Start
+
+### Rotations (SO3)
+
+```python
+from nanomanifold import SO3
+
+# Create rotations
+q1 = SO3.from_axis_angle([1, 0, 0], np.pi/2)    # 90° around X
+q2 = SO3.from_euler([0, 0, np.pi/4])            # 45° around Z
+q3 = SO3.from_matrix(rotation_matrix)
+
+# Compose and interpolate
+q_combined = SO3.multiply(q1, q2)
+q_halfway = SO3.slerp(q1, q2, t=0.5)
+
+# Apply to points
+points = np.array([[1, 0, 0], [0, 1, 0]])
+rotated = SO3.rotate_points(q_combined, points)
+```
+
+### Rigid Transforms (SE3)
+
+```python
+from nanomanifold import SE3
+
+# Create transforms
+T1 = SE3.from_rt(q1, [1, 2, 3])               # rotation + translation
+T2 = SE3.from_matrix(transformation_matrix)
+
+# Compose transforms
+T_combined = SE3.multiply(T1, T2)
+T_inverse = SE3.inverse(T_combined)
+
+# Apply to points
+transformed = SE3.transform_points(T_combined, points)
+```
+
+## API Reference
+
+### SO3 (3D Rotations)
+
+| Function                       | Input → Output                      | Description                 |
+| ------------------------------ | ----------------------------------- | --------------------------- |
+| `from_axis_angle(axis, angle)` | `(...,3), (...) → (...,4)`          | Create from axis-angle      |
+| `from_euler(angles)`           | `(...,3) → (...,4)`                 | Create from Euler angles    |
+| `from_matrix(R)`               | `(...,3,3) → (...,4)`               | Create from rotation matrix |
+| `multiply(q1, q2)`             | `(...,4), (...,4) → (...,4)`        | Compose rotations           |
+| `slerp(q1, q2, t)`             | `(...,4), (...,4), (...) → (...,4)` | Spherical interpolation     |
+| `rotate_points(q, points)`     | `(...,4), (...,N,3) → (...,N,3)`    | Rotate 3D points            |
+
+### SE3 (Rigid Transforms)
+
+| Function                      | Input → Output                   | Description                        |
+| ----------------------------- | -------------------------------- | ---------------------------------- |
+| `from_rt(q, t)`               | `(...,4), (...,3) → (...,7)`     | Create from rotation + translation |
+| `from_matrix(T)`              | `(...,4,4) → (...,7)`            | Create from 4×4 matrix             |
+| `multiply(T1, T2)`            | `(...,7), (...,7) → (...,7)`     | Compose transforms                 |
+| `inverse(T)`                  | `(...,7) → (...,7)`              | Invert transform                   |
+| `transform_points(T, points)` | `(...,7), (...,N,3) → (...,N,3)` | Transform 3D points                |
+
+## Installation
+
+```bash
+pip install nanomanifold
+```
+
+## License
+
+MIT

nanomanifold-0.1.1.dist-info/RECORD

@@ -0,0 +1,31 @@
+nanomanifold/__init__.py,sha256=VuueSV8KaH4sg23rqB_sKIoI4MHhHgWfswH30hnMe0M,49
+nanomanifold/common.py,sha256=xM2CEafWnf9TM9r3cK3lbGap2sdGpk9TxqN6wfxOHlA,487
+nanomanifold/SE3/__init__.py,sha256=2VqjGg0ZKxI9Uqq0oVGTEEQYE2ISy2AwRsDhOq3LmbY,462
+nanomanifold/SE3/canonicalize.py,sha256=kQ_Pf_wILTxTxYhEbhwc_kgIbvUQBbSE5jqP45INmrE,692
+nanomanifold/SE3/exp.py,sha256=qn0aUHQR5q9wT5BMz6PUhW733g9_SNedEdoxa8uWv3U,2466
+nanomanifold/SE3/inverse.py,sha256=UVUkqKwnIM8tNtgLXoZ5OhXSXaa2TT8kszaZaGtXXYI,919
+nanomanifold/SE3/log.py,sha256=JTm1Tg1qJmata8vrKyYzztOy3LSTdx2dk5jwEzJeI0U,2600
+nanomanifold/SE3/multiply.py,sha256=ChrxGyOYDsgnaAlrIc8vXwlltPckQNUohxjfrSlaroc,1467
+nanomanifold/SE3/transform_points.py,sha256=2ELZCrhqEQap8EUbOPQxGSqn9zLY18lzrbwVgBIujyA,901
+nanomanifold/SE3/conversions/__init__.py,sha256=6MEel9koLk-YVJgzg-oTorl4VNi68msmLr4bIsQqb0Q,153
+nanomanifold/SE3/conversions/matrix.py,sha256=6ePkIyPl4xc-1DeX5RqP2j2Vofi8KUFt8v68I3jZGmo,1494
+nanomanifold/SE3/conversions/rt.py,sha256=rRY17oa2bWxuf81ycZGE0qQc0kwQMtxKKY7lL2C82ns,842
+nanomanifold/SO3/__init__.py,sha256=OgI8iCNwke19_mSzcKT4wBFjwwxaD4rvc8S0OSTJRP8,808
+nanomanifold/SO3/canonicalize.py,sha256=QFW4J9Ep6bkcu9y6JbygxLaU0aDle-HFJh7uG-ZgTaw,403
+nanomanifold/SO3/distance.py,sha256=2U4YEG2xmqTdu6jShmRGBvp2RNPr924iLxuaMF8gYx0,1672
+nanomanifold/SO3/exp.py,sha256=jBun_y-4ekAzQADLIiYIh28xi7OzfibkinamtOJKN9g,872
+nanomanifold/SO3/hat.py,sha256=K7OyXhCTfTpLh-OoQHP7wwBPjTu1YTV22iC1jXy5kms,766
+nanomanifold/SO3/inverse.py,sha256=D_WjUJz5dSJv1zYfLa2xi03K-tJZ4UrQYbH_8Tk9iPA,390
+nanomanifold/SO3/log.py,sha256=pdR2rtbxsfLqXcExPRAodQRhG7MFoGkJyxzG29eXQuQ,809
+nanomanifold/SO3/multiply.py,sha256=wSAuJaLqTZJTsUlPrLJgKqDdzk81J-6w4xnPHK5UjpU,1173
+nanomanifold/SO3/rotate_points.py,sha256=JiknHDLMmwl1AIzLgppzsP0kq3McTYAHxnY_f3bb2RM,1364
+nanomanifold/SO3/slerp.py,sha256=t14CBV8BbLgkqvg6Oa-RzvB1ivKMtpxuGvejSCJwXc4,2303
+nanomanifold/SO3/vee.py,sha256=OiyiH0g0FKXzIA-EBnxqW-79XNCiZcbovCraR1T9JoI,589
+nanomanifold/SO3/weighted_mean.py,sha256=uOGbqTMmXLIPwqsuCa_pGRfYSbse9zga1wexQuyipgU,3418
+nanomanifold/SO3/conversions/__init__.py,sha256=lJVUaKfkiQvcUsSIQYE4T6t5P64jRRhK_MbnICxdEhM,302
+nanomanifold/SO3/conversions/axis_angle.py,sha256=g-YNicc2paE3CBBTUYc_IqzFGgCCJbq8OCDC3QyEFas,1712
+nanomanifold/SO3/conversions/euler.py,sha256=vjuUFZGHN2iyvrnJXSqcYtzTnh7pIQInPPC3XckT2L8,4486
+nanomanifold/SO3/conversions/matrix.py,sha256=ngKi5NSN3G2AA_ggUaq1095_u-L79q8nW3_3w9zMuNI,2830
+nanomanifold-0.1.1.dist-info/METADATA,sha256=s6Rq6byQFxPtVzYClzqs8qnllCiedeTxsEy6gOxukBU,4092
+nanomanifold-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nanomanifold-0.1.1.dist-info/RECORD,,

nanomanifold-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any