Tools/KickSelectionTable.h

Go to the documentation of this file.

/** 
* @file KickSelectionTable.h
* Declaration of class KickSelectionTable.
*
* @author <A href=mailto:juengel@informatik.hu-berlin.de>Matthias Jüngel</A>
* @author Martin Lötzsch
*/

#ifndef _KickSelectionTable_h_
#define _KickSelectionTable_h_

#include "Tools/Math/Vector2.h"
#include "Platform/GTAssert.h"
#include "Representations/Motion/MotionRequest.h"
#include "Representations/Cognition/RobotPose.h"
/**
* Represents the results and the preconditions of a single kick experiment
* @author Martin Lötzsch
*/
class KickCase
{
public:
  /** The relative x position of the ball when the kick was requested */
  double ballXR;

  /** The relative y position of the ball when the kick was requested */
  double ballYR;

  /** The time since the ball was seen last when the kick was requested */
  unsigned long ballTR;

  /** The relative x position of the ball when the kick was started */
  double ballXS;

  /** The relative y position of the ball when the kick was started */
  double ballYS;

  /** The time since the ball was seen last when the kick was started */
  unsigned long ballTS;

  /** The relative x position of the ball after the kick */
  double ballXA;

  /** The relative y position of the ball after the kick */
  double ballYA;

  /** The time since the kick was finished when the record was written */
  unsigned long tA;

};

/**
* @class KickSelectionTable
*
* @author <A href=mailto:juengel@informatik.hu-berlin.de>Matthias Jüngel</A>
* @author Martin Lötzsch
*
* Provides for a set of tables which provides a kick selection depending 
* on a desired kick angle and ball position.
*/
class KickSelectionTable
{
public:
  /** Constructor */
  KickSelectionTable();
  
  /** Destructor */
  ~KickSelectionTable();
  
  /** Ids for all possible actions */
  enum ActionID{
    nothing = 0,
    headLeft,
    headRight,
    anyLeft,
    anyRight,
    hookLeft,
    hookRight,
    leftPaw,
    rightPaw,
    armLeft,
    armRight,
    pushSoft,
    pushStrong,
    chestSoft,
    chestStrong,
    putRight,
    putLeft,
    forwardKickFast,
    forwardKickHard,
    slapRight,
    slapLeft,
    headLeftSoft,
    headRightSoft,
    backKickLeft,
    backKickRight,
    kickAlongArmLeft,
    kickAlongArmRight,
    bbHeadLeftSoft,
    bbHeadLeftStrong,
    bbHeadRightSoft,
    bbHeadRightStrong,
    kickWithBackLegLeft,
    kickWithBackLegRight,
    numberOfActions
  };
  
  /** returns names for action ids */
  static const char* getActionName(ActionID id)
  {
    switch (id)
    {
    case nothing: return "nothing";
    case headLeft: return "headLeft"; 
    case headRight: return "headRight";
    case anyLeft: return "anyLeft";
    case anyRight: return "anyRight";
    case hookLeft: return "hookLeft";
    case hookRight: return "hookRight";
    case leftPaw: return "leftPaw";
    case rightPaw: return "rightPaw";
    case armLeft: return "armLeft";
    case armRight: return "armRight";
    case pushSoft: return "pushSoft";
    case pushStrong: return "pushStrong";
    case chestSoft: return "chestSoft";
    case chestStrong: return "chestStrong";
    case putRight: return "putRight";
    case putLeft: return "putLeft";
    case forwardKickFast: return "forwardKickFast";
    case forwardKickHard: return "forwardKickHard";
    case slapRight: return "slapRight";
    case slapLeft: return "slapLeft";
    case headLeftSoft: return "headLeftSoft";
    case headRightSoft: return "headRightSoft";
    case backKickLeft: return "backKickLeft";
    case backKickRight: return "backKickRight";
    case kickAlongArmLeft: return "kickAlongArmLeft";
    case kickAlongArmRight: return "kickAlongArmRight";
    case bbHeadLeftSoft: return "bbHeadLeftSoft";
    case bbHeadLeftStrong: return "bbHeadLeftStrong";
    case bbHeadRightSoft: return "bbHeadRightSoft";
    case bbHeadRightStrong: return "bbHeadRightStrong";
    case kickWithBackLegLeft: return "kickWithBackLegLeft";
    case kickWithBackLegRight: return "kickWithBackLegRight";
    default: return "please edit KickSelectionTable::getActionName";
    }
  }
  
