fv.h

Go to the documentation of this file.

#ifndef __FV_H
#define __FV_H
#include <vector>
#include <iostream>
#include <assert.h>

using namespace std;


class Coords : public pair<float,float>{
  public : 
    Coords( float a=0, float b=0 ) { first = a; second = b; }
    //look like the vgl libs version for future association
    float x() { return first; }
    float y() { return second; }
    void set(float in1, float in2 ) {
      first = in1; 
      second = in2;
    }
    void print() {
      cerr<<" "<<x()<<" "<<y()<<" ";
    }
};

class Feature : public Coords {
  public:

    vector<float> descriptor;        


    float orientation;               
    float dx;                        
    float dy;                        
    float magnitude;                 

    Feature() {
      descriptor.reserve(128*sizeof(float));
    }
    double norm() {                  
      double n=0.0;
      for( int i=0 ;i<128; i++ ) { 
        n += descriptor[i]*descriptor[i];
      } 
      return sqrt(n);
    }
};

class Scene {
  public:
    vector<Feature> features;
};

//typedef pair<Feature *, Feature *> Match ;

class Match : public pair<Feature *, Feature *> {
  public:
    Match( Feature *a, Feature *b ) : pair<Feature *,Feature*>( a, b ) {} 

    bool Match::operator==(Match op) {    
      return ( ( first==op.first )&&( second==op.second ) );
    }
};

typedef vector<Match> Matches ; 
/*
double distSq( Coords &c0, Coords &c1 ) {
  double X,Y;
  X = c0.x() - c1.x();
  Y = c0.y() - c1.y();
  return X*X + Y*Y ;
}


float featureDiffSq( Feature &f0, Feature &f1 ) 
{
  assert( f0.descriptor.size() == 128 ); 
  assert( f1.descriptor.size() == 128 ); 
  double ssd = 0.0;
  for( int i=0 ; i<128 ; i++ ) {
    float diff = (f0.descriptor[i]-f1.descriptor[i]);
    ssd += (double)diff*(double)diff;
  }
  return (float)ssd; 
}

Feature *findBestMatch( Feature &f0, Scene &s1, float magRadius, float thresh) 
{
  float dist1 = 9999;
  float dist2 = 9999;

  vector<Feature>::iterator it1, bestMatch ; 

  for( it1 = s1.features.begin() ; it1 != s1.features.end() ; it1++ ) {

    // only check those vectors who have nearby magnitudes (restricts it to 
    //  a shell of radius it->magnitude around the origin )

    if( fabsf(f0.magnitude - it1->magnitude) < magRadius*magRadius ) {

      float dist = featureDiffSq ( f0, *it1 );

      if( dist < dist1 ) { 
        dist2 = dist1 ;
        dist1 = dist ;
        bestMatch = it1 ; 
      }
      else if( dist < dist2 ) {
        dist2 = dist;
      }//endif

    }//endiff
    

  }//endfor

  // returns if the match is well defined (not a noisy clump) 
  if( dist1 < thresh*thresh * dist2  ) { 
    return &(*bestMatch) ;  
  }
  else {
    return NULL;
  }
}

Matches &findMatches( Scene &s0, 
                      Scene &s1, 
                      float magRadius , 
                      float improvement  ) 
{
  Matches *matches = new Matches() ;
  vector<Feature>::iterator it0 ;     

  //cerr<<"start\n";
  for( it0 = s0.features.begin() ; it0 != s0.features.end() ; it0++ ) {
    Feature *bestMatch = NULL;
    if( ( bestMatch = findBestMatch( *it0, s1, magRadius, improvement ) ) != NULL ) {
      Match *match = new Match( &(*it0), bestMatch  );
      matches->push_back( *match );
    }
  }
  //cerr<<"Done "<<matches->size() <<" matches found"<<endl;
  return *matches;
}
*/
#endif

---