Modules/ImageProcessor/RasterImageProcessor/RFieldSpecialist.h

Go to the documentation of this file.

/**
* @file Modules/ImageProcessor/RasterImageProcessor/RFieldSpecialist.h
* 
* Declaration of RFieldSpecialist.h
*
* @author <A href="damd@free.fr">DEOM Damien</A>
* 
*/

#ifndef RFIELDSPECIALIST_H
#define RFIELDSPECIALIST_H

/** 
  * @class RFieldSpecialist
  *
  * This class regognizes lines on the field, and the intersection of them.
  * The most important points are shown: corners, goal points ...
  */

#include "RasterSpecialist.h"
#include "RasterStrategy.h"
#include "Modules/ImageProcessor/RasterImageProcessor/REdgeDetection.h"
#include "Modules/ImageProcessor/ImageProcessorTools/SegmentationTools.h"
#include "Tools/Location.h"

using namespace std;


class RFieldSpecialist :public RasterSpecialist  {

public:

  typedef slist<LinePair2> lstLinePair;
  typedef slist<figure> lstFig;

  //! The default constructor and destructor
  RFieldSpecialist(RasterImageProcessor &processor,RasterStrategy &strategy);
  virtual ~RFieldSpecialist();

  //! Returns the id of the specialist
  virtual int getType();

  /**
  * Clears the buffers of points
  * @see lst_pts
  * @see segments_img
  */
  virtual void init();  

  /**
  *  Function called by a given Strategy class
  *  Calling it one time stores the given coordinates in a temporar vector
  *  Calling it a second time creates an horizontal linepair and stores
  *  it in the linepair buffer
  *  @see lst_pts
  */
  void invokeOnPreScan(int x,int y);

  //! unused in this specialist
  void invokeOnPostScan(int x, int y);

  /**
  *  Function called in the post scan section of the RDefaultStrategy
  *  when a line has been recognized
  *  @param type the type of the line
  *  @param pt the first oint of the line
  *  @param id the id of the scan line where the line has been found
  *
  *  The point is then stored in a vector of points
  *  @see segments_img
  */
  void addLinePoint(LinesPercept::LineType type, point & pt, int& id);

  /**
  * Processing phase of the points 
  * @see lst_pts
  * @see segments_img
  */
  void executePostProcessing();

private:
    
  //! a pointer to the strategy tha scan the image
  RasterStrategy *strategy;

//! the scanner for adjusting the incoming point coordinates
  REdgeDetection edgeScanner;

  /**
  * this structure contains important parameters for the line recognition:
  * @param min_size minimum number of sub lines required to form a line.
  * @param step number of points to junp in order to form a sub line
  * @param tol_alpha angular tolerance related to the sub lines (in degrees).
  */
  struct processParam {
    unsigned int min_size;
    unsigned int step_alpha;
    unsigned int tol_alpha;

    processParam(): min_size(6), step_alpha(5),
      tol_alpha(20) {}
  };

  //! the default parameter set
  processParam* defaultParam;

  /**
  * List of points stored during the horizontal scan
  */
  lstFig lst_pts;

  /**
  *  Temporar points
  */
  point temp;
  LinesPercept::LineType lineInside;

  /**
  * id of the incoming line
  */
  inline int id(LinesPercept::LineType);
  inline LinesPercept::LineType id(int i) ;

  /**
  * line recognition
  * @param inputList input list containing the points to analyse
  * @param linePairList the list of recognized lines
  * @param param the 3 parameters defined above
  * @return a boolean that indicate if a line has been created
  */
  bool makeLines(lstFig& inputList, lstLinePair& linePairList, const processParam* param);

  /**
  * The resulting lines
  */ 
  vector <lstLinePair> vecLines;

  /**
  * The edges coming from the post scan method 
  * @see RDefaulstrategy2
  */
  vector <lstFig> segments_img;

  /**
  * fusion spaced lines having the same angle value
  */
  void fusionLines(lstLinePair& lst);

  /**
  * id of the incoming goal line
  */
  enum goal_line {
    NONE = 0,  /*!< No line */  
    YELLOW,    /*!< Yellow goal line */  
    SKYBLUE    /*!< Skyblue goal line */ 
  };   

  /**
  *  Computes the intersction of the lines and shows the result
  */
  unsigned int analyzeLines();

  /**
  * open challenge related function 
  * computes the angle of the ramp (must be a red line) and generate 
  * the corresponding line percept
  */
  void checkRamp(lstLinePair &ramp);

