opencv-ffi 0.0.1

data/ext/opensurf/utils.h

@@ -0,0 +1,63 @@
+/*********************************************************** 
+*  --- 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 UTILS_H
+#define UTILS_H
+
+#include <opencv2/core/core.hpp>
+#include "ipoint.h"
+
+#include <vector>
+
+
+//! Display error message and terminate program
+void error(const char *msg);
+
+//! Show the provided image and wait for keypress
+void showImage(const IplImage *img);
+
+//! Show the provided image in titled window and wait for keypress
+void showImage(char *title,const IplImage *img);
+
+// Convert image to single channel 32F
+IplImage* getGray(const IplImage *img);
+
+//! Draw a single feature on the image
+void drawIpoint(IplImage *img, Ipoint &ipt, int tailSize = 0);
+
+//! Draw all the Ipoints in the provided vector
+void drawIpoints(IplImage *img, std::vector<Ipoint> &ipts, int tailSize = 0);
+
+//! Draw descriptor windows around Ipoints in the provided vector
+void drawWindows(IplImage *img, std::vector<Ipoint> &ipts);
+
+// Draw the FPS figure on the image (requires at least 2 calls)
+void drawFPS(IplImage *img);
+
+//! Draw a Point at feature location
+void drawPoint(IplImage *img, Ipoint &ipt);
+
+//! Draw a Point at all features
+void drawPoints(IplImage *img, std::vector<Ipoint> &ipts);
+
+//! Save the SURF features to file
+void saveSurf(char *filename, std::vector<Ipoint> &ipts);
+
+//! Load the SURF features from file
+void loadSurf(char *filename, std::vector<Ipoint> &ipts);
+
+//! Round float to nearest integer
+inline int fRound(float flt)
+{
+  return (int) floor(flt+0.5f);
+}
+
+#endif

data/lib/.gitignore

@@ -0,0 +1 @@
+*.so

data/lib/opencv-ffi-ext/eigen.rb

@@ -0,0 +1,84 @@
+
+require 'opencv-ffi'
+require 'opencv-ffi-wrappers'
+
+module CVFFI
+  module Eigen
+    extend NiceFFI::Library
+
+    libs_dir = File.dirname(__FILE__) + "/../../ext/eigen/"
+    pathset = NiceFFI::PathSet::DEFAULT.prepend( libs_dir )
+    load_library("cvffi_eigen", pathset)
+
+
+    ##--- SVD bits ---
+    class EigenSvdResults < NiceFFI::Struct
+      layout :D, CvMat.typed_pointer,
+        :U, CvMat.typed_pointer,
+        :V, CvMat.typed_pointer
+    end
+
+    attach_function :eigenSvdWithCvMat, [:pointer, :pointer, :uchar], :void
+
+    def self.svd( a, opts = {} )
+      thin = opts[:thin] ? 1 : 0
+
+      results = EigenSvdResults.new '\0'
+      eigenSvdWithCvMat( a.to_CvMat, results, thin )
+
+      [ results.U, results.D, results.V ]
+    end
+
+    ##-- Eigenvector solvers
+    class EigenDecompResults < NiceFFI::Struct
+      layout :D, CvMat.typed_pointer,
+             :V, CvMat.typed_pointer
+    end
+
+    attach_function :eigenDecompWithCvMat, [:pointer, :pointer], :void
+
+    def self.eigen( a )
+      results = EigenDecompResults.new '\0'
+      eigenDecompWithCvMat( a.to_CvMat, results )
+
+      [results.D, results.V]
+    end
+    
+
+    ##--- Polynomial solver bits --
+    class Eigen7d <NiceFFI::Struct
+      layout :a, :double,
+             :b, :double,
+             :c, :double,
+             :d, :double,
+             :e, :double,
+             :f, :double,
+             :g, :double
+    end
+
+    class Eigen6d < NiceFFI::Struct
+      layout :a, :double,
+             :b, :double,
+             :c, :double,
+             :d, :double,
+             :e, :double,
+             :f, :double
+    end
+
+    attach_function :eigenPoly6Solver, [Eigen7d.by_value], Eigen6d.by_value
+
+    def self.polySolver( a )
+
+      case a.length
+      when 7  then
+        coeffs = Eigen7d.new( a )
+        answer = eigenPoly6Solver( coeffs )
+      else
+        raise "Can't solve polynomial with #{a.length} coefficients"
+      end
+
+      answer.to_ary
+    end
+  end
+end
+

data/lib/opencv-ffi-ext/features2d.rb

@@ -0,0 +1,4 @@
+
+
+require 'opencv-ffi-wrappers/features2d/image_patch'
+

data/lib/opencv-ffi-ext/matcher_helper.rb

@@ -0,0 +1,24 @@
+
+require 'nice-ffi'
+require 'opencv-ffi-wrappers/matcher'
+
+module CVFFI
+    extend NiceFFI::Library
+
+    libs_dir = File.dirname(__FILE__) + "/../../ext/opencv-ffi/"
+    pathset = NiceFFI::PathSet::DEFAULT.prepend( libs_dir )
+    load_library("cvffi", pathset)
+
+    attach_function :computeReprojError, [:pointer, :pointer], :double
+    attach_function :computeSetReprojError, [:pointer, :pointer], :void
+
+    def self.compute_reproj_error( match, model )
+      computeReprojError( match, model.to_CvMat( :type => :CV_64F ) )
+    end
+
+    def self.compute_set_reproj_error( matchSet, model )
+      computeSetReprojError( matchSet, model.to_CvMat( :type => :CV_64F ) ) 
+    end
+end
+
+

data/lib/opencv-ffi-ext/opensurf.rb

@@ -0,0 +1,217 @@
+
+require 'nice-ffi'
+
+require 'opencv-ffi-wrappers/features2d/surf'
+
+module CVFFI
+  module OpenSURF
+    extend NiceFFI::Library
+
+    libs_dir = File.dirname(__FILE__) + "/../../ext/opensurf/"
+    pathset = NiceFFI::PathSet::DEFAULT.prepend( libs_dir )
+    load_library("cvffi_opensurf", pathset)
+
+    class OpenSURFParams < NiceFFI::Struct
+      layout :upright, :char,
+             :octaves, :int,
+             :intervals, :int,
+             :init_sample, :int,
+             :thres, :float 
+    end
+
+    class OpenSURFPoint < NiceFFI::Struct
+      layout :pt, CvPoint,
+             :scale, :float,
+             :orientation, :float,
+             :laplacian, :int,
+             :descriptor, [ :float, 64 ]
+    end
+
+
+    # CvSeq *opensurfDet( IplImage *img,
+    #                   CvMemStorage *storage,
+    #                   CvSURFParams params )
+    attach_function :openSurfDetect, [ :pointer, :pointer, OpenSURFParams.by_value ], CvSeq.typed_pointer 
+    attach_function :openSurfDescribe, [ :pointer, :pointer, OpenSURFParams.by_value ], CvSeq.typed_pointer 
+    attach_function :createOpenSURFPointSequence, [:pointer ], CvSeq.typed_pointer
+
+    class Result
+      attr_accessor :kp
+      def initialize( kp )
+         @kp = CVFFI::OpenSURF::OpenSURFPoint.new(kp)
+      end
+
+      def pt; @kp.pt; end
+      def x;  pt.x; end
+      def y;  pt.y; end
+
+      def scale; @kp.scale; end
+      def laplacian; @kp.laplacian; end
+      def orientation; @kp.orientation; end
+      def descriptor; @kp.descriptor; end
+
+      def distance_to(b)
+        CVFFI::VectorMath::L2distance( @kp.descriptor, b.descriptor, 64 )
+      end
+
+      def to_vector
+        Vector.[]( x, y, 1 )
+      end
+      
+      def to_Point
+        pt.to_Point
+      end
+
+      def packed_descriptor
+        [@kp.descriptor.to_a.pack('e64')].pack('m0')
+      end
+   end
+
+    class ResultArray
+      include Enumerable
+
+      attr_reader :kp, :pool
+
+      def initialize( kp, pool )
+        @kp = Sequence.new(kp)
+        @pool = pool
+        @results = Array.new( @kp.length )
+
+        destructor = Proc.new { poolPtr = FFI::MemoryPointer.new :pointer 
+                                poolPtr.putPointer( 0, @pool ) 
+                                cvReleaseMemStorage( poolPtr ) }
+        ObjectSpace.define_finalizer( self, destructor )
+      end
+
+      def reset( kp )
+        @kp = Sequence.new(kp)
+        @pool = kp.storage
+        @results = Array.new( @kp.length )
+        self
+      end
+
+      def result(i)
+        @results[i] ||= Result.new( @kp[i] )
+      end
+
+      def each
+        @results.each_index { |i| 
+          yield result(i) 
+        }
+      end
+
+      def [](i)
+        result(i)
+      end
+
+      def size
+        @kp.size
+      end
+      alias :length :size
+
+      def to_CvSeq
+        @kp.seq
+      end
+
+      def mark_on_image( img, opts )
+        each { |r|
+          CVFFI::draw_circle( img, r.kp.pt, opts )
+        }
+      end
+
+      def to_a
+        Array.new( size ) { |i|
+          r = result(i)
+          [ r.x, r.y, r.scale, r.orientation, r.laplacian, r.packed_descriptor ]
+          }
+      end
+
+      def self.from_a( a )
+        a = YAML::load(a) if a.is_a? String
+        raise "Don't know what to do" unless a.is_a? Array
+
+        pool = CVFFI::cvCreateMemStorage(0)
+        cvseq = CVFFI::OpenSURF::createOpenSURFPointSequence( pool )
+        seq = Sequence.new cvseq
+        
+        a.each { |r|
+          raise "Hm, not what I expected" unless r.length == 6
+          point = CVFFI::OpenSURF::OpenSURFPoint.new( '' )
+          # Hm, the embedded CvPoint buggers up initialization by hash
+          point.scale = r[2]
+          point.orientation = r[3]
+          point.laplacian = r[4]
+          d = r[5].unpack('m')[0].unpack('e64')
+
+          d.each_with_index { |d,i| point.descriptor[i] = d }
+
+          # r[5].unpack('e64')
+          point.pt.x = r[0]
+          point.pt.y = r[1]
+          seq.push( point )
+        }
+
+
+        ra = ResultArray.new( cvseq, pool )
+      end
+
+    end
+
+    class Params
+      DEFAULTS = { upright: 0,
+                   octaves: 5,
+                   intervals: 4,
+                   thres: 0.0004,
+                   init_sample: 2 }
+
+      def initialize( opts = {} )
+        @params = {}
+        DEFAULTS.keys.each { |k|
+          @params[k] = opts[k] || DEFAULTS[k]
+        }
+      end
+
+      def to_OpenSurfParams
+        OpenSURFParams.new( @params )
+      end
+
+      def to_hash
+        @params
+      end
+    end
+
+
+    # Detection sets x,y,scale, laplacian
+    def self.detect( img, params )
+      params = params.to_OpenSurfParams unless params.is_a?( OpenSURFParams ) 
+      raise ArgumentError unless params.is_a?( OpenSURFParams ) 
+
+      mem_storage = CVFFI::cvCreateMemStorage( 0 )
+
+      img = img.ensure_greyscale
+      kp = CVFFI::CvSeq.new openSurfDetect( img, mem_storage, params )
+
+      ResultArray.new( kp, mem_storage )
+    end
+
+    # Descriptor takes x,y, scale.  Apparently not laplcian
+    # Sets orientation, descriptor
+    def self.describe( img, points, params )
+      params = params.to_OpenSurfParams unless params.is_a?( OpenSURFParams ) 
+      raise ArgumentError unless params.is_a?( OpenSURFParams ) 
+
+      img = img.ensure_greyscale
+
+      puts "Extracting #{points.length} features"
+
+      kp = points.to_CvSeq
+
+      openSurfDescribe( img, kp, params )
+
+      points.reset(kp)
+      points
+    end
+
+
+  end
+end

data/lib/opencv-ffi-ext/sift.rb

@@ -0,0 +1,118 @@
+
+require 'nice-ffi'
+
+require 'opencv-ffi-wrappers/misc/params'
+
+module CVFFI
+
+  module SIFT
+    extend NiceFFI::Library
+
+    libs_dir = File.dirname(__FILE__) + "/../../ext/aishack-sift/"
+    pathset = NiceFFI::PathSet::DEFAULT.prepend( libs_dir )
+    load_library("cvffi_sift", pathset)
+
+    class SiftParams < NiceFFI::Struct
+      layout :octaves, :int,
+        :intervals, :int
+    end
+
+    NUM_BINS = 36
+    class SiftKeypoint < NiceFFI::Struct
+      layout :x, :float,
+        :y, :float,
+        :mag, [:float, NUM_BINS],
+        :orien, [:float, NUM_BINS],
+        :num_bins, :uint,
+        :scale, :uint
+    end
+
+    FV_LENGTH = 128
+    class SiftDescriptor < NiceFFI::Struct
+      layout :x, :float,
+        :y, :float,
+        :fv, [:float, FV_LENGTH],
+        :fv_length, :uint
+    end
+
+    class SiftResults< NiceFFI::Struct
+      layout :kps, :pointer,
+        :descs, :pointer,
+        :len, :uint
+    end
+
+    class Results
+      attr_accessor :kps, :descs
+
+      def initialize( k, d )
+        @kps = k
+        @descs = d
+      end
+
+      def size
+        @kps.length
+      end
+      alias :length :size
+
+      def to_a
+        a = Array.new
+        a << Array.new( size ) { |i|
+          kp = kps[i]
+          [ kp.x, kp.y, kp.mag, kp.orien, kp.num_bins, kp.scale ]
+        }
+        a << Array.new( size ) { |i|
+          d = descs[i]
+          [d.x, d.y, d.fv, d.fv_length]
+        }
+      end
+
+      def self.from_a( a )
+        a = YAML::load(a) if a.is_a? String
+        raise "Don't know what to do" unless a.is_a? Array
+        raise "Result isn't a two-element array" unless a.length == 2
+
+        kps = a[0]
+        descs = a[1]
+      end
+
+    end
+
+    attach_function :siftDetectDescribe_real, :siftDetectDescribe, [ :pointer, SiftParams.by_value ], SiftResults.typed_pointer
+
+
+    class Params < CVFFI::Params
+      param :octaves, 4
+      param :intervals, 5 
+
+      def to_SiftParams
+        SiftParams.new( octaves: octaves, 
+                       intervals: intervals )
+      end
+
+    end
+
+
+    def self.detect( image, params )
+      params = params.to_SiftParams unless params.is_a?( SiftParams )
+
+      puts "Running SIFT algorithm with #{params.octaves} octaves and #{params.intervals} intervals."
+
+      kps = siftDetectDescribe_real( image, params )
+
+      # Unwrap the SiftKeypoints to an Array.
+      keypoints = Array.new( kps.len ) { |i|
+        SiftKeypoint.new( kps.kps + (i*SiftKeypoint.size))
+      }
+      descs = Array.new( kps.len ) { |i|
+        SiftDescriptor.new( kps.descs + (i*SiftDescriptor.size) )
+      }
+
+      p keypoints[0]
+      p descs[0]
+
+      Results.new( keypoints, descs )
+    end
+
+
+  end
+end