opencv-ffi 0.0.1

data/lib/opencv-ffi-wrappers/core/size.rb

@@ -0,0 +1,88 @@
+
+require 'opencv-ffi/core/types'
+require 'opencv-ffi-wrappers/core/point'
+
+module CVFFI
+
+  module CvSizeFunctions
+    def x; self.width; end
+    def y; self.height; end
+
+    def x=(a); self.width=a; end
+    def y=(a); self.height=a; end
+
+    def ===(b)
+      width === b.width and height === b.height
+    end
+    def ==(b)
+      width == b.width and height == b.height
+    end
+  end
+
+  module CvSizeCastMethods
+    def to_CvSize2D64f
+      CvSize2D64f.new( :width => x, :height => y )
+    end
+
+    def to_CvSize2D32f
+      CvSize2D32f.new( :width => x, :height => y )
+    end
+
+    def to_CvSize
+      CvSize.new( :width => x.to_i, :height => y.to_i )
+    end
+  end
+
+  class CvSizeBase
+    include CvSizeFunctions
+    include CvSizeCastMethods
+  end
+
+  class CvSize; def to_CvSize; self; end; end
+  class CvSize2D32f; def to_CvSize2D32f; self; end; end
+  class CvSize2D64f; def to_CvSize2D64f; self; end; end
+
+  class Size < Point
+    include CvSizeCastMethods
+
+    #attr_accessor :height, :width
+    alias :width :x
+    alias :height :y
+    alias :width= :x=
+    alias :height= :y=
+
+    def initialize( *args )
+      if args.length == 2
+        @x= args[0]
+        @y= args[1]
+      else
+        args = args.shift
+        case args
+        when Hash
+          @x= args[:width] || args[:x]
+          @y= args[:height] || args[:y]
+        when Array
+          @x = args[0]
+          @y = args[1]
+        else
+          @x = args.width || args.x
+          @y = args.height || args.y
+        end
+      end
+    end
+
+    def area
+      height*width
+    end
+
+    def floor
+      @x = x.to_i
+      @y = y.to_i
+    end
+
+  end
+
+
+
+
+end

data/lib/opencv-ffi-wrappers/enumerable.rb

@@ -0,0 +1,10 @@
+
+
+# From:http://rpheath.com/posts/341-ruby-inject-with-index
+
+module Enumerable
+  def inject_with_index(injected)
+    each_with_index{ |obj, index| injected = yield(injected, obj, index) }
+    injected
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'opencv-ffi-wrappers/features2d/surf'
+require 'opencv-ffi-wrappers/features2d/star'
+require 'opencv-ffi-wrappers/features2d/image_patch'
+
+module CVFFI
+  def self.draw_keypoints( img, pts, opts = {} )
+    color = opts[:color] || CVFFI::CvScalar.new( {:w=>255, :x=>255, :y=>255, :z=>0} )
+    radius = opts[:radius] || 2
+    fill = opts[:fill] || true
+
+    pts.each { |kp|
+      CVFFI::cvCircle( img, CVFFI::Point.new( kp ).to_CvPoint,
+                      radius, color, (fill ? -1: 1), 8, 0 )
+    }
+    img
+  end
+end

data/lib/opencv-ffi-wrappers/features2d/image_patch.rb

