Struct FrameTransform 

pub struct FrameTransform<T: Copy + Debug + Default + Serialize + 'static> {
    pub transform: Transform3D<T>,
    pub parent_frame: FrameIdString,
    pub child_frame: FrameIdString,
}

Transform message useable as a payload for CuStampedData. This contains just the transform data without timestamps, as timestamps are handled by CuStampedData

Example

use cu_transform::{FrameTransform, Transform3D};
use cu29::prelude::*;
use cu29::clock::{CuDuration, Tov};
use cu_transform::transform_payload::StampedFrameTransform;

// Create a transform message
let transform = Transform3D::<f32>::default();
let payload = FrameTransform::new(
    transform,
    "world",
    "robot"
);

let data = StampedFrameTransform::new(Some(payload));

Fields

transform: Transform3D<T>

The actual transform

parent_frame: FrameIdString

Parent frame identifier

child_frame: FrameIdString

Child frame identifier

Implementations

impl<T: Copy + Debug + Default + Serialize + 'static> FrameTransform<T>

pub fn new( transform: Transform3D<T>, parent_frame: impl AsRef<str>, child_frame: impl AsRef<str>, ) -> Self

Create a new transform message

Examples found in repository

examples/payload_usage.rs (lines 26-30)

fn main() {
    println!("Cu Transform - CuMsg Pattern Demo");
    println!("=================================");
    println!();

    // Create a transform tree
    let mut tree = TransformTree::<f32>::new();
    let clock = RobotClock::default();

    // Create transforms using the new CuMsg pattern
    println!("Creating transforms with CuMsg...");

    // World to base transform
    let transform1 = Transform3D::from_matrix([
        [1.0f32, 0.0, 0.0, 0.0], // Column-major: each inner array is a column
        [0.0, 1.0, 0.0, 0.0],
        [0.0, 0.0, 1.0, 0.0],
        [1.0, 0.0, 0.0, 1.0], // Translation (1, 0, 0)
    ]);

    let frame_transform = FrameTransform::new(
        transform1,
        FrameIdString::from("world").expect("Frame name too long"),
        FrameIdString::from("base").expect("Frame name too long"),
    );
    let mut sft = StampedFrameTransform::new(Some(frame_transform));
    sft.tov = Tov::Time(CuDuration(1_000_000_000)); // 1 second

    // Add to tree using the new API
    tree.add_transform(&sft).expect("Failed to add transform");
    println!("  Added world->base transform at t=1s");

    // Base to arm transform
    let transform2 = Transform3D::from_matrix([
        [0.0, 1.0, 0.0, 0.0], // 90-degree rotation around Z
        [-1.0, 0.0, 0.0, 0.0],
        [0.0, 0.0, 1.0, 0.0],
        [0.5, 0.0, 0.0, 1.0], // Translation (0.5, 0, 0)
    ]);

    let msg2 = FrameTransform::new(
        transform2,
        FrameIdString::from("base").expect("Frame name too long"),
        FrameIdString::from("arm").expect("Frame name too long"),
    );
    let mut sft = StampedFrameTransform::new(Some(msg2));
    sft.tov = Tov::Time(CuDuration(1_000_000_000)); // 1 second

    tree.add_transform(&sft).expect("Failed to add transform");
    println!("  Added base->arm transform at t=1s");

    // Demonstrate using time ranges for a broadcast
    println!("\nBroadcasting multiple transforms with time range...");

    // Create multiple transforms at different times
    let times = [
        CuDuration(2_000_000_000), // 2 seconds
        CuDuration(2_100_000_000), // 2.1 seconds
        CuDuration(2_200_000_000),
    ];

    for (i, &time) in times.iter().enumerate() {
        let x_translation = 1.0 + (i as f32) * 0.1;
        let transform = Transform3D::from_matrix([
            [1.0, 0.0, 0.0, 0.0],
            [0.0, 1.0, 0.0, 0.0],
            [0.0, 0.0, 1.0, 0.0],
            [x_translation, 0.0, 0.0, 1.0],
        ]);

        let msg = FrameTransform::new(
            transform,
            FrameIdString::from("world").expect("Frame name too long"),
            FrameIdString::from("base").expect("Frame name too long"),
        );
        let mut sft = StampedFrameTransform::new(Some(msg));

        // For a broadcast with multiple transforms, use Range
        if i == 0 {
            sft.tov = Tov::Range(cu29::clock::CuTimeRange {
                start: times[0],
                end: *times.last().unwrap(),
            });
        } else {
            sft.tov = Tov::Time(time);
        }

        tree.add_transform(&sft).expect("Failed to add transform");
    }

    println!("  Added 3 transforms with time range 2.0s - 2.2s");

    // Query the tree
    println!("\nQuerying transforms...");

    let result = tree.lookup_transform("world", "arm", CuDuration(1_000_000_000), &clock);
    match result {
        Ok(transform) => {
            let mat = transform.to_matrix();
            println!(
                "  World->arm at t=1s: translation=({:.2}, {:.2}, {:.2})",
                mat[3][0], mat[3][1], mat[3][2]
            );
        }
        Err(e) => println!("  Error: {e}"),
    }

    // Query velocity (requires transforms at multiple times)
    let velocity = tree.lookup_velocity("world", "base", CuDuration(2_100_000_000), &clock);
    match velocity {
        Ok(vel) => {
            println!(
                "  World->base velocity at t=2.1s: linear=({:.2}, {:.2}, {:.2}) m/s",
                vel.linear[0], vel.linear[1], vel.linear[2]
            );
        }
        Err(e) => println!("  Error computing velocity: {e}"),
    }

    println!("\nKey advantages of CuMsg pattern:");
    println!("- Integrates with Copper message system");
    println!("- Timestamps handled by CuMsg metadata (Tov)");
    println!("- Supports time ranges for broadcasts");
}

