Modules/ImageProcessor/RasterImageProcessor/REdgeDetection.h

Go to the documentation of this file.

/**
* @file Modules/ImageProcessor/RasterImageProcessor/REdgeDetection.h
* 
* This file contains an utility-class for detecting edges in digital images. 
*
* @author <A href="mailto:sadprofessor@web.de">Bernd Schmidt</A>
*/

#ifndef __REdgeDetection_h_
#define __REdgeDetection_h_

#include "Representations/Perception/Image.h"
#include "Modules/ImageProcessor/ImageProcessor.h"
#include "Modules/ImageProcessor/ImageProcessorTools/ColorCorrector.h"
#include "Modules/ImageProcessor/ImageProcessorTools/SUSANEdgeDetectionLite.h"

/**
* @class REdgeDetection
* Utility-class for edge-detection.
*/
class REdgeDetection
{  

public:

  /**
  * Default constructor.
  * @param processor The image processor interfaces.
  */
  REdgeDetection(ImageProcessor& processor);
  
  /**Destructor*/
  ~REdgeDetection();
  /** Threshold for edge scans */
  int threshold;

  /** Holds the last visited x-coordinate of a scan */
  int tempX;

  /** Holds the last visited y-coordinate of a scan */
  int tempY;

  /** Scans to the right side of the image and detects edges.
  * The position of the edge is stored in x,y. 
  * @param x Starting x-coordinate of the scan.
  * @param y Starting y-coordinate of the scan.
  * @return Tells if an edge was found at the last run.
  */
  bool scanEast(int& x, int& y);
  /** Scans to the left side of the image and detects edges.
  * The position of the edge is stored in x,y. 
  * @param x Starting x-coordinate of the scan.
  * @param y Starting y-coordinate of the scan.
  * @return Tells if an edge was found at the last run.
  */
  bool scanWest(int& x, int& y);
  /** Scans to the top and detects edges.
  * The position of the edge is stored in x,y. 
  * @param x Starting x-coordinate of the scan.
  * @param y Starting y-coordinate of the scan.
  * @return Tells if an edge was found at the last run.
  */
  bool scanNorth(int& x, int& y);
  
  /** Scans to the bottom and detects edges.
  * The position of the edge is stored in x,y. 
  * @param x Starting x-coordinate of the scan.
  * @param y Starting y-coordinate of the scan.
  * @return Tells if an edge was found at the last run.
  */
  bool scanSouth(int& x, int& y);

  /** Scans to the right side and detects edges of balls.
  * The position of the edge is stored in x,y.
  * @param x Starting x-coordinate of the scan.
  * @param y Starting y-coordinate of the scan.
  * @return Tells if an edge was found at the last run.
  */
  bool ballScanEast(int& x, int& y);
  
  /** Scans to the left side and detects edges of balls.
  * The position of the edge is stored in x,y.
  * @param x Starting x-coordinate of the scan.
  * @param y Starting y-coordinate of the scan.
  * @return Tells if an edge was found at the last run.
  */
  bool ballScanWest(int& x, int& y);

  /** Follows the given direction,
  * and determines edges by the sum of all three channels.
  * The position of the edge is stored in x and y.
  * @param x The starting x-value.
  * @param y The starting y-value.
  * @param direction The direction of the scan.
  * @return edge was found*/
  bool scan(int& x,int& y,Vector2<double> direction);

  /** Follows the given direction,
  * and determines edges by the sum of all three channels.
  * The position of the edge is stored in x and y.
  * Fills the colorBuffer while scanning, so the client
  * can determine with the colorBuffer-Array what kind of
  * object was found.
  *
  * @param x The starting x-value.
  * @param y The starting y-value.
  * @param direction The direction of the scan.
  * @return edge was found*/
  bool bufferedScan(int& x,int& y,Vector2<double> direction);

  /** Follows the last given direction. Skips 3 pixels at the beginning
  * of each scan, while filling the buffer.
  *
  * @param x x-coordinate
  * @param y y-coordinate
  */ 
  bool bufferedScan(int& x,int& y);

  /** Follows the given direction,and searches for field-edge-points. 
  * Determines edges by the sum of the first two channels.
  * The position of the edge is stored in x and y.
  * @param x The starting x-value.
  * @param y The starting y-value.
  * @param direction The direction of the scan.
  * @return edge was found*/
  bool scanField(int& x,int& y,Vector2<double> direction);