@@ -0,0 +1,322 @@
+require 'opencv-ffi'
+require 'opencv-ffi-wrappers/core/iplimage'
+require 'opencv-ffi-wrappers/core/point'
+require 'opencv-ffi-ext/eigen'
+
+module CVFFI
+
+  module ImagePatch
+
+    class Mask
+      attr_reader :size
+      def initialize(size)
+        @size = size
+      end
+
+      def self.make( params )
+        case params.shape
+        when :square
+          SquareMask.new( params.size )
+        when :circle, :circular
+          CircularMask.new(params.size )
+        else 
+          raise "Don't know how to make shape #{params.shape}"
+        end
+      end
+
+
+    end
+
+    class SquareMask < Mask
+      def initialize(size)
+        super(size)
+      end
+      def valid?(i,j)
+        raise "Requesting point outside mask" unless ((0...@size).include? i and (0...@size).include? j) 
+        true
+      end
+      def to_a
+        Array.new(size) { |i| Array.new(size) { |j| true } }
+      end
+    end
+
+    class CircularMask < Mask
+      def initialize(size)
+        super(size)
+
+        @mask = build_circle( size/2.0 )
+      end
+
+      def build_circle( radius )
+        ## Returns row-major Array of Arrays
+        center = CVFFI::Point.new(radius,radius)
+        @mask = Array.new(radius.ceil) { |i|
+          Array.new(radius.ceil) { |j|
+            pt = CVFFI::Point.new( 0.5 + j, 0.5 + i )
+            center.l2distance( pt ) <= radius ? true : false
+          }
+        }
+
+        # Now mirror the one quadrant across Y, then across X
+        @mask.map! { |a| a + a.reverse }
+        @mask + @mask.reverse
+      end
+
+      def valid?(i,j)
+        @mask[i][j]
+      end
+
+      def to_a
+        @mask.map { |m| m.map { |m| m ? true: false } }
+      end
+    end
+
+    class Result 
+
+      attr_accessor :center
+      attr_accessor :angle
+
+      def initialize( center, patch, angle = 0.0, isOriented = false )
+        @center = CVFFI::Point.new center
+          @patch = CVFFI::Mat.rows( patch, :CV_8U )
+        @angle = angle
+
+        # Set this if the patch has already been rotated
+        @oriented_patch = @patch if isOriented
+      end
+
+      def ==(b)
+        @center == b.center and
+        @angle == b.angle and
+        @patch == b.patch
+      end
+
+      # TODO:  Consider whether rotating just the patch is ever a good idea
+      # or if you should always get the patch by rotating the original image
+      def orient_patch
+        rotmat = CVFFI::CvMat.new CVFFI::cvCreateMat( 2,3, :CV_32F )
+        CVFFI::cv2DRotationMatrix( CVFFI::CvPoint2D32f.new( [ @patch.width/2.0, @patch.height/2.0 ]), -@angle*180.0/Math::PI, 1.0, rotmat )
+
+        dstimg = @patch.twin
+        CVFFI::cvWarpAffine( @patch, dstimg, rotmat )
+
+         dstimg 
+      end
+
+      def oriented_patch
+        @oriented_patch ||= orient_patch
+      end
+
+      def patch( oriented = true )
+        return @patch if angle == 0.0 or oriented == false
+        oriented_patch
+      end
+
+      def to_a
+        [ center.x, center.y, angle, oriented_patch.to_a ]
+      end
+
+      def distance_to( b )
+        patch.l2distance( b.patch )
+      end
+
+      def self.from_a(a)
+        # Serialized results are always oriented
+        Result.new( CVFFI::Point.new( a[0],a[1] ), a[3],a[2], true )
+        end
+    end
+
+    class ResultsArray < Array
+      attr_reader :mask
+
+      def initialize( params, mask = nil )
+        @params = params
+        @mask = mask || Mask::make( params )
+      end
+
+      def patch_size
+        @params.size
+      end
+
+      def to_a
+        each.map { |r|
+          r.to_a
+        }
+      end
+
+      def self.from_a(a, params = {} )
+        r = ResultsArray.new( Params.new params )
+        a.each { |a| r << Result.from_a( a ) }
+        r
+      end
+
+      def draw_index_image( opts = {} )
+        border = 5
+        max_cols = opts[:max_cols] || 20 
+
+        # Aim for square index
+        cols = Math::sqrt(size).ceil
+        cols = [cols,max_cols].min
+
+        rows = (size*1.0/cols).ceil
+      #  puts "Building index #{cols} x #{rows}"
+      #  puts "Image patch size #{patch_size}"
+
+        img_size = CVFFI::CvSize.new( [ (cols)*(patch_size+border) + border, (rows)*(patch_size+border) + border ] )
+
+        img = CVFFI::cvCreateImage(img_size, 8, 1 )
+        CVFFI::cvSet( img, CVFFI::CvScalar.new( [ 200.0,0.0,0.0,0.0 ] ), nil )
+
+        each_with_index { |patch,i|
+          c = i%cols
+          r = (i/cols).floor
+
+          xoffset = c*(patch_size+border)+border
+          yoffset = r*(patch_size+border)+border
+
+      #    puts "Offsets: #{xoffset} x #{yoffset}"
+
+          patch.oriented_patch.each_with_indices { |value, i, j|
+              if mask.valid?(i,j)
+                CVFFI::cvSet2D( img, yoffset+i, xoffset+j, CVFFI::CvScalar.new( [ value, 0, 0, 0 ] ) )
+              end
+          }
+        }
+
+        img
+      end
+    end
+
+    class Params
+
+      DEFAULTS = { size: 9,
+        oriented: false,
+        shape: :square }
+
+      def initialize( opts = {} )
+
+        @params = {}
+        DEFAULTS.each_key { |k|
+          @params[k] = (opts[k] or opts[k.to_s] or DEFAULTS[k])
+          define_singleton_method( k ) { @params[k] }
+        }
+
+        # Ensure the shape is a symbol
+        @params[:shape] = @params[:shape].to_sym
+      end
+
+      def check_params
+        raise "Image patches need to be odd" unless size.odd?
+      end
+
+      def to_hash
+        @params
+      end
+    end
+
+    def self.describe( img, keypoints, params )
+      img = img.to_IplImage.ensure_greyscale
+      preOriented = false
+
+      half_size = (params.size/2).floor
+
+      results = ResultsArray.new( params )
+      mask = results.mask
+
+      puts "Extracting #{keypoints.length} keypoints"
+      keypoints.each_with_index { |kp,idx|
+        next if kp.x < half_size or 
+        kp.y < half_size or
+        (img.width - kp.x) <= half_size or
+        (img.height - kp.y) <= half_size
+
+        angle = 0.0
+        rect = Rect.new( [ kp.x-half_size, kp.y-half_size, params.size, params.size ] )
+        CVFFI::cvSetImageROI( img, rect.to_CvRect )
+        #
+        ## Simple single-channel implementation
+        #  Patch is row-major (i == row == y, j = column == x)
+        patch = Array.new( params.size ) { |i|
+          Array.new( params.size ) { |j|
+             mask.valid?(i,j) ?  CVFFI::cvGetReal2D( img, i,j ) : 0.0
+          }
+        }
+        CVFFI::cvResetImageROI( img )
+
+        if params.oriented  == true
+          # Calculate covariance matrix by Yingen Xiong
+          patch_sum = mxi = mxj = 0.0
+          patch.each_index { |i|
+            patch[i].each_index { |j|
+              if mask.valid?(i,j)
+                patch_sum += patch[i][j]
+                mxi += i*patch[i][j]
+                mxj += j*patch[i][j]
+              end
+            }
+          }
+          mxi /= patch_sum
+          mxj /= patch_sum
+
+        #  puts "Medoids = " + [mxi,mxj].join(',')
+
+          c11 = c12 = c22 = 0.0
+          patch.each_index { |i|
+            patch[i].each_index { |j|
+              if mask.valid?(i,j)
+                c11 += patch[i][j] * (i-mxi)*(i-mxi)
+                c12 += patch[i][j] * (i-mxi)*(j-mxj)
+                c22 += patch[i][j] * (j-mxj)*(j-mxj)
+              end
+            }
+          }
+
+          c = Matrix.rows( [ [c11,c12],[c12,c22] ] )
+          d,v = CVFFI::Eigen.eigen( c )
+
+          d = d.to_a
+          i = if d[0] == d[1]
+                # Equal eigenvalues
+                0
+              else
+                d.find_index( d.max )
+              end
+
+          vec = v.to_Matrix.column_vectors[i]
+
+          # Eigenvector corresponding to larger eignvector defines orientation
+          #  However it's in i-j space, which is OpenCV (y-down, x-right)
+          #  Subtract from 2PI to put in mathematical (x-right, y-up) space
+          angle = 2*Math::PI - Math::atan2( vec[0],vec[1] )
+          angle %= 2*Math::PI
+          #puts "Computed angle #{angle * 180.0/Math::PI}"
+
+            ## Pre-orient patch
+           # puts "Pre-orienting patch"
+            rotmat = CVFFI::CvMat.new CVFFI::cvCreateMat( 2,3, :CV_32F )
+            CVFFI::cv2DRotationMatrix( kp.to_CvPoint2D32f, -angle*180.0/Math::PI, 1.0, rotmat )
+
+            dstimg = img.twin
+            CVFFI::cvWarpAffine( img, dstimg, rotmat )
+            CVFFI::cvSetImageROI( dstimg, rect.to_CvRect )
+            patch = Array.new( params.size ) { |i|
+              Array.new( params.size ) { |j|
+                mask.valid?(i,j) ?  CVFFI::cvGetReal2D( dstimg, i,j ) : 0.0
+              }
+            }
+            CVFFI::cvResetImageROI( dstimg )
+            CVFFI::cvReleaseImage( dstimg )
+            preOriented = true
+
+            GC.start if (idx % 5) == 0 
+
+        end
+
+        results << Result.new( kp, patch, angle, preOriented )
+      }
+
+      results
+    end
+  end
+end
+

