opencv-ffi 0.0.1

data/ext/aishack-sift/SIFT.h

@@ -0,0 +1,84 @@
+/****************************************************** 
+ *	Code by Utkarsh Sinha
+ *	Based on JIFT by Jun Liu
+ *	Visit http://aishack.in/ for more indepth articles and tutorials
+ *	on artificial intelligence
+ * Use, reuse, modify, hack, kick. Do whatever you want with
+ * this code :)
+ ******************************************************/
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+
+#include "KeyPoint.h"
+#include "Descriptor.h"
+
+#define SIGMA_ANTIALIAS			0.5
+#define SIGMA_PREBLUR			1.0
+#define CURVATURE_THRESHOLD		5.0
+#define CONTRAST_THRESHOLD		0.03		// in terms of 255
+#define NUM_BINS				36
+#define MAX_KERNEL_SIZE			20
+#define FEATURE_WINDOW_SIZE		16
+#define DESC_NUM_BINS			8
+#define FVSIZE					128
+#define	FV_THRESHOLD			0.2
+
+
+class SIFT
+{
+  public:
+    SIFT(IplImage* img, int octaves, int intervals);
+    SIFT(const char* filename, int octaves, int intervals);
+    ~SIFT();
+
+    void DoSift();
+    void DetectKeypoints();
+    void DescribeKeypoints();
+
+    void ShowKeypoints();
+    void ShowAbsSigma();
+
+    const vector<Keypoint> keypoints( void ) { return m_keyPoints; }
+    const vector<Descriptor> descriptors( void ) { return m_keyDescs; }
+
+  private:
+    void GenerateLists();
+    void BuildScaleSpace();
+    void DetectExtrema();
+    void AssignOrientations();
+    void ExtractKeypointDescriptors();
+
+    unsigned int GetKernelSize(double sigma, double cut_off=0.001);
+    CvMat* BuildInterpolatedGaussianTable(unsigned int size, double sigma);
+    double gaussian2D(double x, double y, double sigma);
+
+
+  private:
+    IplImage* m_srcImage;			// The image we're working on
+    unsigned int m_numOctaves;		// The desired number of octaves
+    unsigned int m_numIntervals;	// The desired number of intervals
+    unsigned int m_numKeypoints;	// The number of keypoints detected
+
+    IplImage***	m_gList;		// A 2D array to hold the different gaussian blurred images
+    IplImage*** m_dogList;		// A 2D array to hold the different DoG images
+    IplImage*** m_extrema;		// A 2D array to hold binary images. In the binary image, 1 = extrema, 0 = not extrema
+    double**	m_absSigma;		// A 2D array to hold the sigma used to blur a particular image
+
+    class Extrema {
+      public:
+      int octave, interval, xi, yi;
+
+      Extrema( int oct, int intv, int x, int y )
+        : octave( oct ), interval( intv ), xi( x ), yi( y )
+      {}
+    };
+
+    vector<Extrema> extrema;
+
+    vector<Keypoint> m_keyPoints;	// Holds each keypoint's basic info
+    vector<Descriptor> m_keyDescs;	// Holds each keypoint's descriptor
+
+    IplImage *magnitude_mat( int i, int j );
+    double orientation_at( int i, int j, int xi, int yi );
+};

data/ext/aishack-sift/example/.gitignore

@@ -0,0 +1,2 @@
+MySIFT
+ReadMe.txt

data/ext/aishack-sift/example/Makefile

@@ -0,0 +1,24 @@
+
+CXX = g++
+BIN = MySIFT
+OBJS = MySIFT.o  ../SIFT.o
+
+CFLAGS = -ggdb -I.. -I/localhome/amm299/usr/include
+LFLAGS = -L/localhome/amm299/usr/lib 
+LIBS = -lopencv_core -lopencv_highgui -lopencv_imgproc
+
+
+default: run
+
+run: $(BIN)
+	LD_LIBRARY_PATH=~/usr/lib ./MySIFT 
+
+
+$(BIN): $(OBJS)
+	$(CXX) $(CFLAGS) -o $@ $^ $(LFLAGS) $(LIBS)
+
+.cpp.o:
+	$(CXX) -c  $(CFLAGS) -o $@ $^
+
+clean:
+	rm -f $(BIN) *.o

data/ext/aishack-sift/example/MySIFT.cpp

