/opt/ros/diamondback/stacks/graspit_simulator/graspit/graspit_source/include/grasp.h

Go to the documentation of this file.

//######################################################################
//
// GraspIt!
// Copyright (C) 2002-2009  Columbia University in the City of New York.
// All rights reserved.
//
// GraspIt! is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GraspIt! is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GraspIt!.  If not, see <http://www.gnu.org/licenses/>.
//
// Author(s): Andrew T. Miller and Matei T. Ciocarlie
//
// $Id: grasp.h,v 1.26 2009/07/21 19:30:27 cmatei Exp $
//
//######################################################################

#ifndef GRASP_HXX

#include <list>
#include <vector>
#include <set>
#include <QObject>

//Inventor includes
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/Qt/viewers/SoQtExaminerViewer.h>
class SoTransform;
class SoCoordinate3;
class SoIndexedFaceSet;

class vec3;
class transf;
class position;
class Hand;
class GraspableBody;
class Contact;
class VirtualContact;
class Link;
class GWS;
class QualityMeasure;
class QMDlg;
class GWSprojection;
class Matrix;
class Joint;

#define MAX_FEAS_LOOPS  100 

#define MAX_OPTM_LOOPS  100 

extern bool saveSetup;
extern int saveCounter;

//  It also has methods to optimize grasping forces.
class Grasp : public QObject{
  Q_OBJECT

public:
  static const std::vector<int> ALL_DIMENSIONS;

protected:
  friend class LMIOptimizer;

  Hand *hand;

  GraspableBody *object;

  bool valid;

  std::list<GWS *> gwsList;

  std::list<QualityMeasure *> qmList;

  std::list<GWSprojection *> projectionList;

  int numQM;

  std::vector<Contact *> contactVec;

  int numContacts;

  double minWrench[6];  

  bool useGravity;

  double *getLinkJacobian(int f, int l);

  void setVirtualCentroid();

  vec3 virtualCentroid();

  void setRealCentroid(GraspableBody *body);

  friend class QMDlg;

signals:
  void graspUpdated();

public:
  Grasp(Hand *h);

  ~Grasp();

  bool                    isValid() const {return valid;}

  //bool                    isFeasible() const {return feasible;}

  int                     getNumQM() const {return numQM;}

  GraspableBody *         getObject() const {return object;}

  int                     getNumContacts() const {return numContacts;}

  Contact *               getContact(int i) const {return contactVec[i];}

  void                    getMinWrench(double *w) const
  {
    if (w) memcpy(w,minWrench,6*sizeof(double));
  }

  void                    setMinWrench(double *w)
  {
    if (w) memcpy(minWrench,w,6*sizeof(double));
  }

  void                    setObject(GraspableBody *g) {object = g; update();}

  /* this is a hack; I had to do it due to some bug I was never able to trace down*/
  void                    setObjectNoUpdate(GraspableBody *g) {object = g;}

  void collectContacts();
  void collectVirtualContacts();
  void collectVirtualContactsOnObject();

  void update(std::vector<int> useDimensions = ALL_DIMENSIONS);
  void updateWrenchSpaces(std::vector<int> useDimensions = ALL_DIMENSIONS);

  double getMaxRadius();
  position getCoG();

  GWS *addGWS(const char *type);
  GWS *getGWS(const char *type);
  void removeGWS(GWS *gws);
  void addQM(QualityMeasure *qm);
  void replaceQM(int which,QualityMeasure *qm);
  QualityMeasure *getQM(int which);
  void removeQM(int which);
  
  void addProjection(GWSprojection *gp);
  void removeProjection(GWSprojection *gp);
  static void destroyProjection(void * user, SoQtComponent * component);

  void setGravity(bool g){useGravity = g;}
  bool isGravitySet(){return useGravity;}

  //------------------- Grasp Force Optimization (GFO) routines --------------------------

  static const int CONTACT_FORCE_EXISTENCE;
  static const int CONTACT_FORCE_OPTIMIZATION;
  static const int GRASP_FORCE_EXISTENCE;
  static const int GRASP_FORCE_OPTIMIZATION;

  int computeQuasistaticForcesAndTorques(Matrix *robotTau, int computation);

  int computeQuasistaticForces(const Matrix &robotTau);

  std::list<Joint*> getJointsOnContactChains();

  Matrix contactJacobian(const std::list<Joint*> &joints, 
                         const std::list< std::pair<transf, Link*> > &contact_locations);

  Matrix contactJacobian(const std::list<Joint*> &joints, 
                         const std::list<Contact*> &contacts);

  Matrix contactJacobian(const std::list<Joint*> &joints, 
                         const std::list<VirtualContact*> &contacts);

  static Matrix graspMapMatrix(const Matrix &R, const Matrix &D);

  void displayContactWrenches(std::list<Contact*> *contacts, const Matrix &contactWrenches);
  void accumulateAndDisplayObjectWrenches(std::list<Contact*> *contacts, 
                                                                                  const Matrix &objectWrenches);
};

#define GRASP_HXX
#endif

---

graspit
Author(s):
autogenerated on Wed Jan 25 10:58:51 2012