Representations/Cognition/PlayerPoseCollection.h

Go to the documentation of this file.

/**
 * @file PlayerPoseCollection.h
 * 
 * Declaration of class PlayerPoseCollection
 * @author <A href=mailto:kspiess@informatik.uni-bremen.de>Kai Spiess</A>
 */ 

#ifndef __PlayerPoseCollection_h_
#define __PlayerPoseCollection_h_

#include "Representations/Cognition/RobotPose.h"
#include "Tools/Streams/InOut.h"
#include "Tools/Math/Pose2D.h"
#include "Tools/Player.h"
#include "Platform/SystemCall.h"


/**
 *  This class contains the informations about the PlayerPose 
 *  of a located robot. This is not for informations about the own robot.
 */
class PlayerPose
{
public:
  /** Constructor */
  PlayerPose(){speed = 0;playerNumber=Player::undefinedPlayerNumber;sigmaMin=-1;sigmaMaj=-1;timeStamp=0;}
  /** Copy-Constructor */
  PlayerPose(const PlayerPose& other){*this = other;};
  /** Destructor */
  ~PlayerPose(){};

  unsigned long frameNumber; /**< The frame number of the image that was used to create the percept. */
  
  void setFrameNumber(unsigned long frameNumber) {this->frameNumber = frameNumber;}

  /** sets the pose */
  void setPose(const Pose2D& p) {pose = p;}

  /** sets the pose */
  void setRobotPose(const RobotPose& p) 
  {
    pose = p.getPose();
    validity = p.getValidity();
    timeStamp = p.timestamp;
  }

  /** sets the pose */
  void setPose(const double& x, const double& y, const double& rotation)
  { pose.translation.x = x; pose.translation.y = y; pose.rotation = rotation; }

  /** returns the pose */
  const Pose2D& getPose() const {return pose;}

  /** sets the speed */
  void setSpeed(const double& _speed) {
    speed = _speed;
  }

  /** returns the speed */
  const double& getSpeed() const {return speed;}

  /** sets the validity */
  void setValidity(const double& v) {validity = v;}

  /** sets the player number */
  void setPlayerNumber(const Player::playerNumber p) {playerNumber = p;}

  /** sets the timestamp */
  void setTimeStamp(const long& t) {timeStamp = t;}

  /** returns the validity */
  const double& getValidity() const {return validity;}

  /** returns the playerRole */
  const Player::playerNumber& getPlayerNumber() const {return playerNumber;}

  /** return the timeStamp */
  const long& getTimeStamp() const {return timeStamp;}

  /** returns the player number as an Integer */
  int getPlayerNumberAsInt() const {return (int)playerNumber; }

  /** copies another PlayerPose to this one */
  void operator = (const PlayerPose& other);

  /** sets the sigmaMin */
  void setSigmaMin(const double sigma) {sigmaMin = sigma;}

  /** returns the sigmaMin */
  const double& getSigmaMin() const {return sigmaMin;}

  /** sets the sigmaMaj */
  void setSigmaMaj(const double sigma) {sigmaMaj = sigma;}

  /** returns the sigmaMaj */
  const double& getSigmaMaj() const {return sigmaMaj;}

  /** sets the cosAngle */
  void setCosAngle(const double cos) {cosAngle = cos;}

  /** returns the cosAngle */
  const double& getCosAngle() const {return cosAngle;}

  /** sets the sinAngle */
  void setSinAngle(const double sin) {sinAngle = sin;}

  /** returns the sinAngle */
  const double& getSinAngle() const {return sinAngle;}

private:
  /** The position and orientation of the player as a Pose2D */
  Pose2D pose;

  /** The speed of the player */
  double speed;

  /** The validity of the located robot */
  double validity;

  /** The variance in Min-direction */
  double sigmaMin;

  /** The variance in Maj-direction */
  double sigmaMaj;

  /** The cosinus of the angle of the variance-ellipse */
  double cosAngle;

  /** The sinus of the angle of the variance-ellipse */
  double sinAngle;

  /** These values are only needed for the own team */
  /** The last update of position */
  long timeStamp;

  /** Playernumber */
  Player::playerNumber playerNumber;
};

/**
 * Streaming operator that reads a PlayerPose from a stream.
 * @param stream The stream from which is read.
 * @param playerPose The PlayerPose object.
 * @return The stream.
 */ 
In& operator>>(In& stream,PlayerPose& playerPose);

/**
 * Streaming operator that writes a PlayerPose to a stream.
 * @param stream The stream to write on.
 * @param playerPose The PlayerPose object.
 * @return The stream.
 */ 
Out& operator<<(Out& stream, const PlayerPose& playerPose);



/**
 *  This class contains the PlayerPoses of all detected robots.
 */