@@ -0,0 +1,29 @@
+/****************************************************** 
+ *	Code by Utkarsh Sinha
+ *	Based on JIFT by Jun Liu
+ *	Visit http://aishack.in/ for more indepth articles and tutorials
+ *	on artificial intelligence
+ * Use, reuse, modify, hack, kick. Do whatever you want with
+ * this code :)
+ ******************************************************/
+
+// MySIFT.cpp : Defines the entry point for the console application.
+//
+
+#include "SIFT.h"
+
+#include <opencv2/core/core.hpp>
+
+// The main function!
+int main()
+{
+  // Create an instance of SIFT
+  SIFT *sift = new SIFT("IMG_7088_small.JPG", 1, 5);
+
+  sift->DoSift();				// Find keypoints
+
+  // Cleanup and exit
+  delete sift;
+  return 0;
+}
+

data/ext/aishack-sift/mkrf_conf.rb

@@ -0,0 +1,13 @@
+require '../mkrf-monkey'
+
+Mkrf::Generator.new('libcvffi_sift', [ "*.cpp" ], { :compiler=>"g++"}) { |g|
+  g.include_library 'stdc++'
+
+  raise "Can't find 'opencv_core'" unless g.include_library 'opencv_core', 'main', "#{ENV['HOME']}/usr/lib"
+  raise "Can't find 'opencv_imgproc'" unless g.include_library 'opencv_imgproc', 'main', "#{ENV['HOME']}/usr/lib"
+  raise "Can't find 'opencv_highgui'" unless g.include_library 'opencv_highgui', 'main', "#{ENV['HOME']}/usr/lib"
+
+  g.cflags += "-I#{ENV['HOME']}/usr/include "
+
+}
+

data/ext/aishack-sift/siftlib.cpp

@@ -0,0 +1,85 @@
+
+#include "SIFT.h"
+
+#include <stdio.h>
+
+typedef struct {
+  int octaves;
+  int intervals;
+} SiftParams_t;
+
+typedef struct {
+  float xi;
+  float yi;
+  float mag[NUM_BINS];
+  float orien[NUM_BINS];
+  unsigned int num_bins;
+
+  unsigned int scale;
+} SiftKeypoint_t;
+
+typedef struct {
+  float xi, yi;
+  float fv[FVSIZE];
+  unsigned int fv_size;
+} SiftDescriptor_t;
+
+typedef struct {
+  SiftKeypoint_t *kps;
+  SiftDescriptor_t *descs;
+  unsigned int len;
+} SiftResults_t;
+
+
+SiftResults_t *buildSiftResults( const vector<Keypoint> kps, const vector<Descriptor> descs )
+{
+  printf("Creating array for %d keypoints.\n", kps.size() );
+  SiftKeypoint_t *kp_array = new SiftKeypoint_t[ kps.size() ];
+
+  unsigned int idx = 0;
+  for( vector<Keypoint>::const_iterator itr = kps.begin(); itr != kps.end(); itr++ ) {
+    kp_array[idx].xi = (*itr).xi;
+    kp_array[idx].yi = (*itr).yi;
+    kp_array[idx].scale = (*itr).scale;
+
+    assert( (*itr).mag.size() == (*itr).orien.size() );
+
+    kp_array[idx].num_bins = (*itr).mag.size();
+    for( unsigned int j = 0; j < (*itr).mag.size(); j++ ) {
+      kp_array[idx].mag[j]   = (*itr).mag[j];
+      kp_array[idx].orien[j] = (*itr).orien[j];
+    }
+
+    idx++;
+  }
+
+  printf("Creating array for %d descriptors.\n", descs.size() );
+  SiftDescriptor_t *desc_array = new SiftDescriptor_t[ descs.size() ];
+  idx = 0;
+  for( vector<Descriptor>::const_iterator itr = descs.begin(); itr != descs.end(); itr++ ) {
+    desc_array[idx].xi = (*itr).xi;
+    desc_array[idx].yi = (*itr).yi;
+
+    desc_array[idx].fv_size = FVSIZE;
+    for( unsigned int i = 0; i < FVSIZE; i++ ) {
+      desc_array[idx].fv[i] = (*itr).fv[i];
+    }
+    ++idx;
+  }
+
+  SiftResults_t *results= new SiftResults_t;
+  results->kps = kp_array;
+  results->descs = desc_array;
+  results->len = kps.size();
+
+  return results;
+}
+
+extern "C" 
+SiftResults_t *siftDetectDescribe( IplImage *img, SiftParams_t params )
+{
+  SIFT sift( img, params.octaves, params.intervals );
+  sift.DoSift();
+
+  return buildSiftResults( sift.keypoints(), sift.descriptors() );
+}

data/ext/eigen/.gitignore

@@ -0,0 +1,4 @@
+*.o
+Rakefile
+libcvffi_eigen.so
+mkrf.log

