opencv-ffi 0.0.1

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

@@ -0,0 +1,37 @@
+
+class Matrix
+
+  def to_Matrix
+    self
+  end
+
+  # Painful but that's OK...
+  def to_CvMat( opts = {} )
+    type = opts[:type] || :CV_32F
+    a = CVFFI::cvCreateMat( row_size, column_size, type )
+    each_with_index { |e,i,j|
+      a.set_f( i, j, e )
+    }
+    a
+  end
+
+end
+
+class Vector
+
+  def to_Vector
+    self
+  end
+
+  def to_CvMat( opts = {} )
+    type = opts[:type] || :CV_32F
+    a = CVFFI::cvCreateMat( size, 1,  type )
+    size.times { |i|
+      CVFFI::cvSetReal1D( a, i, element(i))
+    }
+    a
+  end
+
+end
+
+    

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

@@ -0,0 +1,41 @@
+require 'opencv-ffi/core/types'
+
+module CVFFI
+
+  def self.print_matrix(m, opts={})
+    opts ||= {}
+    opts = { :caption=>opts } if opts.is_a? String
+    puts opts[:caption] if opts[:caption]
+
+    # Lots of potential to make this better...
+    f = '%'
+    case opts[:format]
+    when :e, :exp, :exponential 
+      f += '- 10.5e'
+    else
+      f += '- 10.5f'
+    end
+
+    nChannels = CVFFI::matChannels(m)
+    #  puts "#{nChannels} channel data"
+
+    m.height.times { |i|
+      m.width.times {|j|
+        scalar = CVFFI::cvGet2D( m, i, j )
+        case nChannels
+        when 1
+          printf "#{f}  ", scalar.w
+        when 2
+          printf "[#{f} #{f}] ", scalar.w, scalar.x
+        when 3
+          printf "[#{f} #{f} #{f}] ", scalar.w, scalar.x, scalar.y
+        when 4
+          printf "[#{f} #{f} #{f} #{f}] ", scalar.w, scalar.x, scalar.y, scalar.z
+        end
+      }
+      puts
+    }
+
+  end
+
+end

data/lib/opencv-ffi-wrappers/misc/params.rb

@@ -0,0 +1,34 @@
+
+require 'opencv-ffi'
+
+module CVFFI
+
+  class Params
+
+    def self.defaults; @defaults ||= {}; end
+    def defaults;      self.class.defaults; end
+
+    def self.param( *args )
+      while args.length > 0
+        default,name = [args.pop, args.pop]
+        defaults[ name ] = default
+      end
+    end
+
+    attr_reader :params
+
+    def initialize( opts = {} )
+      @params = {}
+      self.class.defaults.each_key { |k|
+        @params[k] = (opts[k] or opts[k.to_s] or self.class.defaults[k])
+        define_singleton_method( k ) { @params[k] }
+        instance_eval "def #{k}=(a); @params[:#{k}] = a; end"
+      }
+    end
+
+    def to_hash
+      @params
+    end
+  end
+
+end

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

@@ -0,0 +1,37 @@
+
+require 'opencv-ffi/core/dynamic'
+
+module CVFFI
+
+  class Sequence
+    include Enumerable
+
+    attr_accessor :seq
+
+    def initialize( seq )
+      raise "Don't know how to handle class #{seq.class}" unless seq.is_a?(CvSeq)
+      @seq = seq
+    end
+
+    def each
+      size.times { |i|
+        yield CVFFI::cvGetSeqElem( @seq, i )
+      }
+    end
+
+    def push( a )
+      CVFFI::cvSeqPush( @seq, a )
+    end
+
+    def size
+      @seq.total
+    end
+    alias :length :size
+
+    def [](i)
+      CVFFI::cvGetSeqElem( @seq, i )
+    end
+
+  end
+
+end

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

