This class generates a finger of n links. The number of links and their properties are defined by a json configuration file. It also calculates the forwared kinematics of the finger given the rotation of its joints and its origin. More...

#include <finger.h>

Collaboration diagram for Finger:

[legend]

Public Member Functions
	Finger ()

void	initialize (const std::string &name_id, const nlohmann::json &json_file, igl::opengl::glfw::Viewer *viewer, int mesh_idx)
	Initialize finger. More...

void	update (const std::vector< dm::JointState > &state)
	Update state. More...

std::vector< Eigen::MatrixXd >	get_vertices (void)
	Get finger vertices. More...

std::vector< int >	get_frame_ids (void)
	Get the ids of the finger frames. More...

void	load_mesh_files (igl::opengl::glfw::Viewer *viewer)
	Load finger mesh files. More...

std::vector< dm::JointState >	get_state (void)
	Get current state of the finger. More...

Private Member Functions
void	parse_json_file (const nlohmann::json &json_file)
	Parses the finger configuration json file. More...

void	initialize_mesh_containers (void)
	Initialize mesh files. More...

void	get_mesh_data (igl::opengl::glfw::Viewer *viewer)
	Get mesh data. More...

void	postprocess_meshes (void)
	Postproccess meshes. More...

void	initialize_state (const std::vector< double > &link_lengths, const dm::JointState &origin)
	Initialize state. More...

Private Attributes
std::string	m_name_id
	Finger name id. More...

dm::JointState	m_origin
	Finger origin. More...

std::vector< double >	m_link_lengths
	The lengths of the finger links. More...

std::vector< int >	m_frame_ids
	The frame ids of the finger. More...

std::string	m_joint_rel_filename = "share/joint.obj"
	Joint mesh file. More...

std::string	m_bone_rel_filename = "share/bone.obj"
	Bone (link) mesh file. More...

std::vector< std::string >	m_meshes_filenames
	Mesh files for joints and bones(links). More...

double	m_joint_scale = 0.05
	Joint scales. More...

std::vector< double >	m_geom_scales
	Finger scales. More...

int	m_viewer_data_lower_idx
	Viewer data lower idx see (Hand::m_viewer_data_lower_idx). More...

int	m_viewer_data_upper_idx
	Viewer data upper idx (see Hand::m_viewer_data_lower_idx). More...

std::vector< Eigen::MatrixXd >	m_vertices_data_o
	Vertices data (original). More...

std::vector< Eigen::MatrixXd >	m_vertices_data_oh
	Vertices data (original homogeneous). More...

std::vector< Eigen::MatrixXd >	m_vertices_data
	Vertices data. More...

std::vector< Eigen::MatrixXi >	m_faces_data
	Faces data. More...

std::vector< dm::JointState >	m_state_vec
	Finger state. More...

int	m_state_size
	State size. More...

std::vector< Eigen::Matrix4d >	m_local_transform
	Local transforamation matrix. More...

std::vector< Eigen::Matrix4d >	m_global_transform
	Global transforamation matrix. More...

Detailed Description

This class generates a finger of n links. The number of links and their properties are defined by a json configuration file. It also calculates the forwared kinematics of the finger given the rotation of its joints and its origin.

Definition at line 20 of file finger.h.

Constructor & Destructor Documentation

◆ Finger()

Finger::Finger ( )

inline

Definition at line 23 of file finger.h.

23{};

Member Function Documentation

◆ get_frame_ids()

std::vector< int > Finger::get_frame_ids ( void )

inline

Get the ids of the finger frames.

Definition at line 36 of file finger.h.

36{ return m_frame_ids; };

Finger::m_frame_ids

std::vector< int > m_frame_ids

The frame ids of the finger.

Definition: finger.h:56

◆ get_mesh_data()

void Finger::get_mesh_data ( igl::opengl::glfw::Viewer * viewer )

private

Get mesh data.

It passes a copy of the vertex data from the viewer to the local member variables of the finger instance.

Parameters

viewer Pointer to the viewer object.

Definition at line 197 of file finger.cpp.

{
    for (size_t i = m_viewer_data_lower_idx; i <= m_viewer_data_upper_idx; i++)
    {
        // Push back vertices data
        m_vertices_data_o.push_back(viewer->data_list.at(i).V);
 
        // Push back faces data
        m_faces_data.push_back(viewer->data_list.at(i).F);
    }
}

Here is the caller graph for this function:

◆ get_state()

std::vector< dm::JointState > Finger::get_state ( void )

inline

Get current state of the finger.

Definition at line 42 of file finger.h.

42{ return m_state_vec; }

