/opt/ros/diamondback/stacks/graspit_simulator/graspit/graspit_source/include/gloveInterface.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): Matei T. Ciocarlie
//
// $Id: gloveInterface.h,v 1.10 2009/04/21 14:53:07 cmatei Exp $
//
//######################################################################

#ifndef _GLOVEINTERFACE_H_
#define _GLOVEINTERFACE_H_

class vec3;
class position;
class CyberGlove;
class Robot;

#include <QString>
#include <list>
#include <vector>

#include "matvec3D.h"


class CalibrationPose {
private:
        int mSize;
        double *jointValues;
        int *sensorValues;

        int *sensorMap;
        transf mTransf;
        void init(int size);
public:
        CalibrationPose(int size);
        CalibrationPose(int size, double *joints, int *map);
        ~CalibrationPose();

        void setJointValue(int j, double jv);
        void setAllJointValues(double *jv);
        void setSensorValue(int i, int sv);
        void setAllSensorValues(int *sv);
        void setMap(int i, int mv);
        void setAllMaps(int *m);
        void setTransf(transf t){mTransf = t;}

        double getJointValue(int i){return jointValues[i];}
        double *getAllJointValues(){return jointValues;}
        int getSensorValue(int i){return sensorValues[i];}
        int *getAllSensorValues(){return sensorValues;}
        int getMap(int i){return sensorMap[i];}
        int *getAllMaps(){return sensorMap;}
        transf getTransf(){return mTransf;}

        bool isSet();
        int getSize(){return mSize;}
        bool jointsSet, sensorsSet, mapSet, poseSet;

        double recordedDistance;

        QString miscInfo;

        void writeToFile(FILE *fp);
        void readFromFile(FILE *fp);
};


class CData {
private:
        double *slopes,*intercepts;
        int nDOF, nSensors;
public:
        CData(int nd, int ns);
        ~CData();
        double getSlope(int d, int s);
        double getIntercept(int d);
        void setSlope(int d, int s, double val);
        void setIntercept(int d, double val);
        void addToSlope(int d, int s, double val);
        void addToIntercept(int d, double val);
        void reset();
};


class GloveInterface {
private:
        CyberGlove *rawGlove;
        Robot *mRobot;
        CData *mData;

        std::list<CalibrationPose*> cPoses;
        std::list<CalibrationPose*>::iterator currentPose;
        int cType;
        bool mCalibrated;

        double *savedDOFVals;

        bool computeMeanPose();
        bool performSimpleCalibration();
        bool performThumbCalibration();
        bool performComplexCalibration();
        bool complexCalibrationStep();

        float getDOFValue(int d, int *rawValues);
public:
        GloveInterface(Robot *robot);
        ~GloveInterface();
        Robot* getRobot(){return mRobot;}
        void setGlove(CyberGlove *glove);


        void startGlove();
        int instantRead();

        bool isDOFControlled(int d);
        float getDOFValue(int d);

        int getNumSensors();
        void setParameters(int s, int d, float sMin, float sMax, float dMin, float dMax);
        void setParameters(int s, int d, float slope, float intercept);

        /* All the other function here are used for calibration of various types*/              


        enum calibrationTypes{FIST, SIMPLE_THUMB, COMPLEX_THUMB, ABD_ADD, MEAN_POSE};

        void nextPose(int direction);
        void showCurrentPose();
        void recordPoseFromGlove(int d=0);

        bool poseSet();
        bool readyToCalibrate();
        bool calibrated(){return mCalibrated;}

        void saveCalibrationPoses(const char* filename);
        void loadCalibrationPoses(const char* filename);
        void clearPoses();
        int getNumPoses(){return cPoses.size();}

        bool loadCalibration(const char* filename);
        void saveCalibration(const char* filename);

        void initCalibration(int type);
        bool performCalibration();

        double getPoseError(vec3* error=NULL, position* thumbLocation=NULL);
        double getTotalError();
        void getPoseJacobian(double *J);
        void assembleJMatrix(double *D, int lda);
        void assemblePMatrix( double *P );

        void saveRobotPose();
        void revertRobotPose();
};
#endif

---

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