Representations/Perception/LinesPercept.h

Go to the documentation of this file.

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

#ifndef __LinesPercept_h_
#define __LinesPercept_h_

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

/**
* The class represents a percepted line on the field with its type and a Vector of points belonging to it.
*/
class LinesPercept : public Streamable
{
  public:
    enum {maxNumberOfPoints = 200}; /**< Specifies the maximum number of points per line type. */

    enum LineType
    {
      field,
      border,
      yellowGoal, 
      skyblueGoal,
//      sideOfPenaltyArea,
      numberOfLineTypes,
      redRobot = numberOfLineTypes,
      blueRobot,
      ball,
      numberOfTypes,
      xField = ball,
      yField,
      boundary
    }; /**< Defines the different kinds of lines. */

    
    enum {UNDEF = -4};

    class LinePoint : public Vector2<int>
    {
    public:
      double angle;

      LinePoint() {angle = UNDEF;}
      LinePoint(const Vector2<int>& v, double angle = UNDEF) 
      {
        x = v.x; 
        y = v.y; 
        this->angle = angle;
      }

      LinePoint& operator=(Vector2<int>& v) 
      {
        x = v.x; 
        y = v.y; 
        angle = UNDEF; 
        return *this;
      }

      void serialize(In* in, Out* out)
      {
        STREAM_REGISTER_BEGIN();
        STREAM_BASE(Vector2<int>);
        STREAM(angle);
        STREAM_REGISTER_FINISH();
      }
    };
    class LinePoints : public Streamable
    {
    public:
      LinePoint pointsOnField[ LinesPercept::maxNumberOfPoints]; /**< The points on lines. */
      LinePoint pointsInImage[ LinesPercept::maxNumberOfPoints];/**< The points on lines. */
      int numberOfPoints;

      void serialize(In* in, Out* out)
      {
        STREAM_REGISTER_BEGIN();
        STREAM_DYN_ARRAY( pointsOnField, numberOfPoints);
        STREAM_DYN_ARRAY( pointsInImage, numberOfPoints);
        STREAM_REGISTER_FINISH();
      }
    };

    LinePoints points[numberOfTypes];
    
    unsigned long frameNumber; /**< The frame number when perceived. */ 

    /** Defines what lies on the 4 "sides" of a line crossing*/
    enum CrossingCharacteristic {lineOnThisSide, noLineOnThisSide, dontKnow, numberOfCrossingCharacteristics}; 
    static const char* getCrossingCharacteristicName(CrossingCharacteristic id)
    {
      switch(id)
      {
        case lineOnThisSide: return "lineOnThisSide";
        case noLineOnThisSide: return "noLineOnThisSide";
        case dontKnow: default: return "dontKnow";
      }
    }

    class LineCrossingPoint : public Streamable
    {
    public:
      Vector2<int> locationOnField;
      Vector2<int> locationInImage;
      double angleOnField, angleInImage1, angleInImage2;
      CrossingCharacteristic side1,side2,side3,side4; // sides in mathematical positive order beginning from the one directly left of the orientation vector
      bool outOfImage;

      void serialize(In* in, Out* out)
      {
        STREAM_REGISTER_BEGIN();
        STREAM(locationOnField);
        STREAM(locationInImage);
        STREAM(angleOnField);
        STREAM(angleInImage1);
        STREAM(angleInImage2);
        STREAM_ENUM(side1, numberOfCrossingCharacteristics, LinesPercept::getCrossingCharacteristicName);
        STREAM_ENUM(side2, numberOfCrossingCharacteristics, LinesPercept::getCrossingCharacteristicName);
        STREAM_ENUM(side3, numberOfCrossingCharacteristics, LinesPercept::getCrossingCharacteristicName);
        STREAM_ENUM(side4, numberOfCrossingCharacteristics, LinesPercept::getCrossingCharacteristicName);
        STREAM(outOfImage);
        STREAM_REGISTER_FINISH();
      }
    };

    enum {maxNumberOfLineCrossings = 10};
    int numberOfLineCrossings;
    LineCrossingPoint lineCrossings[maxNumberOfLineCrossings];

    class CenterCircle : public Streamable
    {
    public:
      Vector2<int> location;
      double orientation; // angle of the center line (if detected)
      bool orientationKnown;

      void serialize(In* in, Out* out)
      {
        STREAM_REGISTER_BEGIN();
        STREAM(location);
        STREAM(orientation);
        STREAM(orientationKnown);
        STREAM_REGISTER_FINISH();
      }
    };
    CenterCircle centerCircle;
    bool centerCircleFound;

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

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

    /**
     * The function adds a new point to the lines percept.
     * @param type The line type of the point.
     * @param point The point.
     * @param angle The angle of the normal of the line.
     */
    void add(LineType type, const Vector2<int>& pointOnField, const Vector2<int>& pointInImage, 
                            double angleOnField = UNDEF, double angleInImage = UNDEF);

    void serialize(In* in, Out* out)
    {
      STREAM_REGISTER_BEGIN();
      STREAM(frameNumber);
      STREAM_ARRAY(points);
      STREAM_DYN_ARRAY(lineCrossings, numberOfLineCrossings);
      STREAM(centerCircle);
      STREAM(centerCircleFound);
      STREAM_REGISTER_FINISH();
    }
};

#endif //__LinesPercept_h_

---