Finger::m_state_vec

std::vector< dm::JointState > m_state_vec

Finger state.

Definition: finger.h:114

◆ get_vertices()

std::vector< Eigen::MatrixXd > Finger::get_vertices ( void )

inline

Get finger vertices.

Definition at line 33 of file finger.h.

33{ return m_vertices_data; }

Finger::m_vertices_data

std::vector< Eigen::MatrixXd > m_vertices_data

Vertices data.

Definition: finger.h:99

◆ initialize()

void Finger::initialize	(	const std::string &	name_id,
		const nlohmann::json &	json_file,
		igl::opengl::glfw::Viewer *	viewer,
		int	mesh_idx
	)

Initialize finger.

This initialization function first parses the finger configuration file (see Hand::m_config_rel_path) and sets up the properties of the finger. It also loads and processes the meshes for the links and the joints and initializes the finger state.

Parameters

name_id	The name id of the finger.
json_file	The json finger configuration file.
viewer	Pointer to the viewer handle.
mesh_idx	The mesh index.

Definition at line 13 of file finger.cpp.

{
    // Get finger id
    m_name_id = name_id;
 
    // Parse the json file
    parse_json_file(json_file);
 
    // Initialize mesh files
    initialize_mesh_containers();
 
    // Load mesh files
    load_mesh_files(viewer);
 
    // Set viewer data indices
    m_viewer_data_lower_idx = mesh_idx;
    m_viewer_data_upper_idx = m_viewer_data_lower_idx +
        (m_meshes_filenames.size() - 1);
    
    // Get mesh data
    get_mesh_data(viewer);
    
    // Postprocess meshes
    postprocess_meshes();
    
    // Initialize state
    initialize_state(m_link_lengths, m_origin);
 
    // Initialize meshes
    update(m_state_vec);
}

Here is the call graph for this function:

◆ initialize_mesh_containers()

void Finger::initialize_mesh_containers ( void )

private

Initialize mesh files.

It initializes the mesh containers for its link and joint based on their properties defined in the configuration file Hand::m_config_rel_path.

Definition at line 160 of file finger.cpp.

{
    // Get mesh files absolute filenames
    auto joint_mesh_abs = std::filesystem::current_path() / m_joint_rel_filename;
    auto bone_mesh_abs = std::filesystem::current_path() / m_bone_rel_filename;
 
   // Generate meshses filenames
    for (size_t i = 0; i < m_link_lengths.size(); i++)
    {
       // Meshes filenames configuration
       m_meshes_filenames.push_back(joint_mesh_abs.string());
       m_meshes_filenames.push_back(bone_mesh_abs.string());
 
       // Geometry scales configurations
       m_geom_scales.push_back(m_joint_scale);
       m_geom_scales.push_back(m_link_lengths.at(i));
    }
}

Here is the caller graph for this function:

◆ initialize_state()

void Finger::initialize_state	(	const std::vector< double > &	link_lengths,
		const dm::JointState &	origin
	)

private

Initialize state.

It initializes the state of the finger based on the link_lengths and their origins as defined from the configuration file (Hand::m_config_rel_path)

Parameters

link_lengths	The lengths of the links.
origin	The origins of the links.

Definition at line 130 of file finger.cpp.

{
    // State size 
    m_state_size = link_lengths.size();
 
    // Initialize state vector
    m_state_vec.resize(m_state_size);
 
    // Set origin
    m_state_vec.at(0) = origin;
 
    // Generate initial state vector states  
    int idx = 0;
 
    for (size_t i = 1; i < m_state_size; i++)
    {
        // Set link lengths
        m_state_vec.at(i).position(0) = link_lengths.at(idx);
 
        // Update idx
        idx++;
    }
}

Here is the caller graph for this function:

◆ load_mesh_files()

void Finger::load_mesh_files ( igl::opengl::glfw::Viewer * viewer )

Load finger mesh files.

Simply loads the meshes to the viewer.

Parameters

viewer Pointer to the viewer object.

Definition at line 184 of file finger.cpp.

{
    for (size_t i = 0; i < m_meshes_filenames.size(); i++)
    {
        viewer->load_mesh_from_file(m_meshes_filenames.at(i));
    }
}

Here is the caller graph for this function:

◆ parse_json_file()

void Finger::parse_json_file ( const nlohmann::json & json_file )

private

Parses the finger configuration json file.

Simply parses the finger configuration file.

Parameters

json_file The json file namek

Definition at line 248 of file finger.cpp.