  /** Follows the last given direction,and searches for field-edge-points. 
  * Determines edges by the sum of the first two channels.
  * The position of the edge is stored in x and y.
  * @param x The starting x-value.
  * @param y The starting y-value.
  * @return edge was found*/
  bool scanField(int& x,int& y);

  /** Follows the last given direction,
  * and determines edges by the sum of all three channels 
  *
  * @param x x-coordinate
  * @param y y-coordinate
  */
  bool scan(int& x,int& y);

  /** Follows the given direction,
  * and determines edges by looking for 
  * differences of the colorClass of two following pixels.
  * @param x The starting x-value.
  * @param y The starting y-value.
  * @param direction Teh direction of the color scan.
  * @param lastColor The color of the last scan.
  * @return edge was found
  */
  bool colorScan(int& x,int& y,Vector2<double> direction,colorClass& lastColor);
  
  /** Follows the current direction,
  * and determines edges by looking for 
  * differences of the colorClass of two following pixels.
  * @param x The starting x-value.
  * @param y The starting y-value.
  * @param lastColor The color of the last scan.
  * @return edge was found
  */
  bool colorScan(int& x,int& y,colorClass& lastColor);
  /** Follows the given direction,
  * and determines edges with help of the SUSANEdgeDetection.
  * The position of the edge is stored in x and y.
  * @param x The starting x-value.
  * @param y The starting y-value.
  * @param direction The direction of the scan.
  * @return edge was found*/  
  bool susanScan(int& x,int& y,Vector2<double> direction);
  /** Follows the given direction,
  * and determines edges by the sum of all three channels.
  * The position of the edge is stored in x and y.
  * @param x The starting x-coordinate.
  * @param y The starting y-coordinate.
  * @param x1 The x-coordinate of the end.
  * @param y1 The y-coordinate of the end.
  * @return edge was found*/  
  bool scan(int& x,int& y,int x1,int y1);
  /** Follows the given direction,
  * and determines edges by the sum of all three channels.
  * The position of the edge is stored in x and y.
  * @param x The starting x-coordinate.
  * @param y The starting y-coordinate.
  * @param x1 The x-coordinate of the end.
  * @param y1 The y-coordinate of the end.
  * @param lastColor The color of the last run.
  * @return edge was found*/  
  bool colorScan(int& x,int& y,int x1,int y1,colorClass& lastColor);
  /** Setter for member direction.
  *   @param dir The new direction.
  */
  inline void setDirection(Vector2<double> dir){
    cx = (dir.x<0)? -1 : 1;
    cy = (dir.y<0)? -1 : 1;
    dx = abs((int)(dir.x * 500.0f));
    dy = abs((int)(dir.y * 500.0f));
    if (dx>dy){
      e = dx - 2*dy;
      f = 2*(dx - dy);
      g = -2*dy;
    }
    else{
      e = dy - 2*dx;
      f = 2*(dy - dx);
      g = -2*dx;
    }
    direction = dir;
  }
  /** Returns a color from the color buffer.
  * @param index The index of the color.  
  * @return The color for the index.
  */
  inline colorClass getColor(int index){
    return colorBuffer[index];
  }
  /** Returns a range from the range buffer.
  * @param index The index of the range.  
  * @return The range for the index.
  */
  inline int getRange(int index){
    return ranges[index];
  }
  /** This function implements a edge filter for horizontal edges. 
  *   @param x x-coordinate.
  *   @param y y-coordinate.
  *   @return True, if vote for the edgness is greater than threshold.
  */
  inline bool isHorizontalEdge(int x, int y){
    return horizontalEdgeVote(x,y) > threshold;
  }
  /** This function implements a edge filter for horizontal edges. 
  *   @param x x-coordinate.
  *   @param y y-coordinate.
  *   @return A vote for the edgness.
  */
  inline int horizontalEdgeVote(int x,int y){
    if (x < 1 || x > ip.image.cameraInfo.resolutionWidth-2) return -1;
    int cx1 = x-1;
    int cx2 = x+1;
    int a1 = ip.image.image[y][0][cx1];
    int b1 = ip.image.image[y][1][cx1];
    int c1 = ip.image.image[y][2][cx1];
    int a2 = ip.image.image[y][0][cx2];
    int b2 = ip.image.image[y][1][cx2];
    int c2 = ip.image.image[y][2][cx2];

    return abs(a1 - a2) + abs(b1 - b2) + abs(c1 - c2);
  }
  /** This function implements a edge filter for vertical edges. 
  *   @param x x-coordinate.
  *   @param y y-coordinate.
  *   @return True, if vote for the edgness is greater than threshold.
  */
  inline bool isVerticalEdge(int x, int y){
    return verticalEdgeVote(x,y) > threshold;
  }
  /** This function implements a edge filter for vertical edges. 
  *   @param x x-coordinate.
  *   @param y y-coordinate.
  *   @return A vote for the edgness.
  */
  inline int verticalEdgeVote(int x,int y){
    if (y < 1 || y > ip.image.cameraInfo.resolutionHeight-2) return -1;
    int cy1 = y-1;
    int cy2 = y+1;
    int a1 = ip.image.image[cy1][0][x];
    int b1 = ip.image.image[cy1][1][x];
    int c1 = ip.image.image[cy1][2][x];
    int a2 = ip.image.image[cy2][0][x];
    int b2 = ip.image.image[cy2][1][x];
    int c2 = ip.image.image[cy2][2][x];

    return abs(a1 - a2) + abs(b1 - b2) + abs(c1 - c2);
  }
  /** This function implements a edge filter for the ball. 
  *   @param x x-coordinate.
  *   @param y y-coordinate.
  *   @return A vote for the edgness.
  */
  inline int ballEdgeVote(int x,int y){
    //could be different code as in crossEdgeVote()
    if (x < 1 || x > ip.image.cameraInfo.resolutionWidth-2) return -1;
    if (y < 1 || y > ip.image.cameraInfo.resolutionHeight-2) return -1;
    int vertical = 0;
    int horizontal = 0;
    int p1 = x-1;
    int p2 = x+1;
    int a1 = ip.image.image[y][0][p1];
    int b1 = ip.image.image[y][1][p1];
    int c1 = ip.image.image[y][2][p1];
    int a2 = ip.image.image[y][0][p2];
    int b2 = ip.image.image[y][1][p2];
    int c2 = ip.image.image[y][2][p2];
    
    horizontal = abs(a1 - a2) + abs(b1 - b2) + abs(c1 - c2);
    
    p1 = y-1;
    p2 = y+1;
    a1 = ip.image.image[p1][0][x];
    b1 = ip.image.image[p1][1][x];
    c1 = ip.image.image[p1][2][x];
    a2 = ip.image.image[p2][0][x];
    b2 = ip.image.image[p2][1][x];
    c2 = ip.image.image[p2][2][x];
    
    vertical = abs(a1 - a2) + abs(b1 - b2) + abs(c1 - c2);
    
    return (vertical > horizontal) ? vertical : horizontal; 
  }
  /** This function implements a edge filter. 
  *   @param x x-coordinate.
  *   @param y y-coordinate.
  *   @return A vote for the edgness.
  */
  inline int crossEdgeVote(int x,int y){
    if (x < 1 || x > ip.image.cameraInfo.resolutionWidth-2) return -1;
    if (y < 1 || y > ip.image.cameraInfo.resolutionHeight-2) return -1;
    int vertical = 0;
    int horizontal = 0;
    int p1 = x-1;
    int p2 = x+1;
    int a1 = ip.image.image[y][0][p1];
    int b1 = ip.image.image[y][1][p1];
    int c1 = ip.image.image[y][2][p1];
    int a2 = ip.image.image[y][0][p2];
    int b2 = ip.image.image[y][1][p2];
    int c2 = ip.image.image[y][2][p2];
    
    horizontal = abs(a1 - a2) + abs(b1 - b2) + abs(c1 - c2);
    
    p1 = y-1;
    p2 = y+1;
    a1 = ip.image.image[p1][0][x];
    b1 = ip.image.image[p1][1][x];
    c1 = ip.image.image[p1][2][x];
    a2 = ip.image.image[p2][0][x];
    b2 = ip.image.image[p2][1][x];
    c2 = ip.image.image[p2][2][x];
    
    vertical = abs(a1 - a2) + abs(b1 - b2) + abs(c1 - c2);
    
    return (vertical > horizontal) ? vertical : horizontal; 
  }
  /** This function implements a edge filter.
  *   Only looking at the gradients of the channels Y and U.
  *   @param x x-coordinate.
  *   @param y y-coordinate.
  *   @return A vote for the edgness.
  */
  inline int fieldEdgeVote(int x,int y){
    if (x < 1 || x > ip.image.cameraInfo.resolutionWidth-2) return -1;
    if (y < 1 || y > ip.image.cameraInfo.resolutionHeight-2) return -1;
    int vertical = 0;
    int horizontal = 0;
    int p1 = x-1;
    int p2 = x+1;
    int a1 = ip.image.image[y][0][p1];
    int b1 = ip.image.image[y][1][p1];
    int a2 = ip.image.image[y][0][p2];
    int b2 = ip.image.image[y][1][p2];

    
    horizontal = abs(a1 - a2) + abs(b1 - b2);
    
    p1 = y-1;
    p2 = y+1;
    a1 = ip.image.image[p1][0][x];
    b1 = ip.image.image[p1][1][x];
    a2 = ip.image.image[p2][0][x];
    b2 = ip.image.image[p2][1][x];
    
    vertical = abs(a1 - a2) + abs(b1 - b2);
    
    return (vertical > horizontal) ? vertical : horizontal; 
  }
  
