Struct Model 

pub struct Model {
    pub name: String,
    pub joint_names: Vec<String>,
    pub joint_parents: Vec<usize>,
    pub joint_placements: Vec<SE3>,
    pub joint_models: Vec<JointWrapper>,
    pub nq: usize,
    pub nv: usize,
    pub inertias: Vec<Inertia>,
    pub frames: Vec<Frame>,
    pub gravity: Vector3D,
}

Data structure that contains the immutable properties of the robot model. It contains information about the joints, frames, and their local placements.

Fields

name: String

Name of the model.

joint_names: Vec<String>

Names of the joints.

joint_parents: Vec<usize>

Parent joint of each joint.

joint_placements: Vec<SE3>

Placements of the joints relative to their parent joints.

joint_models: Vec<JointWrapper>

Joint models.

nq: usize

Number of position variables.

nv: usize

Number of velocity variables.

inertias: Vec<Inertia>

Inertias of the bodies at each joint.

frames: Vec<Frame>

Operational frames at each joint

gravity: Vector3D

The spatial gravity of the model.

Implementations

impl Model

pub fn new(name: String) -> Model

Creates a new Model with given name.

Same as Model::new_empty().

Arguments

• name - The name of the model.

pub fn new_empty() -> Model

Creates a new empty Model.

Returns

A new empty Model.

pub fn add_joint( &mut self, parent_id: usize, joint_model: JointWrapper, placement: SE3, name: String, ) -> Result<usize, ModelError>

Adds a joint to the model.

Arguments

• parent_id - The identifier of the parent joint. Use 0 for the root joint.
• joint_model - The joint model to add.
• placement - The placement of the joint in the parent frame.
• name - The name of the joint.

pub fn add_frame( &mut self, frame: Frame, append_inertia: bool, ) -> Result<usize, ModelError>

Adds a frame (fixed joint) to the model.

Arguments

• placement - The placement of the frame in the parent frame.
• name - The name of the frame.

Returns

The identifier of the frame.

pub fn create_data(&self) -> Data

Creates the data associated with the model.

Returns

The data associated with the model.

Examples found in repository

examples/inverse_dynamics.rs (line 17)

fn main() {
    let urdf_path = "./examples/descriptions/ur5/ur5_robot.urdf"; // Path to the URDF file
    let mesh_path = "./examples/descriptions/ur5/"; // Optional mesh path

    // Build models from the URDF file
    let (model, _coll_model, _viz_model) =
        build_models_from_urdf(urdf_path, Some(mesh_path)).expect("Failed to parse URDF file");

    // Generate a random configuration, velocity and acceleration
    let q = random_configuration(&model);
    let v = Configuration::from_element(model.nv, 1.0);
    let a = Configuration::from_element(model.nv, 1.0);

    // Create data structure for the model
    let mut data = model.create_data();

    // Compute inverse dynamics
    inverse_dynamics(&model, &mut data, &q, &v, &a, None)
        .expect("Failed to compute inverse dynamics");

    // Print the computed torques
    println!("Computed torques: {}", data.tau);
}

examples/forward_dynamics.rs (line 17)

fn main() {
    let urdf_path = "./examples/descriptions/ur5/ur5_robot.urdf"; // Path to the URDF file
    let mesh_path = "./examples/descriptions/ur5/"; // Optional mesh path

    // Build models from the URDF file
    let (model, _coll_model, _viz_model) =
        build_models_from_urdf(urdf_path, Some(mesh_path)).expect("Failed to parse URDF file");

    // Generate a random configuration, velocity and acceleration
    let q = random_configuration(&model);
    let v = Configuration::from_element(model.nv, 1.0);
    let tau = Configuration::from_element(model.nv, 1.0);

    // Create data structure for the model
    let mut data = model.create_data();

    // Compute forward dynamics
    let ddq = forward_dynamics(&model, &mut data, &q, &v, &tau, None, ABAConvention::Local)
        .expect("Failed to compute forward dynamics");

    // Print the computed torques
    println!("Joint accelerations: {}", ddq);
}

examples/forward_kinematics.rs (line 16)

fn main() {
    let urdf_path = "./examples/descriptions/ur5/ur5_robot.urdf"; // Path to the URDF file
    let mesh_path = "./examples/descriptions/ur5/"; // Optional mesh path

    // Build models from the URDF file
    let (model, _coll_model, _viz_model) =
        build_models_from_urdf(urdf_path, Some(mesh_path)).expect("Failed to parse URDF file");

    // Generate a random configuration
    let q = random_configuration(&model);
    println!("Random configuration q: {}", q);

    // Create data structure for the model
    let mut data = model.create_data();

    // Compute forward kinematics
    forward_kinematics(&model, &mut data, &q, None, None)
        .expect("Failed to compute forward kinematics");

    // Print the placement of the joint 'wrist_3_joint'
    let id = model.get_joint_id("wrist_3_joint").unwrap();
    let placement = &data.joint_placements[id];
    println!("Placement of 'wrist_3_joint':\n{}", placement);

    // Compute the frame placements
    update_frame_placements(&model, &mut data);

    // Print the placement of the frame 'tool0'
    let frame_id = model.get_frame_id("tool0", None).unwrap();
    // we don't specify a frame type (None) as there is only one frame with this name
    let frame_placement = &data.frame_placements[frame_id];
    println!("Placement of frame 'tool0':\n{}", frame_placement);
}

