opencv-ffi 0.0.1

data/ext/opensurf/fasthessian.h

@@ -0,0 +1,108 @@
+/*********************************************************** 
+*  --- OpenSURF ---                                       *
+*  This library is distributed under the GNU GPL. Please   *
+*  use the contact form at http://www.chrisevansdev.com    *
+*  for more information.                                   *
+*                                                          *
+*  C. Evans, Research Into Robust Visual Features,         *
+*  MSc University of Bristol, 2008.                        *
+*                                                          *
+************************************************************/
+
+#ifndef FASTHESSIAN_H
+#define FASTHESSIAN_H
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/core/core_c.h>
+#include "ipoint.h"
+
+#include <vector>
+
+class ResponseLayer;
+static const int OCTAVES = 5;
+static const int INTERVALS = 4;
+static const float THRES = 0.0004f;
+static const int INIT_SAMPLE = 2;
+
+
+class FastHessian {
+  
+  public:
+   
+    //! Constructor without image
+    FastHessian(std::vector<Ipoint> &ipts, 
+                const int octaves = OCTAVES, 
+                const int intervals = INTERVALS, 
+                const int init_sample = INIT_SAMPLE, 
+                const float thres = THRES);
+
+    //! Constructor with image
+    FastHessian(IplImage *img, 
+                std::vector<Ipoint> &ipts, 
+                const int octaves = OCTAVES, 
+                const int intervals = INTERVALS, 
+                const int init_sample = INIT_SAMPLE, 
+                const float thres = THRES);
+
+    //! Destructor
+    ~FastHessian();
+
+    //! Save the parameters
+    void saveParameters(const int octaves, 
+                        const int intervals,
+                        const int init_sample, 
+                        const float thres);
+
+    //! Set or re-set the integral image source
+    void setIntImage(IplImage *img);
+
+    //! Find the image features and write into vector of features
+    void getIpoints();
+    
+  private:
+
+    //---------------- Private Functions -----------------//
+
+    //! Build map of DoH responses
+    void buildResponseMap();
+
+    //! Calculate DoH responses for supplied layer
+    void buildResponseLayer(ResponseLayer *r);
+
+    //! 3x3x3 Extrema test
+    int isExtremum(int r, int c, ResponseLayer *t, ResponseLayer *m, ResponseLayer *b);    
+    
+    //! Interpolation functions - adapted from Lowe's SIFT implementation
+    void interpolateExtremum(int r, int c, ResponseLayer *t, ResponseLayer *m, ResponseLayer *b);
+    void interpolateStep(int r, int c, ResponseLayer *t, ResponseLayer *m, ResponseLayer *b,
+                          double* xi, double* xr, double* xc );
+    CvMat* deriv3D(int r, int c, ResponseLayer *t, ResponseLayer *m, ResponseLayer *b);
+    CvMat* hessian3D(int r, int c, ResponseLayer *t, ResponseLayer *m, ResponseLayer *b);
+
+    //---------------- Private Variables -----------------//
+
+    //! Pointer to the integral Image, and its attributes 
+    IplImage *img;
+    int i_width, i_height;
+
+    //! Reference to vector of features passed from outside 
+    std::vector<Ipoint> &ipts;
+
+    //! Response stack of determinant of hessian values
+    std::vector<ResponseLayer *> responseMap;
+
+    //! Number of Octaves
+    int octaves;
+
+    //! Number of Intervals per octave
+    int intervals;
+
+    //! Initial sampling step for Ipoint detection
+    int init_sample;
+
+    //! Threshold value for blob resonses
+    float thresh;
+};
+
+
+#endif

data/ext/opensurf/integral.cpp

@@ -0,0 +1,58 @@
+/*********************************************************** 
+*  --- OpenSURF ---                                       *
+*  This library is distributed under the GNU GPL. Please   *
+*  use the contact form at http://www.chrisevansdev.com    *
+*  for more information.                                   *
+*                                                          *
+*  C. Evans, Research Into Robust Visual Features,         *
+*  MSc University of Bristol, 2008.                        *
+*                                                          *
+************************************************************/
+
+#include <opencv2/imgproc/imgproc_c.h>
+
+#include "utils.h"
+
+#include "integral.h"
+
+//! Computes the integral image of image img.  Assumes source image to be a 
+//! 32-bit floating point.  Returns IplImage of 32-bit float form.
+IplImage *Integral(IplImage *source)
+{
+  // convert the image to single channel 32f
+  IplImage *img = getGray(source);
+  IplImage *int_img = cvCreateImage(cvGetSize(img), IPL_DEPTH_32F, 1);
+
+  // set up variables for data access
+  int height = img->height;
+  int width = img->width;
+  int step = img->widthStep/sizeof(float);
+  float *data   = (float *) img->imageData;  
+  float *i_data = (float *) int_img->imageData;  
+
+  // first row only
+  float rs = 0.0f;
+  for(int j=0; j<width; j++) 
+  {
+    rs += data[j]; 
+    i_data[j] = rs;
+  }
+
+  // remaining cells are sum above and to the left
+  for(int i=1; i<height; ++i) 
+  {
+    rs = 0.0f;
+    for(int j=0; j<width; ++j) 
+    {
+      rs += data[i*step+j]; 
+      i_data[i*step+j] = rs + i_data[(i-1)*step+j];
+    }
+  }
+
+  // release the gray image
+  cvReleaseImage(&img);
+
+  // return the integral image
+  return int_img;
+}
+