  /** Implemented with ColorTable interface.
  * Corrects the color before classifying.
  * @param x x-coordinate of the requested pixel
  * @param y y-coordinate of the requested pixel
  * @return The classified color of the pixel.*/
  inline colorClass getColor(int x,int y){
    if (x < 1 || x > ip.image.cameraInfo.resolutionWidth-2) return (colorClass)-1;
    if (y < 1 || y > ip.image.cameraInfo.resolutionHeight-2) return (colorClass)-1;

    unsigned char cy = ip.image.image[y][0][x];
    unsigned char cu = ip.image.image[y][1][x];
    unsigned char cv = ip.image.image[y][2][x];
    ColorCorrector::correct(x,y,cy,cu,cv);
    return ip.colorTable.getColorClass(cy,cu,cv); 
  }

  /** Gives the next pixel of last scan. This is only for the scans that
    * use Bresenham's algorithm.
    *
    * @param x The x-coordinate.
    * @param y The y-coordinate.    
    */
  inline void skip(int& x,int& y){
    if (dx>dy){
      x+=cx;
      if (e<0) {
        y+=cy;
        e+=f;
      }
      else {
        e+=g;
      }
    }
    else{
      y+=cy;
      if (e<0) {
        x+=cx;
        e+=f;
      }
      else {
        e+=g;
      }
    }
  }

