Representations/Perception/BallPercept.h

Go to the documentation of this file.

/**
* @file BallPercept.h
*
* Declaration of class BallPercept
*
* @author <A href=mailto:roefer@tzi.de>Thomas Röfer</A>
* @author <a href="mailto:juengel@informatik.hu-berlin.de">Matthias Juengel</a>
* @author <a href="mailto:walter.nistico@uni-dortmund.de">Walter Nistico</a>
*/ 


#ifndef __BallPercept_h_
#define __BallPercept_h_

#include "Tools/Streams/InOut.h"
#include "Tools/Math/Vector2.h"
#include "Tools/Math/Vector3.h"
#include "Tools/Math/Common.h"
#include "Tools/FieldDimensions.h"
#include "Tools/RobotConfiguration.h"
#include "MultipleBallPerceptElement.h"
#include "MultipleBallPerceptList.h"

/**
* Contains a percept for a ball
*/ 
class BallPercept;

class BallPercept : public Streamable
{
  void serialize(In* in, Out* out)
  {
    STREAM_REGISTER_BEGIN();
    STREAM(ballWasSeen);
    STREAM(offsetOnField);
    STREAM(bearingBasedOffsetOnField);
    STREAM(sizeBasedOffsetOnField);
    STREAM(centerInImage);
    STREAM(radiusInImage);
    STREAM(reliability);
    STREAM(isCameraMatrixValid);
    STREAM(multiplePercepts);
    STREAM(frameNumber);
    STREAM_REGISTER_FINISH();
  }

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

  /** The functions resets the percept. */
  void reset(unsigned long frameNumber) {this->frameNumber = frameNumber; ballWasSeen = false;}

  /** The function adds a seen ball to the percept */
  void add(const Vector2<double>& offsetOnField,
    const Vector2<double>& bearingBasedOffsetOnField,
    const Vector2<double>& sizeBasedOffsetOnField,
    const Vector2<double>& centerInImage,
    double radiusInImage,
    double reliability,
    bool isCameraMatrixValid);

  /** Adds a seen ball to the percept, specifing its center and radius in image coords and additionally its reliability */
  void addHighRes(const Vector2<int>& centerInPixel,
                  const Vector2<double>& centerAsAngles,
                  double radiusInPixel,
                  double radiusAsAngle,
                  const Vector3<double>& translationOfCamera,
                  bool isCameraMatrixValid,
                  double reliability);

  bool ballWasSeen; /**< Indicates if the ball was seen. */
  Vector2<double> offsetOnField; /**< Ball offset based interpolated between size based and bearing based. */
  Vector2<double> bearingBasedOffsetOnField; /**< Ball offset based on intersection with the field plane. */
  Vector2<double> sizeBasedOffsetOnField; /**< Ball offset based on the size in the image. */
  Vector2<double> centerInImage; /**< The center of the ball in image coordinates. */
  double radiusInImage; /**< The center of the ball in image coordinates. */
  double reliability; /**< The reliability of the percept. */
  bool isCameraMatrixValid; /**< Indicates, whether the camera matrix was reliable when the percept was created. */
  MultipleBallPerceptList multiplePercepts; /**< Array stores the multiple ball percepts, ordered by reliability */
  unsigned long frameNumber; /**< The frame number of the image that was used to create the percept. */

private:
  void checkOffset(Vector2<double>& offset) const;

  /** Calculates ball position based on intrinsic camera parameters, instead of opening angle width*/
  //void getOffsetIntrinsic(Vector2<double>& offset) const;
};

#endif //__BallPercept_h_

---