{
    // Get lengths
    auto lengths_json = json_file[m_name_id]["Lengths"];
 
    // Get frame ids
    auto frames_json = json_file[m_name_id]["Frames"];
 
    // Get origin position
    auto origin_position_json = json_file[m_name_id]["Origin"]["Position"];
    
    // Get origin orientation
    auto origin_euler_json = json_file[m_name_id]["Origin"]["Euler"];
    
    for(size_t i = 0; i < lengths_json.size(); i++)
    {
        // Push back link lengths
        m_link_lengths.push_back(lengths_json.at(i));
 
        // Set origin position
        m_origin.position(0) = origin_position_json.at(0);
        m_origin.position(1) = origin_position_json.at(1);
        m_origin.position(2) = origin_position_json.at(2);
 
        // Set origin orientation
        m_origin.euler(0) = origin_euler_json.at(0);
        m_origin.euler(1) = origin_euler_json.at(1);
        m_origin.euler(2) = origin_euler_json.at(2);
    }
 
    for(size_t i = 0; i < frames_json.size(); i++)
    {
        m_frame_ids.push_back(frames_json.at(i));
    }
}

Here is the caller graph for this function:

◆ postprocess_meshes()

void Finger::postprocess_meshes ( void )

private

Postproccess meshes.

It sets the scale of the meshes based on the links length and the joints desired size.

Definition at line 213 of file finger.cpp.

{
    // Scale meshes
    for (size_t i = 0; i < m_vertices_data_o.size(); i++)
    {
        /************** Scale data *******************/
        Eigen::Matrix3d scale_matrix;
        scale_matrix << m_geom_scales.at(i), 0.0, 0.0,
            0.0, m_geom_scales.at(i), 0.0, 0.0, 0.0, m_geom_scales.at(i);
 
        m_vertices_data_o.at(i) = (scale_matrix *
            m_vertices_data_o.at(i).transpose()).transpose();
 
        /************** Generate homogeneous vertices data *******************/
        // Get mesh i
        Eigen::MatrixXd mesh_i = m_vertices_data_o.at(i);
 
        // Initialize homogeneous coordinates
        Eigen::MatrixXd mesh_i_oh = Eigen::MatrixXd::Ones(mesh_i.rows(),
            mesh_i.cols() + 1);
 
        // Generate matrix of homogeneous coordinates
        mesh_i_oh.col(0) = mesh_i.col(0);
        mesh_i_oh.col(1) = mesh_i.col(1);
        mesh_i_oh.col(2) = mesh_i.col(2);
 
        m_vertices_data_oh.push_back(mesh_i_oh);
    }
}

Here is the caller graph for this function:

◆ update()

void Finger::update ( const std::vector< dm::JointState > & state )

Update state.

This function updates the finger's state (position and orientation of its links and joints). It performs the forward kinematics for each link of the finger. It first calculates the local transform of each links with respect to each previous link. Then it calculates the global transforms (with respect to the hand's base frame $f_{{W}_{0}}$ ) by performing and iterative compound transormation (post-miltiply rules, see Forward Kinematics Spong * Robot Modeling and Control). The frame conventions and the definitions of the rotation and translation matrices used are given in the handover document.

Parameters

state The vector of joint euler angles and postions as defined in dm::JointStateu.

Definition at line 60 of file finger.cpp.

