Struct k::node::Node

pub struct Node<T: RealField>(/* private fields */);

Parts of Chain

It contains joint, joint (transform), and parent/children.

Implementations

impl<T> Node<T>

where T: RealField + SubsetOf<f64>,

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

pub fn joint(&self) -> JointRefGuard<'_, T>

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

pub fn parent(&self) -> Option<Node<T>>

pub fn children(&self) -> ChildrenRefGuard<'_, T>

pub fn iter_ancestors(&self) -> Ancestors<T>

iter from the end to root, it contains nodes[id] itself

pub fn iter_descendants(&self) -> Descendants<T>

iter to the end, it contains nodes[id] itself

pub fn set_parent(&self, parent: &Node<T>)

Set parent and child relations at same time

pub fn remove_parent(&self, parent: &Node<T>)

Remove parent and child relations at same time

pub fn is_root(&self) -> bool

Examples

use k::*;

let l0 = k::NodeBuilder::<f32>::new().into_node();
let l1 = k::NodeBuilder::new().into_node();
l1.set_parent(&l0);
assert!(l0.is_root());
assert!(!l1.is_root());

pub fn is_end(&self) -> bool

Examples

let l0 = k::NodeBuilder::<f64>::new().into_node();
let l1 = k::NodeBuilder::new().into_node();
l1.set_parent(&l0);
assert!(!l0.is_end());
assert!(l1.is_end());

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

Set the origin transform of the joint

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

Get the origin transform of the joint

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

Set the position (angle) of the joint

If position is out of limit, it returns Err.

Examples

use k::*;
let l0 = NodeBuilder::new()
    .joint_type(JointType::Linear{axis: Vector3::z_axis()})
    .limits(Some((0.0..=2.0).into()))
    .into_node();
assert!(l0.set_joint_position(1.0).is_ok());
assert!(l0.set_joint_position(-1.0).is_err());

Setting position for Fixed joint is error.

use k::*;
let l0 = NodeBuilder::new()
    .joint_type(JointType::Fixed)
    .into_node();
assert!(l0.set_joint_position(0.0).is_err());

k::joint::Mimic can be used to copy other joint’s position.

use k::*;
let j0 = NodeBuilder::new()
    .joint_type(JointType::Linear{axis: Vector3::z_axis()})
    .limits(Some((0.0..=2.0).into()))
    .into_node();
let j1 = NodeBuilder::new()
    .joint_type(JointType::Linear{axis: Vector3::z_axis()})
    .limits(Some((0.0..=2.0).into()))
    .into_node();
j1.set_mimic_parent(&j0, k::joint::Mimic::new(1.5, 0.1));
assert_eq!(j0.joint_position().unwrap(), 0.0);
assert_eq!(j1.joint_position().unwrap(), 0.0);
assert!(j0.set_joint_position(1.0).is_ok());
assert_eq!(j0.joint_position().unwrap(), 1.0);
assert_eq!(j1.joint_position().unwrap(), 1.6);

pub fn set_joint_position_clamped(&self, position: T)

Set the clamped position (angle) of the joint

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

Examples

use k::*;
let l0 = NodeBuilder::new()
    .joint_type(JointType::Linear{axis: Vector3::z_axis()})
    .limits(Some((-1.0..=1.0).into()))
    .into_node();
l0.set_joint_position_clamped(2.0);
assert_eq!(l0.joint().joint_position(), Some(1.0));
l0.set_joint_position_clamped(-2.0);
assert_eq!(l0.joint().joint_position(), Some(-1.0));

pub fn set_joint_position_unchecked(&self, position: T)

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

Get the calculated world transform. Call Chain::update_transforms() before using this method.

Examples

use k::*;
use k::prelude::*;

let l0 = NodeBuilder::new()
    .translation(Translation3::new(0.0, 0.0, 0.2))
    .joint_type(JointType::Rotational{axis: Vector3::y_axis()})
    .into_node();
let l1 = NodeBuilder::new()
    .translation(Translation3::new(0.0, 0.0, 1.0))
    .joint_type(JointType::Linear{axis: Vector3::z_axis()})
    .into_node();
l1.set_parent(&l0);
let tree = Chain::<f64>::from_root(l0);
tree.set_joint_positions(&vec![3.141592 * 0.5, 0.1]).unwrap();
assert!(l1.world_transform().is_none());
assert!(l1.world_transform().is_none());
let _poses = tree.update_transforms();
assert!((l1.world_transform().unwrap().translation.vector.x - 1.1).abs() < 0.0001);
assert!((l1.world_transform().unwrap().translation.vector.z - 0.2).abs() < 0.0001);

// _poses[0] is as same as l0.world_transform()
// _poses[1] is as same as l1.world_transform()

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

pub fn mimic_parent(&self) -> Option<Node<T>>

pub fn set_mimic_parent(&self, parent: &Node<T>, mimic: Mimic<T>)

pub fn set_link(&self, link: Option<Link<T>>)

pub fn link(&self) -> OptionLinkRefGuard<'_, T>

Trait Implementations

impl<T> Clone for Node<T>

where T: RealField,

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 Node<T>

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

Formats the value using the given formatter.

impl<T: RealField + SubsetOf<f64>> Display for Node<T>

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

Formats the value using the given formatter.

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.

impl<T> PartialEq for Node<T>

where T: RealField,

fn eq(&self, other: &Node<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.