@@ -0,0 +1,38 @@
+
+require 'nice-ffi'
+
+module CVFFI
+
+  class FloatArrayCommon < NiceFFI::Struct
+    include Enumerable
+
+    class << self; attr_accessor :nElem; end
+
+    def nElem; self.class.nElem; end
+    alias :length :nElem
+
+    def each
+      nElem.times { |i|
+        yield d[i]
+      }
+    end
+
+    #def [](i)
+    #  d[i]
+    #end
+
+    #def []=(i)
+    #  d[i] = i
+    #end
+  end
+
+  class Float64 < FloatArrayCommon
+    @nElem = 64
+    layout :d, [ :float, @nElem ]
+  end
+
+  class Float128 < FloatArrayCommon
+    @nElem = 128
+    layout :d, [ :float, @nElem ]
+  end
+end

data/lib/opencv-ffi.rb

@@ -0,0 +1,12 @@
+require "opencv-ffi/version"
+require "opencv-ffi/highgui"
+require "opencv-ffi/core"
+require "opencv-ffi/imgproc"
+require "opencv-ffi/features2d"
+require "opencv-ffi/calib3d"
+
+module Opencv
+  module Ffi
+    # Your code goes here...
+  end
+end

data/lib/opencv-ffi/calib3d.rb

@@ -0,0 +1,26 @@
+
+require 'opencv-ffi/cvffi'
+require 'opencv-ffi/core'
+
+module CVFFI
+  load_library("opencv_calib3d", @pathset)
+
+  enum :cvRansacMethod, [ :CV_FM_7POINT, 1,
+                          :CV_FM_8POINT, 2,
+                          :CV_FM_LMEDS,  4,
+                          :CV_FM_RANSAC, 8 ]
+
+  # CVAPI(int) cvFindFundamentalMat( const CvMat* points1, 
+  #                                  const CvMat* points2,
+  #                                  CvMat* fundamental_matrix,
+  #                                  int method CV_DEFAULT(CV_FM_RANSAC),
+  #                                  double param1 CV_DEFAULT(3.), 
+  #                                  double param2 CV_DEFAULT(0.99),
+  #                                  CvMat* status CV_DEFAULT(NULL) );
+  attach_function :cvFindFundamentalMat, [ :pointer, :pointer, :pointer, 
+                                           :int, :double, :double, :pointer ], :int
+
+
+end
+
+

data/lib/opencv-ffi/core.rb

@@ -0,0 +1,15 @@
+## An omnibus file which brings in all the core/* sub-files
+
+require 'opencv-ffi/core/library'
+
+module CVFFI
+
+  enum :cvBoolean, [ :false, 0,
+                     :true ]
+
+end
+
+require 'opencv-ffi/core/types'
+require 'opencv-ffi/core/dynamic'
+require 'opencv-ffi/core/draw'
+require 'opencv-ffi/core/operations'

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

