Representations/Perception/ObstaclesPercept.h

Go to the documentation of this file.

/**
* @file ObstaclesPercept.h
* 
* Declaration of class ObstaclesPercept
* @author <a href="mailto:juengel@informatik.hu-berlin.de">Matthias Juengel</a>
*/ 

#ifndef __ObstaclesPercept_h_
#define __ObstaclesPercept_h_


#include "Tools/Streams/InOut.h"
#include "Tools/Math/Vector2.h"
#include "Tools/Streams/Streamable.h"
#include "Tools/ColorClasses.h"

/**
* The class represents perceived obstacles on the field.
*/
class ObstaclesPercept : public Streamable
{
  void serialize(In* in, Out* out)
  {
    STREAM_REGISTER_BEGIN();
    STREAM_DYN_ARRAY(segments, numberOfSegments);
    STREAM_ARRAY(freePartOfGoal);
    STREAM(frameNumber);
    STREAM_REGISTER_FINISH();
  }

public:
  enum ObstacleType {border, goal, teammate, opponent, unknown};
  enum {maxNumberOfSegments = 200}; /**< Specifies the maximum number of segments. */
  enum WhoseGoal{ownGoal = 0, opponentGoal = 1};

  class Segment : public Streamable
  {
    void serialize(In* in, Out* out)
    {
      STREAM_REGISTER_BEGIN();
      STREAM(nearPointOnField);
      STREAM(farPointOnField);
      STREAM(nearPointInImage);
      STREAM(farPointInImage);
      STREAM(farPointIsOnImageBorder);
      STREAM_ENUMASINT(obstacleType);
      STREAM_REGISTER_FINISH();
    }

  public:
    Vector2<double> nearPointOnField, /**< The nearest green point in ego-centric field coordinates. */
                    farPointOnField, /**< The most distant green point in ego-centric field coordinates. */
                    nearPointInImage, /**< The nearest green point in image coordinates. */
                    farPointInImage; /**< The most distant green point in image coordinates. */
    bool farPointIsOnImageBorder; /**< Indicates if the far point is an obstacle or the image border */
    ObstacleType obstacleType; /**< The type of the obstacle limiting free space. */

    Segment() : farPointIsOnImageBorder(false), obstacleType(unknown) {}
  };

  class FreePartOfGoal : public Streamable
  {
    void serialize(In* in, Out* out)
    {
      STREAM_REGISTER_BEGIN();
      STREAM(wasDetermined);
//    STREAM(angleLeft);
//    STREAM(angleRight);
      STREAM(leftEndSeen);
      STREAM(rightEndSeen);
      STREAM(directionAsAngle);
      STREAM(distanceOnField);
      STREAM(widthAsAngle);
      STREAM(leftInImage);
      STREAM(rightInImage);
      STREAM_REGISTER_FINISH();
    }

  public:
    bool wasDetermined; 
//  double angleLeft, angleRight;   // TODO: use this
    bool leftEndSeen, rightEndSeen;
    double directionAsAngle,
           distanceOnField,
           widthAsAngle;
    Vector2<int> leftInImage,
                 rightInImage;

    FreePartOfGoal() 
      : wasDetermined(false), 
//      angleLeft(0),
//      angleRight(0),
        directionAsAngle(0), 
        distanceOnField(0),
        widthAsAngle(0) 
    {
    }
  };

  void setFreePartOfGoal(colorClass goalColor, double angleToLeftEndpoint, double angleToRightEndpoint, bool leftEndpointSeen, bool rightEndpointSeen, const Vector2<int>& leftInImage, const Vector2<int>& rightInImage)
  {
    colorClass ownGoalColor = (getPlayer().getTeamColor()==Player::blue) ? skyblue : yellow;
    WhoseGoal index = (goalColor==ownGoalColor) ? ownGoal : opponentGoal;

    FreePartOfGoal& f = freePartOfGoal[index];
    f.directionAsAngle = (angleToLeftEndpoint + angleToRightEndpoint) / 2.0;
    f.widthAsAngle = angleToLeftEndpoint - angleToRightEndpoint;
//  f.angleLeft = angleToLeftEndpoint;  
//  f.angleRight = angleToRightEndpoint;
    f.leftEndSeen = leftEndpointSeen;
    f.rightEndSeen = rightEndpointSeen;
    f.leftInImage = leftInImage;
    f.rightInImage = rightInImage;
    f.distanceOnField = 1500; //TODO: Check if value is used
    f.wasDetermined = true;
  }

  /**
  * Constructor.
  */
  ObstaclesPercept() {reset(0);}

  /**
  * The function empties the obstacle percept.
  */
  void reset(unsigned long frameNumber);

  /**
  * The function adds a new pair of points to the obstacle percept.
  * @param segment The pair of points.
  */
  void add(const Segment& segment);

  Segment segments[maxNumberOfSegments]; /**< The obstacle points. */
  int numberOfSegments; /**< The number of pairs of points */
  FreePartOfGoal freePartOfGoal[2];

  /** The frame number when perceived. */
  unsigned long frameNumber;
};

#endif //__ObstaclesPercept_h_

---