Modules/ImageProcessor/RasterImageProcessor/RBridgeSpecialist.h

Go to the documentation of this file.

/**
* @file RBridgeSpecialist.h
* 
* This file contains the definition of class RBridgeSpecialist.
*
* @author <a href="mailto:sadprofessor@web.de">Bernd Schmidt</a>
*/
#ifndef RBridgeSpecialist_H
#define RBridgeSpecialist_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 RBridgeSpecialist
*
*/
class RBridgeSpecialist :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();
    
    /** A vote for beacon with yellow.*/
    double lmValidityYellow;
    /** A vote for beacon with orange.*/
    double lmValidityOrange;
    /** The bounding box aligned to the horizon.*/
    Rectangle rect;
    /** Number of yellow pixels.*/
    int yellow;
    /** Number of skyblue pixels.*/
    int skyblue;
    /** Number of orange pixels.*/
    int orange;
    /** The number of pixels.*/
    int size;
    /** The left color of a bite-mark.*/
    colorClass leftColor;
    /** The right color of a bite-mark.*/
    colorClass rightColor;
    /** A pointer to the related region.*/
    list<LinePair>* segment;
  };

  typedef Geometry::Line Line;
  typedef vector<list<RasterSpecialist::LinePair> > SVector;



  /** Constructor
  *
  *   @param processor The image processor interfaces.
  *   @param strategy The strategy.
  */
  RBridgeSpecialist(RasterImageProcessor &processor,RasterStrategy &strategy);
  /** Destructor*/
  virtual ~RBridgeSpecialist();
  /** 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);
  /** Returns the type of specialist.
  *   @return Type of specialist.
  */
  virtual int getType();
  /** Initializes the specialist.*/
  virtual void init();

private:
  /** The color of the line behind the bite-marks.*/
  colorClass lineColor;
  /** The strategy.*/
  RasterStrategy *strategy;
  /** The edge scanner.*/
  REdgeDetection edgeScanner;
  /** The runs, which are the input data.*/
  std::list<LinePair> lst_pts;
  /** The calculated horizon.*/
  Geometry::Line horizon;
  /** A perpendicular to the horizon.*/
  Geometry::Line pHorizon;
  /** A Temporary variable.*/
  Vector2 <int> left_border;
  /** The regions, the runs are clustered to.*/
  std::vector<list<LinePair> > segments_img;
  /** Additional data to the regions.*/
  std::vector<SegmentInfo> infos_img;

  /** Builds the bounding boxes of the calculated regions.*/
  void createBBox();
  /** 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);
  /** Detects a bridgeMark, if the region is one. And stores it in
  *   the bite-point percept.
  *   @param si Additional data to the segment.
  */
  void findBridgeMark(SegmentInfo& si);
  /**
  *   Calculates the position of a mark, depending on its colors.
  *
  *   @param mark
  *   @return The position of the mark.
  */
  BitePoint::Position getPosition(SegmentInfo& mark);


  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
  );
  /** Calculates the validities for the several kinds of marks.
  *   The result is stored in info.
  *   @param info input
  */
  void createValidities(SegmentInfo& info);
};

#endif

---