opencv-ffi-fast 0.0.1

data/ext/fast/mkrf_conf.rb

@@ -0,0 +1,6 @@
+require '../mkrf-monkey'
+
+Mkrf::Generator.new('libcvffi_fast', [ "*.c"]) { |g|
+}
+
+

data/ext/fast/nonmax.c

@@ -0,0 +1,117 @@
+#include <stdlib.h>
+#include "fast.h"
+
+
+#define Compare(X, Y) ((X)>=(Y))
+
+xy* nonmax_suppression(const xy* corners, const int* scores, int num_corners, int* ret_num_nonmax)
+{
+	int num_nonmax=0;
+	int last_row;
+	int* row_start;
+	int i, j;
+	xy* ret_nonmax;
+	const int sz = (int)num_corners; 
+
+	/*Point above points (roughly) to the pixel above the one of interest, if there
+    is a feature there.*/
+	int point_above = 0;
+	int point_below = 0;
+
+	
+	if(num_corners < 1)
+	{
+		*ret_num_nonmax = 0;
+		return 0;
+	}
+
+	ret_nonmax = (xy*)malloc(num_corners * sizeof(xy));
+
+	/* Find where each row begins
+	   (the corners are output in raster scan order). A beginning of -1 signifies
+	   that there are no corners on that row. */
+	last_row = corners[num_corners-1].y;
+	row_start = (int*)malloc((last_row+1)*sizeof(int));
+
+	for(i=0; i < last_row+1; i++)
+		row_start[i] = -1;
+	
+	{
+		int prev_row = -1;
+		for(i=0; i< num_corners; i++)
+			if(corners[i].y != prev_row)
+			{
+				row_start[corners[i].y] = i;
+				prev_row = corners[i].y;
+			}
+	}
+	
+	
+	
+	for(i=0; i < sz; i++)
+	{
+		int score = scores[i];
+		xy pos = corners[i];
+			
+		/*Check left */
+		if(i > 0)
+			if(corners[i-1].x == pos.x-1 && corners[i-1].y == pos.y && Compare(scores[i-1], score))
+				continue;
+			
+		/*Check right*/
+		if(i < (sz - 1))
+			if(corners[i+1].x == pos.x+1 && corners[i+1].y == pos.y && Compare(scores[i+1], score))
+				continue;
+			
+		/*Check above (if there is a valid row above)*/
+		if(pos.y != 0 && row_start[pos.y - 1] != -1) 
+		{
+			/*Make sure that current point_above is one
+			  row above.*/
+			if(corners[point_above].y < pos.y - 1)
+				point_above = row_start[pos.y-1];
+			
+			/*Make point_above point to the first of the pixels above the current point,
+			  if it exists.*/
+			for(; corners[point_above].y < pos.y && corners[point_above].x < pos.x - 1; point_above++)
+			{}
+			
+			
+			for(j=point_above; corners[j].y < pos.y && corners[j].x <= pos.x + 1; j++)
+			{
+				int x = corners[j].x;
+				if( (x == pos.x - 1 || x ==pos.x || x == pos.x+1) && Compare(scores[j], score))
+					goto cont;
+			}
+			
+		}
+			
+		/*Check below (if there is anything below)*/
+		if(pos.y != last_row && row_start[pos.y + 1] != -1 && point_below < sz) /*Nothing below*/
+		{
+			if(corners[point_below].y < pos.y + 1)
+				point_below = row_start[pos.y+1];
+			
+			/* Make point below point to one of the pixels belowthe current point, if it
+			   exists.*/
+			for(; point_below < sz && corners[point_below].y == pos.y+1 && corners[point_below].x < pos.x - 1; point_below++)
+			{}
+
+			for(j=point_below; j < sz && corners[j].y == pos.y+1 && corners[j].x <= pos.x + 1; j++)
+			{
+				int x = corners[j].x;
+				if( (x == pos.x - 1 || x ==pos.x || x == pos.x+1) && Compare(scores[j],score))
+					goto cont;
+			}
+		}
+		
+		ret_nonmax[num_nonmax++] = corners[i];
+		cont:
+			;
+	}
+
+	free(row_start);
+	*ret_num_nonmax = num_nonmax;
+	return ret_nonmax;
+}
+

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
+
+

data/ext/mkrf-rakehelper-monkey.rb