  /**
  * debug related functions
  */
  void drawCross(goal_line g, point& v);
  void drawCircle(goal_line g, point& v);
  void drawLine(goal_line g, LinePair2& lp);

};

#endif

/*
* Change log :
* 
* $Log: RFieldSpecialist.h,v $
* Revision 1.8  2004/09/09 11:08:04  spranger
* renamed GT2004EdgeDetection to REdgeDetection for consistency
*
* Revision 1.7  2004/09/08 14:39:02  wachter
* - Fixed some doxygen-errors
*
* Revision 1.6  2004/09/07 16:01:15  deom
* Documentation corrected
*
* Revision 1.5  2004/09/06 12:02:26  schmidtb
* commented almost all members, removed warnings in documentation

* did further code clean up
*
* Revision 1.4  2004/09/02 09:31:19  deom
* commented rfieldspecialist
*
* Revision 1.3  2004/09/02 07:59:29  schmidtb
* Added RasterImageProcessor to repository, because we used it for the OpenChallenge.
*
* Revision 1.26  2004/06/04 12:43:05  deom
* optimized
*
* Revision 1.25  2004/06/02 16:03:53  deom
* merged different versions of FieldSpecialist
*
* Revision 1.24  2004/05/27 16:49:47  deom
* new parameter set + some minor changes
*
* Revision 1.23  2004/05/22 19:03:40  deom
* -now recognizes the red line
* -all the data required for the positionning are computed
*
* Revision 1.17  2004/05/22 16:56:39  pg_dade
* -now recognizes the red line
* -all the data required for the positionning are computed
*
* Revision 1.16  2004/04/15 19:08:34  pg_besc
* merged code
*
* Revision 1.20  2004/03/29 15:25:16  deom
* - the basical segmentation tools are now fast completely debbuged.
* - seem to work pretty good now
* - somes parameters need to be tuned
*
* Revision 1.19  2004/03/23 15:50:26  deom
* now uses two scan methods
*
* Revision 1.18  2004/03/21 21:59:06  deom
* The new scan functions intergrated to RfieldSpecialist. The lines recognition works at 90%
*
* Revision 1.17  2004/03/20 10:47:28  roefer
* Don't check in files that do not compile.
* If you declare functions, implement them, too.
* Global functions implemented in header files must be declared inline.
*
* Revision 1.16  2004/03/19 22:06:49  deom
* now based on  the segmentationTools class
*
* Revision 1.15  2004/03/15 01:17:36  deom
* debugged, now recognizes all predetermined forms
*
* Revision 1.14  2004/03/14 12:51:58  deom
* added an accurate scan method
*
* Revision 1.13  2004/03/12 14:39:13  deom
* debugged
*
* Revision 1.12  2004/03/12 01:37:58  deom
* added some functions required for the lines analysis
*
* Revision 1.11  2004/03/11 19:21:01  deom
* pursued debugging and parametrisation
*
* Revision 1.10  2004/03/11 12:19:00  deom
* debbuged RFieldspecialist
*
* Revision 1.9  2004/03/01 14:17:25  koh
* added new strategy "RFlexibleStrategy" + new specialist "EnemyOnlySpecialist";
* changed references to "RDefaultStrategy" to references to "RasterStrategy" in RFieldSpecialist
* added Geometry::Line horizon to "RasterStrategy"
*
* Revision 1.8  2004/03/01 12:14:41  wachter
* Bug commented out.
*
* Revision 1.7  2004/02/29 20:06:16  deom
* detects complex lines ( but need to be debuged)
*
* Revision 1.6  2004/02/22 19:12:54  deom
* now recognize simple lines
*
* Revision 1.4  2004/02/16 05:00:48  deom
* basical version that show edges
*
* Revision 1.3  2003/12/15 13:55:32  schmidtb
* Merged and patched new version of RasterImageProcessor.
*
* Revision 1.2  2003/12/08 15:02:55  schmidtb
* new version of RIP
*
* Revision 1.1  2003/12/04 09:50:26  schmidtb
* Added RFieldSpecialist
*
* Revision 1.5  2003/12/02 21:59:02  schmidtb
* New version of RasterImageProcessor
*
* Revision 1.4  2003/11/28 14:50:01  dueffert
* bugs and warnings fixed
*
* Revision 1.3  2003/11/20 10:26:56  schmidtb
* Ball Detection added
*
* Revision 1.2  2003/11/13 10:41:29  schmidtb
* renewed RBallSpeciaslist and Strategy
*
* Revision 1.1  2003/11/12 13:13:20  schmidtb
* new RasterImageProcessor added
*
*
*/

---