Modules/ImageProcessor/RasterImageProcessor/BoxSpecialist.h

Go to the documentation of this file.

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


#include "RasterSpecialist.h"
#include "Tools/Math/Geometry.h"
#include "Tools/Math/Vector2.h"
#include "RasterStrategy.h"
#include "Tools/Math/Vector3.h"
#include <list>
#include <vector>
#include <algorithm>
#include "Representations/Perception/LandmarksPercept.h"
#include "Modules/ImageProcessor/RasterImageProcessor/REdgeDetection.h"

using namespace std;

/** @class BoxSpecialist
* This class implements the landmark and goal detection algorithms of the RIP.*/
class BoxSpecialist :public RasterSpecialist
{

public:
/** @class Rectangle
* Struct that represents a rectangle.*/
  struct Rectangle {
    /** Upper left point.*/
    Vector2<double> upperLeft;
    /** Upper right point.*/
    Vector2<double> upperRight;
    /** Bottom left point.*/
    Vector2<double> bottomLeft;
    /** Bottom right point.*/
    Vector2<double> bottomRight;
    /** Center point of the rectangle.*/
    Vector2<double> center;
  };
/** @class SegmentInfo
* This struct holds information about a segment in the image.*/
  struct SegmentInfo {
    /** Constructor */
    SegmentInfo();
    /** Vote for a landmark with yellow.*/
    double lmValidityYellow;
    /** Vote for a landmark with blue.*/
    double lmValiditySkyblue;
    /** Vote for a goal.*/
    double goalValidity;
    /** Durrounding rectangle, aligned to horizon.*/
    Rectangle rect;
    /** Number of yellow pixels.*/
    int yellow;
    /** Number of skyblue pixels.*/
    int skyblue;
    /** Number of pink pixels.*/
    int pink;
    /** Number of pixels.*/
    int size;
    /** Bottom color of a landmark.*/
    colorClass bottomColor;
    /** Top color of a landmark.*/
    colorClass topColor;
    /** Pointer to the list of runs.*/
    list<LinePair>* segment;
  };

  typedef Geometry::Line Line;
  typedef vector<list<RasterSpecialist::LinePair> > SVector;
  /** Constructor
  *
  *   @param processor Image processor interfaces.
  *   @param strategy A strategy is needed for creation (this will change).
  */
  BoxSpecialist(RasterImageProcessor &processor,RasterStrategy &strategy);
  /** Destructor */
  virtual ~BoxSpecialist();
  /** Invokes the specialist in the second scan stage at position (x,y) 
    * (this member should be replaced later).
    *   @param x The x coordinate.
    *   @param y The y coordinate.  
    */
  void invokeOnPostScan(int x, int y);
  /** Executes the detection algorithm. */
  void executePostProcessing(); 
  /** Invokes the specialist in the first scan stage at position (x,y)
    * (this member should be replaced later).
    *   @param x The x coordinate.
    *   @param y The y coordinate.*/
  void invokeOnPreScan(int x,int y);
  
  /** Getter for member type.
  *   @return The type of the specialist.*/
  virtual int getType();
  /** Initializes the specialist.*/
  virtual void init();

private:
  /** The strategy.*/
  RasterStrategy *strategy;
  /** The edge detector.*/
  REdgeDetection edgeScanner;
  /** List of LinePairs. The input data of the detection algorithm.*/
  std::list<LinePair> lst_pts;
  /** The calculated horizon.*/
  Geometry::Line horizon;
  /** The calculated perpendicular to the horizon.*/
  Geometry::Line pHorizon;
  /** The threshold for edge-scans of the landmark detection.*/
  int flagThreshold;
  /** The threshold for edge-scans of the goal detection.*/
  int goalThreshold;
  /** A temporary variable.*/
  Vector2 <int> left_border;
  /** The clustered runs.*/
  std::vector<list<LinePair> > segments_img;
  /** The calculated informations about the segments.*/
  std::vector<SegmentInfo> infos_img;
  /** The bottomPoints of the goal (edges from green to yellow or skyblue).*/
  std::vector<Vector2<int> > bottomPoints;
  /** Creates the bounding box aligned to the horizon for each region.*/  
  void createBBox();
  /** The goal detection algorithm. 
  *   If a goal was found, a percept will be gemerated. 
  *   @param goal SegmentInfo of a region that might be a goal.
  *   @return Returns if the related region is detected as a goal.
  */
  bool searchGoal(SegmentInfo& goal);     
  /** The detection algorithm for landmarks. If one is found a percept
  *   will be generated.
  *
  *   @param flag SegmentInfo of a region that might be a landmark.
  *   @return Returns if the related region is detected as a landmark.
  */
  bool searchLandmark(SegmentInfo& flag);
  /** This function detects the accurate shape of a landmark.   
  *   
  *   @param flag SegmentInfo of a region that was detected as a landmark.
  */
  void fitLandmark(SegmentInfo& flag);
  /** Detects the free part of the goal and generates a percept. This function
  *   is not completed yet.
  */
  void detectFreePartOfGoal();    
  /** Fusions the regions that belong to the same goal. This function is not
  *   completed yet. But the algorithm is tested.
  */
  void fusionGoal();  
  /** Merges two regions. The result is stored in seg1.
  *   @param seg1 The first region.
  *   @param seg2 The second region.
  */
  void mergeBoxes(SegmentInfo& seg1,SegmentInfo& seg2);
  /** Counts the colors of segment si. And stores the result in si.
  *   @param si SegmentInfo of the region.
  *   @param segment List of runs.
  */
  void countColors(SegmentInfo& si, list<LinePair>& segment);
  /** A small test for goals.
  *   @return A validation value.*/ 
  inline bool missingData(bool ulc, bool urc, bool brc, bool blc, int i); 

  void calculateAnglesForPoint
  (
    /** */
    const Vector2<double>& point, 
    /** */
    const CameraMatrix& cameraMatrix, 
    /** */
    const CameraInfo& cameraInfo, 
    /** */
    Vector2<double>& angles
  );  

  bool calculatePointOnField
  (
    /** */
    const double x,
    /** */
    const double y,
    /** */
    const CameraMatrix& cameraMatrix,
    /** */
    const CameraInfo& cameraInfo,
    /** */
    Vector2<int>& pointOnField
  );
  /** Creates the validity values for the different kinds of objects.
  *   The result is stored in info.
  *   @param info The info represents a region.
  */
  void createValidities(SegmentInfo& info);
};

#endif

---