Modules/ImageProcessor/VLCImageProcessor/VLCCenterCircleFinder.h

Go to the documentation of this file.

#ifndef _VLCCenterCircleFinder_h_
#define _VLCCenterCircleFinder_h_

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

class VLCCenterCircleFinder
{
public:
  enum{
      maxNumber = 50,         //size of the array candidatePoints 
      mergeDistance = 30,     //2 candidates, which have got a distance smaller than 30mm, will be merged--> take average of the points
      houghDimensionX = 120,  //size of the 2-dim. array houghSpace in x-direction
      houghDimensionY = 50,   //size of the 2-dim. array houghSpace in y-direction
      radius = 32400,         //the radius of the center-circle in [mm^2]
      areaOfInterestX = 2400, //areaOfInterest defines the area (relative to the robot) around the center-circle. this area will be divided 
      areaOfInterestY = 1000, //through a grid of the size: houghDimensionX * houghDimensionY (both in [mm])
      aMaxEntry = 6,          //the minimum number of entries in a houghSpace-cell needed, in order to be able to assume that the
                              //coordinates of the cell (x,y) is the midpoint of the center-circle.
      mEntry = 6              //aMaxEntry is the absolute-maximum-entry(only one candidate with the maximum value) 
                              //and mEntry is the maximumEntry(more than one candidate with the maximum value)
      };
  


  VLCCenterCircleFinder(const CameraMatrix& cMatrix, const Image& im);
  
  //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();

  bool circleFound;
  Vector2<double> midPoint;
  bool getCircle(Vector2<double>& mid);
  


private:
  struct Candidate
  {
    Vector2<double> pointOnField;
    Vector2<int> pointOfImage;
  };
  
  //candidatePoints manages the possible center-circle candidates
  Candidate candidatePoints[maxNumber];

  //circlePoints will be initialized with true. a cell circlePoints[i] will be set to false, if the candidate in candidatePoints[i] for sure
  //is not a candidate
  bool circlePoints[maxNumber];

  //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 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. 
  //Quantization error = houghStepX/2
  int houghStepX;
  int houghStepY;
  

  //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);

  //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 CameraMatrix& cameraMatrix;
  const Image& image;

  

  

  
  


};


#endif //_VLCCenterCircleFinder_h_

---