Struct k::joint::Joint

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

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

Methods

impl<T> Joint<T> where
    T: RealField, 

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

Create new Joint with name and type

Examples

extern crate nalgebra as na;
extern crate k;

// 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<(), JointError>

Set the position of the joint

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

Examples

extern crate nalgebra as na;
extern crate k;

// 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_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<(), JointError>

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

extern crate nalgebra as na;
extern crate k;

// 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

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, 

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

Performs the conversion.

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

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

Performs the conversion.