examples/basic_usage.rs (lines 144-148)

fn main() {
    // Example using the typed transform approach
    println!("Cu Transform - New Typed Approach Demo");
    println!("=====================================");

    // Create a buffer for world -> robot transforms
    let mut world_to_robot_buffer: TypedTransformBuffer<f32, WorldFrame, RobotFrame, 10> =
        TypedTransformBuffer::new();

    // Create a transform message
    let transform = Transform3D::from_matrix([
        [1.0, 0.0, 0.0, 1.0], // X translation
        [0.0, 1.0, 0.0, 2.0], // Y translation
        [0.0, 0.0, 1.0, 0.0],
        [0.0, 0.0, 0.0, 1.0],
    ]);

    let world_to_robot_msg = TypedTransform::new(transform, CuDuration(1000));

    println!(
        "Created transform from {} to {}",
        world_to_robot_msg.parent_name(),
        world_to_robot_msg.child_name()
    );
    if let Some(t) = world_to_robot_msg.transform() {
        let mat = t.to_matrix();
        println!(
            "  Translation: [{}, {}, {}]",
            mat[0][3], mat[1][3], mat[2][3]
        );
    }

    // Add to buffer
    world_to_robot_buffer.add_transform(world_to_robot_msg);

    // Create second transform
    let transform2 = Transform3D::from_matrix([
        [1.0, 0.0, 0.0, 2.0], // X translation
        [0.0, 1.0, 0.0, 4.0], // Y translation
        [0.0, 0.0, 1.0, 0.0],
        [0.0, 0.0, 0.0, 1.0],
    ]);

    let world_to_robot_msg2 = TypedTransform::new(transform2, CuDuration(2000));
    world_to_robot_buffer.add_transform(world_to_robot_msg2);

    // Query the buffer
    if let Some(latest) = world_to_robot_buffer.get_latest_transform() {
        println!(
            "\nLatest transform at time {}:",
            latest.timestamp().unwrap().as_nanos()
        );
        if let Some(t) = latest.transform() {
            let mat = t.to_matrix();
            println!(
                "  Translation: [{}, {}, {}]",
                mat[0][3], mat[1][3], mat[2][3]
            );
        }
    }

    // Query closest to a specific time
    if let Some(closest) = world_to_robot_buffer.get_closest_transform(CuDuration(1500)) {
        println!("\nClosest transform to time 1500:");
        println!("  Actual time: {}", closest.timestamp().unwrap().as_nanos());
        if let Some(t) = closest.transform() {
            let mat = t.to_matrix();
            println!(
                "  Translation: [{}, {}, {}]",
                mat[0][3], mat[1][3], mat[2][3]
            );
        }
    }

    // Demonstrate time range
    if let Some(range) = world_to_robot_buffer.get_time_range() {
        println!(
            "\nTime range: {} to {}",
            range.start.as_nanos(),
            range.end.as_nanos()
        );
    }

    // Demonstrate velocity computation
    if let Some(latest) = world_to_robot_buffer.get_latest_transform() {
        if let Some(closest) = world_to_robot_buffer.get_closest_transform(CuDuration(1000)) {
            if let Some(velocity) = latest.compute_velocity(closest) {
                println!("\nVelocity computation:");
                println!(
                    "  Linear velocity: [{}, {}, {}]",
                    velocity.linear[0], velocity.linear[1], velocity.linear[2]
                );
            }
        }
    }

    // Demonstrate the stringly typed version of the API.
    println!("\n\nConstant-Size Buffer Demo");
    println!("===========================================");

    let mut const_buffer: ConstTransformBuffer<f32, 5> = ConstTransformBuffer::new();

    // Add some stamped transforms
    let stamped_transform = StampedTransform {
        transform,
        stamp: CuDuration(1000),
        parent_frame: "world".try_into().unwrap(),
        child_frame: "robot".try_into().unwrap(),
    };

    const_buffer.add_transform(stamped_transform);

    if let Some(latest_stamped) = const_buffer.get_latest_transform() {
        println!("Latest transform in constant buffer:");
        println!(
            "  From: {} to: {}",
            latest_stamped.parent_frame, latest_stamped.child_frame
        );
        println!("  Time: {}", latest_stamped.stamp.as_nanos());
        let mat = latest_stamped.transform.to_matrix();
        println!(
            "  Translation: [{}, {}, {}]",
            mat[0][3], mat[1][3], mat[2][3]
        );
    }

    println!("\nThis buffer is stack-allocated with capacity 5 - no heap allocation!");

    // Demonstrate the StampedFrameTransform pattern with TransformTree
    println!("\n\nStampedFrameTransform Pattern Demo");
    println!("================================");

    let mut tree = TransformTree::<f32>::new();

    // Create a CuMsg with TransformMsg
    let frame_transform = FrameTransform::new(
        transform,
        FrameIdString::from("world").expect("Frame name too long"),
        FrameIdString::from("robot").expect("Frame name too long"),
    );

    let mut sft = StampedFrameTransform::new(Some(frame_transform));
    sft.tov = Tov::Time(CuDuration(1_000_000_000)); // 1 second

    // Add using the new API
    tree.add_transform(&sft).expect("Failed to add transform");
    println!("Added transform using CuMsg<TransformMsg> pattern");

    // Query the transform
    let robot_clock = cu29::clock::RobotClock::default();
    let result = tree.lookup_transform("world", "robot", CuDuration(1_000_000_000), &robot_clock);

    match result {
        Ok(transform) => {
            let mat = transform.to_matrix();
            println!(
                "Retrieved transform: translation=({:.2}, {:.2}, {:.2})",
                mat[3][0], mat[3][1], mat[3][2]
            );
        }
        Err(e) => println!("Error: {e}"),
    }
}

pub fn from_stamped(stamped: &StampedTransform<T>) -> Self

Create from a StampedTransform (for migration)

Trait Implementations

impl<T: Clone + Copy + Debug + Default + Serialize + 'static> Clone for FrameTransform<T>

fn clone(&self) -> FrameTransform<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Copy + Debug + Default + Serialize + 'static> Debug for FrameTransform<T>

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

Formats the value using the given formatter.

impl<T> Decode<()> for FrameTransform<T>

where T: Decode<()> + Copy + Debug + Default + Serialize + 'static,

fn decode<D: Decoder<Context = ()>>( decoder: &mut D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<T: Default + Copy + Debug + Default + Serialize + 'static> Default for FrameTransform<T>

fn default() -> FrameTransform<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for FrameTransform<T>

where T: Deserialize<'de> + Copy + Debug + Default + Serialize + 'static,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Encode for FrameTransform<T>

where T: Encode + Copy + Debug + Default + Serialize + 'static,

fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError>

Encode a given type.

impl<T> Serialize for FrameTransform<T>

where T: Serialize + Copy + Debug + Default + Serialize + 'static,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.