Struct Multibody

pub struct Multibody { /* private fields */ }

An articulated body simulated using the reduced-coordinates approach.

Implementations

impl Multibody

pub fn new() -> Self

Creates a new multibody with no link.

pub fn self_contacts_enabled(&self) -> bool

Whether self-contacts are enabled on this multibody.

If set to false no two link from this multibody can generate contacts, even if the contact is enabled on the individual joint with GenericJoint::contacts_enabled.

pub fn set_self_contacts_enabled(&mut self, enabled: bool)

Sets whether self-contacts are enabled on this multibody.

If set to false no two link from this multibody can generate contacts, even if the contact is enabled on the individual joint with GenericJoint::contacts_enabled.

pub fn inv_augmented_mass(&self) -> &LU<f32, Dyn, Dyn>

The inverse augmented mass matrix of this multibody.

pub fn root(&self) -> &MultibodyLink

The first link of this multibody.

pub fn root_mut(&mut self) -> &mut MultibodyLink

Mutable reference to the first link of this multibody.

pub fn link(&self, id: usize) -> Option<&MultibodyLink>

Reference i-th multibody link of this multibody.

Return None if there is less than i + 1 multibody links.

pub fn link_mut(&mut self, id: usize) -> Option<&mut MultibodyLink>

Mutable reference to the multibody link with the given id.

Return None if the given id does not identifies a multibody link part of self.

pub fn num_links(&self) -> usize

The number of links on this multibody.

pub fn links(&self) -> impl Iterator<Item = &MultibodyLink>

Iterator through all the links of this multibody.

All link are guaranteed to be yielded before its descendant.

pub fn links_mut(&mut self) -> impl Iterator<Item = &mut MultibodyLink>

Mutable iterator through all the links of this multibody.

All link are guaranteed to be yielded before its descendant.

pub fn damping(&self) -> &DVector<f32>

The vector of damping applied to this multibody.

pub fn damping_mut(&mut self) -> &mut DVector<f32>

Mutable vector of damping applied to this multibody.

pub fn joint_velocity(&self, link: &MultibodyLink) -> DVectorView<'_, f32>

The generalized velocity at the multibody_joint of the given link.

pub fn generalized_acceleration(&self) -> DVectorView<'_, f32>

The generalized accelerations of this multibodies.

pub fn generalized_velocity(&self) -> DVectorView<'_, f32>

The generalized velocities of this multibodies.

pub fn body_jacobian(&self, link_id: usize) -> &Jacobian<f32>

The body jacobian for link link_id calculated by the last call to Multibody::forward_kinematics.

pub fn generalized_velocity_mut(&mut self) -> DVectorViewMut<'_, f32>

The mutable generalized velocities of this multibodies.

pub fn apply_displacements(&mut self, disp: &[f32])

Apply displacements, in generalized coordinates, to this multibody.

Note this does not updates the link poses, only their generalized coordinates. To update the link poses and associated rigid-bodies, call Self::forward_kinematics.

pub fn update_rigid_bodies( &self, bodies: &mut RigidBodySet, update_mass_properties: bool, )

Update the rigid-body poses based on this multibody joint poses.

This is typically called after Self::forward_kinematics to apply the new joint poses to the rigid-bodies.

pub fn forward_kinematics( &mut self, bodies: &RigidBodySet, read_root_pose_from_rigid_body: bool, )

Apply forward-kinematics to this multibody.

This will update the MultibodyLink pose information as wall as the body jacobians. This will also ensure that the multibody has the proper number of degrees of freedom if its root node changed between dynamic and non-dynamic.

Note that this does not update the poses of the RigidBody attached to the joints. Run Self::update_rigid_bodies to trigger that update.

This method updates self with the result of the forward-kinematics operation. For a non-mutable version running forward kinematics on a single link, see Self::forward_kinematics_single_link.

Parameters

• bodies: the set of rigid-bodies.
• read_root_pose_from_rigid_body: if set to true, the root joint (either a fixed joint, or a free joint) will have its pose set to its associated-rigid-body pose. Set this to true when the root rigid-body pose has been modified and needs to affect the multibody.

pub fn kinematic_branch(&self, link_id: usize) -> Vec<usize>

Computes the ids of all the links between the root and the link identified by link_id.

pub fn forward_kinematics_single_link( &self, bodies: &RigidBodySet, link_id: usize, displacement: Option<&[f32]>, out_jacobian: Option<&mut Jacobian<f32>>, ) -> Isometry<f32>

Apply forward-kinematics to compute the position of a single link of this multibody.

If out_jacobian is Some, this will simultaneously compute the new jacobian of this link. If displacement is Some, the generalized position considered during transform propagation is the sum of the current position of self and this displacement.

pub fn forward_kinematics_single_branch( &self, bodies: &RigidBodySet, branch: &[usize], displacement: Option<&[f32]>, out_jacobian: Option<&mut Jacobian<f32>>, ) -> Isometry<f32>

Apply forward-kinematics to compute the position of a single sorted branch of this multibody.

The given branch must have the following properties:

• It must be sorted, i.e., branch[i] < branch[i + 1].
• All the indices must be part of the same kinematic branch.
• If a link is branch[i], then branch[i - 1] must be its parent.

In general, this method shouldn’t be used directly and [Self::forward_kinematics_single_link̦] should be preferred since it computes the branch indices automatically.

If you want to calculate the branch indices manually, see Self::kinematic_branch.

If out_jacobian is Some, this will simultaneously compute the new jacobian of this branch. This represents the body jacobian for the last link in the branch.

If displacement is Some, the generalized position considered during transform propagation is the sum of the current position of self and this displacement.

pub fn ndofs(&self) -> usize

The total number of freedoms of this multibody.

impl Multibody

pub fn inverse_kinematics_delta( &self, link_id: usize, desired_movement: &SpacialVector<f32>, damping: f32, displacements: &mut DVector<f32>, )

Computes the displacement needed to have the link identified by link_id move by the desired transform.

The displacement calculated by this function is added to the displacement vector.

pub fn inverse_kinematics_delta_with_jacobian( jacobian: &Jacobian<f32>, desired_movement: &SpacialVector<f32>, damping: f32, displacements: &mut DVector<f32>, )

Computes the displacement needed to have a link with the given jacobian move by the desired transform.

The displacement calculated by this function is added to the displacement vector.

pub fn inverse_kinematics( &self, bodies: &RigidBodySet, link_id: usize, options: &InverseKinematicsOption, target_pose: &Isometry<f32>, joint_can_move: impl Fn(&MultibodyLink) -> bool, displacements: &mut DVector<f32>, )

Computes the displacement needed to have the link identified by link_id have a pose equal (or as close as possible) to target_pose.

If displacement is given non-zero, the current pose of the rigid-body is considered to be obtained from its current generalized coordinates summed with the displacement vector.

The displacements vector is overwritten with the new displacement.

The joint_can_move argument is a closure that lets you indicate which joint can be moved through the inverse-kinematics process. Any joint for which joint_can_move returns false will have its corresponding displacement constrained to 0. Set the closure to |_| true if all the joints are free to move.

Trait Implementations

impl Clone for Multibody

fn clone(&self) -> Multibody

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Multibody

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

Formats the value using the given formatter.

impl Default for Multibody

fn default() -> Self

Returns the “default value” for a type.