@@ -0,0 +1,52 @@
+
+require 'mkrf/rakehelper'
+
+alias :old_setup_extension :setup_extension
+
+module Mkrf
+  @all_libs = []
+
+  def self.all_libs
+    @all_libs
+  end
+
+  def self.all_libs=(a)
+    @all_libs = a
+  end
+end
+
+def rake( rakedir, args = nil )
+  Dir.chdir( rakedir ) do
+    if args
+      sh "rake #{args}"
+    else
+      sh 'rake'
+    end
+  end
+end
+
+def setup_extension(dir, extension)
+
+  old_setup_extension( dir, extension )
+
+  ext_dir = "ext/#{dir}"
+  ext_so = "#{ext_dir}/#{extension}.#{Config::CONFIG['DLEXT']}"
+
+  task ext_so => FileList["#{ext_dir}/**/*.c*", "#{ext_dir}/mkrf_conf.rb"]
+
+  Mkrf::all_libs << extension.to_sym
+
+  namespace extension.to_sym do
+
+    desc "Run \"rake clean\" in #{ext_dir}"
+    task :clean do
+      rake ext_dir, 'clean'
+    end
+
+    desc "Run \"rake clobber\" in #{ext_dir}"
+    task :clobber do
+      rake extd_dir, 'clobber'
+    end
+  end
+
+end

data/ext/mkrf_conf.rb

@@ -0,0 +1,3 @@
+#
+# Just a shell to fake out Gem
+#

data/lib/opencv-ffi-fast.rb

@@ -0,0 +1 @@
+require "opencv-ffi-fast/version"

data/lib/opencv-ffi-fast/fast.rb

@@ -0,0 +1,113 @@
+
+require 'nice-ffi'
+require 'opencv-ffi'
+
+module CVFFI
+  module FAST
+
+    class FASTResultsArray
+      include Enumerable
+
+      attr_accessor :points
+      attr_accessor :nPoints
+
+      def initialize( pts, nPts )
+        @points = pts
+        @nPoints = nPts
+
+        # Define a destructor do dispose of the results
+        destructor = Proc.new { pts.free }
+        ObjectSpace.define_finalizer( self, destructor )
+      end
+
+      def each
+        if @nPoints > 0
+          0.upto(@nPoints-1) { |i|
+yield Xy.new( @points[i] )
+          }
+        end
+      end
+
+      alias :size :nPoints
+
+    end
+
+    class Params
+      attr_accessor :points, :threshold
+
+      VALID_SIZES = [ 9, 10, 11, 12 ]
+
+      def size_valid?( sz )
+        VALID_SIZES.include? sz
+      end
+
+      def initialize( opts = {} )
+        p opts
+        @points = opts[:points] ||  9
+        @threshold = opts[:threshold] || 20
+
+        raise "Hm, invalid size #{@points} specified for FAST keypoint detector" unless size_valid? @points
+      end
+
+      def to_hash
+        { :points => @points, :threshold => @threshold }
+      end
+    end
+
+
+    def self.detect( img, params )
+      FASTDetect( params.points, img, params.threshold )
+    end
+
+    def self.FASTDetect( size, img, threshold )
+      nResults = FFI::MemoryPointer.new :int
+
+      if img.is_a?( IplImage )
+        # Ensure the image is b&w
+        img = img.ensure_greyscale
+
+        results = FFI::Pointer.new :pointer, method("fast#{size}_detect").call( img.imageData, img.width, img.height, img.widthStep, threshold, nResults )
+      else
+        raise ArgumentError, "Don't know how to deal with image class #{img.class}"
+      end
+
+      # Dereference the two pointers
+      nPoints = nResults.read_int
+      points = FFI::Pointer.new Xy, results
+
+      FASTResultsArray.new( points, nPoints )
+    end
+
+    def self.FAST9Detect( img, threshold );  FASTDetect( 9, img, threshold ); end
+    def self.FAST10Detect( img, threshold ); FASTDetect( 10, img, threshold ); end
+    def self.FAST11Detect( img, threshold ); FASTDetect( 11, img, threshold ); end
+    def self.FAST12Detect( img, threshold ); FASTDetect( 12, img, threshold ); end
+
+#
+## Here's the actual FFI interface
+#
+    extend NiceFFI::Library
+
+    libs_dir = File.dirname(__FILE__) + "/../../ext/fast/"
+    pathset = NiceFFI::PathSet::DEFAULT.prepend( libs_dir )
+    load_library("cvffi_fast", pathset)
+
+    class Xy < NiceFFI::Struct
+      layout :x, :int,
+             :y, :int
+    end
+
+    # Leave result as pointer, not Xy.typed_pointer as it makes it easier to deference
+    # it to an array of Xy
+
+    def self.fast_detect_function( sz )
+      attach_function "fast#{sz}_detect".to_sym, [ :pointer, :int, :int, :int, :int, :pointer ], :pointer
+    end
+
+    fast_detect_function 9
+    fast_detect_function 10
+    fast_detect_function 11
+    fast_detect_function 12
+
+  end
+end

