Modules/ImageProcessor/RasterImageProcessor/RFieldStateMachine.h

Go to the documentation of this file.

/**
* @file RFieldStateMachine.h
* 
* This file contains the definition of class RFieldStateMachine.
*
* @author <a href="mailto:sadprofessor@web.de">Bernd Schmidt</a>
*/
#ifndef _RFieldStateMachine_h_
#define _RFieldStateMachine_h_


#include "Modules/ImageProcessor/RasterImageProcessor/REdgeDetection.h"

/**
* @class RFieldStateMachine
*
* This class represents a deterministic state machine.
* The machine has the ability to determine
* the object-type of an edge-point found on
* the field.
* The scans should go from the horizon to the ground.
* It is not really needed to scan perpendicular to the
* horizon.
* The machine is reading from the buffers of the edgeDetection
* and changes its states automaticly. For this the client should
* call reset() before every scan and then use a buffered scan to
* an edge to fill the buffer. After this call update() to update
* the state of the machine and continue the scan. So the client has
* to call update() after an edge is found or the scan is finished.
*
*
* @author <A href=mailto:sadprofessor@web.de>Bernd Schmidt</A>
*/
class RFieldStateMachine 
{
    
public:
  
  /** Different point types.*/
  enum PointTypes {
    nothing = 0,
    blueRobot,
    redRobot,
    border,
    line,
    ball,
    skyblueGoal,
    yellowGoal,
    unknown,
    numberOfPointTypes
  };

  /** The different states.*/
  enum FIELD_STATES{
    START = 0,
    FOUND_WHITE,
    FOUND_FIELD,
    FOUND_BORDER,
    LINE_IN,
    LINE_OUT,
    YELLOW_GOAL,
    YELLOW_FINISHED,
    SKYBLUE_GOAL,
    SKYBLUE_FINISHED,
    FOUND_RED_ROBOT,
    FOUND_BLUE_ROBOT,
    FINISHED_BLUE_ROBOT,
    FINISHED_RED_ROBOT,
    FOUND_BALL,
    FINISHED_BALL,
    FOUND_UNKNOWN,
    FINISHED_UNKNOWN
  };
  
  /** Constructor */
  RFieldStateMachine();
  /** Destructor */
  ~RFieldStateMachine();

  /** Updates the state machine after a scan.
  * 
  *   @param x current x-coordinate.  
  *   @param y current y-coordinate.
  *   @param scanner Reference of the edge scanner.
  */
  void update(int x,int y,REdgeDetection& scanner);
  /** Resets the state machine. The first point is setted to (x,y).
  *   
  *   @param x x-coordinate
  *   @param y y-coordinate
  */
  void reset(int x,int y);
  /** Returns one of the detected edge points.
  *   
  *   @param index The index of the point.
  *   @return The edge point as Vector2<int>
  */
  inline Vector2<int> getEdge(int index){
    return edgeBuffer[index];
  }
  /** Returns the type of one of the detected edge points.
  *   
  *   @param index The index of the point.
  *   @return The type of a edge point.
  */
  inline PointTypes getType(int index){
    return types[index];
  }
  /** Returns the number of edges found after the last reset.
  *   @return Number of edge points.
  */
  inline int size(){
    return numberOfEdges;
  }
  /** Tells if the machine determined a obstacle and its free space.
  *   @return True, if the machine determined a obstacle after the last reset.
  */
  inline bool foundObstacle(){
    return obstacleNearPoint != -1 && obstacleFarPoint != -1;
  }
  /** Returns the near point of the detected obstacle space.
  *   @return The near obstacle point.
  */
  inline Vector2<int>& nearPoint(){
    return edgeBuffer[obstacleNearPoint];
  }
  /** Returns the far point of the detected obstacle space.
  *   @return The far obstacle point.
  */
  inline Vector2<int>& farPoint(){
    return edgeBuffer[obstacleFarPoint];
  }
  /** Returns the type of the obstacle.
  *   @return The obstacle type.
  */
  inline ObstaclesPercept::ObstacleType getObstacleType(){
    switch (types[obstacleFarPoint]){
    case blueRobot: 
      if(getPlayer().getTeamColor() == Player::blue) 
          return ObstaclesPercept::teammate;
      else
        return ObstaclesPercept::opponent;
      
    case redRobot:
      if(getPlayer().getTeamColor() == Player::red)
          return ObstaclesPercept::teammate;
      else
        return ObstaclesPercept::opponent;
    case border:    return ObstaclesPercept::border;
    case yellowGoal: return ObstaclesPercept::goal;
    case skyblueGoal: return ObstaclesPercept::goal;
    case unknown: return ObstaclesPercept::unknown;
    default: return ObstaclesPercept::unknown;      
    }
  }

private :

  /** Calculates the next state.*/
  void findNextState();
  /** Executes the active state.*/
  void executeState();
  /** Current color.*/
  colorClass color;
  /** The range between the last two edges.*/
  int range;
  /** The sum of ranges since the last reset.*/
  int rangeSum;
  /** The sum of the green range.*/
  int greenRange;
  /** The sum of the white range.*/
  int whiteRange;
  /** The sum of the gray range.*/
  int grayRange;
  /** Temporary variable.*/
  bool isUnknownBot;
  /** The edge buffer.*/
  Vector2<int> edgeBuffer[20];
  /** The start point stored at the last reset*/
  Vector2<int> start;
  /** The type buffer.*/
  PointTypes types[20];
  /** The active state.*/
  FIELD_STATES state;
  /** The number of edges found since last reset.*/
  int numberOfEdges;
  /** The far point of the obstacle.*/
  int obstacleFarPoint;
  /** The near point of the obstacle.*/
  int obstacleNearPoint;

};

#endif   //  _RFieldStateMachine_h_

/*
* Change log :
* 
* $Log: RFieldStateMachine.h,v $
* Revision 1.6  2004/09/09 11:08:05  spranger
* renamed GT2004EdgeDetection to REdgeDetection for consistency
* 
* Revision 1.5  2004/09/09 10:15:55  spranger
* fixed doxygen-errors
* 
* Revision 1.4  2004/09/06 12:02:25  schmidtb
* commented almost all members, removed warnings in documentation

* did further code clean up
* 
* Revision 1.3  2004/09/02 07:59:29  schmidtb
* Added RasterImageProcessor to repository, because we used it for the OpenChallenge.
* 
* Revision 1.3  2004/05/25 13:27:33  schmidtb
* modified version of rip for open-challenge
* 
* Revision 1.2  2004/03/25 15:29:04  pg_besc
* made some changes
* 
* Revision 1.1  2004/03/17 22:12:39  schmidtb
* established RFieldStateMachine
* 
*
*/

---