  /** Determines the first valid point on a run.
  *
  *   @param start The original start point.
  *   @param dir The direction.
  *   @return If the scan line intersects the image.
  */
  inline bool findStart(Vector2<int>& start,const Vector2<double>& dir){
    int dx = (int)(dir.x*300 + 0.5);
      int dy = (int)(dir.y*300 + 0.5);

    Vector2<int> rightBorder(start.x + dx,start.y + dy);

    return Geometry::clipLineWithRectangleCohenSutherland(
      Vector2<int>(1,1),
      Vector2<int>(ip.image.cameraInfo.resolutionWidth -2,ip.image.cameraInfo.resolutionHeight -2),
      start,
      rightBorder
      );
  }

  /** Getter for the size of the color-buffer 
  * @return size of the color-buffer*/
  inline int getBufferSize(){
    return bufferSize;
  }

//Bresenham
//inline void draw_line(int x0, int y0, int x1, int y1){
//  int x,y=y0,dx = 2*(x1-x0),dy = 2*(y1-y0);
//  int dydx = dy - dx, d = dy - dx/2;
//  for(x=x0;x<=x1;x++){
//    DOT(imageProcessor_general,x,y,
//      Drawings::white, Drawings::red);
//    if(d<0) {d+= dy;}
//    else {y+=1; d += dydx;}
//  }
//}


private:

  /** the image processor interfaces */
  ImageProcessor& ip;
  
  /** an external edgeDetector */
  SUSANEdgeDetectionLite susanDetector; 
  /** current scan direction */
  Vector2<double> direction;

  /** a value for bresenham algorithm*/
  int e;
  /** a value for bresenham algorithm*/
  int f;
  /** a value for bresenham algorithm*/
  int g;
  /** a value for bresenham algorithm*/
  int dx;
  /** a value for bresenham algorithm*/
  int dy;
  /** a value for bresenham algorithm*/
  int cx;
  /** a value for bresenham algorithm*/
  int cy;
  /** current buffer size */
  int bufferSize;
  /** holds the color of the active pixel*/
  colorClass currentColor;
  /** holds the color of the previous pixel*/
  colorClass lastColor;
  
