Struct k::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

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

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<(), Error>

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

extern crate nalgebra as na;
extern crate k;

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

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>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

pub 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>, 

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

Performs the conversion.

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

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

Performs the conversion.