data/ext/eigen/eigen_polynomial.cpp

@@ -0,0 +1,41 @@
+
+#include <eigen3/Eigen/Core>
+#include <eigen3/unsupported/Eigen/Polynomials>
+#include <vector>
+#include <iostream>
+
+using Eigen::MatrixXf;
+using namespace Eigen;
+using namespace std;
+
+
+typedef struct {
+  double a[7];
+} Eigen7d_t;
+
+typedef struct {
+  double a[6];
+} Eigen6d_t;
+
+extern "C"
+Eigen6d_t eigenPoly6Solver( Eigen7d_t coeff )
+{
+  Eigen::Matrix<double,7,1> polynomial;
+  for( unsigned int i = 0; i < 7; i++ ) polynomial[i] = coeff.a[i]; 
+
+  PolynomialSolver<double,6> psolve( polynomial );
+
+  std::vector<double> realRoots;
+  psolve.realRoots( realRoots );
+
+  Eigen6d_t result;
+  for( unsigned int i = 0; i < 6; i++ ) {
+    if( i < realRoots.size() )
+      result.a[i] = realRoots[i];
+    else
+      result.a[i] = 0.0;
+  }
+
+  return result;
+}
+

data/ext/eigen/eigen_svd.cpp

@@ -0,0 +1,100 @@
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/core/core_c.h>
+#include <eigen3/Eigen/Core>
+#include <eigen3/Eigen/SVD>
+#include <eigen3/Eigen/Eigenvalues>
+
+using Eigen::MatrixXf;
+using namespace Eigen;
+using namespace cv;
+
+
+typedef struct {
+  CvMat *D;
+  CvMat *U, *V;
+} EigenSVDResult_t;
+
+MatrixXf cvMatToEigen( CvMat *A )
+{
+  MatrixXf a( A->rows, A->cols );
+  for( int i = 0; i < A->rows; i++ ) {
+    for( int j = 0; j < A->cols; j++ ) {
+      a(i,j) = cvGetReal2D( A, i, j );
+    }
+  }
+  return a;
+}
+
+CvMat *eigenToCvMat( MatrixXf a )
+{
+  CvMat *mat = cvCreateMat( a.rows(), a.cols(), CV_32F );
+  
+  for( int i = 0; i < a.rows(); i++ ) {
+    for( int j = 0; j < a.cols(); j++ ) { 
+      cvSetReal2D( mat, i, j, a(i,j) );
+    }
+  }
+
+  return mat;
+}
+
+extern "C"
+void eigenSvdWithCvMat( CvMat* A, EigenSVDResult_t *result, unsigned char thin )
+{
+  // Brute force pack/unpack I'm afraid
+//  assert( ( A->type == CV_32F ) || (A->type == CV_64F) );
+
+  MatrixXf m = cvMatToEigen( A );
+  unsigned int options = (thin == 0) ? (ComputeFullU | ComputeFullV) : (ComputeThinU | ComputeThinV);
+  JacobiSVD<MatrixXf> svd( m, options );
+
+  result->D = eigenToCvMat( svd.singularValues() );
+  result->U = eigenToCvMat( svd.matrixU() );
+  result->V = eigenToCvMat( svd.matrixV() );
+}
+
+typedef struct {
+  CvMat *D;
+  CvMat *V;
+} EigenDecompResult_t;
+
+CvMat *eigenvaluesToCvMat( EigenSolver<MatrixXf>::EigenvalueType a )
+{
+  CvMat *mat = cvCreateMat( a.rows(), a.cols(), CV_32F );
+  
+  for( int i = 0; i < a.rows(); i++ ) {
+    for( int j = 0; j < a.cols(); j++ ) { 
+      cvSetReal2D( mat, i, j, a(i,j).real() );
+    }
+  }
+
+  return mat;
+}
+
+CvMat *eigenvectorsToCvMat( EigenSolver<MatrixXf>::EigenvectorsType a )
+{
+  CvMat *mat = cvCreateMat( a.rows(), a.cols(), CV_32F );
+  
+  for( int i = 0; i < a.rows(); i++ ) {
+    for( int j = 0; j < a.cols(); j++ ) { 
+      cvSetReal2D( mat, i, j, a(i,j).real() );
+    }
+  }
+
+  return mat;
+}
+
+extern "C"
+void eigenDecompWithCvMat( CvMat *A, EigenDecompResult_t *result )
+{
+  // Brute force pack/unpack I'm afraid
+//  assert( ( A->type == CV_32F ) || (A->type == CV_64F) );
+
+  MatrixXf m = cvMatToEigen( A );
+  EigenSolver<MatrixXf> eig( m );
+
+  result->D = eigenvaluesToCvMat( eig.eigenvalues() );
+  result->V = eigenvectorsToCvMat( eig.eigenvectors() );
+}
+

