hough_transform2.h

Go to the documentation of this file.

#ifndef HOUGH_TRANSFORM2_H
#define HOUGH_TRANSFORM2_H

#include <boost/multi_array.hpp>
#include <algorithm>
#include <vector>
#include <cmath>

#include "image.h"
#include "multi_array_op.h"
#include "image_fileinput.h"
#include "image_funcs.h"
#include "property_image.h"
#include "image_draw.h"
#include "primitives.h"

#ifndef NDEBUG

#include <iostream>
#include <fstream>

#endif

namespace mimas{
  
  typedef boost::multi_array<double,2> Array2D;

  template< typename ImageIteratorSource >
  class find_line{

  protected:
    int nbOrientationDiv;
    double thresh;

    double maxVal;

    ImageIteratorSource ul;
    ImageIteratorSource lr;

    int w,h;
    int imageDiagonalSize;
    int center_x, center_y;

    Array2D parameterSpace;
   
    //this function has been adapted from Parker's book
    //it is the core of the hough transform:
    //it transforms edge points into parametre space for line 
    void hough (void) {
      double conv = M_PI/nbOrientationDiv;
      //Centering the frame on the centre of the image we divide by 2
      //the sample space needed for r as this value can be negative
      //and its max(|r|) is divided by 2.  The two first loop are used
      //all the time -> find a generic way to apply an operation to
      //each pixel of an image.

      ImageIteratorSource temp(ul);
      for (int i = 0; i < w; i++, temp.x++){
  ImageIteratorSource temp2(temp);
  for (int j = 0; j < h; j++,temp2.y++)
    //the logic that constaint less the feature input image. (compared with == 255 for instance) 
    if (*temp2 != 0)
      for (int omega = 0; omega < nbOrientationDiv; omega++) 
        {
    int r = (int)( (i - center_x) * cos(double(omega*conv)) - (j - center_y) * sin(double(omega*conv)));
        
    assert(imageDiagonalSize / 2 + r > 0 ||imageDiagonalSize / 2 + r <= imageDiagonalSize);
    parameterSpace[omega][imageDiagonalSize / 2 + r] += 1;
        }
      }
    }

    void findMax(void)
    {
      maxVal  = *(std::max_element(parameterSpace.data(), parameterSpace.data()+parameterSpace.num_elements()));
#ifndef NDEBUG
      std::cerr<< "find_line: MaxValue is: " <<maxVal<<std::endl;
#endif
    }

    void findLine(void){
      //rubish code: use template programing
      for (int t=0; t<nbOrientationDiv; t++)
  for (int r=0; r< imageDiagonalSize; r++)
    if ((parameterSpace[t][r] >= maxVal * thresh))
      lines.push_back(polar_to_castesian( t,r - imageDiagonalSize /2));
    }


    image<unsigned char> displayLine(void) {
      image<unsigned char> x;
      x.init(w,h);
      for(typename std::vector< segment< point > >::iterator it = lines.begin(); it != lines.end(); it++)
  drawLine(x, it->p1.x, it->p1.y, it->p2.x, it->p2.y, (unsigned char)(200));

      return x;
    }


  public:
    std::vector< segment< point > > lines;

    //Helper function to convert a point from the parametre space to a line 
    //in the image space. Add the line to the vector of line.
    segment< point > polar_to_castesian(double theta,double r)
    {
      int test = 1000;
      //calculate the intersection point between the line and its perpenducular
      //that is passing through the origin
    
      double x = r * cos (double(theta*M_PI/nbOrientationDiv));
      double y = r * sin (double(theta*M_PI/nbOrientationDiv));
      //the direction of the line is (y,-x)
      //scale and check in  the bound of image if necessary

      //we take 2 points on the line centered on intersection,separated by
      //2*test distance
      double size = sqrt(x*x + y*y);

      point p1 = point( int(x + y * test /size) + center_x , center_y - int(y - x * test /size) );
      point p2 = point( int(x - y * test /size) + center_x , center_y - int(y + x * test /size) );

      return segment< point >(p1,p2);
    }

    //Take an image of feature as input value. The thresh_factor value
    //is multiplied with the maximum number of hit for a bin. The
    //resulting value serves as the minimum threshold value to
    //detemine if a bin represent a line or not (see findline())
    find_line(ImageIteratorSource ul, ImageIteratorSource lr, double thresh_factor = .7, int orientationDivision = 180)
      :
      nbOrientationDiv(orientationDivision),   
      thresh(thresh_factor),ul(ul),lr(lr),
      w(lr.x - ul.x),h(lr.y - ul.y),
      imageDiagonalSize(int(sqrt(double(w*w+h*h)))),
      //size has to be checked maybe +1 would be the right measure
      parameterSpace(boost::extents[orientationDivision][imageDiagonalSize])
    {
      assert(thresh < 1);
      
      center_x = w /2;
      center_y = h /2;
    }
  
    image< unsigned char > exec(void) {
      hough();
      findMax();
      findLine();  
      return displayLine();
    }

    std::vector< segment< point > > getLines(void) {
      hough();
      findMax();
      findLine();  
      return lines;
    }

  };
  
}

#endif

---