Modules/ImageProcessor/GT2004ImageProcessor/GT2004BallSpecialist.h

Go to the documentation of this file.

/**
* @file GT2004BallSpecialist.h
* 
* This file contains a class for Image Processing.
* @author <A href=mailto:juengel@informatik.hu-berlin.de> Matthias Juengel</A>
* @author Max Risler
* @author <A href=mailto:brunn@sim.tu-darmstadt.de> Ronnie Brunn</A>
* @author <A href=mailto:mkunz@sim.tu-darmstadt.de> Michael Kunz</A>
* @author <a href="mailto:walter.nistico@uni-dortmund.de">W alter Nistico</a>
*/

#ifndef __GT2004BallSpecialist_h_
#define __GT2004BallSpecialist_h_

#include "Tools/Math/Geometry.h"
#include "Tools/Debugging/DebugImages.h"
#include "Representations/Perception/ColorTable.h"
#include "Representations/Perception/Image.h"
#include "Representations/Perception/CameraMatrix.h"
#include "Representations/Perception/BallPercept.h"
#include "Modules/ImageProcessor/ImageProcessorTools/ColorCorrector.h"
#include "Modules/ImageProcessor/ImageProcessorTools/BresenhamLineScan.h"
#include "Tools/Math/Common.h"

/**
The BallSpecialist finds a single ball in an image.
*/
class GT2004BallSpecialist  
{
public:
  GT2004BallSpecialist(const ColorCorrector& colorCorrector);
  
  /** 
  * Searches for the ball in the image, starting from the secified point. 
  */
  void searchBall
  (
    const Image& image,
    const ColorTable& colorTable,
    const CameraMatrix& cameraMatrix,
    const CameraMatrix& prevCameraMatrix,
    int x, int y,
    BallPercept& ballPercept
  );
  
  /**
  * Returns the Similarity of the given color to orange.
  */
  unsigned char getSimilarityToOrange (unsigned char y, unsigned char u, unsigned char v)
  {
/*      double r = y + 1.140 * (u - 128);
      double g = y - 0.394 * (v - 128) - 0.581 * (u - 128);
      double b = y + 2.028 * (v - 128);
      if(r < 0) r = 0; if(r > 255) r = 255;
      if(g < 0) g = 0; if(g > 255) g = 255;
      if(b < 0) b = 0; if(b > 255) b = 255;*/
    unsigned char r, g, b;
    Image::convertFromYCbCrToRGB(y, u, v, r, g, b);

//    return (unsigned char) min(max(r-2*b-abs(2*g-r),0),255);
    return (unsigned char) min(max(r - 2*b - 3*max((g-r/2),0) - (3*max((r/2-g),0))/2 ,0),255);
  }

private:
  /**
  * The class represents a ball point.
  */
  class BallPoint : public Vector2<int>
  {
  public:
    BallPoint() : atBorder(false), greenIsClose(true), yellowIsClose(false), hardEdge(true){};
    bool greenIsClose;
    bool yellowIsClose;
    bool hardEdge;
    bool atBorder;

    BallPoint& operator=(const Vector2<int>& other)
    {
      x = other.x;
      y = other.y;

      return *this;
    }
  };

  class BallPointList
  {
  public:
    BallPointList() : number(0) {};

    enum {maxNumberOfPoints = 400}; /**< The maximum number of ball points. */
    BallPoint ballPoints[maxNumberOfPoints]; /**< The ball points. */
    int number; /**< The actual number of ball points. */

    void add(const BallPoint& ballPoint);

    BallPoint& operator[] (int i) { return ballPoints[i]; }
    const BallPoint& operator[] (int i) const { return ballPoints[i]; }
  };

  /** Scan for the ball starting at a given trigger point */
  void scanForBallPoints
  (
   const Image& image,
   const CameraInfo& bwCameraInfo,
   const ColorTable& colorTable,
   int x, int y,
   BallPointList& ballPoints,
   int& countAmbiguous,
   int& countOrange,
   int& maxOrangePerLine,
   int& countPixel
  );

  /** Finds the end of the ball */
  bool findEndOfBall(
    const Image& image,
    const CameraInfo& bwCameraInfo,
    const ColorTable& colorTable,
    const BallPoint& start,
    const Vector2<int>& step,
    BallPoint& destination,
    int& countAmbiguous,
    int& countOrange,
    int& maxOrangePerLine,
    int& countPixel
    );

  /**
  * The function tries to calculate the ball percept by using the Levenberg-Marquardt
  * algorithm. The function fails if less than 3 points are available.
  * @return true if ball percept was created
  */
  bool createBallPerceptLevenbergMarquardt
  (
    const BallPointList& ballPoints,
    Vector2<int>& center,
    double& radius
  );

  /*
  * Check if a list of points is inside a given circle
  */
  bool checkIfPointsAreInsideBall(const BallPointList& ballPoints, Vector2<int>& center, double radius);

  /**
  * The function checks whether a ball percept is plausible and will add it if so.
  * @param image The image the ballpercept comes from.
  * @param bwCameraInfo Object containing camera parameters.
  * @param colorTable The colortable to be used
  * @param cameraMatrix The matrix of the camera of the image.
  * @param prevCameraMatrix The matrix of the camera of a previous image.
  * @param center The center of the ball.
  * @param radius The radius of the ball.
  * @param ballPercept The object the ball is added to.
  */
  void addBallPercept
  (
    const Image& image,
    const CameraInfo& bwCameraInfo,
    const ColorTable& colorTable,
    const CameraMatrix& cameraMatrix,
    const CameraMatrix& prevCameraMatrix,
    const Vector2<int>& center,
    double radius,
    BallPercept& ballPercept
  );  

  const ColorCorrector& colorCorrector;
};

#endif// __BallSpecialist_h_

/*
* $Log: GT2004BallSpecialist.h,v $
* Revision 1.9  2004/09/09 11:37:39  wachter
* - Fixed some more doxygen-errors
*
* Revision 1.8  2004/09/09 10:15:57  spranger
* fixed doxygen-errors
*
* Revision 1.7  2004/07/09 14:04:38  mkunz
* comments corrected
*
* Revision 1.6  2004/06/13 11:28:16  nistico
* Post processing scan on small balls, scanning radially always starting
* from the calculated canter, looking for percentage of orange.
* Ghost balls on pink/yellow landmarks problem should be finally fixed now.
*
* Revision 1.5  2004/06/05 07:58:21  roefer
* Compensation for motion distortions of images
*
* Revision 1.4  2004/05/27 19:38:26  loetzsch
* compilation fixed
*
* Revision 1.3  2004/05/25 17:45:09  mkunz
* parameters of calculation of oranges similarity tuned
*
* Revision 1.2  2004/05/25 10:09:49  mkunz
* use global YCbCr-->RGB method
*
* Revision 1.1.1.1  2004/05/22 17:19:41  cvsadm
* created new repository GT2004_WM
*
* Revision 1.2  2004/05/14 16:37:42  nistico
* Ghost balls on landmark improvements:
* -introduced ambiguous (pink, red, yellow) color check in ball recognition
* -some parameter tuning
*
* Revision 1.1  2004/05/04 13:40:19  tim
* added GT2004ImageProcessor
*
*/

---