data/ext/opensurf/integral.h

@@ -0,0 +1,55 @@
+/*********************************************************** 
+*  --- OpenSURF ---                                       *
+*  This library is distributed under the GNU GPL. Please   *
+*  use the contact form at http://www.chrisevansdev.com    *
+*  for more information.                                   *
+*                                                          *
+*  C. Evans, Research Into Robust Visual Features,         *
+*  MSc University of Bristol, 2008.                        *
+*                                                          *
+************************************************************/
+
+#ifndef INTEGRAL_H
+#define INTEGRAL_H
+
+#include <algorithm>  // req'd for std::min/max
+
+// undefine VS macros
+#ifdef min
+  #undef min
+#endif
+
+#ifdef max
+  #undef max
+#endif
+
+#include <opencv2/core/core.hpp>
+
+//! Computes the integral image of image img.  Assumes source image to be a 
+//! 32-bit floating point.  Returns IplImage in 32-bit float form.
+IplImage *Integral(IplImage *img);
+
+
+//! Computes the sum of pixels within the rectangle specified by the top-left start
+//! co-ordinate and size
+inline float BoxIntegral(IplImage *img, int row, int col, int rows, int cols) 
+{
+  float *data = (float *) img->imageData;
+  int step = img->widthStep/sizeof(float);
+
+  // The subtraction by one for row/col is because row/col is inclusive.
+  int r1 = std::min(row,          img->height) - 1;
+  int c1 = std::min(col,          img->width)  - 1;
+  int r2 = std::min(row + rows,   img->height) - 1;
+  int c2 = std::min(col + cols,   img->width)  - 1;
+
+  float A(0.0f), B(0.0f), C(0.0f), D(0.0f);
+  if (r1 >= 0 && c1 >= 0) A = data[r1 * step + c1];
+  if (r1 >= 0 && c2 >= 0) B = data[r1 * step + c2];
+  if (r2 >= 0 && c1 >= 0) C = data[r2 * step + c1];
+  if (r2 >= 0 && c2 >= 0) D = data[r2 * step + c2];
+
+  return std::max(0.f, A - B - C + D);
+}
+
+#endif

data/ext/opensurf/ipoint.cpp