data/ext/eigen/mkrf_conf.rb

@@ -0,0 +1,14 @@
+require '../mkrf-monkey'
+
+# The compiler for availability checking must be specified as 'g++'
+# otherwise it will use gcc and choke on Eigen
+#
+Mkrf::Generator.new('libcvffi_eigen', [ "*.cpp" ], { :compiler=>"g++"}) { |g|
+  g.include_library 'stdc++'
+  raise "Can't find 'opencv_core'" unless g.include_library 'opencv_core', 'main', "#{ENV['HOME']}/usr/lib"
+  raise "Can't find #include<eigne3/Eigen/Core>" unless g.include_header  'eigen3/Eigen/Core', "#{ENV['HOME']}/usr/include"
+
+  # This is awkward.  Eigen's unsupported has internal includes <Eigen/Core>
+  g.cflags += "-I#{ENV['HOME']}/usr/include -I/usr/local/include/eigen3 -I#{ENV['HOME']}/usr/include/eigen3"
+}
+

data/ext/mkrf-monkey.rb

@@ -0,0 +1,85 @@
+
+require 'mkrf'
+
+# I admit it, I'm monkey-patching mkrf to get the behavior I want.
+module Mkrf
+
+  class Generator
+
+    def rakefile_contents # :nodoc:
+      objext = CONFIG['OBJEXT']
+      cc = CONFIG['CC'] || 'gcc'
+      cpp = CONFIG['CXX'] || 'g++'
+      extension_sym = File.basename( @extension_name, ".#{CONFIG['DLEXT']}" ).to_sym
+
+
+      <<-END_RAKEFILE
+# Generated by mkrf, monkey patched for opencv-ffi
+require 'rake/clean'
+
+
+SRC = FileList[#{sources.join(',')}]
+OBJ = SRC.ext('#{objext}')
+CC = '#{cc}'
+CPP = '#{cpp}'
+
+CLEAN.include(OBJ)
+CLOBBER.include('#{@extension_name}', 'mkrf.log', 'Rakefile')
+
+ADDITIONAL_OBJECTS = '#{objects}'
+
+LDSHARED = "#{@available.ldshared_string} #{ldshared}"
+
+LIBPATH =  "#{library_path(CONFIG['libdir'])} #{@available.library_paths_compile_string}"
+
+INCLUDES = "#{@available.includes_compile_string}"
+
+LIBS = "#{@available.library_compile_string}"
+
+CFLAGS = "#{cflags} #{defines_compile_string}"
+
+RUBYARCHDIR = "\#{ENV["RUBYARCHDIR"]}"
+LIBRUBYARG_SHARED = "#{CONFIG['LIBRUBYARG_SHARED']}"
+
+task :default => :build_library
+
+# Add one layer of indirection so I can generically call "rake build_library"
+# and have it work ... or not work if the wrong rakefile is being run
+task :build_library => '#{@extension_name}'
+
+rule '.#{objext}' => '.c' do |t|
+  sh "\#{CC} \#{CFLAGS} \#{INCLUDES} -o \#{t.name} -c \#{t.source}"
+end
+
+rule '.#{objext}' => '.cpp' do |t|
+  sh "\#{CPP} \#{CFLAGS} \#{INCLUDES} -o \#{t.name} -c \#{t.source}"
+end
+
+DEPS = OBJ.clone.add('Rakefile')
+desc "Build this extension"
+file '#{@extension_name}' => DEPS do
+  sh "\#{LDSHARED} \#{LIBPATH} #{@available.ld_outfile(@extension_name)} \#{OBJ} \#{ADDITIONAL_OBJECTS} \#{LIBS} \#{LIBRUBYARG_SHARED}"
+end
+
+desc "Rebuild rakefile"
+file 'Rakefile' => 'mkrf_conf.rb' do |t|
+  ruby 'mkrf_conf.rb'
+  puts "Rebuilt Rakefile.  Run \'rake #{extension_sym.to_s}\' again"
+end
+
+desc "Install this extension"
+task :install => '#{@extension_name}' do
+  makedirs "\#{RUBYARCHDIR}"
+  install "#{@extension_name}", "\#{RUBYARCHDIR}"
+end
+
+#{additional_code}
+      END_RAKEFILE
+    end
+ 
+
+  end
+
+end
+
+