  /** returns short names for action ids (used by streaming operator)*/
  static const char* getShortActionName(ActionID id)
  {
    switch (id)
    {
    case nothing: return "no";
    case headLeft: return "head_l"; 
    case headRight: return "head_r";
    case anyLeft: return "any_l";
    case anyRight: return "any_r";
    case hookLeft: return "hook_l";
    case hookRight: return "hook_r";
    case leftPaw: return "l_paw";
    case rightPaw: return "r_paw";
    case armLeft: return "arm_l";
    case armRight: return "arm_r";
    case pushSoft: return "push_so";
    case pushStrong: return "pu_str";
    case chestSoft: return "che_so";
    case chestStrong: return "ch_str";
    case putRight: return "put_r";
    case putLeft: return "put_l";
    case forwardKickFast: return "forw_f";
    case forwardKickHard: return "forw_h";
    case slapRight: return "slap_r";
    case slapLeft: return "slap_l";
    case headLeftSoft: return "head_sl";
    case headRightSoft: return "head_sr";
    case backKickLeft: return "back_l";
    case backKickRight: return "back_r";
    case kickAlongArmLeft: return "along_a_l";
    case kickAlongArmRight: return "along_a_r";
    case bbHeadLeftSoft: return "bb_h_l";
    case bbHeadLeftStrong: return "bb_h_l_s";
    case bbHeadRightSoft: return "bb_h_r";
    case bbHeadRightStrong: return "bb_h_r_s";
    case kickWithBackLegLeft: return "backleg_l";
    case kickWithBackLegRight: return "backleg_r";
    default: 
      ASSERT(false);
      return 0;
    }
  }
  
  /** IDs for different kick selection tables */
  enum KickSelectionTableID
  {
    inCenterOfField, 
    atLeftBorder, 
    atRightBorder, 
    atLeftOpponentBorder, 
    atRightOpponentBorder, 
    nearOwnGoal, 
    goalie,
    whenStuck,
    passing,
    intentionalKick,
    hardKicks,
    numberOfKickSelectionTableIDs
  };
  
  /** returns a name for an action table id */
  static const char* getKickSelectionTableIDName(KickSelectionTableID id)
  {
    switch (id)
    {
    case inCenterOfField: return "inCenterOfField";
    case atLeftBorder: return "atLeftBorder";
    case atRightBorder: return "atRightBorder";
    case atLeftOpponentBorder: return "atLeftOpponentBorder";
    case atRightOpponentBorder: return "atRightOpponentBorder";
    case nearOwnGoal: return "nearOwnGoal"; 
    case goalie: return "goalie";
    case whenStuck: return "whenStuck";
    case passing: return "passing";
    case intentionalKick: return "intentionalKick";
    case hardKicks: return "hardKicks";
    default: 
      ASSERT(false);
      return 0;
    }
  }
  