@@ -0,0 +1,108 @@
+/*********************************************************** 
+*  --- OpenSURF ---                                       *
+*  This library is distributed under the GNU GPL. Please   *
+*  use the contact form at http://www.chrisevansdev.com    *
+*  for more information.                                   *
+*                                                          *
+*  C. Evans, Research Into Robust Visual Features,         *
+*  MSc University of Bristol, 2008.                        *
+*                                                          *
+************************************************************/
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/calib3d/calib3d.hpp>
+#include <vector>
+
+#include "ipoint.h"
+
+using namespace cv;
+
+//! Populate IpPairVec with matched ipts 
+void getMatches(IpVec &ipts1, IpVec &ipts2, IpPairVec &matches)
+{
+  float dist, d1, d2;
+  Ipoint *match;
+
+  matches.clear();
+
+  for(unsigned int i = 0; i < ipts1.size(); i++) 
+  {
+    d1 = d2 = FLT_MAX;
+
+    for(unsigned int j = 0; j < ipts2.size(); j++) 
+    {
+      dist = ipts1[i] - ipts2[j];  
+
+      if(dist<d1) // if this feature matches better than current best
+      {
+        d2 = d1;
+        d1 = dist;
+        match = &ipts2[j];
+      }
+      else if(dist<d2) // this feature matches better than second best
+      {
+        d2 = dist;
+      }
+    }
+
+    // If match has a d1:d2 ratio < 0.65 ipoints are a match
+    if(d1/d2 < 0.65) 
+    { 
+      // Store the change in position
+      ipts1[i].dx = match->x - ipts1[i].x; 
+      ipts1[i].dy = match->y - ipts1[i].y;
+      matches.push_back(std::make_pair(ipts1[i], *match));
+    }
+  }
+}
+
+//
+// This function uses homography with CV_RANSAC (OpenCV 1.1)
+// Won't compile on most linux distributions
+//
+
+//-------------------------------------------------------
+
+//! Find homography between matched points and translate src_corners to dst_corners
+int translateCorners(IpPairVec &matches, const CvPoint src_corners[4], CvPoint dst_corners[4])
+{
+#ifndef LINUX
+  double h[9];
+  CvMat _h = cvMat(3, 3, CV_64F, h);
+  std::vector<CvPoint2D32f> pt1, pt2;
+  CvMat _pt1, _pt2;
+  
+  int n = (int)matches.size();
+  if( n < 4 ) return 0;
+
+  // Set vectors to correct size
+  pt1.resize(n);
+  pt2.resize(n);
+
+  // Copy Ipoints from match vector into cvPoint vectors
+  for(int i = 0; i < n; i++ )
+  {
+    pt1[i] = cvPoint2D32f(matches[i].second.x, matches[i].second.y);
+    pt2[i] = cvPoint2D32f(matches[i].first.x, matches[i].first.y);
+  }
+  _pt1 = cvMat(1, n, CV_32FC2, &pt1[0] );
+  _pt2 = cvMat(1, n, CV_32FC2, &pt2[0] );
+
+  // Find the homography (transformation) between the two sets of points
+  if(!cvFindHomography(&_pt1, &_pt2, &_h, CV_RANSAC, 5))  // this line requires opencv 1.1
+    return 0;
+
+  // Translate src_corners to dst_corners using homography
+  for(int i = 0; i < 4; i++ )
+  {
+    double x = src_corners[i].x, y = src_corners[i].y;
+    double Z = 1./(h[6]*x + h[7]*y + h[8]);
+    double X = (h[0]*x + h[1]*y + h[2])*Z;
+    double Y = (h[3]*x + h[4]*y + h[5])*Z;
+    dst_corners[i] = cvPoint(cvRound(X), cvRound(Y));
+  }
+#endif
+  return 1;
+}
+
+

data/ext/opensurf/ipoint.h

@@ -0,0 +1,76 @@
+/*********************************************************** 
+*  --- OpenSURF ---                                       *
+*  This library is distributed under the GNU GPL. Please   *
+*  use the contact form at http://www.chrisevansdev.com    *
+*  for more information.                                   *
+*                                                          *
+*  C. Evans, Research Into Robust Visual Features,         *
+*  MSc University of Bristol, 2008.                        *
+*                                                          *
+************************************************************/
+
+#ifndef IPOINT_H
+#define IPOINT_H
+
+#include <vector>
+#include <math.h>
+
+//-------------------------------------------------------
+
+class Ipoint; // Pre-declaration
+typedef std::vector<Ipoint> IpVec;
+typedef std::vector<std::pair<Ipoint, Ipoint> > IpPairVec;
+
+//-------------------------------------------------------
+
+//! Ipoint operations
+void getMatches(IpVec &ipts1, IpVec &ipts2, IpPairVec &matches);
+int translateCorners(IpPairVec &matches, const CvPoint src_corners[4], CvPoint dst_corners[4]);
+
+//-------------------------------------------------------
+
+class Ipoint {
+
+public:
+
+  //! Destructor
+  ~Ipoint() {};
+
+  //! Constructor
+  Ipoint() : orientation(0) {};
+
+  //! Gets the distance in descriptor space between Ipoints
+  float operator-(const Ipoint &rhs)
+  {
+    float sum=0.f;
+    for(int i=0; i < 64; ++i)
+      sum += (this->descriptor[i] - rhs.descriptor[i])*(this->descriptor[i] - rhs.descriptor[i]);
+    return sqrt(sum);
+  };
+
+  //! Coordinates of the detected interest point
+  float x, y;
+
+  //! Detected scale
+  float scale;
+
+  //! Orientation measured anti-clockwise from +ve x-axis
+  float orientation;
+
+  //! Sign of laplacian for fast matching purposes
+  int laplacian;
+
+  //! Vector of descriptor components
+  float descriptor[64];
+
+  //! Placeholds for point motion (can be used for frame to frame motion analysis)
+  float dx, dy;
+
+  //! Used to store cluster index
+  int clusterIndex;
+};
+
+//-------------------------------------------------------
+
+
+#endif

data/ext/opensurf/kmeans.h

