Struct k::SerialChain

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

Kinematic chain without any branch.

All joints are connected sequentially.

Implementations

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

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::NodeBuilder::<f32>::new().into_node();
let chain = k::Chain::from_root(node);
assert!(k::SerialChain::try_new(chain).is_some());

let node0 = k::NodeBuilder::<f32>::new().into_node();
let node1 = k::NodeBuilder::new().into_node();
let node2 = k::NodeBuilder::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::NodeBuilder::<f32>::new().into_node();
let s_chain = k::SerialChain::from_end(&node);

pub fn from_end_to_root( end_joint: &Node<T>, root_joint: &Node<T> ) -> SerialChain<T>

Create SerialChain from the end Node and root Node.

Examples

let node0 = k::NodeBuilder::<f32>::new().into_node();
let node1 = k::NodeBuilder::<f32>::new().into_node();
let node2 = k::NodeBuilder::<f32>::new().into_node();
let node3 = k::NodeBuilder::<f32>::new().into_node();
use k::connect;
connect![node0 => node1 => node2 => node3];
let s_chain = k::SerialChain::from_end_to_root(&node2, &node1);
assert_eq!(s_chain.iter().count(), 2);

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 set_origin(&self, pose: Isometry3<T>)

Set the Chain’s origin

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 c = Chain::<f32>::from_end(&l1);
let mut o = c.origin();
assert!(o.translation.vector[0].abs() < 0.000001);
o.translation.vector[0] = 1.0;
c.set_origin(o);
assert!((o.translation.vector[0] - 1.0).abs() < 0.000001);

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

Get the Chain’s origin

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 = NodeBuilder::new()
    .joint_type(JointType::Fixed)
    .finalize()
    .into();
let l1 : Node<f64> = NodeBuilder::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(NodeBuilder::new()
    .name("fixed")
    .finalize());
let l1 = Node::new(NodeBuilder::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 find_link(&self, link_name: &str) -> Option<&Node<T>>

Find the joint by link name

Examples

use k::*;

let l0 = Node::new(NodeBuilder::new()
    .name("fixed")
    .finalize());
l0.set_link(Some(link::LinkBuilder::new().name("link0").finalize()));
let mut l1 = Node::new(NodeBuilder::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);
l1.set_link(Some(link::LinkBuilder::new().name("link1").finalize()));
let tree = Chain::from_root(l0);
let joint_name = tree.find_link("link1").unwrap()
.joint().name.clone();
assert_eq!(joint_name, "pitch1");

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

Set the positions of the joints

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

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

Set the clamped positions of the joints

This function is safe, in contrast to set_joint_positions_unchecked.

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> Clone for SerialChain<T>where T: RealField + SubsetOf<f64>,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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 + SubsetOf<f64>,

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

Formats the value using the given formatter.