pub fn append_body_to_joint( &mut self, joint_id: usize, inertia: &Inertia, placement: SE3, ) -> Result<(), ModelError>

Appends a body of given inertia to the joint with given id.

Arguments

• joint_id - The identifier of the joint to append the body to.
• inertia - The inertia of the body to append.
• placement - The placement of the body in the joint frame.

Returns

A result indicating success or failure.

pub fn get_joint_id(&self, name: &str) -> Option<usize>

Returns the index of the joint with the given name.

Examples found in repository

examples/forward_kinematics.rs (line 23)

fn main() {
    let urdf_path = "./examples/descriptions/ur5/ur5_robot.urdf"; // Path to the URDF file
    let mesh_path = "./examples/descriptions/ur5/"; // Optional mesh path

    // Build models from the URDF file
    let (model, _coll_model, _viz_model) =
        build_models_from_urdf(urdf_path, Some(mesh_path)).expect("Failed to parse URDF file");

    // Generate a random configuration
    let q = random_configuration(&model);
    println!("Random configuration q: {}", q);

    // Create data structure for the model
    let mut data = model.create_data();

    // Compute forward kinematics
    forward_kinematics(&model, &mut data, &q, None, None)
        .expect("Failed to compute forward kinematics");

    // Print the placement of the joint 'wrist_3_joint'
    let id = model.get_joint_id("wrist_3_joint").unwrap();
    let placement = &data.joint_placements[id];
    println!("Placement of 'wrist_3_joint':\n{}", placement);

    // Compute the frame placements
    update_frame_placements(&model, &mut data);

    // Print the placement of the frame 'tool0'
    let frame_id = model.get_frame_id("tool0", None).unwrap();
    // we don't specify a frame type (None) as there is only one frame with this name
    let frame_placement = &data.frame_placements[frame_id];
    println!("Placement of frame 'tool0':\n{}", frame_placement);
}

pub fn get_frame_id( &self, name: &str, frame_type: Option<&FrameType>, ) -> Option<usize>

Returns the index of the frame with the given name.

Arguments

• name - The name of the frame.
• frame_type - The type of the frame.

Returns

The index of the frame with the given name and type, or None if not found.

Examples found in repository

examples/forward_kinematics.rs (line 31)

fn main() {
    let urdf_path = "./examples/descriptions/ur5/ur5_robot.urdf"; // Path to the URDF file
    let mesh_path = "./examples/descriptions/ur5/"; // Optional mesh path

    // Build models from the URDF file
    let (model, _coll_model, _viz_model) =
        build_models_from_urdf(urdf_path, Some(mesh_path)).expect("Failed to parse URDF file");

    // Generate a random configuration
    let q = random_configuration(&model);
    println!("Random configuration q: {}", q);

    // Create data structure for the model
    let mut data = model.create_data();

    // Compute forward kinematics
    forward_kinematics(&model, &mut data, &q, None, None)
        .expect("Failed to compute forward kinematics");

    // Print the placement of the joint 'wrist_3_joint'
    let id = model.get_joint_id("wrist_3_joint").unwrap();
    let placement = &data.joint_placements[id];
    println!("Placement of 'wrist_3_joint':\n{}", placement);

    // Compute the frame placements
    update_frame_placements(&model, &mut data);

    // Print the placement of the frame 'tool0'
    let frame_id = model.get_frame_id("tool0", None).unwrap();
    // we don't specify a frame type (None) as there is only one frame with this name
    let frame_placement = &data.frame_placements[frame_id];
    println!("Placement of frame 'tool0':\n{}", frame_placement);
}

pub fn njoints(&self) -> usize

Returns the number of joints in the model, including the world frame.

pub fn nframes(&self) -> usize

Returns the number of frames in the model, including the world frame.

pub fn print_joint_tree(&self) -> Result<(), Error>

Prints the joint tree of the model to the standard output.

Examples found in repository

examples/parse_urdf.rs (line 25)

fn main() {
    let urdf_path = "./examples/descriptions/ur5/ur5_robot.urdf"; // Path to the URDF file
    let mesh_path = "./examples/descriptions/ur5/"; // Optional mesh path

    // Build models from the URDF file
    let (model, _coll_model, _viz_model) =
        build_models_from_urdf(urdf_path, Some(mesh_path)).expect("Failed to parse URDF file");

    // Print the names of the joints
    println!("Joints in the model:");
    for joint_name in &model.joint_names {
        println!("- {}", joint_name);
    }

    // Print the names of the frames
    println!("\nFrames in the model:");
    for frame in &model.frames {
        println!("- {}", frame.name);
    }
    println!();

    // Print the joint tree
    model.print_joint_tree().unwrap();
}

Trait Implementations

impl Clone for Model

fn clone(&self) -> Model

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Model

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

Formats the value using the given formatter.