@@ -0,0 +1,172 @@
+/*********************************************************** 
+*  --- OpenSURF ---                                       *
+*  This library is distributed under the GNU GPL. Please   *
+*  use the contact form at http://www.chrisevansdev.com    *
+*  for more information.                                   *
+*                                                          *
+*  C. Evans, Research Into Robust Visual Features,         *
+*  MSc University of Bristol, 2008.                        *
+*                                                          *
+************************************************************/
+
+#include "ipoint.h"
+
+#include <vector>
+#include <time.h>
+#include <stdlib.h>
+
+//-----------------------------------------------------------
+// Kmeans clustering class (under development)
+//  - Can be used to cluster points based on their location.
+//  - Create Kmeans object and call Run with IpVec.
+//  - Planned improvements include clustering based on motion 
+//    and descriptor components.
+//-----------------------------------------------------------
+
+class Kmeans {
+
+public:
+
+  //! Destructor
+  ~Kmeans() {};
+
+  //! Constructor
+  Kmeans() {};
+
+  //! Do it all!
+  void Run(IpVec *ipts, int clusters, bool init = false);
+
+  //! Set the ipts to be used
+  void SetIpoints(IpVec *ipts);
+
+  //! Randomly distribute 'n' clusters
+  void InitRandomClusters(int n);
+
+  //! Assign Ipoints to clusters
+  bool AssignToClusters();
+
+  //! Calculate new cluster centers
+  void RepositionClusters();
+
+  //! Function to measure the distance between 2 ipoints
+  float Distance(Ipoint &ip1, Ipoint &ip2);
+
+  //! Vector stores ipoints for this run
+  IpVec *ipts;
+
+  //! Vector stores cluster centers
+  IpVec clusters;
+
+};
+
+//-------------------------------------------------------
+
+void Kmeans::Run(IpVec *ipts, int clusters, bool init)
+{
+  if (!ipts->size()) return;
+
+  SetIpoints(ipts);
+
+  if (init) InitRandomClusters(clusters);
+  
+  while (AssignToClusters());
+  {
+    RepositionClusters();
+  }
+}
+
+//-------------------------------------------------------
+
+void Kmeans::SetIpoints(IpVec *ipts)
+{
+  this->ipts = ipts;
+}
+
+//-------------------------------------------------------
+
+void Kmeans::InitRandomClusters(int n)
+{
+  // clear the cluster vector
+  clusters.clear();
+
+  // Seed the random number generator
+  srand((int)time(NULL));
+
+  // add 'n' random ipoints to clusters list as initial centers
+  for (int i = 0; i < n; ++i)
+  {
+    clusters.push_back(ipts->at(rand() % ipts->size()));
+  }
+}
+
+//-------------------------------------------------------
+
+bool Kmeans::AssignToClusters()
+{
+  bool Updated = false;
+
+  // loop over all Ipoints and assign each to closest cluster
+  for (unsigned int i = 0; i < ipts->size(); ++i)
+  {
+    float bestDist = FLT_MAX;
+    int oldIndex = ipts->at(i).clusterIndex;
+
+    for (unsigned int j = 0; j < clusters.size(); ++j)
+    {
+      float currentDist = Distance(ipts->at(i), clusters[j]);
+      if (currentDist < bestDist)
+      {
+        bestDist = currentDist;
+        ipts->at(i).clusterIndex = j;
+      }
+    }
+
+    // determine whether point has changed cluster
+    if (ipts->at(i).clusterIndex != oldIndex) Updated = true;
+  }
+
+  return Updated;
+}
+
+//-------------------------------------------------------
+
+void Kmeans::RepositionClusters()
+{
+  float x, y, dx, dy, count;
+
+  for (unsigned int i = 0; i < clusters.size(); ++i)
+  {
+    x = y = dx = dy = 0;
+    count = 1;
+
+    for (unsigned int j = 0; j < ipts->size(); ++j)
+    {
+      if (ipts->at(j).clusterIndex == i)
+      {
+        Ipoint ip = ipts->at(j);
+        x += ip.x;
+        y += ip.y;
+        dx += ip.dx;
+        dy += ip.dy;
+        ++count;
+      }
+    }
+
+    clusters[i].x = x/count;
+    clusters[i].y = y/count;
+    clusters[i].dx = dx/count;
+    clusters[i].dy = dy/count;
+  }
+}
+
+//-------------------------------------------------------
+
+float Kmeans::Distance(Ipoint &ip1, Ipoint &ip2)
+{
+  return sqrt(pow(ip1.x - ip2.x, 2) 
+            + pow(ip1.y - ip2.y, 2)
+            /*+ pow(ip1.dx - ip2.dx, 2) 
+            + pow(ip1.dy - ip2.dy, 2)*/);
+}
+
+//-------------------------------------------------------