Struct k::SerialChain

pub struct SerialChain<T: RealField> { /* fields omitted */ }

Kinematic chain without any branch.

All joints are connected sequentially.

Methods

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

pub fn new_unchecked(inner: Chain<T>) -> Self

Convert Chain into SerialChain without any check

If the input Chain has any branches it causes serious bugs.

pub fn try_new(inner: Chain<T>) -> Option<Self>

Convert Chain into SerialChain

If the input Chain has any branches it fails.

Examples

let node = k::JointBuilder::<f32>::new().into_node();
let chain = k::Chain::from_root(node);
assert!(k::SerialChain::try_new(chain).is_some());

let node0 = k::JointBuilder::<f32>::new().into_node();
let node1 = k::JointBuilder::new().into_node();
let node2 = k::JointBuilder::new().into_node();
node1.set_parent(&node0);
node2.set_parent(&node0);
let chain = k::Chain::from_root(node0);
assert!(k::SerialChain::try_new(chain).is_none());

pub fn from_end(end_joint: &Node<T>) -> SerialChain<T>

Create SerialChain from the end Node

Examples

let node = k::JointBuilder::<f32>::new().into_node();
let s_chain = k::SerialChain::from_end(&node);

pub fn unwrap(self) -> Chain<T>

Safely unwrap and returns inner Chain instance

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

Calculate transform of the end joint

Methods from Deref<Target = Chain<T>>

pub fn iter(&self) -> impl Iterator<Item = &Node<T>>

Iterate for all joint nodes

The order is from parent to children. You can assume that parent is already iterated.

Examples

use k::*;

let l0 = Node::new(Joint::new("fixed0", JointType::Fixed));
let l1 = Node::new(Joint::new("fixed1", JointType::Fixed));
l1.set_parent(&l0);
let tree = Chain::<f64>::from_root(l0);
let names = tree.iter().map(|node| node.joint().name.to_owned()).collect::<Vec<_>>();
assert_eq!(names.len(), 2);
assert_eq!(names[0], "fixed0");
assert_eq!(names[1], "fixed1");

pub fn iter_joints(&self) -> impl Iterator<Item = JointRefGuard<T>>

Iterate for movable joints

Fixed joints are ignored. If you want to manipulate on Fixed, use iter() instead of iter_joints()

pub fn iter_links(&self) -> impl Iterator<Item = LinkRefGuard<T>>

Iterate for links

pub fn dof(&self) -> usize

Calculate the degree of freedom

Examples

use k::*;
let l0 = JointBuilder::new()
    .joint_type(JointType::Fixed)
    .finalize()
    .into();
let l1 : Node<f64> = JointBuilder::new()
    .joint_type(JointType::Rotational{axis: Vector3::y_axis()})
    .finalize()
    .into();
l1.set_parent(&l0);
let tree = Chain::from_root(l0);
assert_eq!(tree.dof(), 1);

pub fn find(&self, joint_name: &str) -> Option<&Node<T>>

Find the joint by name

Examples

use k::*;

let l0 = Node::new(JointBuilder::new()
    .name("fixed")
    .finalize());
let l1 = Node::new(JointBuilder::new()
    .name("pitch1")
    .translation(Translation3::new(0.0, 0.1, 0.0))
    .joint_type(JointType::Rotational{axis: Vector3::y_axis()})
    .finalize());
l1.set_parent(&l0);
let tree = Chain::from_root(l0);
let j = tree.find("pitch1").unwrap();
j.set_joint_position(0.5).unwrap();
assert_eq!(j.joint_position().unwrap(), 0.5);

pub fn joint_positions(&self) -> Vec<T>

Get the positions of the joints

FixedJoint is ignored. the length is the same with dof()

pub fn set_joint_positions(&self, positions_vec: &[T]) -> Result<(), JointError>

Set the positions of the joints

FixedJoints are ignored. the input number must be equal with dof()

pub fn set_joint_positions_unchecked(&self, positions_vec: &[T])

Fast, but without check, dangerous set_joint_positions

pub fn update_transforms(&self) -> Vec<Isometry3<T>>

Update world_transform() of the joints

pub fn update_velocities(&self) -> Vec<Velocity<T>>

Update world_velocity() of the joints

pub fn update_link_transforms(&self)

Update transforms of the links

Trait Implementations

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

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

Formats the value using the given formatter.

impl<T> Deref for SerialChain<T> where
    T: RealField, 

type Target = Chain<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> Display for SerialChain<T> where
    T: RealField, 

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

Formats the value using the given formatter.