Tools/Field.h

Go to the documentation of this file.

/**
* @file Tools/Field.h
* 
* This file contains a class representing the field boundary.
*
* @author <A href=mailto:roefer@tzi.de>Thomas Röfer</A>
*/

#ifndef __Field_h_
#define __Field_h_

#include "Representations/Perception/LinesPercept.h"
#include "Representations/Perception/ObstaclesPercept.h"
#include "Representations/Cognition/PlayerPoseCollection.h"
#include "Tools/Boundary.h"
#include "Tools/FieldDimensions.h"
#include "Tools/Debugging/DebugDrawings.h"
#include "Tools/Math/Pose2D.h"

/**
* The class represents the field area.
*/
class Field : public Boundary<double>
{
private:
  /**
  * This is a collection of line- or boundary segments with start-Pose2D and length.
  */
  class Table
  {
  private:
    void free()
    {
      if(maxNumberOfEntries) 
      {
        delete [] corner; 
        delete [] length;
        maxNumberOfEntries = 0;
      }
    }

  public:
    Pose2D* corner; /**< The field corners. */
    double* length; /**< The lengths of the border segments starting at a corresponding corner. */
    int maxNumberOfEntries,  /**< The maximum number of corners in the table. */
        numberOfEntries; /**< The number of corners in the table. */

    Table() {maxNumberOfEntries = 0;}

    ~Table() {free();}

    void setSize(int size)
    {
      if(size != maxNumberOfEntries)
      {
        free();
        if(size)
        {          
          maxNumberOfEntries = size;
          corner = new Pose2D[size];
          length = new double[size];
        }
      }
      numberOfEntries = 0;
    }

    void push(const Pose2D& p, double l)
    {
      corner[numberOfEntries] = p;
      length[numberOfEntries++] = l;
    }
  };

  Table lines[LinesPercept::numberOfLineTypes + 5];

  void initBoundary(Table& table);
  void initBoundaryForHugeField(Table& table);
  void initLines(Table& table, Table& xTable, Table& yTable);
  void initBorder(Table& table);
  void initBorderForHugeField(Table& table);
  void initOpponentGoal(Table& table);
  void initOwnGoal(Table& table);
  void initSimpleLines(Table& table);
  void initSimpleLinesForHugeField(Table& table);

  void addCoords(Table& table,int number,double* x,double* y, bool rotate = false);
  void addCoords(Table& table,Table& xTable,Table& yTable,int number,double* x,double* y, bool rotate = false);
  void addPlayer(const Pose2D& pose);

public:
  /**
  * Constructor.
  */
  Field();

  /**
  * The function checks whether a point is inside the field.
  * @param v The point.
  * @return Is the point inside?
  */
  bool isReallyInside(const Vector2<double>& v) const;

  /**
  * The function clips a point to the field.
  * @param v The point.
  * @return How far was the point moved?
  */
  double clip(Vector2<double>& v) const;

  /**
  * The function returns the point on a line of a certain type closest to given a point.
  * @param v The reference point.
  * @param type The type of the lines.
  * @return The point on a line.
  */
  Vector2<double> getClosestPoint(const Vector2<double>& v, LinesPercept::LineType type) const;

  /**
  * The function returns the point on a line of a certain type closest to given a point.
  * @param p The reference point and the rotation of the line.
  * @param numberOfRotations The number of discretizations of line rotations.
  * @param type The type of the lines.
  * @param point The point on a line.
  * @return whether there is a matching point in that direction
  */
  bool getClosestPoint(Vector2<double>& point, const Pose2D& p, int numberOfRotations, LinesPercept::LineType type) const;

  /**
  * The function returns the distance between a point and the closest point on a line of a certain type.
  * @param v The reference point.
  * @param type The type of the lines.
  * @return The distance.
  */
  double getClosestDistance(const Vector2<double>& v, LinesPercept::LineType type) const;

  /**
  * The function returns the distance between a point and the closest point on a line of a certain type in a certain direction.
  * @param pose The reference point and direction.
  * @param type The type of the lines.
  * @return The distance. It is -1 if no line of that type exists in the certain direction.
  */
  double getDistance(const Pose2D& pose, LinesPercept::LineType type) const;

  /**
  * The function returns the distance between a point and the closest point on a line in a certain direction.
  * @param pose The reference point and direction.
  * @param ignoreFieldLines The field lines are ignored during the search.
  * @return The distance. It is -1 if no line of that type exists in the certain direction.
  */
  double getDistance(const Pose2D& pose,bool ignoreFieldLines = false) const;

  /**
  * The function returns the distance to the robots own penalty area for a given pose.
  * @param pose The reference point and direction (robot pose).
  * @return The distance. It is -1 if no line of that type exists in the certain direction.
  */
  double getDistanceToOwnPenaltyArea(const Pose2D& pose) const;

  /**
  * The function returns the distance between a point and the closest obstacle point in a certain direction.
  * @param pose The reference point and direction.
  * @param obstacleType The Obstacletype to be determined.
  * @return The distance. It is -1 if no line of that type exists in the certain direction.
  */
  double getObstacleDistance(const Pose2D& pose, ObstaclesPercept::ObstacleType& obstacleType) const;

  /**
  * The function places all robots as obstacles in an internal data structure.
  * @param ppc The poses of all other players on the field.
  */
  void placePlayers(const PlayerPoseCollection& ppc);

  /**
  * The function returns a random pose inside the field.
  * @return The random pose.
  */
  Pose2D randomPose() const;

  /**
  * The function draws all lines of a cetain type.
  * It is use to control the correctness of the model.
  * @param color The color the lines will be drawn in.
  * @param type The type of the lines.
  */
  void draw(const Drawings::Color color, LinesPercept::LineType type) const;
};

#endif // __Field_h_

---