data/lib/opencv-ffi-wrappers/features2d/star.rb

@@ -0,0 +1,111 @@
+require 'opencv-ffi/features2d'
+require 'opencv-ffi-wrappers/core/iplimage'
+require 'opencv-ffi-wrappers/core/misc_draw'
+require 'opencv-ffi-wrappers/sequence'
+require 'opencv-ffi-wrappers/enumerable'
+require 'opencv-ffi-wrappers/vectors'
+require 'opencv-ffi-ext/vector_math'
+
+module CVFFI
+  
+
+  module STAR
+
+    class Result 
+      attr_accessor :kp
+      def initialize( kp )
+        @kp = CVFFI::CvStarKeypoint.new(kp)
+      end
+
+      def pt; @kp.pt; end
+      def x;  pt.x; end
+      def y;  pt.y; end
+
+      def size; @kp.size; end
+      def response; @kp.response; end
+
+      def to_vector( homogeneous = true )
+        homogeneous ?  Vector.[]( x, y, 1 ) : Vector.[](x,y)
+      end
+      
+      def to_Point
+        pt.to_Point
+      end
+   end
+
+    class ResultsArray
+      include Enumerable
+
+      attr_accessor :kp
+
+      def initialize( kp )
+        @kp = Sequence.new(kp)
+        @results = Array.new( @kp.length )
+      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 mark_on_image( img, opts )
+        each { |r|
+          CVFFI::draw_circle( img, r.kp.pt, opts )
+        }
+      end
+    end
+
+    class Params
+
+      DEFAULTS = { maxSize: 45,
+                   responseThreshold: 30,
+                   lineThresholdProjected: 10,
+                   lineThresholdBinarized: 8,
+                   suppressNonmaxSize: 5 }
+
+      def initialize( opts = {} )
+
+        @params = {}
+        DEFAULTS.each_key { |k|
+          @params[k] = (opts[k] or DEFAULTS[k])
+        }
+      end
+
+      def to_CvStarDetectorParams
+        par = @params
+        par.delete_if { |k,v| DEFAULTS.keys.include? k == false }
+        p par
+        CVFFI::CvStarDetectorParams.new( par )
+      end
+
+      def to_hash
+        @params
+      end
+    end
+
+    def self.detect( img, params )
+      params = params.to_CvStarDetectorParams unless  params.is_a?( CvStarDetectorParams )
+      raise ArgumentError unless params.is_a?( CvStarDetectorParams ) 
+
+      img = img.to_IplImage.ensure_greyscale
+      mem_storage = CVFFI::cvCreateMemStorage( 0 )
+
+      keypoints = CVFFI::CvSeq.new CVFFI::cvGetStarKeypoints( img, mem_storage, params )
+      ResultsArray.new( keypoints )
+    end
+  end
+end