Modules/BehaviorControl/CommonXabsl2Symbols/AngleSymbols.h

Go to the documentation of this file.

/** 
* @file AngleSymbols.h
*
* Declaration of class AngleSymbols.
*
* @author Matthias Jüngel
*/

#ifndef __AngleSymbols_h_
#define __AngleSymbols_h_

#include "../BehaviorControl.h"
#include "Tools/Xabsl2/Xabsl2Engine/Xabsl2Engine.h"
#include "Tools/FieldDimensions.h"
#include "Tools/Actorics/RobotDimensions.h"

/**
* The Xabsl2 symbols that are defined in "angle-symbols.xml"
*
* @author Matthias Jüngel
*/ 
class AngleSymbols : public Xabsl2FunctionProvider, public BehaviorControlInterfaces
{
public:
/*
* Constructor.
* @param interfaces The paramters of the BehaviorControl module.
  */
  AngleSymbols(const BehaviorControlInterfaces& interfaces);
  
  /** registers the symbols at an engine */
  void registerSymbols(Xabsl2Engine& engine);
  
    /** updates the symbols */
  void update();

  //!@name Input symbols
  //!@{

  //localisation based:
  double getAngleToCenterOfField(); /*!< calculates the value for the symbol "robot-pose.best-angle-away-from-own-goal" */
  double getAngleToBbSupporter(); 
  double getAngleToOpponentGoal(); /*!< A function for the symbol "robot-pose.angle-to-opponent-goal" */
  double getAngleToPointBehindOpponentGoal(); /*!< calculates the value for the symbol "robot-pose.angle-to-point-behind-opponent-goal" */
  double getAngleToCenterOfOpponentPenaltyArea(); /*!< calculates the value for the symbol "robot-pose.angle-to-center-of-opponent-penalty-area" */

    // combined: vision + odometry modelling + localisation
  double getPerfectAngleToOpponentGoal(); /*!< calculates the value for the symbol "robot-pose.best-angle-to-opponent-goal" */

  // combined: vision + localisation
  double getBestAngleToOpponentGoal(); /*!< calculates the value for the symbol "robot-pose.best-angle-to-opponent-goal" */
  double getBestAngleToOpponentGoalNoObstacles(); /*!< calculates the value for the symbol "robot-pose.best-angle-to-opponent-goal-no-obstacles" */
  double getBestWidthOfOpponentGoal(); /*!< calculates the value for the symbol "robot-pose.best-width-of-opponent-goal" */
  double getBestWidthOfOpponentGoalNoObstacles(); /*!< calculates the value for the symbol "robot-pose.best-width-of-opponent-goal-no-obstacles" */
  double getBestAngleAwayFromOwnGoal(); /*!< calculates the value for the symbol "robot-pose.best-angle-away-from-own-goal" */
  double getBestAngleAwayFromOwnGoalNoObstacles(); /*!< calculates the value for the symbol "robot-pose.best-angle-away-from-own-goal-no-obstacles" */
  double getGoalieGoalKickAngle(); /*!< calculates the value for the symbol "goalie.goal-kick-angle" */
  double getTimeSinceOpponentGoalDetection(); /*!< calculates the value for the symbol "angle.time-since-opponent-goal-detected" />*/

  // vision based + odometry in not seen cases
  double getSeenAngleToOpponentGoal(); /*!< calculates the value for the symbol "angle.seen-angle-to-opponent-goal" */
  double getTimeSinceLastSeenOpponentGoal(); /*!< calculates the value for the symbol "angle.time-since-last-seen-opponent-goal" />*/
  bool getTrustOfSeenAngleToOpponentGoal();

  

  double getTestAngle();

  //!@}

  /** The angle that is shown by the top white LEDs */
  enum Angles {
    undefined,
    //localisation based:
    angleToCenterOfField,                //input symbol
    angleToBbSupporter,
    angleToOpponentGoal,                 //input symbol
    angleToLeftOpponentGoalPost,
    angleToRightOpponentGoalPost,        
    angleToLeftOpponentGoalCorner,
    angleToRightOpponentGoalCorner,        
    angleToPointBehindOpponentGoal,      //input symbol
    angleToCenterOfOpponentPenaltyArea,  

