Tools/Field.cpp

Go to the documentation of this file.

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

#include "Field.h"
#include "Tools/Debugging/Debugging.h"
#include "Tools/Player.h"
#include "Tools/RobotConfiguration.h"
#include "Platform/GTAssert.h"

Field::Field()
: Boundary<double>(0,0)
{
#ifdef HUGE_FIELD
  add(Vector2<double>(xPosOpponentGoal,yPosLeftFlags + flagRadius));
  add(Vector2<double>(xPosOwnGoal,yPosRightFlags - flagRadius));
  initBoundaryForHugeField(lines[LinesPercept::boundary]);
  initBorderForHugeField(lines[LinesPercept::border]); // carpet borders
#else
  add(Vector2<double>(xPosOpponentGoal,yPosLeftSideline));
  add(Vector2<double>(xPosOwnGoal,yPosRightSideline));
  initBoundary(lines[LinesPercept::boundary]);
  initBorder(lines[LinesPercept::border]); // field borders
#endif
  initLines(lines[LinesPercept::field], lines[LinesPercept::xField], lines[LinesPercept::yField]);
  initOwnGoal(lines[LinesPercept::yellowGoal]); // for red player
  initOpponentGoal(lines[LinesPercept::skyblueGoal]); // for red player
#ifdef HUGE_FIELD
  initSimpleLinesForHugeField(lines[LinesPercept::numberOfLineTypes]);
#else
  initSimpleLines(lines[LinesPercept::numberOfLineTypes]);
#endif
}

void Field::initBoundary(Table& table)
{
  double x[] =
  {
    xPosOwnGroundline,
    xPosOwnSideCorner,
    xPosOpponentSideCorner,
    xPosOpponentGroundline,
    xPosOpponentGroundline,
    xPosOpponentGoal - 100,
    xPosOpponentGoal - 100,
    xPosOpponentGroundline,
    xPosOpponentGroundline,
    xPosOpponentSideCorner,
    xPosOwnSideCorner,
    xPosOwnGroundline,
    xPosOwnGroundline,
    xPosOwnGoal + 100,
    xPosOwnGoal + 100,
    xPosOwnGroundline,
    xPosOwnGroundline
  },
         y[] =
  {
    yPosLeftGroundline,
    yPosLeftSideline,
    yPosLeftSideline,
    yPosLeftGroundline,
    yPosLeftGoal,
    yPosLeftGoal,
    yPosRightGoal,
    yPosRightGoal,
    yPosRightGroundline,
    yPosRightSideline,
    yPosRightSideline,
    yPosRightGroundline,
    yPosRightGoal,
    yPosRightGoal,
    yPosLeftGoal,
    yPosLeftGoal,
    yPosLeftGroundline
  };

  table.setSize(sizeof(x) / sizeof(x[0]) - 1);
  addCoords(table,table.maxNumberOfEntries,x,y);
}

void Field::initBoundaryForHugeField(Table& table)
{
  double x[] =
  {
    xPosOwnGoal,
    xPosOwnGoal,
    xPosOpponentGoal,
    xPosOpponentGoal,
    xPosOwnGoal
  },
         y[] =
  {
    yPosLeftFlags + (int) flagRadius,
    yPosRightFlags - (int) flagRadius,
    yPosRightFlags - (int) flagRadius,
    yPosLeftFlags + (int) flagRadius,
    yPosLeftFlags + (int) flagRadius
  };

  table.setSize(4);
  addCoords(table,4,x,y);
}

