Struct k::joint::Joint

pub struct Joint<T: RealField> {
    pub name: String,
    pub joint_type: JointType<T>,
    pub limits: Option<Range<T>>,
    /* private fields */
}

Joint with type

Fields

name: String

Name of this joint

joint_type: JointType<T>

Type of this joint

limits: Option<Range<T>>

Limits of this joint

Implementations

impl<T> Joint<T>where
    T: RealField + SubsetOf<f64>,

pub fn new(name: &str, joint_type: JointType<T>) -> Joint<T>

Create new Joint with name and type

Examples

use nalgebra as na;

// create fixed joint
let fixed = k::Joint::<f32>::new("f0", k::JointType::Fixed);
assert!(fixed.joint_position().is_none());

// create rotational joint with Y-axis
let rot = k::Joint::<f64>::new("r0", k::JointType::Rotational { axis: na::Vector3::y_axis() });
assert_eq!(rot.joint_position().unwrap(), 0.0);

pub fn set_joint_position(&mut self, position: T) -> Result<(), Error>

Set the position of the joint

It returns Err if it is out of the limits, or this is fixed joint.

Examples

use nalgebra as na;

// Create fixed joint
let mut fixed = k::Joint::<f32>::new("f0", k::JointType::Fixed);
// Set position to fixed joint always fails
assert!(fixed.set_joint_position(1.0).is_err());

// Create rotational joint with Y-axis
let mut rot = k::Joint::<f64>::new("r0", k::JointType::Rotational { axis: na::Vector3::y_axis() });
// As default, it has not limit

// Initial position is 0.0
assert_eq!(rot.joint_position().unwrap(), 0.0);
// If it has no limits, set_joint_position always succeeds.
rot.set_joint_position(0.2).unwrap();
assert_eq!(rot.joint_position().unwrap(), 0.2);

pub fn set_joint_position_clamped(&mut self, position: T)

Set the clamped position of the joint

It refers to the joint limit and clamps the argument. This function does nothing if this is fixed joint.

Examples

use nalgebra as na;

// Create rotational joint with Y-axis
let mut rot = k::Joint::<f64>::new("r0", k::JointType::Rotational { axis: na::Vector3::y_axis() });

let limits = k::joint::Range::new(-1.0, 1.0);
rot.limits = Some(limits);

// Initial position is 0.0
assert_eq!(rot.joint_position().unwrap(), 0.0);
rot.set_joint_position_clamped(2.0);
assert_eq!(rot.joint_position().unwrap(), 1.0);
rot.set_joint_position_clamped(-2.0);
assert_eq!(rot.joint_position().unwrap(), -1.0);

pub fn set_joint_position_unchecked(&mut self, position: T)

pub fn joint_position(&self) -> Option<T>

Returns the position (angle)

pub fn origin(&self) -> &Isometry3<T>

pub fn set_origin(&mut self, origin: Isometry3<T>)

pub fn set_joint_velocity(&mut self, velocity: T) -> Result<(), Error>

pub fn joint_velocity(&self) -> Option<T>

Returns the velocity

pub fn local_transform(&self) -> Isometry3<T>

Calculate and returns the transform of the end of this joint

Examples

use nalgebra as na;

// Create linear joint with X-axis
let mut lin = k::Joint::<f64>::new("l0", k::JointType::Linear { axis: na::Vector3::x_axis() });
assert_eq!(lin.local_transform().translation.vector.x, 0.0);
lin.set_joint_position(-1.0).unwrap();
assert_eq!(lin.local_transform().translation.vector.x, -1.0);

pub fn world_transform(&self) -> Option<Isometry3<T>>

Get the result of forward kinematics

The value is updated by Chain::update_transforms

pub fn world_velocity(&self) -> Option<Velocity<T>>

pub fn is_movable(&self) -> bool

pub fn clear_caches(&self)

Clear caches defined in the world coordinate

Trait Implementations

impl<T: Clone + RealField> Clone for Joint<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + RealField> Debug for Joint<T>

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

Formats the value using the given formatter.

impl<T: RealField> Display for Joint<T>

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

Formats the value using the given formatter.

impl<'a, T> From<&'a Joint> for Joint<T>where
    T: RealField + SubsetOf<f64>,

fn from(joint: &Joint) -> Joint<T>

Converts to this type from the input type.

impl<T> From<Joint<T>> for Node<T>where
    T: RealField + SubsetOf<f64>,

fn from(joint: Joint<T>) -> Self

Converts to this type from the input type.