    // vision based
    angleToFreePartOfOpponentGoalLeft,   
    angleToFreePartOfOpponentGoalRight,   
    angleToFreePartOfOpponentGoal,   
    widthOfFreePartOfOpponentGoal,

    // combined: vision + odometry modelling + localisation
    perfectAngleToOpponentGoal,          //input symbol
    // combined: vision + localisation
    bestAngleToOpponentGoal,             //input symbol
    bestWidthOfOpponentGoal,             //input symbol
    bestAngleToOpponentGoalNoObstacles,  //input symbol
    bestWidthOfOpponentGoalNoObstacles,  //input symbol
    bestAngleAwayFromOwnGoal,            //input symbol
    bestAngleAwayFromOwnGoalNoObstacles, //input symbol
    goalieGoalKickAngle,                 //input symbol

    // vision + odometry(non seen cases) based
    seenAngleToOpponentGoal,
    testAngle,                           //input symbol

    numberOfAngles
  };

  double getAngle(Angles id);
  
  static const char* getAngleName(Angles id)
  {
    switch(id)
    {
    case undefined: return "undefined";
    //localisation based:
    case angleToCenterOfField: return "angleToCenterOfField";
  case angleToBbSupporter: return "angleToBbSupporter";
    case angleToOpponentGoal: return "angleToOpponentGoal";
    case angleToLeftOpponentGoalPost: return "angleToLeftOpponentGoalPost";
    case angleToRightOpponentGoalPost: return "angleToRightOpponentGoalPost";
    case angleToLeftOpponentGoalCorner: return "angleToLeftOpponentGoalCorner";
    case angleToRightOpponentGoalCorner: return "angleToRightOpponentGoalCorner";
    case angleToPointBehindOpponentGoal: return "angleToPointBehindOpponentGoal";
    case angleToCenterOfOpponentPenaltyArea: return "angleToCenterOfOpponentPenaltyArea";

    // vision based
    case angleToFreePartOfOpponentGoalLeft: return "angleToFreePartOfOpponentGoalLeft";
    case angleToFreePartOfOpponentGoalRight: return "angleToFreePartOfOpponentGoalRight";
    case angleToFreePartOfOpponentGoal: return "angleToFreePartOfOpponentGoal";
    case widthOfFreePartOfOpponentGoal: return "widthOfFreePartOfOpponentGoal";

    // combined: vision + odometry modelling + localisation
    case perfectAngleToOpponentGoal: return "perfectAngleToOpponentGoal";
    // combined: vision + localisation
    case bestAngleToOpponentGoal: return "bestAngleToOpponentGoal";
    case bestWidthOfOpponentGoal: return "bestWidthOfOpponentGoal";
    case bestAngleToOpponentGoalNoObstacles: return "bestAngleToOpponentGoalNoObstacles";
    case bestWidthOfOpponentGoalNoObstacles: return "bestWidthOfOpponentGoalNoObstacles";
    case bestAngleAwayFromOwnGoal: return "bestAngleAwayFromOwnGoal";
    case bestAngleAwayFromOwnGoalNoObstacles: return "bestAngleAwayFromOwnGoalNoObstacles";
    case goalieGoalKickAngle: return "goalieGoalKickAngle";

      // vision based + odometry in non seen cases
    case seenAngleToOpponentGoal: return "seenAngleToOpponentGoal";

    case testAngle: return "testAngle";
    default: return "please-edit-angle-name";
    }
  }

  Angles angleShownByLEDs;
  void drawAngleShownByLeds();
  void drawAngles();
  Angles angleUsedForPerfectAngle;

private:
  void setTestAngle();
  void calculateVisionBasedAngles();
  void calculateLocalisationBasedAngles();
  void calculateCombinedAngles();
  double angles[numberOfAngles];
  bool angleIsUsedByTheCurrentBehavior[numberOfAngles];
};


#endif // __AngleSymbols_h_

---