  /** The last range of a color scan. */
  int colorRange;

  /** This buffer is used to store the colors 
  * passed by a buffered scan-method during the last scan
  */
  colorClass colorBuffer[20];

  /** This buffer is used to store the ranges of the colors */
  int ranges[20];

  /** This function implements a edge filter. 
  *   @param x x-coordinate.
  *   @param y y-coordinate.
  *   @return A vote for the edgness.
  */
  inline int fastCrossEdgeVote(int x,int y){
    int vertical = 0;
    int horizontal = 0;
    int p1 = x-1;
    int p2 = x+1;
    int a1 = ip.image.image[y][0][p1];
    int b1 = ip.image.image[y][1][p1];
    int c1 = ip.image.image[y][2][p1];
    int a2 = ip.image.image[y][0][p2];
    int b2 = ip.image.image[y][1][p2];
    int c2 = ip.image.image[y][2][p2];
    
    horizontal = abs(a1 - a2) + abs(b1 - b2) + abs(c1 - c2);
    
    p1 = y-1;
    p2 = y+1;
    a1 = ip.image.image[p1][0][x];
    b1 = ip.image.image[p1][1][x];
    c1 = ip.image.image[p1][2][x];
    a2 = ip.image.image[p2][0][x];
    b2 = ip.image.image[p2][1][x];
    c2 = ip.image.image[p2][2][x];
    
    vertical = abs(a1 - a2) + abs(b1 - b2) + abs(c1 - c2);
    
    return (vertical > horizontal) ? vertical : horizontal; 
  }
  /** Adds a color and its range to the buffers*/
  inline void addColor(){
    if (lastColor != -1){
      colorBuffer[bufferSize] = lastColor;
      ranges[bufferSize] = colorRange;
      bufferSize++;
      colorRange = 0;
    }
    else{
      colorRange = 0;
    }
  }
  /** Tests, if a point is a valid. Thats a helper.
  * @param x x-coordinate
  * @param y y-coordinate
  * @return True, if point is valid.
  */
  inline bool insideImage(int x,int y){
    if (x < 1 || x > ip.image.cameraInfo.resolutionWidth-2) return false;
    if (y < 1 || y > ip.image.cameraInfo.resolutionHeight-2) return false;
    return true;
  }
  /** This function implements a edge filter. 
  *   @param x x-coordinate.
  *   @param y y-coordinate.
  *   @return A vote for the edgness.
  */
  inline int susanVote(int x,int y){
    if (x < 1 || x > ip.image.cameraInfo.resolutionWidth-2) return -1;
    if (y < 1 || y > ip.image.cameraInfo.resolutionHeight-2) return -1;
    int vote = susanDetector.isEdgePoint(ip.image,x,y,SUSANEdgeDetectionLite::componentA);
    vote += susanDetector.isEdgePoint(ip.image,x,y,
      SUSANEdgeDetectionLite::componentB);
    vote += susanDetector.isEdgePoint(ip.image,x,y,
      SUSANEdgeDetectionLite::componentC);
    return vote;
  }


  
};

#endif// __REdgeDetection_h_

/*
* Change log :
* 
* $Log: REdgeDetection.h,v $
* Revision 1.1  2004/09/09 11:08:04  spranger
* renamed GT2004EdgeDetection to REdgeDetection for consistency
*
* Revision 1.4  2004/09/06 12:02:25  schmidtb
* commented almost all members, removed warnings in documentation

* did further code clean up
*
* Revision 1.2  2004/09/02 07:59:29  schmidtb
* Added RasterImageProcessor to repository, because we used it for the OpenChallenge.
*
* Revision 1.1  2004/05/17 11:57:04  nistico
* Imported ball detection from RasterImageProcessor (integrated in MSH by Bernd in New Orleans)
*
* Revision 1.1  2004/04/25 17:40:18  pg_arce
* stand 1. spiel
*
* Revision 1.3  2004/03/25 15:10:03  pg_besc
* made some changes
*
* Revision 1.2  2004/03/17 20:58:47  schmidtb
* added new scan methods and buffering.
*
* Revision 1.1  2004/03/11 20:19:43  schmidtb
* Established GT2004EdgeDetection.
*
*/

---