cartesian-tree 0.2.1__tar.gz → 0.4.0__tar.gz

{cartesian_tree-0.2.1 → cartesian_tree-0.4.0}/Cargo.lock

@@ -4,13 +4,16 @@ version = 4
 
 [[package]]
 name = "CartesianTree"
-version = "0.2.1"
+version = "0.4.0"
 dependencies = [
+ "approx",
  "nalgebra",
  "pyo3",
  "serde",
  "serde_json",
+ "slotmap",
  "thiserror",
+ "uuid",
 ]
 
 [[package]]
@@ -28,12 +31,36 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
+[[package]]
+name = "bumpalo"
+version = "3.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+
 [[package]]
 name = "bytemuck"
 version = "1.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9134a6ef01ce4b366b50689c94f82c14bc72bc5d0386829828a2e2752ef7958c"
 
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "getrandom"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasi",
+]
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -52,6 +79,16 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
+[[package]]
+name = "js-sys"
+version = "0.3.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.172"
@@ -258,12 +295,24 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
 [[package]]
 name = "rawpointer"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
 
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
 [[package]]
 name = "ryu"
 version = "1.0.20"
@@ -335,6 +384,15 @@ dependencies = [
  "wide",
 ]
 
+[[package]]
+name = "slotmap"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038"
+dependencies = [
+ "version_check",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.101"
@@ -390,6 +448,86 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
+[[package]]
+name = "uuid"
+version = "1.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
+dependencies = [
+ "getrandom",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.14.7+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "883478de20367e224c0090af9cf5f9fa85bed63a95c1abf3afc5c083ebc06e8c"
+dependencies = [
+ "wasip2",
+]
+
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
+dependencies = [
+ "unicode-ident",
+]
+
 [[package]]
 name = "wide"
 version = "0.7.32"
@@ -399,3 +537,9 @@ dependencies = [
  "bytemuck",
  "safe_arch",
 ]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"

{cartesian_tree-0.2.1 → cartesian_tree-0.4.0}/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 authors = ["Kn0g"]
 name = "CartesianTree"
-version = "0.2.1"
+version = "0.4.0"
 edition = "2024"
 description = "Build hierarchical Cartesian coordinate systems to easily transform poses."
 homepage = "https://github.com/Kn0g/cartesian-tree"
@@ -13,16 +13,19 @@ keywords = ["Cartesian", "coordinate-systems", "transform", "poses"]
 categories = ["mathematics", "data-structures"]
 
 [lints.clippy]
-all = "warn"
-style = "warn"
-pedantic = "warn"
-cargo = "warn"
-nursery = "warn"
+all = { level = "warn", priority = -1 }
+style = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+cargo = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
 missing_panics_doc = "warn"
 missing_errors_doc = "warn"
 missing_safety_doc = "warn"
 empty_line_after_outer_attr = "warn"
 empty_line_after_doc_comments = "warn"
+# Guards in this crate are already scoped as tightly as the borrow checker allows;
+# this nursery lint's suggestions frequently do not compile here.
+significant_drop_tightening = "allow"
 
 [dependencies]
 nalgebra = { version = "0.33.2", features = ["serde-serialize"] }
@@ -30,6 +33,11 @@ pyo3 = { version = "0.25.0", features = ["extension-module"] , optional = true}
 thiserror = "2.0.12"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+slotmap = "1"
+uuid = { version = "1", features = ["v4"] }
+
+[dev-dependencies]
+approx = "0.5.1"
 
 [features]
 bindings = ["dep:pyo3"]

cartesian_tree-0.4.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: cartesian-tree
+Version: 0.4.0
+Classifier: Programming Language :: Python
+Requires-Dist: maturin==1.8.6 ; extra == 'build'
+Requires-Dist: cartesian-tree[lint] ; extra == 'dev'
+Requires-Dist: cartesian-tree[test] ; extra == 'dev'
+Requires-Dist: cartesian-tree[build] ; extra == 'dev'
+Requires-Dist: ruff==0.12.4 ; extra == 'lint'
+Requires-Dist: mypy==1.17.0 ; extra == 'lint'
+Requires-Dist: pytest==8.4.1 ; extra == 'test'
+Provides-Extra: build
+Provides-Extra: dev
+Provides-Extra: lint
+Provides-Extra: test
+License-File: license-mit
+Summary: Build hierarchical Cartesian coordinate systems to easily transform poses.
+Keywords: Cartesian,coordinate systems,transform,poses
+Home-Page: https://github.com/Kn0g/cartesian-tree
+Author: Kn0g
+Maintainer: Kn0g
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# cartesian-tree
+
+cartesian-tree is a library for managing and transforming poses in a tree-structured hierarchy of 3D coordinate frames in rust as well as python.
+
+## Key ideas
+- Tree Structure: Frames form a tree where each frame defines its position and orientation relative to a parent frame.
+- Poses and Transformations: A Pose represents a position + orientation in a frame. Easily transform poses between frames of the same tree.
+- Unified Rotations: Supports quaternions and roll-pitch-yaw (RPY) interchangeably.
+- Lazy Operations: Quick adjustments like translations (`+ x(1.0)`) or rotations (`* rz(PI/4)`).
+- Thread Safety: Frames and poses can be shared across threads; every operation sees a consistent snapshot of the tree.
+
+## Installation
+The project can be found on [crates.io](https://crates.io/crates/cartesiantree) and [pypi.org](https://pypi.org/project/cartesian-tree/#description)
+
+
+## Usage
+Rust:
+
+```rust
+use cartesian_tree::{Frame, Pose};
+use nalgebra::{Vector3, UnitQuaternion};
+
+fn main() {
+    // Create root frame
+    let world = Frame::new_origin("world");
+
+    // Add a child frame
+    let child = world.add_child(
+        "child",
+        Vector3::new(1.0, 0.0, 0.0),
+        UnitQuaternion::from_euler_angles(0.0, 0.0, std::f64::consts::FRAC_PI_2),
+    ).unwrap();
+
+    // Create a pose in the world frame
+    let pose = world.add_pose(Vector3::new(0.0, 1.0, 0.0), UnitQuaternion::identity());
+
+    // Transform the pose to the child frame
+    let pose_in_child = pose.in_frame(&child).unwrap();
+
+    println!("Pose in child: {:?}", pose_in_child.transformation());
+```
+Python:
+
+```python
+from cartesian_tree import Frame, Rotation, Vector3
+
+# Create root frame
+world = Frame("world")
+
+# Add a child frame
+child = world.add_child(
+    "child",
+    Vector3(1.0, 0.0, 0.0),
+    Rotation.identity()
+)
+
+# Create a pose in the world frame
+pose = world.add_pose(
+    Vector3(0.0, 1.0, 0.0), Rotation.identity()
+)
+
+# Transform the pose to the child frame
+pose_in_child = pose.in_frame(child)
+
+print(f"Pose in child: {pose_in_child}")
+```

cartesian_tree-0.4.0/README.md

@@ -0,0 +1,66 @@
+# cartesian-tree
+
+cartesian-tree is a library for managing and transforming poses in a tree-structured hierarchy of 3D coordinate frames in rust as well as python.
+
+## Key ideas
+- Tree Structure: Frames form a tree where each frame defines its position and orientation relative to a parent frame.
+- Poses and Transformations: A Pose represents a position + orientation in a frame. Easily transform poses between frames of the same tree.
+- Unified Rotations: Supports quaternions and roll-pitch-yaw (RPY) interchangeably.
+- Lazy Operations: Quick adjustments like translations (`+ x(1.0)`) or rotations (`* rz(PI/4)`).
+- Thread Safety: Frames and poses can be shared across threads; every operation sees a consistent snapshot of the tree.
+
+## Installation
+The project can be found on [crates.io](https://crates.io/crates/cartesiantree) and [pypi.org](https://pypi.org/project/cartesian-tree/#description)
+
+
+## Usage
+Rust:
+
+```rust
+use cartesian_tree::{Frame, Pose};
+use nalgebra::{Vector3, UnitQuaternion};
+
+fn main() {
+    // Create root frame
+    let world = Frame::new_origin("world");
+
+    // Add a child frame
+    let child = world.add_child(
+        "child",
+        Vector3::new(1.0, 0.0, 0.0),
+        UnitQuaternion::from_euler_angles(0.0, 0.0, std::f64::consts::FRAC_PI_2),
+    ).unwrap();
+
+    // Create a pose in the world frame
+    let pose = world.add_pose(Vector3::new(0.0, 1.0, 0.0), UnitQuaternion::identity());
+
+    // Transform the pose to the child frame
+    let pose_in_child = pose.in_frame(&child).unwrap();
+
+    println!("Pose in child: {:?}", pose_in_child.transformation());
+```
+Python:
+
+```python
+from cartesian_tree import Frame, Rotation, Vector3
+
+# Create root frame
+world = Frame("world")
+
+# Add a child frame
+child = world.add_child(
+    "child",
+    Vector3(1.0, 0.0, 0.0),
+    Rotation.identity()
+)
+
+# Create a pose in the world frame
+pose = world.add_pose(
+    Vector3(0.0, 1.0, 0.0), Rotation.identity()
+)
+
+# Transform the pose to the child frame
+pose_in_child = pose.in_frame(child)
+
+print(f"Pose in child: {pose_in_child}")
+```

{cartesian_tree-0.2.1 → cartesian_tree-0.4.0}/pyproject.toml

@@ -62,13 +62,13 @@ skip-magic-trailing-comma = false
 docstring-code-format = true
 
 [tool.ruff.lint.per-file-ignores]
-"python/tests/*" = ["D103", "S101"]
+"python/tests/*" = ["D103", "S101", "PLR2004"]
 
 [tool.mypy]
 disallow_untyped_defs = true
 warn_unused_ignores = true
 exclude = [
-    "scr/",
+    "src/",
     "venv.*/",
     "log/",
     "target/",

cartesian_tree-0.4.0/python/cartesian_tree/__init__.py

@@ -0,0 +1,9 @@
+"""A library for calculating Cartesian poses in different coordinate systems."""
+
+from .angles import RPY
+from .base_types import Isometry, Rotation, Vector3
+from .lazy_access import rx, ry, rz, x, y, z
+from .lib import Frame, Pose
+from .quaternion import Quaternion
+
+__all__ = ["RPY", "Frame", "Isometry", "Pose", "Quaternion", "Rotation", "Vector3", "rx", "ry", "rz", "x", "y", "z"]

cartesian_tree-0.4.0/python/cartesian_tree/_cartesian_tree.pyi

@@ -0,0 +1,95 @@
+# Type stubs for the Rust extension module `cartesian_tree._cartesian_tree`.
+# Keep in sync with the pymethods in src/bindings/.
+
+class Vector3:
+    def __init__(self, x: float, y: float, z: float) -> None: ...
+    @property
+    def x(self) -> float: ...
+    @property
+    def y(self) -> float: ...
+    @property
+    def z(self) -> float: ...
+    def to_tuple(self) -> tuple[float, float, float]: ...
+
+class Rotation:
+    @classmethod
+    def from_quaternion(cls, x: float, y: float, z: float, w: float) -> Rotation: ...
+    @classmethod
+    def from_rpy(cls, roll: float, pitch: float, yaw: float) -> Rotation: ...
+    @classmethod
+    def identity(cls) -> Rotation: ...
+    def as_quaternion(self) -> tuple[float, float, float, float]: ...
+    def as_rpy(self) -> tuple[float, float, float]: ...
+
+class Isometry:
+    @classmethod
+    def identity(cls) -> Isometry: ...
+    @classmethod
+    def from_translation(cls, translation: Vector3) -> Isometry: ...
+    @classmethod
+    def from_rotation(cls, rotation: Rotation) -> Isometry: ...
+    @classmethod
+    def from_parts(cls, translation: Vector3, rotation: Rotation) -> Isometry: ...
+    def decompose(self) -> tuple[Vector3, Rotation]: ...
+    def translation(self) -> Vector3: ...
+    def rotation(self) -> Rotation: ...
+    def inverse(self) -> Isometry: ...
+    def __mul__(self, other: Isometry) -> Isometry: ...
+
+class LazyTranslation: ...
+class LazyRotation: ...
+
+class Frame:
+    def __init__(self, name: str) -> None: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def depth(self) -> int: ...
+    @property
+    def position(self) -> Vector3: ...
+    @property
+    def orientation(self) -> Rotation: ...
+    def add_child(self, name: str, position: Vector3, orientation: Rotation) -> Frame: ...
+    def remove_child(self, name: str) -> None: ...
+    def calibrate_child(
+        self,
+        name: str,
+        desired_position: Vector3,
+        desired_orientation: Rotation,
+        reference_pose: Pose,
+    ) -> Frame: ...
+    def add_pose(self, position: Vector3, orientation: Rotation) -> Pose: ...
+    def transformation(self) -> tuple[Vector3, Rotation]: ...
+    def set(self, position: Vector3, orientation: Rotation) -> None: ...
+    def apply_in_parent_frame(self, isometry: Isometry) -> None: ...
+    def apply_in_local_frame(self, isometry: Isometry) -> None: ...
+    def to_json(self) -> str: ...
+    def apply_config(self, json: str) -> None: ...
+    def root(self) -> Frame: ...
+    def parent(self) -> Frame | None: ...
+    def children(self) -> list[Frame]: ...
+    def __add__(self, other: LazyTranslation) -> Frame: ...
+    def __sub__(self, other: LazyTranslation) -> Frame: ...
+    def __mul__(self, other: LazyRotation) -> Frame: ...
+
+class Pose:
+    def frame(self) -> Frame | None: ...
+    @property
+    def position(self) -> Vector3: ...
+    @property
+    def orientation(self) -> Rotation: ...
+    def transformation(self) -> tuple[Vector3, Rotation]: ...
+    def set(self, position: Vector3, orientation: Rotation) -> None: ...
+    def apply_in_parent_frame(self, isometry: Isometry) -> None: ...
+    def apply_in_local_frame(self, isometry: Isometry) -> None: ...
+    def in_frame(self, target_frame: Frame) -> Pose: ...
+    def __add__(self, other: LazyTranslation) -> Pose: ...
+    def __sub__(self, other: LazyTranslation) -> Pose: ...
+    def __mul__(self, other: LazyRotation) -> Pose: ...
+
+def x(value: float) -> LazyTranslation: ...
+def y(value: float) -> LazyTranslation: ...
+def z(value: float) -> LazyTranslation: ...
+def rx(value: float) -> LazyRotation: ...
+def ry(value: float) -> LazyRotation: ...
+def rz(value: float) -> LazyRotation: ...

cartesian_tree-0.4.0/python/cartesian_tree/angles.py

@@ -0,0 +1,79 @@
+"""Contains angle representations."""
+
+from __future__ import annotations
+
+from cartesian_tree import _cartesian_tree as _core
+
+
+class RPY:
+    """Defines a roll-pitch-yaw angle representation."""
+
+    def __init__(self, roll: float, pitch: float, yaw: float) -> None:
+        """Initializes the roll-pitch-yaw angles.
+
+        Args:
+            roll: The roll angle in radians.
+            pitch: The pitch angle in radians.
+            yaw: The yaw angle in radians
+        """
+        self._core_rotation = _core.Rotation.from_rpy(roll, pitch, yaw)
+
+    @classmethod
+    def identity(cls) -> RPY:
+        """Initializes the identity RPY angles."""
+        instance = cls.__new__(cls)
+        instance._core_rotation = _core.Rotation.from_rpy(0.0, 0.0, 0.0)
+        return instance
+
+    @property
+    def roll(self) -> float:
+        """The roll angle in radians."""
+        return self._core_rotation.as_rpy()[0]
+
+    @property
+    def pitch(self) -> float:
+        """The pitch angle in radians."""
+        return self._core_rotation.as_rpy()[1]
+
+    @property
+    def yaw(self) -> float:
+        """The yaw angle in radians."""
+        return self._core_rotation.as_rpy()[2]
+
+    def as_list(self) -> list[float]:
+        """Returns the angles as list.
+
+        Returns:
+            The angle as list.
+        """
+        return list(self._core_rotation.as_rpy())
+
+    def as_tuple(self) -> tuple[float, float, float]:
+        """Returns the angles as tuple.
+
+        Returns:
+            The angles as tuple.
+        """
+        return self._core_rotation.as_rpy()
+
+    def __eq__(self, other: object) -> bool:
+        """Exact component-wise equality of the angle values (no angle wrapping)."""
+        if not isinstance(other, RPY):
+            return NotImplemented
+        return self.as_tuple() == other.as_tuple()
+
+    def __hash__(self) -> int:
+        return hash(self.as_tuple())
+
+    @classmethod
+    def _from_rust(cls, rust_rotation: _core.Rotation) -> RPY:
+        instance = cls.__new__(cls)
+        instance._core_rotation = rust_rotation
+        return instance
+
+    def __str__(self) -> str:
+        roll, pitch, yaw = self._core_rotation.as_rpy()
+        return f"({roll}, {pitch}, {yaw})"
+
+    def __repr__(self) -> str:
+        return self.__str__()