Modules/ImageProcessor/GT2005ImageProcessor/GT2005CenterCircleFinder.h

Go to the documentation of this file.

#ifndef _GT2005CenterCircleFinder_h_
#define _GT2005CenterCircleFinder_h_

#include "Tools/Math/Vector2.h"
#include "Representations/Perception/Image.h"
#include "Tools/Math/Geometry.h"
#include "Representations/Perception/CameraMatrix.h"
#include "GT2005ImageProcessorTools.h"

class GT2005CenterCircleFinder
{
public:
  enum{
      maxNumberOfCandidatesPossible = 90,         //size of the array candidatePoints 
      houghDimensionX = 100,  //size of the 2-dim. array houghSpace in x-direction
      houghDimensionY = 50,   //size of the 2-dim. array houghSpace in y-direction
      radius = 180,         //the radius of the center-circle in mm
      areaOfInterestX = 3000, //areaOfInterest defines the area (relative to the robot) around the center-circle. this area will be divided 
      areaOfInterestY = 2000, //through a grid of the size: houghDimensionX * houghDimensionY (both in [mm])
      mEntry = 4,             //the minimum number of entries in a houghSpace-cell needed, in order to be able to assume that the
      mEntry2 = 15,  
      mEntry3 = 11,               //coordinates of the cell (x,y) is the midpoint of the center-circle.
      scanLength = 140,    
      minNumberOfPositives = 7, //number of positives scan tests
      minNumberOfPositivesForDistanceCheck = 4,
      enoughPros = 45,        
      maximalDistanceAllowedBetweenMidAndBorder = 290,
      maxNumberOfCandidatesMaxEntry = 150,
      acceptedAvgDistance  = 200,
      onlyWhiteAllowed = 2,
      numberOfScanLines = 8,
      neededWhiteCount = 2
      };
  


  GT2005CenterCircleFinder(const ColorCorrector& colorCorrector, const ColorTable& cTable);
  
  //reset: set numberOfCandidates to zero, initialize houghSpace and flagY 
  void reset();
  
  //candidates which are inside the area of interest, will be added to the array candidatePoints
  void addCandidate(Vector2<int>& candiOnField, Vector2<int>& candiOfImage);
  
  //determineCirclePoint() uses Hough-Transformation, in order to determine the midpoint of the center-circle
  void determineCirclePoint(const CameraMatrix& cameraMatrix, const Image& image, const RobotPose& robotPose, const CameraMatrix& prevCameraMatrix);

  bool circleFound;
 
  bool getCircle(Vector2<double>& mid);
  
  //Löschen!!!
  bool circle(Vector2<double>& mid)
  {
    if(circleFound)
      mid = midPoint;
    return(circleFound);
  }
  
  //Löschen!!!


private:
  struct Candidate
  {
    Vector2<double> pointOnField;
    Vector2<int> pointOfImage;
  };
  struct multipleCandidate
  {
    Vector2<double> pointOnField;
    int count;
    double avgDistance;
  };

   Vector2<double> midPoint;
  
  //candidatePoints manages the possible center-circle candidates
  Candidate candidatePoints[maxNumberOfCandidatesPossible];

  //number of entries in candidatePoints
  int numberOfCandidates;

  //the grid that will divide the area of interest. it´s origin (houghDimension[0][0]) is at the coordinates: 
  //houghDimensionX/2, houghDimensionY/2
  int houghSpace[houghDimensionX][houghDimensionY];

  //flagY[i] marks, if there is an entry in the 2-dim. array houghSpace[houghDimensionX][i] is made, so that not the whole area of interest has
  //to be checked for maximum entries
  bool flagY[houghDimensionY];

  //houghStepX = areaOfInterestX / houghDimensionX, so the areaOfInterestX should be divisible through houghStepX. 
  int houghStepX;
  int houghStepY;

  //max Quantization error in x-direction = houghStepX/2
  //max Quantization error in y-direction = houghStepY/2
  double maxQuantizationErrorX;
  double maxQuantizationErrorY;

  //for fading away the drawings of the circle, dependent on the time the midpoint was last seen
  int timeTillLastSeen;
  Vector2<double> midPointLastSeenField;
  Vector2<int> midPointLastSeenFieldInt;

  double lineThicknessRateAllowed;
  

  //transforms the indices of the array houghSpace to corresponding field-coordinates.
  //@xDirection: xDirection is true, if arrayIndex is a x-index
  //@fieldPosition: that is calculated field-position
  void transformArrayToField(int arrayIndex, bool xDirection, int& fieldPosition);

  //transforms the field-position inside the area of interest to the correspoinding array-index.
  //@xDirection: xDirection is true, if arrayIndex is a x-index
  //@arrayIndex: that is the calculated array-index
  void transformFieldToArray(double fieldPos, bool xDirection, int& arrayIndex);

  //checks the midpoint-candidate, given by the hough transformation
  void checkCircleMidpoint(Vector2<double> candidate, int absMaxEntry, const CameraMatrix& cameraMatrix, const Image& image, const RobotPose& robotPose, const CameraMatrix& prevCameraMatrix);

  //same as checkCircleMidpoint, but with more than one candidate
  void  checkCircleMidpoint2(int maxEntry, int NumberOfEntriesMaxEntry, multipleCandidate maxEntryFieldCoord[maxNumberOfCandidatesMaxEntry],                                const CameraMatrix& cameraMatrix,const Image& image, const RobotPose& robotPose,                                                               const CameraMatrix& prevCameraMatrix);

  bool scanSurrounding(Vector2<int> start, Vector2<double> startOnField, const CameraMatrix& cameraMatrix, const Image& image, const RobotPose& robotPose, const CameraMatrix& prevCameraMatrix);

 void scan(Vector2<int> start, Vector2<double> startOnField, Vector2<int> end, Vector2<int> step, int& positiveInNumberOfDirection, const CameraMatrix& cameraMatrix, const Image& image, const RobotPose& robotPose, const CameraMatrix& prevCameraMatrix,double& distance,                                         bool& positiv);

  //cameraMatrix and image will only be used, in order to transform the results from field-coordinates to image-coordinates, which will
  //display the result
  const ColorCorrector& colorCorrector; //needed for scanning
  const ColorTable& colorTable;


 
};


#endif //_GT2005CenterCircleFinder_h_

---