Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

# Modules/WalkingEngine/GT2004ParameterSet.h

Go to the documentation of this file.

    00001 /**
    00002 * @file GT2004ParameterSet.h
    00003 *
    00004 * Definition of class GT2004Parameters and GT2004ParametersSet
    00005 *
    00006 * @author Uwe Düffert
    00007 */
    00008
    00009 #ifndef __GT2004Parameters_h_
    00010 #define __GT2004Parameters_h_
    00011
    00012 #include "InvKinWalkingParameters.h"
    00013 #include "Tools/Actorics/Kinematics.h"
    00014 #include "Tools/Evolution/Individual.h"
    00015 #include "Tools/Math/Pose2D.h"
    00016 #include <string.h>
    00017
    00018 class InvKinWalkingParameters;
    00019
    00020 /**
    00021 * @class GT2004Parameters
    00022 *
    00023 * Parameters for GT2004WalkingEngine
    00024 *
    00025 * @author Uwe Düffert
    00026 */
    00027 class GT2004Parameters: public Individual
    00028 {
    00029 public:
    00030   int index;           ///< good parameters now, which index they have in a parametersSet
    00031   Pose2D requestedMotion; ///< these parameters are optimized for this requestedMotion
    00032   Pose2D correctedMotion; ///< these parameters use correctedMotion to get something like requestedMotion as result
    00033
    00034   double foreHeight;   ///< fore walking height
    00035   double foreWidth;    ///< fore walking width distance robot center to foot
    00036   double foreCenterX;  ///< fore x-axis foot center position
    00037
    00038   double hindHeight;   ///< hind walking height
    00039   double hindWidth;    ///< hind walking width distance robot center to foot
    00040   double hindCenterX;  ///< hind x-axis foot center position
    00041
    00042   double foreFootLift; ///< height of lifted fore foots
    00043   double hindFootLift; ///< height of lifted hind foots
    00044
    00045   double foreFootTilt; ///< tangens of tilt angle for fore foot movement
    00046   double hindFootTilt; ///< tangens of tilt angle for hind foot movement
    00047
    00048   int stepLen;         ///< number of ticks for one complete step
    00049
    00050   enum FootMode {
    00051     rectangle = 0,
    00052       halfCircle,
    00053       circle,
    00054       rounded,
    00055       optimized,
    00056       freeFormQuad,
    00057       numOfFootModes
    00058   };
    00059
    00060   FootMode footMode; ///< how to move the feet
    00061   double groundPhase[2];   ///<part of leg phase with foot on ground, front/hind legs
    00062   double legPhase[4]; ///< relative leg phases, time indexes for lifting each leg
    00063
    00064 double liftPhase[2];     ///<part of leg phase lifting foot, front/hind legs
    00065 double loweringPhase[2]; ///<part of leg phase lowering foot, front/hind legs
    00066 double bodyShiftX;       ///<value for shifting body away from lifted legs in x direction (mm when leg fully lifted)
    00067 double bodyShiftY;       ///<value for shifting body away from lifted legs in y direction (mm when leg fully lifted)
    00068 double bodyShiftOffset;  ///<value by which the shift body motion is delayed (relative part of leg phase)
    00069
    00070
    00071   //do we need double freeFormQuadPos[2][4][3];
    00072   //do we need canterZ-front/hind or is changing groundphase enough?
    00073
    00074   /**
    00075   * joint angles for joints not used for walking
    00076   * these must be jointDataInvalidValue to enable head motion
    00077   * use these for special walks that use the head eg for grabbing the ball
    00078   */
    00079   long headTilt, headPan, headRoll, mouth;
    00080
    00081   /** Constructor */
    00082   GT2004Parameters(int index=-1,
    00083     Pose2D requestedMotion=Pose2D(0,0,0),
    00084     double foreHeight = 0,
    00085     double foreWidth = 0,
    00086     double foreCenterX = 0,
    00087     double hindHeight = 0,
    00088     double hindWidth= 0,
    00089     double hindCenterX = 0,
    00090     double foreFootLift = 0,
    00091     double hindFootLift = 0,
    00092     double foreFootTilt = 0,
    00093     double hindFootTilt = 0,
    00094     int stepLen = 80,
    00095     int footMode = (int)rectangle,
    00096     double groundPhaseF = 0.5,
    00097 double liftPhaseF = 0, //temp for BB support
    00098 double loweringPhaseF = 0, //temp for BB support
    00099     double groundPhaseH = 0.5,
    00100 double liftPhaseH = 0, //temp for BB support
    00101 double loweringPhaseH = 0, //temp for BB support
    00102     double legPhase0 = 0,
    00103     double legPhase1 = 0.5,
    00104     double legPhase2 = 0.5,
    00105     double legPhase3 = 0,
    00106 //double bodyShiftX = 0, //temp for BB support
    00107 //double bodyShiftY = 0, //temp for BB support
    00108 //double bodyShiftOffset = 0, //temp for BB support
    00109     long headTilt = jointDataInvalidValue,
    00110     long headPan = jointDataInvalidValue,
    00111     long headRoll = jointDataInvalidValue,
    00112     long mouth = jointDataInvalidValue) :
    00113   index(index),
    00114     requestedMotion(requestedMotion),
    00115     correctedMotion(requestedMotion),
    00116     foreHeight(foreHeight),
    00117     foreWidth(foreWidth),
    00118     foreCenterX(foreCenterX),
    00119     hindHeight(hindHeight),
    00120     hindWidth(hindWidth),
    00121     hindCenterX(hindCenterX),
    00122     foreFootLift(foreFootLift),
    00123     hindFootLift(hindFootLift),
    00124     foreFootTilt(foreFootTilt),
    00125     hindFootTilt(hindFootTilt),
    00126     stepLen(stepLen),
    00127 //bodyShiftX(bodyShiftX), //temp for BB support
    00128 //bodyShiftY(bodyShiftY), //temp for BB support
    00129 //bodyShiftOffset(bodyShiftOffset), //temp for BB support
    00130     footMode((FootMode)footMode),
    00131     headTilt(headTilt),
    00132     headPan(headPan),
    00133     headRoll(headRoll),
    00134     mouth(mouth)
    00135   {
    00136     legPhase[0]=legPhase0;
    00137     legPhase[1]=legPhase1;
    00138     legPhase[2]=legPhase2;
    00139     legPhase[3]=legPhase3;
    00140     groundPhase[0]=groundPhaseF;
    00141 liftPhase[0]=liftPhaseF; //temp for BB support
    00142 loweringPhase[0]=loweringPhaseF; //temp for BB support
    00143     groundPhase[1]=groundPhaseH;
    00144 liftPhase[1]=liftPhaseH; //temp for BB support
    00145 loweringPhase[1]=loweringPhaseH; //temp for BB support
    00146   }
    00147
    00148   /** Constructor */
    00149   GT2004Parameters(const InvKinWalkingParameters& invKinParam);
    00150
    00151   /** report a measured (and may be averaged) speed of that walk parameters with this function.
    00152   * It will modify correctedMotion accordingly if this seems to be usefull.
    00153   * @param real measured motion speed in real life
    00154   * @return true if correctedMotion was successfully changed, otherwise its unlikely that requestedMotion is reachable with this params - you might want to evolve params or reduce requestedMotion
    00155   */
    00156   bool reportRealMotion(const Pose2D& real);
    00157
    00158   virtual void getDimension(int& dim1, int& dim2)
    00159   {
    00160     dim1=19;
    00161     dim2=1;
    00162   }
    00163
    00164   virtual void getValue(int index1, int index2, double& min, double& max, double& value, ValueType& type)
    00165   {
    00166     switch(index1)
    00167     {
    00168       case 0: value=correctedMotion.translation.x; min=1; max=60; type=valueDouble; break;
    00169       case 1: value=correctedMotion.translation.y; min=1; max=60; type=valueDouble; break;
    00170
    00171       case 2: value=foreHeight; min=30; max=170; type=valueDouble; break;
    00172       case 3: value=foreWidth; min=40; max=120; type=valueDouble; break;
    00173       case 4: value=foreCenterX; min=-20; max=80; type=valueDouble; break;
    00174
    00175       case 5: value=hindHeight; min=40; max=190; type=valueDouble; break;
    00176       case 6: value=hindWidth; min=40; max=140; type=valueDouble; break;
    00177       case 7: value=hindCenterX; min=-80; max=20; type=valueDouble; break;
    00178
    00179       case 8: value=foreFootLift; min=0; max=40; type=valueDouble; break;
    00180       case 9: value=hindFootLift; min=0; max=40; type=valueDouble; break;
    00181       case 10: value=foreFootTilt; min=-0.44; max=0.44; type=valueDouble; break;
    00182       case 11: value=hindFootTilt; min=-0.44; max=0.44; type=valueDouble; break;
    00183
    00184       case 12: value=stepLen; min=20; max=120; type=valueInt; break;
    00185
    00186       case 13: value=groundPhase[0]; min=0.01; max=0.99; type=valueDouble; break;
    00187       case 14: value=groundPhase[1]; min=0.01; max=0.99; type=valueDouble; break;
    00188
    00189       case 15: value=legPhase[0]; min=0; max=0.99; type=valueDouble; break;
    00190       case 16: value=legPhase[1]; min=0; max=0.99; type=valueDouble; break;
    00191       case 17: value=legPhase[2]; min=0; max=0.99; type=valueDouble; break;
    00192       case 18: value=legPhase[3]; min=0; max=0.99; type=valueDouble; break;
    00193
    00194       //case 19: value=liftPhase[0]; min=0.01; max=0.99; type=valueDouble; break;
    00195       //case 20: value=loweringPhase[0]; min=0.01; max=0.99; type=valueDouble; break;
    00196       //case 21: value=liftPhase[1]; min=0.01; max=0.99; type=valueDouble; break;
    00197       //case 22: value=loweringPhase[1]; min=0.01; max=0.99; type=valueDouble; break;
    00198     }
    00199   }
    00200
    00201   virtual void setValue(int index1, int index2, double value)
    00202   {
    00203     switch(index1)
    00204     {
    00205       case 0: correctedMotion.translation.x=value; break;
    00206       case 1: correctedMotion.translation.y=value; break;
    00207
    00208       case 2: foreHeight=value; break;
    00209       case 3: foreWidth=value; break;
    00210       case 4: foreCenterX=value; break;
    00211
    00212       case 5: hindHeight=value; break;
    00213       case 6: hindWidth=value; break;
    00214       case 7: hindCenterX=value; break;
    00215
    00216       case 8: foreFootLift=value; break;
    00217       case 9: hindFootLift=value; break;
    00218       case 10: foreFootTilt=value; break;
    00219       case 11: hindFootTilt=value; break;
    00220
    00221       case 12: stepLen=(int)value; break;
    00222
    00223       case 13: groundPhase[0]=value; break;
    00224       case 14: groundPhase[1]=value; break;
    00225
    00226       case 15: legPhase[0]=value; break;
    00227       case 16: legPhase[1]=value; break;
    00228       case 17: legPhase[2]=value; break;
    00229       case 18: legPhase[3]=value; break;
    00230
    00231       //case 19: liftPhase[0]=value; break;
    00232       //case 20: loweringPhase[0]=value; break;
    00233       //case 21: liftPhase[1]=value; break;
    00234       //case 22: loweringPhase[1]=value; break;
    00235     }
    00236   }
    00237
    00238 #define interpolateInvalid(v1,v2,factor1) \
    00239   (((v1==jointDataInvalidValue)||(v2==jointDataInvalidValue))? \
    00240   ((factor1<0.5)?v2:v1):(factor1*v1+(1-factor1)*v2));
    00241
    00242   inline void interpolate(GT2004Parameters& p1, GT2004Parameters& p2, double factor1)
    00243   {
    00244     index = -1; //these are merged parameters, they cant be found with index in a parametersSet
    00245     requestedMotion.translation = p1.requestedMotion.translation*factor1+p2.requestedMotion.translation*(1-factor1);
    00246     requestedMotion.rotation = factor1*p1.requestedMotion.rotation+(1-factor1)*p2.requestedMotion.rotation;
    00247     correctedMotion.translation = p1.correctedMotion.translation*factor1+p2.correctedMotion.translation*(1-factor1);
    00248     correctedMotion.rotation= factor1*p1.correctedMotion.rotation+(1-factor1)*p2.correctedMotion.rotation;
    00249
    00250     foreHeight=factor1*p1.foreHeight+(1-factor1)*p2.foreHeight;
    00251     foreWidth=factor1*p1.foreWidth+(1-factor1)*p2.foreWidth;
    00252     foreCenterX=factor1*p1.foreCenterX+(1-factor1)*p2.foreCenterX;
    00253
    00254     hindHeight=factor1*p1.hindHeight+(1-factor1)*p2.hindHeight;
    00255     hindWidth=factor1*p1.hindWidth+(1-factor1)*p2.hindWidth;
    00256     hindCenterX=factor1*p1.hindCenterX+(1-factor1)*p2.hindCenterX;
    00257
    00258     foreFootLift=factor1*p1.foreFootLift+(1-factor1)*p2.foreFootLift;
    00259     hindFootLift=factor1*p1.hindFootLift+(1-factor1)*p2.hindFootLift;
    00260     foreFootTilt=factor1*p1.foreFootTilt+(1-factor1)*p2.foreFootTilt;
    00261     hindFootTilt=factor1*p1.hindFootTilt+(1-factor1)*p2.hindFootTilt;
    00262
    00263     stepLen=(int)(factor1*p1.stepLen+(1-factor1)*p2.stepLen);
    00264     footMode=(factor1<0.5)?p2.footMode:p1.footMode;
    00265
    00266     groundPhase[0]=factor1*p1.groundPhase[0]+(1-factor1)*p2.groundPhase[0];
    00267 liftPhase[0]=factor1*p1.liftPhase[0]+(1-factor1)*p2.liftPhase[0]; //temp for BB support
    00268 loweringPhase[0]=factor1*p1.loweringPhase[0]+(1-factor1)*p2.loweringPhase[0]; //temp for BB support
    00269     groundPhase[1]=factor1*p1.groundPhase[1]+(1-factor1)*p2.groundPhase[1];
    00270 liftPhase[1]=factor1*p1.liftPhase[1]+(1-factor1)*p2.liftPhase[1]; //temp for BB support
    00271 loweringPhase[1]=factor1*p1.loweringPhase[1]+(1-factor1)*p2.loweringPhase[1]; //temp for BB support
    00272
    00273     legPhase[0]=factor1*p1.legPhase[0]+(1-factor1)*p2.legPhase[0];
    00274     legPhase[1]=factor1*p1.legPhase[1]+(1-factor1)*p2.legPhase[1];
    00275     legPhase[2]=factor1*p1.legPhase[2]+(1-factor1)*p2.legPhase[2];
    00276     legPhase[3]=factor1*p1.legPhase[3]+(1-factor1)*p2.legPhase[3];
    00277
    00278 //bodyShiftX=factor1*p1.bodyShiftX+(1-factor1)*p2.bodyShiftX; //temp for BB support
    00279 //bodyShiftY=factor1*p1.bodyShiftY+(1-factor1)*p2.bodyShiftY; //temp for BB support
    00280 //bodyShiftOffset=factor1*p1.bodyShiftOffset+(1-factor1)*p2.bodyShiftOffset; //temp for BB support
    00281
    00282     headTilt=(long)interpolateInvalid(p1.headTilt,p2.headTilt,factor1);
    00283     headPan=(long)interpolateInvalid(p1.headPan,p2.headPan,factor1);
    00284     headRoll=(long)interpolateInvalid(p1.headRoll,p2.headRoll,factor1);
    00285     mouth=(long)interpolateInvalid(p1.mouth,p2.mouth,factor1);
    00286
    00287     //    neckHeight=factor1*p1.neckHeight+(1-factor1)*p2.neckHeight;
    00288   }
    00289 };
    00290
    00291 /**
    00292 * Streaming operator that reads GT2004Parameters from a stream.
    00293 * @param stream The stream from which is read.
    00294 * @param walkingParameters The GT2004Parameters object.
    00295 * @return The stream.
    00296 */
    00297 In& operator>>(In& stream,GT2004Parameters& walkingParameters);
    00298
    00299 /**
    00300 * Streaming operator that writes GT2004Parameters to a stream.
    00301 * @param stream The stream to write on.
    00302 * @param walkingParameters The GT2004Parameters object.
    00303 * @return The stream.
    00304 */
    00305 Out& operator<<(Out& stream, const GT2004Parameters& walkingParameters);
    00306
    00307 /**
    00308 * @class GT2004ParametersSet
    00309 *
    00310 * ParametersSet for GT2004WalkingEngine
    00311 *
    00312 * @author Uwe Düffert
    00313 */
    00314 class GT2004ParametersSet
    00315 {
    00316 public:
    00317 /**
    00318 * enum describing indexes of a set of parameters
    00319   */
    00320   enum IndexName {
    00321     much_rturn_fast, much_rturn_med, much_rturn_slow, stand, much_lturn_slow, much_lturn_med, much_lturn_fast,
    00322
    00323     med_rturn_min180_slow, med_rturn_min135_slow, med_rturn_min90_slow, med_rturn_min45_slow,
    00324     med_rturn_0_slow, med_rturn_45_slow, med_rturn_90_slow, med_rturn_135_slow,
    00325     few_rturn_min180_slow, few_rturn_min135_slow, few_rturn_min90_slow, few_rturn_min45_slow,
    00326     few_rturn_0_slow, few_rturn_45_slow, few_rturn_90_slow, few_rturn_135_slow,
    00327     no_turn_min180_slow, no_turn_min135_slow, no_turn_min90_slow, no_turn_min45_slow,
    00328     no_turn_0_slow, no_turn_45_slow, no_turn_90_slow, no_turn_135_slow,
    00329     few_lturn_min180_slow, few_lturn_min135_slow, few_lturn_min90_slow, few_lturn_min45_slow,
    00330     few_lturn_0_slow, few_lturn_45_slow, few_lturn_90_slow, few_lturn_135_slow,
    00331     med_lturn_min180_slow, med_lturn_min135_slow, med_lturn_min90_slow, med_lturn_min45_slow,
    00332     med_lturn_0_slow, med_lturn_45_slow, med_lturn_90_slow, med_lturn_135_slow,
    00333
    00334     med_rturn_min180_med, med_rturn_min135_med, med_rturn_min90_med, med_rturn_min45_med,
    00335     med_rturn_0_med, med_rturn_45_med, med_rturn_90_med, med_rturn_135_med,
    00336     few_rturn_min180_med, few_rturn_min135_med, few_rturn_min90_med, few_rturn_min45_med,
    00337     few_rturn_0_med, few_rturn_45_med, few_rturn_90_med, few_rturn_135_med,
    00338     no_turn_min180_med, no_turn_min135_med, no_turn_min90_med, no_turn_min45_med,
    00339     no_turn_0_med, no_turn_45_med, no_turn_90_med, no_turn_135_med,
    00340     few_lturn_min180_med, few_lturn_min135_med, few_lturn_min90_med, few_lturn_min45_med,
    00341     few_lturn_0_med, few_lturn_45_med, few_lturn_90_med, few_lturn_135_med,
    00342     med_lturn_min180_med, med_lturn_min135_med, med_lturn_min90_med, med_lturn_min45_med,
    00343     med_lturn_0_med, med_lturn_45_med, med_lturn_90_med, med_lturn_135_med,
    00344
    00345     med_rturn_min180_fast, med_rturn_min135_fast, med_rturn_min90_fast, med_rturn_min45_fast,
    00346     med_rturn_0_fast, med_rturn_45_fast, med_rturn_90_fast, med_rturn_135_fast,
    00347     few_rturn_min180_fast, few_rturn_min135_fast, few_rturn_min90_fast, few_rturn_min45_fast,
    00348     few_rturn_0_fast, few_rturn_45_fast, few_rturn_90_fast, few_rturn_135_fast,
    00349     no_turn_min180_fast, no_turn_min135_fast, no_turn_min90_fast, no_turn_min45_fast,
    00350     no_turn_0_fast, no_turn_45_fast, no_turn_90_fast, no_turn_135_fast,
    00351     few_lturn_min180_fast, few_lturn_min135_fast, few_lturn_min90_fast, few_lturn_min45_fast,
    00352     few_lturn_0_fast, few_lturn_45_fast, few_lturn_90_fast, few_lturn_135_fast,
    00353     med_lturn_min180_fast, med_lturn_min135_fast, med_lturn_min90_fast, med_lturn_min45_fast,
    00354     med_lturn_0_fast, med_lturn_45_fast, med_lturn_90_fast, med_lturn_135_fast,
    00355
    00356     numberOfParameters
    00357   };
    00358
    00359   //rotationWalkRatio determines, in which cone we are
    00360   //double rotationWalkRatio=atan2(currentRequest.rotation/2.7,currentRequest.translation.abs()/300)/pi;
    00361   //-> -1=turn right only, 0=walk only [8], 1=turn left only [1]
    00362   //double movementStrength=sqrt((currentRequest.rotation/2.7)*(currentRequest.rotation/2.7)+((currentRequest.translation.x*currentRequest.translation.x+currentRequest.translation.y*currentRequest.translation.y)/(300*300)));
    00363   GT2004Parameters rotationOnly[7]; //[-max, -med, -min, 0, min, med, max]
    00364   GT2004Parameters withWalk[3][5][8];
    00365   //3 speeds [min, med, max] *                  //speedIndex
    00366   //5 rotWalkRatios [-0.3, -0.1, 0, 0.1, 0.3] * //ratioIndex
    00367   //8 directions [-pi, -3/4pi, -pi/2, ...]      //directionIndex
    00368
    00369   /** buffers for merging up to 8 parameter sets around the requested one */
    00370   GT2004Parameters llBuf,luBuf,ulBuf,uuBuf,lBuf,uBuf,mBuf;
    00371
    00372   /** pointers to merged parameter sets to minimize merging afford */
    00373   GT2004Parameters *lowRatioLowSpeed, *lowRatioUpSpeed, *upRatioLowSpeed, *upRatioUpSpeed;
    00374   GT2004Parameters *lowSpeed, *upSpeed, *mergedParameters;
    00375
    00376   /** default constructor */
    00377   GT2004ParametersSet();
    00378
    00379   /** calculate merged parameters set according to motion request
    00380   * @param currentRequest the request the merged parameters set shall be optimized for
    00381   */
    00382   void calculateMergedParameterSet(Pose2D& currentRequest);
    00383
    00384   /** return one of the GT2004Parameters in the tables according to index */
    00385   GT2004Parameters* getParameters(int index);
    00386
    00387   /** returns true if the given index is for a parametersset designed for max speed */
    00388   bool isMaxSpeedIndex(int index);
    00389
    00390   /** returns the name string of a certain index
    00391   * @param index the index of the parameters we would like to get the name of
    00392   * @return the name of the index as char*
    00393   */
    00394   static char* getIndexString(int index);
    00395
    00396   /** return the index of the left right mirrored parameters set
    00397   * @param index the index of the parameters set you want to get the mirrored version of
    00398   * @return the index of the left right mirrored parameters set or -1 if that doesnt exist
    00399   */
    00400   static int getIndexOfMirror(int index);
    00401
    00402   /** changes the mirrored parameters set to match the given one except for sign
    00403   * @param index the index of the source parameters set, the mirrored one shall look like that
    00404   */
    00405   void mirrorThis(int index);
    00406
    00407   /** changes all right turn parameters to match the according left turn parameters
    00408   */
    00409   void mirrorLeftTurnToRightTurn();
    00410
    00411   /** some functions to access and modify polar parts of a (motionRequest) Pose2D */
    00412   static double getSpeed(const Pose2D& request);
    00413   static double getRatio(const Pose2D& request);
    00414   static double getDirection(const Pose2D& request);
    00415   static void setSpeed(Pose2D& request, double speed);
    00416   static void setRatio(Pose2D& request, double ratio);
    00417   static void setDirection(Pose2D& request, double direct);
    00418
    00419   /** tries to load the parameters set from a file
    00420   * @return true, if reading was successful, false if set is unchanged
    00421   */
    00422   bool load(char* filename=0);
    00423
    00424   /** saves the parameters set to a file */
    00425   void save(char* filename=0);
    00426 };
    00427
    00428 /**
    00429 * Streaming operator that reads GT2004ParametersSets from a stream.
    00430 * @param stream The stream from which is read.
    00431 * @param walkingParametersSet The GT2004ParametersSet object.
    00432 * @return The stream.
    00433 */
    00434 In& operator>>(In& stream,GT2004ParametersSet& walkingParametersSet);
    00435
    00436 /**
    00437 * Streaming operator that writes GT2004ParametersSets to a stream.
    00438 * @param stream The stream to write on.
    00439 * @param walkingParametersSet The GT2004ParametersSet object.
    00440 * @return The stream.
    00441 */
    00442 Out& operator<<(Out& stream, const GT2004ParametersSet& walkingParametersSet);
    00443
    00444 #endif// __GT2004Parameters_h_