Modules/WalkingEngine/GT2005Parameters.h

Go to the documentation of this file.

/***************************************************************************
* @file GT2005Parameters.h
* Definition of class GT2005Parameters
* @author Denis Fisseler
****************************************************************************/

#ifndef GT2005Parameters_h
#define GT2005Parameters_h

#include "Tools/Math/Vector3.h"
#include "Tools/Math/Pose2D.h"
#include "Representations/Motion/MotionRequest.h"
#include "GT2005Polygon.h"
#include "Tools/Debugging/Debugging.h"
#include <string.h>
#include <math.h>

/***************************************************************************
* @class GT2005Parameters
*
* Parameter class for the GT2005 Walking Engine
* @author Denis Fisseler
***************************************************************************/
class GT2005Parameters
{
public:
  // Constructor
  GT2005Parameters();

  // Destructor
  ~GT2005Parameters();

  static const int Leg_FR;
  static const int Leg_FL;
  static const int Leg_HR;
  static const int Leg_HL;

  int stepLength; // time for one walking cycle in ticks (do not use for own calculations!)

  double counterRotation; // rotation correction value for sidesteps (not working yet)

  bool specialMode;

  double footPhase[4]; // relative foot phase offsets
  Vector3<double> footZeroPosition[4]; // foot zero positions

  int activePoints; // number of point actually used by this parameter set

  GT2005Polygon* evoPoly[4]; // polygon used during evolution

  GT2005Polygon* omniPoly[4]; // polygon optimized for omnidirectional walking
  GT2005Polygon* rotPoly[4]; // polygon optimized for fast turning
  GT2005Polygon* sforwardPoly[4]; // polygon optimized for smoothly walking forward
  GT2005Polygon* forwardPoly[4]; // polygon optimized for walking fast forward
  GT2005Polygon* dforwardPoly[4]; // polygon optimized for walking diagonal forward
  GT2005Polygon* sbackwardPoly[4]; // polygon optimized for smoothly walking backwards
  GT2005Polygon* backwardPoly[4]; // polygon optimized for walking fast backwards
  GT2005Polygon* dbackwardPoly[4]; // polygon optimized for walking diagonal backwards
  GT2005Polygon* sidewardsPoly[4]; // polygon optimized for fast sidesteps
  GT2005Polygon* boostPoly[4]; // polygon optimized for beating the dash walk
  GT2005Polygon* grabPoly[4];
  GT2005Polygon* rgrabPoly[4];

  bool load(char* filename); // load parameter set from a file
  void save(char* filename); // save parameter set to a file

  GT2005Polygon* calculateCurrentPoly(int leg, Pose2D mRequest, WalkRequest::WalkType walkType); // calcultates the optimal polygon for a specific motion request

  bool loadingFailed;

private:

  void setBasicParameters(); // set some standars parameters for stepLength ... footZeroPosition
  void setBasicPolygons(); // set some standard 4-sided rectangular polygons
  void setOptimizedPolys(); // load specialized polygons from files

  unsigned long framesSinceBoost;
};

In& operator>>(In& stream, GT2005Parameters& Parameters);
Out& operator<<(Out& stream, const GT2005Parameters& Parameters);

/**
* @class GTWalkParametersIndividual
*
* The class represents an individual for a set of walking parameters.
* 
* @author Matthias Hebbel, Denis Fisseler
*/
class GTWalkParametersIndividual
{
public:
  GTWalkParametersIndividual(); 
  GT2005Parameters walkingParameters; //< The walkingParameters of the individual.
  double fitness; //< The fitness of the individual.
  double strategyParameters[2][32]; //< The mutationStrengths for the walkingParameters.
  double strategyParameterStepLength; //< The mutationStrengths for the stepLength.
  void mutate();
  void calculateTauTau0();
  void crossOver(GTWalkParametersIndividual* parent2);
  // be very careful with using (check if internel delete calls may cause errors)
  void crossingOverOf(GTWalkParametersIndividual* parent1, GTWalkParametersIndividual* parent2);

  int bMessage; //used for evolution messages

  GTWalkParametersIndividual& operator=(const GTWalkParametersIndividual& other);

private:
  double tau, tau0;
  double randG(const double mutationStrength);
};

In& operator>>(In& stream, GTWalkParametersIndividual& individualParameters);
Out& operator<<(Out& stream, const GTWalkParametersIndividual& individualParameters);

#endif // GT2005Parameters_h

---