opencv-ffi 0.0.1

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

@@ -0,0 +1,115 @@
+
+require 'nice-ffi'
+require 'opencv-ffi-wrappers/vectors'
+
+module CVFFI
+  module VectorMath
+    extend NiceFFI::Library
+
+    libs_dir = File.dirname(__FILE__) + "/../../ext/opencv-ffi/"
+    pathset = NiceFFI::PathSet::DEFAULT.prepend( libs_dir )
+    load_library("cvffi", pathset)
+
+    
+    module NativeVectors
+      def self.included( base )
+        base.extend( ClassMethods)
+      end
+
+      module ClassMethods
+        def define_vector( type, length, name = nil )
+          name = name || "#{type}_#{length}_vector"
+          class_eval <<-eos
+          class #{name} < NiceFFI::Struct
+              layout :d, [:#{type}, #{length}]
+              def length; #{length}; end
+          end
+          eos
+          name
+        end
+      end
+
+      class ScalarVector
+
+        def define_vector( type, length, name = nil )
+          name = name || "Auto_#{type}_#{length}_vector"
+          instance_eval <<-eos
+          class #{name} < NiceFFI::Struct
+              layout :d, [:#{type}, #{length}]
+              def length; #{length}; end
+          end
+          eos
+          name
+        end
+
+        attr_accessor :data
+        def initialize( type, length )
+          name = define_vector( type, length )
+          instance_eval "@data = #{name}.new '\0'"
+        end
+
+        def [](i)
+          @data.d[i]
+        end
+
+        def []=(i,b)
+          @data.d[i] = b
+        end
+
+        def as_ScalarArray
+          ScalarArray.new( len: @data.length,
+                           data: @data )
+        end
+        alias :to_c :as_ScalarArray
+
+      end
+    end
+        
+
+
+    class UcharArray < NiceFFI::Struct
+      layout :len, :uint,
+             :data, :pointer
+    end
+
+    class ScalarArray < NiceFFI::Struct
+      layout :len, :uint,
+             :data, :pointer
+    end
+
+    attach_function :L2distance_32f, [:pointer, :pointer, :int], :float
+    attach_function :realL2distance_8u, :L2distance_8u, [UcharArray.by_value, UcharArray.by_value], :float
+
+    def self.L2distance( a,b, len = nil)
+      len ||= a.length
+      L2distance_32f( a, b, len )
+    end
+
+    def self.uchar_array_cast( a )
+      case a
+      when UcharArray
+        a
+      else
+        d = FFI::MemoryPointer.new :uint8, a.length
+        d.write_array_of_uint8( a )
+        #d.write_array_of_uint8( a.map{ |a| [[ a.to_i, 0 ].max, 255].min }  ) 
+        UcharArray.new( len: a.length, data: d )
+      #else
+      #  raise "Can't convert type #{a} to a uchar_array"
+      end
+    end
+
+    def self.L2distance_8u( a,b )
+      ## Allow for some dynamic repacking
+      raise "Arrays not same length" unless a.length == b.length
+      a = uchar_array_cast( a )
+      b = uchar_array_cast( b ) 
+
+      realL2distance_8u( a, b )
+    end
+  end
+
+
+end
+
+

data/lib/opencv-ffi-wrappers.rb

@@ -0,0 +1,7 @@
+
+require 'opencv-ffi-wrappers/core'
+require 'opencv-ffi-wrappers/matcher'
+require 'opencv-ffi-wrappers/misc'
+require 'opencv-ffi-wrappers/highgui'
+require 'opencv-ffi-wrappers/imgproc'
+require 'opencv-ffi-wrappers/features2d'

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

@@ -0,0 +1,24 @@
+
+require 'opencv-ffi-wrappers/core/mat'
+require 'opencv-ffi-wrappers/core/size'
+require 'opencv-ffi-wrappers/core/point'
+require 'opencv-ffi-wrappers/core/iplimage'
+require 'opencv-ffi-wrappers/core/scalar'
+require 'opencv-ffi-wrappers/core/rect'
+require 'opencv-ffi-wrappers/core/misc_draw'
+
+require 'opencv-ffi-wrappers/matrix'
+
+require 'opencv-ffi/core'
+
+
+module CVFFI
+  def self.solveCubic( coeffs )
+    roots = CVFFI::CvMat.new CVFFI::cvCreateMat( 1,3, :CV_32F )
+
+    CVFFI::cvSolveCubic( coeffs.to_CvMat, roots )
+
+    roots.coerce( coeffs )[1]
+  end
+end
+

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

@@ -0,0 +1,50 @@
+
+require 'opencv-ffi/core/types'
+require 'opencv-ffi-wrappers/core'
+
+module CVFFI
+
+  module IplImageFunctions
+    def image_size
+      Size.new( self.width, self.height )
+    end
+
+    def to_IplImage
+      self
+    end
+
+    def clone
+      CVFFI::IplImage.new CVFFI::cvCloneImage( self )
+    end
+
+    def twin( *opts )
+      depth,nChannels = if opts[0].is_a? Hash
+                          opts = opts.pop
+                          [opts[:depth], opts[:channels]]
+                        else
+                          opts
+                        end
+
+      depth ||= self.depth
+      nChannels ||= self.nChannels
+      CVFFI::IplImage.new CVFFI::cvCreateImage( self.image_size.to_CvSize, depth, nChannels )
+    end
+
+    def ensure_greyscale
+      return self if nChannels == 1
+
+      greyImg = CVFFI::cvCreateImage( CVFFI::CvSize.new( { :height => height, 
+                                                        :width => width }), 
+                                                        :IPL_DEPTH_8U, 1 )
+      CVFFI::cvCvtColor( self.to_IplImage, greyImg, :CV_BGR2GRAY )
+      greyImg
+    end
+    alias :ensure_grayscale :ensure_greyscale
+  end
+
+  class IplImage
+    include IplImageFunctions
+  end
+
+
+end

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

@@ -0,0 +1,268 @@
+require 'opencv-ffi/core/types'
+require 'opencv-ffi-wrappers/core'
+require 'opencv-ffi-wrappers/misc'
+
+require 'matrix'
+
+
+# Monkey with Matrix and Vector's coercion functions
+class Vector
+  alias :coerce_orig :coerce
+  def coerce(other)
+    case other
+    when CvMat
+      nil
+    else
+      coerce_orig(other)
+    end
+  end
+end
+
+module CVFFI
+
+  module CvMatFunctions
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    # This is the somewhat funny Matrix format for coerce
+    # which returns the template class as well as the coerced version
+    # of the matrix
+    def coerce( other )
+            case other
+                     when Matrix 
+                       [other, to_Matrix]
+                     when Vector 
+                       [other, to_Vector]
+                     else
+                       raise TypeError, "#{self.class} can't be coerced into #{other.class}, fool"
+                     end
+          end
+
+
+    def to_CvMat( opt = {} )
+      if opt[:type]
+        raise "Need to convert CvMat types" if opt[:type] != type
+      end
+      self
+    end
+
+    def to_Matrix
+      Matrix.build( height, width ) { |i,j|
+        at_f(i,j)
+      }
+    end
+
+    def to_ScalarMatrix
+      ScalarMatrix.rows Array.new( height ) { |y|
+        Array.new( width ) { |x|
+          d = CVFFI::cvGet2D( self, y,x )
+          d.w
+        }
+      }
+    end
+
+    def to_Vector
+      to_Matrix if height > 1 and width > 1
+      a = []
+      if height == 1
+        a = Array.new( width ) { |i| at_f(0,i) } 
+      else
+        a = Array.new( height ) { |i| at_f(i,0) }
+      end
+      Vector[*a]
+    end
+
+    def to_a
+      to_Vector.to_a
+    end
+
+    # This is somewhat awkward because the FFI::Struct-iness of
+    # CvMat uses the Array-like API calls (at, [], size, etc)
+    def at_f(i,j)
+      CVFFI::cvGetReal2D( self, i, j )
+    end
+
+    def set_f( i,j, f )
+      CVFFI::cvSetReal2D( self, i, j, f )
+    end
+
+    def at_scalar(i,j)
+      CVFFI::cvGet2D( self, i, j )
+    end
+
+    def set_scalar( i,j, f )
+      CVFFI::cvSet2D( self, i, j, f )
+    end
+
+    def clone
+      CVFFI::cvCloneMat( self )
+    end
+
+    def mat_size
+      CVFFI::CvSize.new( :width => self.width, :height => self.height ) 
+    end
+
+    def twin
+      CVFFI::cvCreateMat( self.height, self.width, self.type )
+    end
+
+    def transpose
+      a = twin
+      CVFFI::cvTranspose( self, a )
+      a
+    end
+
+    def zero
+      CVFFI::cvSetZero( self )
+    end
+
+    def print( opts = {} )
+      CVFFI::print_matrix( self, opts )
+    end
+
+    module ClassMethods 
+      def eye( x, type = :CV_32F )
+        a = CVFFI::cvCreateMat( x, x, type )
+        CVFFI::cvSetIdentity( a, CVFFI::CvScalar.new( :w => 1, :x => 1, :y => 1, :z => 1 ) )
+        a
+      end
+
+      def print( m, opts = {} )
+        CVFFI::print_matrix( m, opts )
+      end
+
+    end
+
+
+  end
+
+  class CvMat
+    include CvMatFunctions
+  end
+  
+  class Mat
+    include CvMatFunctions
+
+    def self.wrap_function( s )
+      class_eval "def #{s}( *args ); Mat.new( mat.#{s}(*args) ); end"
+    end
+
+    def self.pass_function( s )
+      class_eval "def #{s}( *args ); mat.#{s}(*args); end"
+    end
+
+    [ :twin, :clone ].each { |f| wrap_function f }
+    
+    attr_accessor :mat
+    attr_accessor :type
+
+    def initialize( *args )
+      a1,a2,a3 = *args
+      case a1
+      when Mat
+        # Copy constructor
+        @mat = a1.mat
+      when CvMat
+        @mat = a1
+      else
+        rows,cols,opts = a1,a2,a3
+        opts ||= {}
+        opts = { type: opts } if opts.is_a? Symbol
+        doZero = opts[:zero] || true
+        @type = opts[:type] || :CV_32F
+        @mat = CVFFI::cvCreateMat( rows, cols, @type )
+
+        mat.zero if doZero
+      end
+
+      if block_given?
+      rows.times { |i|
+        cols.times { |j|
+          set(i,j, yield(i,j) )
+        }
+      }
+      end
+
+    end
+
+    def at=(i,j,v)
+      if type == :CV_32F
+      mat.set_f( i,j, v)
+      else
+        mat.set_scalar( i,j, CVFFI::CvScalar.new( { w: v, x: v, y: v, z: v } ) )
+      end
+    end
+    alias :[]= :at=
+    alias :set :at=
+
+    def at(i,j)
+      if type == :CV_32F
+        mat.at_f( i,j)
+      else
+        s = mat.at_scalar( i,j )
+        s.w
+      end
+    end
+    alias :[] :at
+
+    def each( &blk )
+      each_with_indices { |v,i,j| blk.call( v ) }
+    end
+
+    def each_with_indices( &blk )
+      height.times { |i|
+        width.times { |j|
+          blk.call at(i,j), i, j 
+        }
+      }
+    end
+
+
+    [ :height, :width ].each { |f| pass_function f }
+
+    def self.build( rows, cols, opts = {}, &blk )
+      Mat.new( rows, cols, opts ) { |i,j| blk.call(i,j) }
+    end
+
+    def self.eye( size, opts = {} )
+      m = Mat.new( size,size,opts )
+      size.times { |i| m[i,i] = 1 }
+      m
+    end
+
+    def self.rows( r, opts = {} )
+      height = r.length
+      width = r[0].length
+
+      Mat.build( height, width, opts ) { |i,j|
+        r[i][j]
+      }
+    end
+
+
+    # Should impedence match Mat anywhere a CvMat * is required...
+    # TODO: Figure out how to handler passing by_value
+    def to_ptr
+      @mat.pointer
+    end
+
+    def norm( b, type = :CV_L2 )
+      CVFFI::cvNorm( self, b, type )
+    end
+    def l2distance(b); norm(b, :CV_L2 ); end
+
+    def ==(b)
+      return false if width != b.width or height != b.height or type != b.type
+
+      cmpResult = Mat.new( height, width, :CV_8U )
+      # Fills cmpResults with 1 for each element which is not equal
+      CVFFI::cvCmp( self, b, cmpResult, :CV_CMP_NE )
+
+      # If results are equal, cmpResult will be all zeros
+      sum = CVFFI::cvSum( cmpResult )
+      sum.w == 0
+    end
+
+  end
+end