strong_features_tool.h

Go to the documentation of this file.

#include <iostream>
#include <vector>
#include <cmath>
#include <values.h>
#include "image.h"
#include "gauss_tool.h"
#include "matrix_tool.h"
#include "image_funcs.h"

#ifndef STRONG_FEATURES_TOOL_H
#define STRONG_FEATURES_TOOL_H

namespace mimas {
class strong_features_tool
{
  private:
    image<int>        gauss_im;
    image<double>        grad_x, grad_y;
    gauss_tool<int>      gauss;
    int                     wx, wy;
    double                  factor; 

  public:
    strong_features_tool(void);
    ~strong_features_tool(void);
    void findFeatures(image<int> &imagein, image<int> &imageout);

 
};

strong_features_tool::strong_features_tool()
{
  wx=15;
  wy=15;

  factor=0.01;
}

strong_features_tool::~strong_features_tool()
{
}

void strong_features_tool::findFeatures(image<int> &imagein, image<int> &imageout)
{

  matrix_tool u,d,vt;
  image<double> eigimage;
  vector<double> eigval;
  vector<int> coordx, coordy;


  eigimage.init(imagein.getWidth(),imagein.getHeight());

  imageout.init(imagein.getWidth(),imagein.getHeight());

  //(1) first gauss the image
  gauss.filter( imagein, gauss_im );

  //(2) get the horizontal and vertical gradients
  //    grad filter is a simple static function
  //    might be an idea to switch the gauss image to a double first?
  //filter<int>::gradX( gauss_im, grad_x );
  //filter<int>::gradY( gauss_im, grad_y );
  gradSobel(gauss_im, grad_x, _dir_x);
  gradSobel(gauss_im, grad_y, _dir_y);
  //normaliseIt(grad_x, 0.0, 255.0);
  //normaliseIt(grad_y, 0.0, 255.0);

  //to save memory, get rid of gauss_im
  gauss_im.clear();


  int centx=wx/2;
  int centy=wy/2;

  double smalleig;

  for (int j=centy; j<imagein.getHeight()-centy; j++)
    for ( int i=centx; i<imagein.getWidth()-centx; i++)
    {
      matrix_tool C;

      C.zeroes(2,2);

      for (int y=-centy; y<centy; y++)
        for (int x=-centx; x<centx; x++)
        {
          C(0,0)=C(0,0)+fabs((double)(grad_x.pixel(x+i,y+j)*grad_x.pixel(x+i,y+j)));
          C(0,1)=C(0,1)+fabs((double)(grad_x.pixel(x+i,y+j)*grad_y.pixel(x+i,y+j)));
          C(1,0)=C(0,1);
          C(1,1)=C(1,1)+fabs((double)(grad_y.pixel(x+i,y+j)*grad_y.pixel(x+i,y+j)));
        }

      // compute the smalles eigenvalue
      smalleig=( C(0,0) + C(1,1) - sqrt( ( C(0,0)-C(1,1) ) * ( C(0,0)-C(1,1) ) + 4*C(0,1)*C(1,0) ))/2.0;
      
      eigimage.setPixel(i,j,smalleig);
      eigval.push_back(smalleig);
    }

  //normaliseIt(eigimage, 0.0, 255.0);
  //eigimage.display();

  sort(eigval.begin(),eigval.end());

  for (int i=0; i<eigval.size(); i++)
     cout << eigval[i] << std::endl;


  bool notlocalmaximum;
  for (int j=centy; j<imagein.getHeight()-centy; j++)
    for ( int i=centx; i<imagein.getWidth()-centx; i++)
    {
      notlocalmaximum=false;
      
      for (int y=-centy; y<centy; y++)
      {
        for (int x=-centx; x<centx; x++)
        {
          if ( x==0 && y==0) continue;
          
          if ( eigimage.pixel(i,j) >= eigimage.pixel(i+x,j+y) )
          {
                 eigimage.pixel(i+x,j+y)=0.0;
            notlocalmaximum=true;
            //break;
          }
        }
        //if (notlocalmaximum==true) break;
      }
    }
  
  
  double  cutoffval=eigval[eigval.size()-(int)((double)eigval.size()*factor)];

  for (int j=0; j<eigimage.getHeight(); j++)
    for ( int i=0; i<eigimage.getWidth(); i++)
        imageout.pixel(i,j) = eigimage.pixel(i,j)>=cutoffval ? 255 : 0;
  



}
}
#endif

---