void Field::initLines(Table& table, Table& xTable, Table& yTable)
{
  double x[] =
  {
    // own ground line
    xPosOwnGroundline,
    xPosOwnGroundline,
    xPosOwnGroundline - fieldLinesWidth,
    xPosOwnGroundline - fieldLinesWidth,

    // opponent ground line
    xPosOpponentGroundline,
    xPosOpponentGroundline,
    xPosOpponentGroundline + fieldLinesWidth,
    xPosOpponentGroundline + fieldLinesWidth,

    // own inner penalty line border
    xPosOwnGroundline,
    xPosOwnPenaltyArea - fieldLinesWidth,
    xPosOwnPenaltyArea - fieldLinesWidth,
    xPosOwnGroundline,

    // own outer penalty line border
    xPosOwnGroundline,
    xPosOwnPenaltyArea,
    xPosOwnPenaltyArea,
    xPosOwnGroundline,

    // opponent inner penalty line border
    xPosOpponentGroundline,
    xPosOpponentPenaltyArea + fieldLinesWidth,
    xPosOpponentPenaltyArea + fieldLinesWidth,
    xPosOpponentGroundline,

    // opponent outer penalty line border
    xPosOpponentGroundline,
    xPosOpponentPenaltyArea,
    xPosOpponentPenaltyArea,
    xPosOpponentGroundline,

    //                                     _
    // inner center, opponent half-disc:  /_\ .
    -fieldLinesWidth / 2,
    -fieldLinesWidth / 2,
    int(-sin(pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(-sin(pi_2 / 2) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(-sin(3 * pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    -centerCircleRadius + fieldLinesWidth / 2,
    int(-sin(3 * pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(-sin(pi_2 / 2) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(-sin(pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    -fieldLinesWidth / 2,

    //                                     _
    // inner center, opponent half-disc:  /_\ .
    fieldLinesWidth / 2,
    fieldLinesWidth / 2,
    int(sin(pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(sin(pi_2 / 2) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(sin(3 * pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    centerCircleRadius - fieldLinesWidth / 2,
    int(sin(3 * pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(sin(pi_2 / 2) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(sin(pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    fieldLinesWidth / 2,

    //                                          __   __
    // outer circle and center line, own half:    \_/ 
    -fieldLinesWidth / 2,
    -fieldLinesWidth / 2,
    int(-sin(pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(-sin(pi_2 / 2) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(-sin(3 * pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    -centerCircleRadius - fieldLinesWidth / 2,
    int(-sin(3 * pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(-sin(pi_2 / 2) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(-sin(pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    -fieldLinesWidth / 2,
    -fieldLinesWidth / 2,

    //                                                  _
    // outer circle and center line, opponent half:  __/ \__
    fieldLinesWidth / 2,
    fieldLinesWidth / 2,
    int(sin(pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(sin(pi_2 / 2) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(sin(3 * pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    centerCircleRadius + fieldLinesWidth / 2,
    int(sin(3 * pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(sin(pi_2 / 2) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(sin(pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    fieldLinesWidth / 2,
    fieldLinesWidth / 2,

    // outer border
    xPosOwnGroundline - fieldLinesWidth,
    xPosOwnGroundline - fieldLinesWidth,
    xPosOpponentGroundline + fieldLinesWidth,
    xPosOpponentGroundline + fieldLinesWidth,
    xPosOwnGroundline - fieldLinesWidth,

    // goal lines between penalty lines
    xPosOwnGroundline,
    xPosOwnGroundline,
    xPosOpponentGroundline,
    xPosOpponentGroundline,

    // corners
    xPosOwnGroundline,
    xPosOwnGroundline,
    -fieldLinesWidth / 2,

    xPosOwnGroundline,
    xPosOwnGroundline,
    -fieldLinesWidth / 2,

    xPosOpponentGroundline,
    xPosOpponentGroundline,
    fieldLinesWidth / 2,

    xPosOpponentGroundline,
    xPosOpponentGroundline,
    fieldLinesWidth / 2,
},
         y[] =
  {
    // own ground line
    yPosLeftGoal,
    yPosRightGoal,
    yPosLeftGoal,
    yPosRightGoal,

    // opponent ground line
    yPosLeftGoal,
    yPosRightGoal,
    yPosLeftGoal,
    yPosRightGoal,

    // own inner penalty line border
    yPosLeftPenaltyArea - fieldLinesWidth,
    yPosLeftPenaltyArea - fieldLinesWidth,
    yPosRightPenaltyArea + fieldLinesWidth,
    yPosRightPenaltyArea + fieldLinesWidth,

    // own outer penalty line border
    yPosLeftPenaltyArea,
    yPosLeftPenaltyArea,
    yPosRightPenaltyArea,
    yPosRightPenaltyArea,

    // opponent inner penalty line border
    yPosLeftPenaltyArea - fieldLinesWidth,
    yPosLeftPenaltyArea - fieldLinesWidth,
    yPosRightPenaltyArea + fieldLinesWidth,
    yPosRightPenaltyArea + fieldLinesWidth,

    // opponent outer penalty line border
    yPosLeftPenaltyArea,
    yPosLeftPenaltyArea,
    yPosRightPenaltyArea,
    yPosRightPenaltyArea,

    //                                _
    // inner center, own half-disc:  \_/
    centerCircleRadius - fieldLinesWidth / 2,
    -centerCircleRadius + fieldLinesWidth / 2,
    int(-cos(pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(-cos(pi_2 / 2) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(-cos(3 * pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    0,
    int(cos(3 * pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(cos(pi_2 / 2) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(cos(pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    centerCircleRadius - fieldLinesWidth / 2,

    //                                     _
    // inner center, opponent half-disc:  /_\ .
    centerCircleRadius - fieldLinesWidth / 2,
    -centerCircleRadius + fieldLinesWidth / 2,
    int(-cos(pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(-cos(pi_2 / 2) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(-cos(3 * pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    0,
    int(cos(3 * pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(cos(pi_2 / 2) * (centerCircleRadius - fieldLinesWidth / 2)),
    int(cos(pi_2 / 4) * (centerCircleRadius - fieldLinesWidth / 2)),
    centerCircleRadius - fieldLinesWidth / 2,

    //                                          __   __
    // outer circle and center line, own half:    \_/ 
    yPosRightSideline,
    -centerCircleRadius - fieldLinesWidth / 2,
    int(-cos(pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(-cos(pi_2 / 2) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(-cos(3 * pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    0,
    int(cos(3 * pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(cos(pi_2 / 2) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(cos(pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    centerCircleRadius + fieldLinesWidth / 2,
    yPosLeftSideline,

    //                                                  _
    // outer circle and center line, opponent half:  __/ \__
    yPosRightSideline,
    -centerCircleRadius - fieldLinesWidth / 2,
    int(-cos(pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(-cos(pi_2 / 2) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(-cos(3 * pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    0,
    int(cos(3 * pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(cos(pi_2 / 2) * (centerCircleRadius + fieldLinesWidth / 2)),
    int(cos(pi_2 / 4) * (centerCircleRadius + fieldLinesWidth / 2)),
    centerCircleRadius + fieldLinesWidth / 2,
    yPosLeftSideline,

    // outer border
    yPosLeftSideline + fieldLinesWidth,
    yPosRightSideline - fieldLinesWidth,
    yPosRightSideline - fieldLinesWidth,
    yPosLeftSideline + fieldLinesWidth,
    yPosLeftSideline + fieldLinesWidth,

    // goal lines between penalty lines
    yPosLeftPenaltyArea - fieldLinesWidth,
    yPosRightPenaltyArea + fieldLinesWidth,
    yPosLeftPenaltyArea - fieldLinesWidth,
    yPosRightPenaltyArea + fieldLinesWidth,

    // corners
    yPosLeftPenaltyArea,
    yPosLeftSideline,
    yPosLeftSideline,

    yPosRightPenaltyArea,
    yPosRightSideline,
    yPosRightSideline,

    yPosLeftPenaltyArea,
    yPosLeftSideline,
    yPosLeftSideline,

    yPosRightPenaltyArea,
    yPosRightSideline,
    yPosRightSideline,
  };

#ifdef HUGE_FIELD
  table.setSize(64);
  xTable.setSize(64);
  yTable.setSize(64);

  // outer border
  addCoords(table,xTable,yTable,4,x + 66,y + 66, true);
  
  // goal lines between penalty lines
  addCoords(table,xTable,yTable,1,x + 71,y + 71);
  addCoords(table,xTable,yTable,1,x + 73,y + 73, true);

  // corners
  addCoords(table,xTable,yTable,2,x + 75,y + 75, true);
  addCoords(table,xTable,yTable,2,x + 78,y + 78);
  addCoords(table,xTable,yTable,2,x + 81,y + 81);
  addCoords(table,xTable,yTable,2,x + 84,y + 84, true);
#else
  table.setSize(54);
  xTable.setSize(54);
  yTable.setSize(54);

  // ground lines
  for(int i = 0; i < 4; ++i)
    addCoords(table,xTable,yTable,1,x + 2 * i,y + 2 * i, i==1 || i==2);
#endif

  // own penalty
  addCoords(table,xTable,yTable,3,x + 8,y + 8, true);
  addCoords(table,xTable,yTable,3,x + 12,y + 12);

  // opponent penalty
  addCoords(table,xTable,yTable,3,x + 16,y + 16);
  addCoords(table,xTable,yTable,3,x + 20,y + 20, true);

  // inner center
  addCoords(table,xTable,yTable,9,x + 24,y + 24, true);
  addCoords(table,xTable,yTable,9,x + 34,y + 34);

  // outer center and center line
  addCoords(table,xTable,yTable,10,x + 44,y + 44);
  addCoords(table,xTable,yTable,10,x + 55,y + 55, true);
}

void Field::initSimpleLines(Table& table)
{
  double x[] =
  {
    xPosOwnGroundline,
    xPosOwnGroundline,

    xPosOpponentGroundline,
    xPosOpponentGroundline,

    xPosOwnGroundline + fieldLinesWidth / 2,
    xPosOwnPenaltyArea,
    xPosOwnPenaltyArea,
    xPosOwnGroundline + fieldLinesWidth / 2,

    xPosOpponentGroundline - fieldLinesWidth / 2,
    xPosOpponentPenaltyArea,
    xPosOpponentPenaltyArea,
    xPosOpponentGroundline - fieldLinesWidth / 2,

    xPosHalfWayLine,
    xPosHalfWayLine
  },
         y[] =
  {
    yPosLeftGoal,
    yPosRightGoal,

    yPosLeftGoal,
    yPosRightGoal,

    yPosLeftPenaltyArea,
    yPosLeftPenaltyArea,
    yPosRightPenaltyArea,
    yPosRightPenaltyArea,

    yPosLeftPenaltyArea,
    yPosLeftPenaltyArea,
    yPosRightPenaltyArea,
    yPosRightPenaltyArea,

    yPosRightSideline,yPosLeftSideline
  };

  table.setSize(9);

  // ground lines
  addCoords(table,1,x,y);
  addCoords(table,1,x + 2,y + 2);

  // penalty area
  addCoords(table,3,x + 4,y + 4);
  addCoords(table,3,x + 8,y + 8);

  // halfWay line
  addCoords(table,1,x + 12,y + 12);
}

void Field::initSimpleLinesForHugeField(Table& table)
{
  double x[] =
  {
    xPosOwnGroundline - fieldLinesWidth / 2,
    xPosOwnGroundline - fieldLinesWidth / 2,
    xPosOpponentGroundline + fieldLinesWidth / 2,
    xPosOpponentGroundline + fieldLinesWidth / 2,
    xPosOwnGroundline - fieldLinesWidth / 2,

    xPosOwnGroundline - fieldLinesWidth / 2,
    xPosOwnPenaltyArea - fieldLinesWidth / 2,
    xPosOwnPenaltyArea - fieldLinesWidth / 2,
    xPosOwnGroundline - fieldLinesWidth / 2,

    xPosOpponentGroundline + fieldLinesWidth / 2,
    xPosOpponentPenaltyArea + fieldLinesWidth / 2,
    xPosOpponentPenaltyArea + fieldLinesWidth / 2,
    xPosOpponentGroundline + fieldLinesWidth / 2,

    xPosHalfWayLine,
    xPosHalfWayLine
  },
         y[] =
  {
    yPosLeftSideline + fieldLinesWidth / 2,
    yPosRightSideline - fieldLinesWidth / 2,
    yPosRightSideline - fieldLinesWidth / 2,
    yPosLeftSideline + fieldLinesWidth / 2,
    yPosLeftSideline + fieldLinesWidth / 2,

    yPosLeftPenaltyArea - fieldLinesWidth / 2,
    yPosLeftPenaltyArea - fieldLinesWidth / 2,
    yPosRightPenaltyArea + fieldLinesWidth / 2,
    yPosRightPenaltyArea + fieldLinesWidth / 2,

    yPosLeftPenaltyArea - fieldLinesWidth / 2,
    yPosLeftPenaltyArea - fieldLinesWidth / 2,
    yPosRightPenaltyArea + fieldLinesWidth / 2,
    yPosRightPenaltyArea + fieldLinesWidth / 2,

    yPosRightSideline - fieldLinesWidth / 2,
    yPosLeftSideline + fieldLinesWidth / 2
  };

  table.setSize(11);

  // border lines
  addCoords(table,4,x,y);

  // penalty area
  addCoords(table,3,x + 5,y + 5);
  addCoords(table,3,x + 9,y + 9);

  // halfWay line
  addCoords(table,1,x + 13,y + 13);
}

void Field::initBorder(Table& table)
{
  double x[] =
  {
    xPosOwnGoalpost,
    xPosOwnGroundline,
    xPosOwnGroundline,
    xPosOwnSideCorner,
    xPosOpponentSideCorner,
    xPosOpponentGroundline,
    xPosOpponentGroundline,
    xPosOpponentGoalpost,
    // opponent goal
    xPosOpponentGoalpost,
    xPosOpponentGroundline,
    xPosOpponentGroundline,
    xPosOpponentSideCorner,
    xPosOwnSideCorner,
    xPosOwnGroundline,
    xPosOwnGroundline,
    xPosOwnGoalpost
    // own goal
  },
         y[] =
  {
    yPosLeftGoal,
    yPosLeftGoal,
    yPosLeftGroundline,
    yPosLeftSideline,
    yPosLeftSideline,
    yPosLeftGroundline,
    yPosLeftGoal,
    yPosLeftGoal,
    // opponent goal
    yPosRightGoal,
    yPosRightGoal,
    yPosRightGroundline,
    yPosRightSideline,
    yPosRightSideline,
    yPosRightGroundline,
    yPosRightGoal,
    yPosRightGoal
    // own goal
  };

  table.setSize(sizeof(x) / sizeof(x[0]) - 2);
  addCoords(table,7,x,y);
  addCoords(table,7,x+8,y+8);
}

void Field::initBorderForHugeField(Table& table)
{
  double x[] =
  {
    xPosOwnGroundline,
    xPosOwnGoal,
    xPosOwnGoal,
    xPosOpponentGoal,
    xPosOpponentGoal,
    xPosOpponentGroundline,

    xPosOpponentGroundline,
    xPosOpponentGoal,
    xPosOpponentGoal,
    xPosOwnGoal,
    xPosOwnGoal,
    xPosOwnGroundline
  },
         y[] =
  {
    yPosRightGoal,
    yPosRightGoal,
    yPosRightFlags - (int) flagRadius,
    yPosRightFlags - (int) flagRadius,
    yPosRightGoal,
    yPosRightGoal,

    yPosLeftGoal,
    yPosLeftGoal,
    yPosLeftFlags + (int) flagRadius,
    yPosLeftFlags + (int) flagRadius,
    yPosLeftGoal,
    yPosLeftGoal
  };

  table.setSize(10 + 4*16);
  addCoords(table, 5, x, y);
  addCoords(table, 5, x + 6, y + 6);

  // landmarks
  for (int lx = 0; lx < 2; lx++)
    for (int ly = 0; ly < 2; ly++)
    {
      double centerX = (lx == 0) ? xPosFrontFlags : xPosBackFlags;
      double centerY = (ly == 0) ? yPosLeftFlags : yPosRightFlags;
      double x[2], y[2];
      for (double r = 0; r < pi2; r += pi/8)
      {
        if (r > 0)
        {
          x[0] = x[1];
          y[0] = y[1]; 
        }
        x[1] = centerX + sin(r) * flagRadius;
        y[1] = centerY + cos(r) * flagRadius;
        if (r > 0)
          addCoords(table, 1, x, y);
      }
    }
}

void Field::initOpponentGoal(Table& table)
{
  double x[] =
  {
    xPosOpponentGoalpost,
    xPosOpponentGoal,
    xPosOpponentGoal,
    xPosOpponentGoalpost
  },
         y[] =
  {
    yPosLeftGoal,
    yPosLeftGoal,
    yPosRightGoal,
    yPosRightGoal
  };

  table.setSize(sizeof(x) / sizeof(x[0]) - 1);
  addCoords(table,table.maxNumberOfEntries,x,y,true);
}

void Field::initOwnGoal(Table& table)
{
  double x[] =
  {
    xPosOwnGoalpost,
    xPosOwnGoal,
    xPosOwnGoal,
    xPosOwnGoalpost
  },
         y[] =
  {
    yPosRightGoal,
    yPosRightGoal,
    yPosLeftGoal,
    yPosLeftGoal
  };

  table.setSize(sizeof(x) / sizeof(x[0]) - 1);
  addCoords(table,table.maxNumberOfEntries,x,y,true);
}

void Field::addCoords(Table& table,int number,double* x,double* y, bool rotate)
{
  Vector2<double> v1(x[0],y[0]);
  for(int i = 1; i <= number; ++i)
  {
    Vector2<double> v2(x[i],y[i]),
                    vs = (rotate) ? v2 : v1,
                    vd = (rotate) ? v1 - v2 : v2 - v1;
    if(vd.abs())
      table.push(Pose2D(atan2(vd.y,vd.x),vs), vd.abs());
    v1 = v2;
  }
}

void Field::addCoords(Table& table,Table& xTable,Table& yTable,int number,double* x,double* y, bool rotate)
{
  Vector2<double> v1(x[0],y[0]);
  for(int i = 1; i <= number; ++i)
  {
    Vector2<double> v2(x[i],y[i]),
                    vs = (rotate) ? v2 : v1,
                    vd = (rotate) ? v1 - v2 : v2 - v1;
    if(fabs(vd.x) > 1)
      xTable.push(Pose2D(atan2(vd.y,vd.x),vs), vd.abs());
    if(fabs(vd.y) > 1)
      yTable.push(Pose2D(atan2(vd.y,vd.x),vs), vd.abs());
    if(vd.abs())
      table.push(Pose2D(atan2(vd.y,vd.x),vs), vd.abs());
    v1 = v2;
  }
}

bool Field::isReallyInside(const Vector2<double>& v) const
{
  if(!isInside(v))
    return false;
#ifndef HUGE_FIELD
  for(int i = 0; i < lines[LinesPercept::boundary].numberOfEntries; ++i)
  {
    Pose2D diff = Pose2D(v) - lines[LinesPercept::boundary].corner[i];
    if(diff.translation.y > 0 && diff.translation.x >= 0 && diff.translation.x < lines[LinesPercept::boundary].length[i])
      return false;
  }
#endif
  return true;
}

double Field::clip(Vector2<double>& v) const
{
  if(isReallyInside(v))
    return 0;
  else
  {
    Vector2<double> old = v,
                          v2;
    double minDist = 100000;
    for(int i = 0; i < lines[LinesPercept::boundary].numberOfEntries; ++i)
    {
      Vector2<double> diff = (Pose2D(old) - lines[LinesPercept::boundary].corner[i]).translation;
      if(diff.x < 0)
        v2 = lines[LinesPercept::boundary].corner[i].translation;
      else if(diff.x > lines[LinesPercept::boundary].length[i])
        v2 = (lines[LinesPercept::boundary].corner[i] + Pose2D(Vector2<double>(lines[LinesPercept::boundary].length[i],0))).translation;
      else
        v2 = (lines[LinesPercept::boundary].corner[i] + Pose2D(Vector2<double>(diff.x,0))).translation;
      double dist = (old - v2).abs();
      if(minDist > dist)
      {
        minDist = dist;
        v = v2;
      }
    }
    return (v - old).abs();
  }
}

Vector2<double> Field::getClosestPoint(const Vector2<double>& v,
                                       LinesPercept::LineType type) const
{
  const Table& table = lines[type];
  Vector2<double> vMin,
                  v2;
  double minDist = 100000;
  for(int i = 0; i < table.numberOfEntries; ++i)
  {
    Vector2<double> diff = (Pose2D(v) - table.corner[i]).translation;
    if(diff.x < 0)
      v2 = table.corner[i].translation;
    else if(diff.x > table.length[i])
      v2 = (table.corner[i] + Pose2D(Vector2<double>(table.length[i],0))).translation;
    else
      v2 = (table.corner[i] + Pose2D(Vector2<double>(diff.x,0))).translation;
    Vector2<double> vDiff = v2 - v;
    double dist = vDiff.abs();
    if(minDist > dist)
    {
      minDist = dist;
      vMin = v2;
    }
  }
  return vMin;
}

bool Field::getClosestPoint(Vector2<double>& vMin, const Pose2D& p, int numberOfRotations,
                                       LinesPercept::LineType type) const
{
  // target angle -> target index
  double r = p.rotation / pi2 * numberOfRotations + 0.5;
  if(r < 0)
    r += numberOfRotations;
  int targetRot = int(r);
  ASSERT(targetRot >= 0 && targetRot < numberOfRotations);
  const Table& table = lines[type];
  Vector2<double> v2;
  double minDist = 100000;
  for(int i = 0; i < table.numberOfEntries; ++i)
  {
    // angle -> index
    double r = (table.corner[i].rotation + pi_2) / pi2 * numberOfRotations + 0.5;
    if(r < 0)
      r += numberOfRotations;
    int rot = int(r);
    ASSERT(rot >= 0 && rot < numberOfRotations);

    // index must be target index
    if(rot == targetRot)
    {
      Vector2<double> diff = (p - table.corner[i]).translation;
      if(diff.x < 0)
        v2 = table.corner[i].translation;
      else if(diff.x > table.length[i])
        v2 = (table.corner[i] + Pose2D(Vector2<double>(table.length[i],0))).translation;
      else
        v2 = (table.corner[i] + Pose2D(Vector2<double>(diff.x,0))).translation;
      Vector2<double> vDiff = v2 - p.translation;
      double dist = vDiff.abs();
      if(minDist > dist)
      {
        minDist = dist;
        vMin = v2;
      }
    }
  }
  return (minDist<100000);
}

double Field::getClosestDistance(const Vector2<double>& v,
                                 LinesPercept::LineType type) const
{
  return (v - getClosestPoint(v,type)).abs();
}

double Field::getDistance(const Pose2D& pose,
                          LinesPercept::LineType type) const
{
  const Table& table = lines[type];
  double minDist = 100000;
  for(int i = 0; i < table.numberOfEntries; ++i)
  {
    Vector2<double> v1 = (table.corner[i] - pose).translation,
                    v2 = (table.corner[i] + Pose2D(Vector2<double>(table.length[i],0)) 
                          - pose).translation;
    if(v1.y < 0 && v2.y > 0 ||
       v1.y > 0 && v2.y < 0)
    {
      double dist = v1.x + (v2.x - v1.x) * -v1.y / (v2.y - v1.y);
      if(dist >= 0 && dist < minDist)
        minDist = dist;
    }
  }
  return minDist == 100000 ? -1 : minDist;
}

double Field::getDistance(const Pose2D& pose,bool ignoreFieldLines) const
{
  double minDist = 100000;
  for(int i = LinesPercept::numberOfLineTypes - (ignoreFieldLines ? 1 : 0);
      i > 0; --i) // use simpleLines instead of lines
  {
    double dist = getDistance(pose,LinesPercept::LineType(i));
    if(dist != -1 && dist < minDist)
      minDist = dist;
  } 
  return minDist == 100000 ? -1 : minDist;
}

double Field::getDistanceToOwnPenaltyArea(const Pose2D& pose) const
{
  const Table& table = lines[LinesPercept::numberOfLineTypes];
  double minDist = 100000;
// this ifdef is pretty ugly but necessary since huge field has sidelines in simple field line table
// accessing fixed indices in line table is a bad idea anyway...  MR
#ifdef HUGE_FIELD 
  for(int i = 4; i < 7; ++i) //own penalty area in simple field line table for huge field 
#else
  for(int i = 2; i < 5; ++i) //own penalty area in simple field line table for small field
#endif
  {
    Vector2<double> v1 = (table.corner[i] - pose).translation,
                    v2 = (table.corner[i] + Pose2D(Vector2<double>(table.length[i],0)) 
                          - pose).translation;
    if(v1.y < 0 && v2.y > 0 ||
       v1.y > 0 && v2.y < 0)
    {
      double dist = v1.x + (v2.x - v1.x) * -v1.y / (v2.y - v1.y);
      if(dist >= 0 && dist < minDist)
        minDist = dist;
    }
  }
  return minDist == 100000 ? -1 : minDist;
}

double Field::getObstacleDistance(const Pose2D& pose, ObstaclesPercept::ObstacleType& obstacleType) const
{
  double minDist = getDistance(pose,LinesPercept::LineType(LinesPercept::numberOfLineTypes + 1));
  LinesPercept::LineType minDistType = LinesPercept::LineType(LinesPercept::numberOfLineTypes + 1);
  if(minDist == -1)
    minDist = 100000;
 
  for(int i = LinesPercept::numberOfLineTypes - 1; 
    i > 0; // everything but field lines 
    --i)
  {
    double dist = getDistance(pose,LinesPercept::LineType(i));
    if(dist != -1 && dist < minDist)
    {
      minDist = dist;
      minDistType = LinesPercept::LineType(i);
    }
  } 
  
  //minDist = getDistanceToOwnPenaltyArea(pose);
    
  switch(minDistType)
  {
  //case LinesPercept::border: obstacleType = ObstaclesPercept::border; break;
  case LinesPercept::redRobot: obstacleType = ObstaclesPercept::opponent; break;
  case LinesPercept::blueRobot: obstacleType = ObstaclesPercept::teammate; break;
  case LinesPercept::yellowGoal: obstacleType = ObstaclesPercept::goal; break;
  case LinesPercept::skyblueGoal: obstacleType = ObstaclesPercept::goal; break;
  default: obstacleType = ObstaclesPercept::unknown;
  }
  return minDist == 100000 ? -1 : minDist;
}

void Field::placePlayers(const PlayerPoseCollection& ppc)
{
  lines[LinesPercept::numberOfLineTypes + 1].setSize(
    (ppc.numberOfOwnPlayers + ppc.numberOfOpponentPlayers) * 4); // for player boundaries
  for(int i = 0; i < ppc.numberOfOwnPlayers; ++i)
    addPlayer(ppc.getOwnPlayerPose(i).getPose());
  for(int j = 0; j < ppc.numberOfOpponentPlayers; ++j)
    addPlayer(ppc.getOpponentPlayerPose(j).getPose());
}

void Field::addPlayer(const Pose2D& pose)
{
  // @todo These should be the dimensions of the other robot!
  const RobotDimensions& robotDimensions = getRobotConfiguration().getRobotDimensions();
  double front = robotDimensions.bodyLength / 2 - robotDimensions.lengthNeckToBodyCenter,
         back = front - robotDimensions.bodyLength,
         side = robotDimensions.overallBodyWidth / 2;
  Vector2<double> fl = (pose + Pose2D(Vector2<double>(front, side))).translation,
                  fr = (pose + Pose2D(Vector2<double>(front, -side))).translation,
                  bl = (pose + Pose2D(Vector2<double>(back, side))).translation,
                  br = (pose + Pose2D(Vector2<double>(back, -side))).translation;
  double x[] = {fl.x, fr.x, br.x, bl.x, fl.x},
         y[] = {fl.y, fr.y, br.y, bl.y, fl.y};
  addCoords(lines[LinesPercept::numberOfLineTypes + 1], 4, x, y);
}

Pose2D Field::randomPose() const
{ 
  Pose2D pose;
  do
    pose = Pose2D::random(x,y,Range<double>(-pi,pi));
  while(!isReallyInside(pose.translation));
  return pose;
}

void Field::draw(const Drawings::Color color, LinesPercept::LineType type) const
{
  NDECLARE_DEBUGDRAWING("field", "drawingOnField", "displays the field tables");
  const Table& table = lines[type];
  for(int i = 0; i < table.numberOfEntries; ++i)
  {
    Vector2<double> p = (table.corner[i] + 
      Pose2D(Vector2<double>(table.length[i],0))).translation;
    NLINE("field",
       (int) table.corner[i].translation.x,
       (int) table.corner[i].translation.y,
       (int) p.x,
       (int) p.y,
       1, Drawings::ps_solid, color);    
    p = (table.corner[i] + 
      Pose2D(Vector2<double>(table.length[i]/2,0))).translation;
    Vector2<double> p2 = (table.corner[i] + 
      Pose2D(Vector2<double>(table.length[i]/2,100))).translation;
    NLINE("field",
       (int) p2.x,
       (int) p2.y,
       (int) p.x,
       (int) p.y,
       1, Drawings::ps_solid, color);    
  }
}

---