Struct Point

pub struct Point {
    pub position: Vector3,
    pub orientation: Quaternion,
    pub timestamp: Timestamp,
    pub frame: String,
}

Represents a point in space with a position, orientation, and timestamp.

The Point struct encapsulates a 3D position using a Vector3, an orientation using a Quaternion, and a Timestamp to indicate when the point was recorded.

Examples

use transforms::{
    geometry::{Point, Quaternion, Vector3},
    time::Timestamp,
};

let position = Vector3 {
    x: 1.0,
    y: 2.0,
    z: 3.0,
};
let orientation = Quaternion {
    w: 1.0,
    x: 0.0,
    y: 0.0,
    z: 0.0,
};
let timestamp = Timestamp::zero();
let frame = String::from("a");

let point = Point {
    position,
    orientation,
    timestamp,
    frame,
};

assert_eq!(point.position.x, 1.0);
assert_eq!(point.orientation.w, 1.0);

Fields

position: Vector3

orientation: Quaternion

timestamp: Timestamp

frame: String

Trait Implementations

impl Clone for Point

fn clone(&self) -> Point

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Point

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Point

fn eq(&self, other: &Point) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Point

fn partial_cmp(&self, other: &Point) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Transformable for Point

The Transformable trait defines an interface for objects that can be transformed using a Transform. Implementors of this trait can apply a transformation to themselves, modifying their position and orientation.

Below is an example of how to implement the Transformable trait for a Point.

Examples

use transforms::{
    geometry::{Point, Quaternion, Vector3},
    time::Timestamp,
    Transform, Transformable,
};

let position = Vector3 {
    x: 1.0,
    y: 2.0,
    z: 3.0,
};
let orientation = Quaternion {
    w: 1.0,
    x: 0.0,
    y: 0.0,
    z: 0.0,
};
let timestamp = Timestamp { t: 0 };
let frame = String::from("b");

let mut point = Point {
    position,
    orientation,
    timestamp,
    frame,
};

let transform = Transform {
    translation: Vector3 {
        x: 2.0,
        y: 0.0,
        z: 0.0,
    },
    rotation: Quaternion {
        w: 1.0,
        x: 0.0,
        y: 0.0,
        z: 0.0,
    },
    timestamp: Timestamp { t: 0 },
    parent: "a".into(),
    child: "b".into(),
};
let r = point.transform(&transform);
assert!(r.is_ok());
assert_eq!(point.frame, "a");
assert_eq!(point.position.x, 3.0);

fn transform(&mut self, transform: &Transform) -> Result<(), TransformError>

Applies a transformation to the Point.

Arguments

• transform - A reference to the Transform to be applied.

Returns

• Ok(()) if the transformation is successfully applied.
• Err(TransformError) if the frames are incompatible or the timestamps do not match.

impl StructuralPartialEq for Point