data/lib/opencv-ffi-fast/version.rb

@@ -0,0 +1,5 @@
+module CVFFI
+  module FAST
+    VERSION = "0.0.1"
+  end
+end

data/opencv-ffi-fast.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "opencv-ffi-fast/version"
+
+Gem::Specification.new do |s|
+  s.name        = "opencv-ffi-fast"
+  s.version     = CVFFI::FAST::VERSION
+  s.authors     = ["Aaron Marburg"]
+  s.email       = ["aaron.marburg@pg.canterbury.ac.nz"]
+  s.homepage    = "http://github.com/amarburg/opencv-ffi-fast"
+  s.summary     = %q{Edward Rosten's FAST keypoint detector algorithm, as a plug-in for OpenCV-FFI.}
+  s.description = %q{Edward Rosten's FAST keypoint detector algorithm, as a plug-in for OpenCV-FFI.}
+
+  s.rubyforge_project = "opencv-ffi-fast"
+
+  s.files         = `git ls-files`.split("\n")
+  s.extensions    = "ext/mkrf_conf.rb"
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "nice-ffi"
+  s.add_dependency "mkrf"
+  s.add_dependency "opencv-ffi"
+end

data/test/test_ext.rb

@@ -0,0 +1,50 @@
+
+require 'test/setup'
+require 'opencv-ffi-ext/fast'
+require 'opencv-ffi'
+
+class TestSURF < Test::Unit::TestCase
+
+  def setup
+    @img = CVFFI::cvLoadImage( TEST_IMAGE_FILE, CVFFI::CV_LOAD_IMAGE_COLOR  )
+  end
+
+
+  def test_cvFASTDetector
+    greyImg = CVFFI::cvCreateImage( CVFFI::CvSize.new( { :height => @img.height, 
+                                                         :width => @img.width }), 
+                                    :IPL_DEPTH_8U, 1 )
+    CVFFI::cvCvtColor( @img, greyImg, :CV_RGB2GRAY )
+
+    smallGreyImg = CVFFI::cvCreateImage( CVFFI::CvSize.new( { :height => greyImg.height/2,
+                                                              :width => greyImg.width/2 } ),
+                                    :IPL_DEPTH_8U, 1 )
+
+    CVFFI::cvResize( greyImg, smallGreyImg, :CV_INTER_LINEAR )
+
+    #CVFFI::cvSaveImage( TestSetup::output_filename("greyImage.jpg"), smallGreyImg.to_ptr )
+    
+    nResults = FFI::MemoryPointer.new :int
+
+results = FFI::Pointer.new :pointer, CVFFI::FAST::fast12_detect( smallGreyImg.imageData, smallGreyImg.width, smallGreyImg.height, smallGreyImg.widthStep, 50, nResults )
+
+    # Dereference the two pointers
+    nPoints = nResults.read_int
+    points = FFI::Pointer.new CVFFI::FAST::Xy, results
+
+    #p points.inspect
+    #p nPoints.inspect
+
+    0.upto(nPoints-1) { |i|
+      pt = CVFFI::FAST::Xy.new( points[i] )
+
+      CVFFI::cvCircle( smallGreyImg, CVFFI::CvPoint.new( :x => pt.x.to_i, :y => pt.y.to_i ), 5,
+                      CVFFI::CvScalar.new( :w=>255, :x=>255, :y=>255, :z=>0 ), -1, 8, 0 )
+    }
+    CVFFI::cvSaveImage( TestSetup::output_filename("greyImageFASTPts.jpg"), smallGreyImg )
+
+
+    results.free
+ end
+
+end