Struct robot_description_builder::Transform

pub struct Transform {
    pub translation: Option<(f32, f32, f32)>,
    pub rotation: Option<(f32, f32, f32)>,
}

A Transform type to represent the transform from the parent coordinate system to a new coordinate system.

A transform starts from the origin of the parent element and first translates to the origin of the child element, after which a new coordinate system gets by rotating the parent coordinate system over the specified roll, pitch and yaw angles.

The translation is applied first and uses the axes of the parent coordinate system. The translation is specified in meters.

The rotation is applied next and rotates the parent axes with the specified roll, pitch and yaw angles in radians.

In URDF this element is often refered to as <origin>.

Fields

translation: Option<(f32, f32, f32)>

The translation of origin of the new coordinate system in meters.

rotation: Option<(f32, f32, f32)>

The rotation of the new coordinate system in radians.

Implementations

impl Transform

pub fn new(xyz: (f32, f32, f32), rpy: (f32, f32, f32)) -> Self

Creates a new Transform.

Creates a new Transform from a tuple of cartesian coordinates in meters as f32 and a tuple of roll-pitch-yaw angles in radians as f32.

Example

use robot_description_builder::Transform;
use std::f32::consts::PI;
let transform = Transform::new((1., 1000., 0.), (0., PI, 0.));

assert_eq!(
    transform,
    Transform {
       translation: Some((1., 1000., 0.)),
       rotation: Some((0., PI, 0.)),
    }
)

pub fn new_translation(x: f32, y: f32, z: f32) -> Self

Creates a new Transform from cartesian x, y and z coordinates.

Creates a new Transform from a tuple of cartesian coordinates in meters as f32 and leaves the other values at the default.

Example

use robot_description_builder::Transform;
let transform = Transform::new_translation( -0.6, 10., 900.);

assert_eq!(
    transform,
    Transform {
       translation: Some((-0.6, 10., 900.)),
       rotation: None,
    }
)

pub fn new_rotation(r: f32, p: f32, y: f32) -> Self

Creates a new Transform from roll-pitch-yaw angles.

Creates a new Transform from the roll-pitch-yaw angles in radians as f32 and leaves the other values at the default.

Example

use robot_description_builder::Transform;
use std::f32::consts::PI;
let transform = Transform::new_rotation( 0., PI, 0.);

assert_eq!(
    transform,
    Transform {
       translation: None,
       rotation: Some((0., PI, 0.)),
    }
)

pub fn contains_some(&self) -> bool

A function to check if any of the fields are set.

It doesn’t check if the some fields have the default value, since it can be format depended.

Example

assert!(Transform {
    translation: Some((1., 2., 3.)),
    rotation: Some((4., 5., 6.))
}
.contains_some());

assert!(Transform {
    translation: Some((1., 2., 3.)),
    ..Default::default()
}
.contains_some());

assert!(Transform {
    rotation: Some((4., 5., 6.)),
    ..Default::default()
}
.contains_some());

assert!(!Transform::default().contains_some())

Trait Implementations

impl Clone for Transform

fn clone(&self) -> Transform

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transform

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

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Transform

Returns the “default value” for a type.

impl PartialEq for Transform

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl ToURDF for Transform

fn to_urdf( &self, writer: &mut Writer<Cursor<Vec<u8>>>, _urdf_config: &URDFConfig ) -> Result<(), Error>

Represents the element as in URDF format.

impl Copy for Transform

impl StructuralPartialEq for Transform