@@ -0,0 +1,68 @@
+
+require 'opencv-ffi/core/library'
+require 'opencv-ffi/core/types'
+
+module CVFFI
+
+  CvFontDefines = enum [:CV_FONT_HERSHEY_SIMPLEX, 0,
+        :CV_FONT_HERSHEY_PLAIN,
+        :CV_FONT_HERSHEY_DUPLEX,
+        :CV_FONT_HERSHEY_COMPLEX,
+        :CV_FONT_HERSHEY_TRIPLEX,
+        :CV_FONT_HERSHEY_COMPLEX_SMALL,
+        :CV_FONT_HERSHEY_SCRIPT_SIMPLEX,
+        :CV_FONT_HERSHEY_SCRIPT_COMPLEX,
+        :CV_FONT_NORMAL, 8,
+        :CV_FONT_ITALIC, 16 ]
+
+  enum [:CV_AA, 16]
+
+  class CvFont < NiceFFI::Struct
+    layout :nameFont, :string,
+           :color,    CvScalar,
+           :font_face, :int,
+           :ascii,     :pointer,
+           :greek,     :pointer,
+           :cyrillic,  :pointer,
+           :hscale,    :float,
+           :vscale,    :float,
+           :shear,     :float,
+           :thickness, :int,
+           :dx,        :float,
+           :line_type, :int
+  end
+
+  # CVAPI(void)  cvCircle( CvArr* img, 
+  #                        CvPoint center, 
+  #                        int radius,
+  #                        CvScalar color, 
+  #                        int thickness CV_DEFAULT(1),
+  #                        int line_type CV_DEFAULT(8), 
+  #                        int shift CV_DEFAULT(0));
+  attach_function :cvCircle, [ :pointer, CvPoint.by_value, :int,
+                               CvScalar.by_value, :int, :int, :int ], :void
+
+  attach_function :cvGetTextSize, [ :string, :pointer, :pointer, :pointer ], :void
+  
+  # CVAPI(void)  cvInitFont( CvFont* font, int font_face,
+  #                          double hscale, double vscale,
+  #                          double shear CV_DEFAULT(0),
+  #                          int thickness CV_DEFAULT(1),
+  #                          int line_type CV_DEFAULT(8));
+  attach_function :cvInitFont, [:pointer, CvFontDefines, :double, :double, :double, :int, :int ], :void
+  #attach_function :cvFont, [:double, :int ], CvFont.by_value
+  
+  # CVAPI(void)  cvLine( CvArr* img, 
+  #                      CvPoint pt1, 
+  #                      CvPoint pt2,
+  #                      CvScalar color, 
+  #                      int thickness CV_DEFAULT(1),
+  #                      int line_type CV_DEFAULT(8), 
+  #                      int shift CV_DEFAULT(0) );
+  attach_function :cvLine, [ :pointer, CvPoint.by_value, CvPoint.by_value,
+                              CvScalar.by_value, :int, :int, :int ], :void
+
+  attach_function :cvPutText, [ :pointer, :string, 
+                                CvPoint.by_value, :pointer, 
+                                CvScalar.by_value ], :void
+end

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

@@ -0,0 +1,13 @@
+
+require 'opencv-ffi/core/library'
+require 'opencv-ffi/core/types'
+
+module CVFFI
+
+  attach_function :cvCreateMemStorage, [ :int ], CvMemStorage.typed_pointer
+  attach_function :cvReleaseMemStorage, [:pointer], :void
+
+  attach_function :cvGetSeqElem, [ :pointer, :int ], :pointer
+  attach_function :cvSeqPush, [:pointer, :pointer ], :pointer
+
+end

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

@@ -0,0 +1,5 @@
+require 'opencv-ffi/cvffi'
+
+module CVFFI
+  load_library("opencv_core", @pathset)
+end

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

