grasp-synergy repository

Repository Summary

Checkout URI https://github.com/felixduvallet/grasp-synergy.git
VCS Type git
VCS Version master
Last Updated 2019-12-08
Dev Status DEVELOPED
CI status No Continuous Integration
Released RELEASED
Tags No category tags.
Contributing Help Wanted (0)
Good First Issues (0)
Pull Requests to Review (0)

Packages

Name Version
grasp_synergy 0.0.2

README

Grasp Synergy ROS package

Build Status

This package implements grasp synergies (aka eigengrasps): low-dimensional representation of hand configurations.

Very basically, grasp synergies are computed by doing PCA on a bunch of hand configurations (joint angles) to infer a low-dimensional representation.

Points in this low-dimensional space can then be reprojected to the full configuration space to control the hand.

This ROS package is independent of any hand configuration. It consists of two components: - the GraspSynergy class: compute & store synergies from high-dimensional grasp configurations, and compute grasps from low-dimensional input. - the synergy_node: ROS magic to provide nice interfaces for controlling grasp synergies.

grasp_synergy

Grasp Synergies (aka eigengrasps) are just low-dimensional representations of the grasp learned using PCA.

The GraspSynergy class is just a convenience class for computing, storing, and commanding grasp synergies. It is hand-agnostic.

Grasping data can be of any form: - A numpy matrix of joint values (N by D) - A list of sensor_msgs/JointState messages - A filepath to a rosbag file.

Here N are the number of collected grasps and D is the full dimensionality of the hand. We extract all D principal components (synergies), but in practice we will only use a smaller number.

To compute a grasp (in the original space), simply pass in a B-dimensional vector of coefficients to compute_grasp. (Nominally, B < D.) The method will automatically figure out how many components to use, and return the corresponding grasp configuration in the original D-dimensional space.

synergy_node

The synergy node enables you to load a grasp synergy space, create subscribers for the synergy space, and publish desired joint state messages to control the hand. It creates one top-level subscriber for fully-specified coefficient vector and many per-component subscribers for each component (each for a single value).

Each time the node receives a new low-dimensional (synergy-space) point, it computes the hand configuration and publishes a message with the desired joint states.

Subscribers: The node can create a variable number of subscribers: one for the fully-specified coefficient vector, and one per component (with singleton values). By default, the node is trained using a bag file of hand configuration data.

So for example, you might have the following subscribers for 5 synergies:

 * /grasp_synergy [std_msgs/Float32MultiArray]
 * /grasp_synergy/syn_0 [std_msgs/Float32]
 * /grasp_synergy/syn_1 [std_msgs/Float32]
 * /grasp_synergy/syn_2 [std_msgs/Float32]
 * /grasp_synergy/syn_3 [std_msgs/Float32]

This enables you to use tools like rqt_ez_publisher (http://wiki.ros.org/rqt_ez_publisher) to provide a nice slider GUI interface to the synergy space:

rqt_grasp

NOTE: Due to a small bug in rqt_ez_publisher, if you want to use the sliders to control the individual synergies (/grasp_synergy/syn_N) you need to use the latest rqt_ez_publisher (checkout directly from github into your workspace and run the local copy).

Publisher: The desired joint state topic must be given.

CONTRIBUTING

No CONTRIBUTING.md found.