class PlayerPoseCollection
{
public:
  /** Constructor */
  PlayerPoseCollection();

  /** Copy-Constructor */
  PlayerPoseCollection(PlayerPoseCollection& other);

  /** Destructor */
  ~PlayerPoseCollection();

  /** sets a player pose of the own team at a given index */
  void setOwnPlayerPose(int index, const PlayerPose& pose) {ownPlayerPoses[index] = pose;}

  /** sets a player pose of the own team at a given index */
  void setOwnPlayerPose(int index, const double& x, const double& y, const double& rotation) 
  {ownPlayerPoses[index].setPose(x,y,rotation);}

  /** sets a player pose of the own team at a given index */
  void setOwnPlayerPose(int index, const double& x, const double& y, const double& rotation, const double& validity) 
  {
    ownPlayerPoses[index].setPose(x,y,rotation);
    ownPlayerPoses[index].setValidity(validity);
  }

  /** sets a player pose of the own team at a given index */
/* 
  void setOwnPlayerPose(int index, const double& x, const double& y, 
                      const double& rotation,
                      const Player::playerNumber playerNumber,
                      const long timeStamp) 
  {
    ownPlayerPoses[index].setPose(x,y,rotation);
    ownPlayerPoses[index].setValidity(validity);
    ownPlayerPoses[index].setPlayerNumber(playerNumber);
    ownPlayerPoses[index].setTimeStamp(timeStamp);

  }
  */
  /** sets a player pose of the own team */
  void setOwnPlayerPose(const RobotPose pose, const Player::playerNumber playerNumber) 
  {
    if (numberOfOwnPlayers<4)
    {
      ownPlayerPoses[numberOfOwnPlayers].setRobotPose(pose);
      ownPlayerPoses[numberOfOwnPlayers].setPlayerNumber(playerNumber);
      ownPlayerPoses[numberOfOwnPlayers].setTimeStamp(SystemCall::getCurrentSystemTime());
      numberOfOwnPlayers++;
    }
  }
  /** returns a player pose of the own team for a given index */
  const PlayerPose& getOwnPlayerPose(int index) const {return ownPlayerPoses[index];}

  /** returns the player pose of the own team for a given player number */
  const bool getOwnPlayerPoseByPlayerNumber(Player::playerNumber player,PlayerPose& pose) const 
  {
    for (int i=0;i<numberOfOwnPlayers;i++)
    {
      if (ownPlayerPoses[i].getPlayerNumber() == player)
      {
        pose = ownPlayerPoses[i];
        return true;
      }
      else
        return false;
    }
    return false;
  }

  /** sets a player pose of the opponent team at a given index */
  void setOpponentPlayerPose(int index, const PlayerPose& pose) {opponentPlayerPoses[index] = pose;}

  /** sets a player pose of the opponent team at a given index */
  void setOpponentPlayerPose(int index, const double& x, const double& y, const double& rotation) 
  {opponentPlayerPoses[index].setPose(x,y,rotation);}

  /** sets a player pose of the opponent team at a given index */
  void setOpponentPlayerPose(int index, const double& x, const double& y, const double& rotation, const double& validity) 
  {
    opponentPlayerPoses[index].setPose(x,y,rotation);
    opponentPlayerPoses[index].setValidity(validity);
  }
  
  /** returns a player pose of the opponent team for a given index */
  const PlayerPose& getOpponentPlayerPose(int index) const {return opponentPlayerPoses[index];}

  /** copies another PlayerPoseCollection to this one */
  void operator = (const PlayerPoseCollection& other);

  /** Number of located opponent robots */
  int numberOfOpponentPlayers;

  /** Number of located own robots */
  int numberOfOwnPlayers;

  /** give the In operator acess to protected members */
  friend In& operator>>(In& stream,PlayerPoseCollection& playerPoseCollection);

  /** give the Out operator acess to protected members */
  friend Out& operator<<(Out& stream, const PlayerPoseCollection& playerPoseCollection);

protected:
  /** A list of located opponent robots */
  PlayerPose opponentPlayerPoses[4];

  /** A list of located own robots */
  PlayerPose ownPlayerPoses[3];
};

/**
 * Streaming operator that reads a PlayerPoseCollection from a stream.
 * @param stream The stream from which is read.
 * @param playerPoseCollection The PlayerPoseCollection object.
 * @return The stream.
 */ 
In& operator>>(In& stream,PlayerPoseCollection& playerPoseCollection);
 
/**
 * Streaming operator that writes a PlayerPoseCollection to a stream.
 * @param stream The stream to write on.
 * @param playerPoseCollection The PlayerPoseCollection object.
 * @return The stream.
 */ 
Out& operator<<(Out& stream, const PlayerPoseCollection& playerPoseCollection);


#endif //__PlayerPoseCollection_h_

---