Uses a simple Simulated Annealing loop to plans grasps for the hand and object, and stores them in the database. More...

#include <grasp_planning_task.h>

Inheritance diagram for dbase_grasp_planner::GraspPlanningTask:

[legend]

List of all members.

Public Slots
void	plannerComplete ()
	Connected to the complete() signal of the planner.
void	plannerLoopUpdate ()
	Connected to the loopUpdate() signal of the planner.
Public Member Functions
	GraspPlanningTask (graspit_dbase_tasks::DBTaskDispatcher disp, db_planner::DatabaseManager mgr, db_planner::TaskRecord rec)
	Just a stub for now.
virtual void	start ()
	Loads the hand and the object, initializes and starts a loop planner.
virtual	~GraspPlanningTask ()
	Removes the object that has been used from the sim world, but not the hand.
Protected Member Functions
bool	computePreGrasp (const GraspPlanningState final_gps, GraspPlanningState *pre_gps)
	Computes a pre-grasp for the given grasp.
bool	saveGrasp (const GraspPlanningState pre_gps, const GraspPlanningState final_gps)
	Saves a solution grasp to the database.
virtual bool	setPreGrasp (const GraspPlanningState *graspState)
	Sets the hand in the pre-grasp pose given the grasp.
Protected Attributes
Hand *	mHand
	The hand we are planning with.
int	mLastSolution
	The index of the last solution that was already saved in the database.
GraspableBody *	mObject
	The object we are planning on.
EGPlanner *	mPlanner
	The planner that we are using.
db_planner::PlanningTaskRecord	mPlanningTask
	The record of the actual planning task.

Detailed Description

Uses a simple Simulated Annealing loop to plans grasps for the hand and object, and stores them in the database.

This task perform grasp planning for simpe robot hands. It uses the Simulated Annealing planner - see the Eigengrasp Planning chapter in the GraspIt! User's Manual for more details. This planner is well suited for relatively simple hands such as parallel grippers where all that is needed is to bring the fingerpads in contact with the object.

It is well suited for planning with the PR2 Gripper.

For more complex hands, see the GuidedGraspPlanner inside this same package.

For now, it does its own cleanup in the sense that it will remove from the world and delete the object that was used for planning. However, it will leave the hand in, as it might be used by subsequent tasks.

On startup, it will load the hand it needs, unless that hand is already the currently selected hand in the world. It will also load the object it needs. It will not delete anything from the world ar startup.

The init and cleanup so that the world is used by subsequent tasks is not well-defined yet, needs more work. Exactly what initialization and cleanup in the GraspIt world such a planner should do is unclear, might change in the future.

Definition at line 74 of file grasp_planning_task.h.

Constructor & Destructor Documentation

dbase_grasp_planner::GraspPlanningTask::GraspPlanningTask	(	graspit_dbase_tasks::DBTaskDispatcher *	disp,
		db_planner::DatabaseManager *	mgr,
		db_planner::TaskRecord	rec
	)