@@ -0,0 +1,122 @@
+
+require 'opencv-ffi/core/library'
+require 'opencv-ffi/core/types'
+
+module CVFFI
+
+  CvMatType = enum :cvMatType, [ :CV_8U, 0,
+                     :CV_8UC1, 0,
+                     :CV_8S, 
+                     :CV_16U,
+                     :CV_16S,
+                     :CV_32S,
+                     :CV_32F,
+                     :CV_64F,
+                     :CV_USRTYPE1,
+                     :CV_8UC2, 8,
+                     :CV_8SC2, 
+                     :CV_16UC2,
+                     :CV_16SC2,
+                     :CV_32SC2,
+                     :CV_32FC2,
+                     :CV_64FC2,
+                     :CV_8UC3, 16,
+                     :CV_8SC3, 
+                     :CV_16UC3,
+                     :CV_16SC3,
+                     :CV_32SC3,
+                     :CV_32FC3,
+                     :CV_64FC3 ]
+
+  ## As present, the type encodes 9 bits of nChannels and 3 bits of typ
+  def self.matMagicType( m )
+    type = case m.type
+           when Fixnum
+             m.type
+           when Symbol
+             CvMatType[m.type]
+           else
+             raise "Can't convert #{m.type} to a numberic OpenCV type"
+           end
+
+    type & 0xFFF
+  end
+
+  def self.matChannels( m )
+    (matMagicType(m) >> 3) + 1
+  end
+
+  # A bit clumsy
+  def self.matType( m )
+    case m.type & 0x7
+    when :CV_8U; :CV_8U
+    else
+      assert RuntimeError, "This shouldn't happen!"
+    end
+  end
+
+  attach_function :cvAddWeighted, [ :pointer, :double, :pointer, :double, :double, :pointer ], :void
+
+  attach_function :cvCloneImage, [ :pointer ], IplImage.typed_pointer
+  attach_function :cvCloneMat,   [ :pointer ], CvMat.typed_pointer
+
+  enum :cvCmpTypes, [ :CV_CMP_EQ, :CV_CMP_GT, :CV_CMP_GE, :CV_CMP_LT, :CV_CMP_LE, :CV_CMP_NE ]
+  attach_function :cvCmp, [:pointer, :pointer, :pointer, :int], :void
+
+  attach_function :cvCreateMat, [ :int, :int, :cvMatType ], CvMat.typed_pointer
+  attach_function :cvCreateImage, [ CvSize.by_value, :int, :int ], IplImage.typed_pointer
+
+  attach_function :cvCopy, [ :pointer, :pointer, :pointer ], :void
+
+
+  attach_function :cvSetImageROI, [:pointer, CvRect.by_value ], :void
+  attach_function :cvGetImageROI, [:pointer], CvRect.by_value
+  attach_function :cvResetImageROI, [:pointer], :void
+
+  # CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
+  attach_function :cvGet1D, [ :pointer, :int ], CvScalar.by_value
+  attach_function :cvGet2D, [ :pointer, :int, :int ], CvScalar.by_value
+  attach_function :cvGet3D, [ :pointer, :int, :int, :int ], CvScalar.by_value
+
+  attach_function :cvGetReal1D, [ :pointer, :int ], :double
+  attach_function :cvGetReal2D, [ :pointer, :int, :int ], :double
+  attach_function :cvGetReal3D, [ :pointer, :int, :int, :int ], :double
+
+  enum :cvNormTypes, [ :CV_C, 1,
+                       :CV_L1, 2,
+                       :CV_L2, 4 ]
+  attach_function :real_cvNorm, :cvNorm, [ :pointer, :pointer, :int, :pointer ], :double
+  def self.cvNorm( arr1, arr2 = nil, normType = :CV_L2, mask = nil )
+    real_cvNorm( arr1, arr2, normType, mask )
+  end
+
+  attach_function :cvSet,  [ :pointer, CvScalar.by_value, :pointer ], :void
+
+  attach_function :cvSet1D, [ :pointer, :int, CvScalar.by_value ], :void
+  attach_function :cvSet2D, [ :pointer, :int, :int, CvScalar.by_value ], :void
+  attach_function :cvSet3D, [ :pointer, :int, :int, :int, CvScalar.by_value ], :void
+
+  attach_function :cvSetReal1D, [ :pointer, :int, :double ], :void
+  attach_function :cvSetReal2D, [ :pointer, :int, :int, :double ], :void
+  attach_function :cvSetReal3D, [ :pointer, :int, :int, :int, :double ], :void
+
+  attach_function :cvSetIdentity, [ :pointer, CvScalar.by_value ], :void
+  attach_function :cvSetZero, [ :pointer ], :void
+
+  attach_function :cvSolveCubic, [:pointer, :pointer ], :void
+
+  attach_function :cvSum, [:pointer], CvScalar.by_value
+
+  attach_function :cvTranspose, [:pointer, :pointer], :void
+
+  attach_function :cvReleaseMat, [ :pointer ], :void
+  attach_function :cvReleaseData, [ :pointer ], :void
+
+  # cvReleaseImage expects a double-pointer to an IplImage
+  attach_function :cvReleaseImageReal, :cvReleaseImage, [ :pointer ], :void
+  def self.cvReleaseImage( iplImage )
+    #ptr = FFI::MemoryPointer.new :pointer
+    #ptr.put_pointer(0, iplImage.to_ptr )
+    #cvReleaseImageReal iplImage
+  end
+end