{
    // Update state vector
    m_state_vec =  state;
 
    // Resize states
    m_local_transform.resize(m_state_size);
    m_global_transform.resize(m_state_size);
 
    /* Loop through state vector components and
    generate transformation matrices */
    for (size_t i = 0; i < m_state_vec.size(); i++)
    {
        /*********** Local transformation ***********/
        // Initialize transformation matrices
        Eigen::Matrix4d local_transform = Eigen::Matrix4d::Identity();
 
        // Position vector
        local_transform.block<3, 1>(0, 3) = m_state_vec.at(i).position;
 
        // Rotation matrix
        local_transform.block<3, 3>(0, 0) =
            EulerRotations::rotation(m_state_vec.at(i).euler);
 
        // Push back locak transform
        m_local_transform.at(i) = local_transform;
 
        /*********** Global transformation ***********/
        if (i == 0) {
            // Global transform
            m_global_transform.at(i) = m_local_transform.at(i);
        }
        else {
            // Global transform
            m_global_transform.at(i) = m_global_transform.at(i-1) * 
                    m_local_transform.at(i);
        }
    }
 
    // Resize vertices data
    m_vertices_data.resize(2 * m_state_size);
 
    // Loop through global transformation matrices
    for (size_t i = 0; i < m_global_transform.size(); i++)
    {
        // Get global transformation matrix
        Eigen::Matrix4d t_mat = m_global_transform.at(i);
 
        /****************** Transform vertices ********************/
        // Joint vertices
        Eigen::MatrixXd joint_vert =
            (t_mat * m_vertices_data_oh.at(2*i).transpose()).transpose();
 
        // Link vertices
        Eigen::MatrixXd link_vert =
            (t_mat * m_vertices_data_oh.at(2*i+1).transpose()).transpose();
 
        // Push back vertices
        m_vertices_data.at(2*i) = joint_vert.leftCols<3>();
        m_vertices_data.at(2*i+1) = link_vert.leftCols<3>();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_bone_rel_filename

std::string Finger::m_bone_rel_filename = "share/bone.obj"

private

Bone (link) mesh file.

Definition at line 67 of file finger.h.

◆ m_faces_data

std::vector<Eigen::MatrixXi> Finger::m_faces_data

private

Faces data.

Definition at line 102 of file finger.h.

◆ m_frame_ids

std::vector<int> Finger::m_frame_ids

private

The frame ids of the finger.

Definition at line 56 of file finger.h.

◆ m_geom_scales

std::vector<double> Finger::m_geom_scales

private

Finger scales.

Definition at line 79 of file finger.h.

◆ m_global_transform

std::vector<Eigen::Matrix4d> Finger::m_global_transform

private

Global transforamation matrix.

Definition at line 123 of file finger.h.

◆ m_joint_rel_filename

std::string Finger::m_joint_rel_filename = "share/joint.obj"

private

Joint mesh file.

Definition at line 64 of file finger.h.

◆ m_joint_scale

double Finger::m_joint_scale = 0.05

private

Joint scales.

Definition at line 76 of file finger.h.

◆ m_link_lengths

std::vector<double> Finger::m_link_lengths

private

The lengths of the finger links.

Definition at line 53 of file finger.h.

◆ m_local_transform

std::vector<Eigen::Matrix4d> Finger::m_local_transform

private

Local transforamation matrix.

Definition at line 120 of file finger.h.

◆ m_meshes_filenames

std::vector<std::string> Finger::m_meshes_filenames

private

Mesh files for joints and bones(links).

Definition at line 70 of file finger.h.

◆ m_name_id

std::string Finger::m_name_id

private

Finger name id.

Definition at line 47 of file finger.h.

◆ m_origin

dm::JointState Finger::m_origin

private

Finger origin.

Definition at line 50 of file finger.h.

◆ m_state_size

int Finger::m_state_size

private

State size.

Definition at line 117 of file finger.h.

◆ m_state_vec

std::vector<dm::JointState> Finger::m_state_vec

private

Finger state.

Definition at line 114 of file finger.h.

◆ m_vertices_data

std::vector<Eigen::MatrixXd> Finger::m_vertices_data

private

Vertices data.

Definition at line 99 of file finger.h.

◆ m_vertices_data_o

std::vector<Eigen::MatrixXd> Finger::m_vertices_data_o

private

Vertices data (original).

Definition at line 93 of file finger.h.

◆ m_vertices_data_oh

std::vector<Eigen::MatrixXd> Finger::m_vertices_data_oh

private

Vertices data (original homogeneous).

Definition at line 96 of file finger.h.

◆ m_viewer_data_lower_idx

int Finger::m_viewer_data_lower_idx

private

Viewer data lower idx see (Hand::m_viewer_data_lower_idx).

Definition at line 82 of file finger.h.

◆ m_viewer_data_upper_idx

int Finger::m_viewer_data_upper_idx

private

Viewer data upper idx (see Hand::m_viewer_data_lower_idx).

Definition at line 85 of file finger.h.

The documentation for this class was generated from the following files:

include/finger.h
src/finger.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Finger()

Member Function Documentation

◆ get_frame_ids()

◆ get_mesh_data()

◆ get_state()

◆ get_vertices()

◆ initialize()

◆ initialize_mesh_containers()

◆ initialize_state()

◆ load_mesh_files()

◆ parse_json_file()

◆ postprocess_meshes()

◆ update()

Member Data Documentation

◆ m_bone_rel_filename

◆ m_faces_data

◆ m_frame_ids

◆ m_geom_scales

◆ m_global_transform

◆ m_joint_rel_filename

◆ m_joint_scale

◆ m_link_lengths

◆ m_local_transform

◆ m_meshes_filenames

◆ m_name_id

◆ m_origin

◆ m_state_size

◆ m_state_vec

◆ m_vertices_data

◆ m_vertices_data_o

◆ m_vertices_data_oh

◆ m_viewer_data_lower_idx

◆ m_viewer_data_upper_idx