Modules/SelfLocator/LinesTables2005.cpp

Go to the documentation of this file.

/**
 * @file Modules/SelfLocator/LinesTables2005.cpp
 * 
 * This file contains a class that represents the tables used for localization based on field lines.
 *
 * @author <A href=mailto:roefer@tzi.de>Thomas Röfer</A>
 */

#include "LinesTables2005.h"
#include "Tools/Debugging/Debugging.h"
#include "Tools/Streams/InStreams.h"

Field LinesTables2005::field;
LinesTables2005::ObsTable* LinesTables2005::observationTable = 0;
LinesTables2005::TempTable* LinesTables2005::templateTable = 0;
int LinesTables2005::refCount = 0;

//#define SAVE
//#define BOUNDARYASFIELDLINE

static const char* fileName = "lines05.tab";

LinesTables2005::LinesTables2005()
{
  if(!refCount++)
  {
    int i;
    observationTable = new ObsTable[LinesPercept::numberOfLineTypes];
    templateTable = new TempTable;

#ifdef SAVE
    OutBinaryFile stream(fileName);
    for(i = 0; i < LinesPercept::numberOfLineTypes; ++i)
    {
      observationTable[i].create(field,LinesPercept::LineType(i));
      stream << observationTable[i];
    }
    // create template table for yellow goal, as in field red player is assumed
    // the table contains always entries for the own goal
    templateTable->create(field,LinesPercept::yellowGoal);
    stream << *templateTable;
#else
    InBinaryFile stream(fileName);
    if(stream.exists())
    {
      for(i = 0; i < LinesPercept::numberOfLineTypes; ++i)
        stream >> observationTable[i];
      stream >> *templateTable;
    }
    else
    {
      OUTPUT(idText, text, "LinesTables2005 : " << fileName << " not found");
    }
#endif
  }
}

LinesTables2005::~LinesTables2005()
{
  if(!--refCount)
  {
    delete [] observationTable;
    delete templateTable;
  }
}

template<int xSize,int ySize,int cellSize,int pointRes> void LinesTables2005::ObservationTable<xSize,ySize,cellSize,pointRes>::create(const Field& field,LinesPercept::LineType type)
{
  for(int r = 0; r < 4; ++r)
    for(int y = 0; y < ySize; ++y)
      for(int x = 0; x < xSize; ++x)
      {
        Vector2<double> px(
          (x + 0.5 - xSize / 2) * cellSize,
          (y + 0.5 - ySize / 2) * cellSize
        );
        Vector2<double> p;
        if(
          field.getClosestPoint(
            p,
            Pose2D(r * pi_2, px),
            4,
            type))
        {
#ifdef BOUNDARYASFIELDLINE
          if (type == LinesPercept::field)
          {
            Vector2<double> p2 = field.getClosestPoint(
              Pose2D(r * pi_2, px),
              4,
              LinesPercept::boundary);
            if ((p2 - px).abs() < (p - px).abs())
              p = p2;
          }
#endif
          point[r][y][x][0] = char(sgn(p.x) * int(fabs(p.x / pointRes + 0.5)));
          point[r][y][x][1] = char(sgn(p.y) * int(fabs(p.y / pointRes + 0.5)));
          pointIsValid[r][y][x] = true;
        }
        else
          pointIsValid[r][y][x] = false;
      }
}

---