  /** Returns an action id for a special action id */
  static const ActionID getActionIDFromSpecialActionID(SpecialActionRequest::SpecialActionID id)
  {
    switch (id)
    {
      case SpecialActionRequest::headLeft: return headLeft; 
      case SpecialActionRequest::headRight: return headRight;
      case SpecialActionRequest::anyLeft: return anyLeft;
      case SpecialActionRequest::anyRight: return anyRight;
      case SpecialActionRequest::hookLeft: return hookLeft;
      case SpecialActionRequest::hookRight: return hookRight;
      case SpecialActionRequest::leftPaw: return leftPaw;
      case SpecialActionRequest::rightPaw: return rightPaw;
      case SpecialActionRequest::armLeft: return armLeft;
      case SpecialActionRequest::armRight: return armRight;
      case SpecialActionRequest::pushSoft: return pushSoft;
      case SpecialActionRequest::pushStrong: return pushStrong;
      case SpecialActionRequest::chestSoft: return chestSoft;
      case SpecialActionRequest::putRight: return putRight;
      case SpecialActionRequest::putLeft: return putLeft;
      case SpecialActionRequest::forwardKickFast: return forwardKickFast;
      case SpecialActionRequest::forwardKickHard: return forwardKickHard;
      case SpecialActionRequest::slapRight: return slapRight;
      case SpecialActionRequest::slapLeft: return slapLeft;
      case SpecialActionRequest::headLeftSoft: return headLeftSoft;
      case SpecialActionRequest::headRightSoft: return headRightSoft;
      case SpecialActionRequest::backKickLeft: return backKickLeft;
      case SpecialActionRequest::backKickRight: return backKickRight;
      case SpecialActionRequest::kickAlongArmLeft: return kickAlongArmLeft;
      case SpecialActionRequest::kickAlongArmRight: return kickAlongArmRight;
      case SpecialActionRequest::bbHeadLeftSoft: return bbHeadLeftSoft;
      case SpecialActionRequest::bbHeadLeftStrong: return bbHeadLeftStrong;
      case SpecialActionRequest::bbHeadRightSoft: return bbHeadRightSoft;
      case SpecialActionRequest::bbHeadRightStrong: return bbHeadRightStrong;
      case SpecialActionRequest::kickWithBackLegLeft: return kickWithBackLegLeft;
      case SpecialActionRequest::kickWithBackLegRight: return kickWithBackLegRight;
      default: return nothing;
    }
  }
  
  /**  */ 
  enum{xRange = 20}; 
  
  /**  */ 
  enum{yRange = 40};
  
  /**  */ 
  enum{maxNumberOfSectors = 24};
  
  /** 
  * Calculates the best kick based on the position of the ball relative to the 
  * robot and a target angle. 
  */
  ActionID retrieveKick(
    double ballOffsetX, double ballOffsetY, 
    double destinationAngle, double destinationAngleWidth,
    KickSelectionTableID kickSelectionTableID
    ) const;
  
  Vector2<double> searchKickInNeighbourhood(
    double ballOffsetX, double ballOffsetY, 
    double destinationAngle,
    KickSelectionTableID kickSelectionTableID,
    RobotPose robotPose,
    double maxDistance,
    double& kick
   ) const;
  
  /** The action tables */
  ActionID action[xRange][yRange][maxNumberOfSectors][numberOfKickSelectionTableIDs];

  /** The number of sectors */
  int numberOfSectors;
  
  /** Returns a table id for a name */
  static KickSelectionTableID getTableIDFromName(const char* name);
  
  /** Returns an action id for a short name */
  static ActionID getActionIDFromShortName(const char* name);
  
  /** Loads a kick selection table from a file */
  void load(const char* fileName);

private:
  int getSectorFromAngle(double destinationAngle) const;

};

/**
* Streaming operator that reads KickSelectionTable from a stream.
* @param stream The stream from which is read.
* @param kickSelectionTable The KickSelectionTable object.
* @return The stream.
*/ 
In& operator>>(In& stream, KickSelectionTable& kickSelectionTable);

/**
* Streaming operator that writes KickSelectionTable to a stream.
* @param stream The stream to write on.
* @param kickSelectionTable The KickSelectionTable object.
* @return The stream.
*/ 
Out& operator<<(Out& stream, const KickSelectionTable& kickSelectionTable);

/**
* Streaming operator that reads KickCase from a stream.
* @param stream The stream from which is read.
* @param kickCase The KickCase object.
* @return The stream.
*/ 
In& operator>>(In& stream, KickCase& kickCase);

/**
* Streaming operator that writes KickCase to a stream.
* @param stream The stream to write on.
* @param kickCase The KickCase object.
* @return The stream.
*/ 
Out& operator<<(Out& stream, const KickCase& kickCase);


#endif   //  _KickSelectionTable_h_

---