opencv-ffi 0.0.1

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

@@ -0,0 +1,22 @@
+## An omnibus file which brings in all the core/* sub-files
+
+require 'core'
+
+module CVFFI
+
+  class CvPoint < NiceFFI::Struct
+    layout :x, :int,
+           :y, :int
+  end
+
+  class CvPoint2D32f < NiceFFI::Struct
+    layout :x, :float,
+           :y, :float
+  end
+
+  class CvPoint2D64f < NiceFFI::Struct
+    layout :x, :double,
+           :y, :double
+  end
+end
+

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

@@ -0,0 +1,172 @@
+require 'opencv-ffi/core/library'
+
+module CVFFI
+
+  class CvRect < NiceFFI::Struct
+    layout :x, :int,
+           :y, :int,
+           :width, :int,
+           :height, :int
+  end
+
+  class CvSizeBase < NiceFFI::Struct
+  end
+
+  class CvSize < CvSizeBase
+    layout :width, :int,
+           :height, :int
+  end
+
+  class CvSize2D32f < CvSizeBase
+    layout :width, :float,
+           :height, :float
+  end
+
+  class CvSize2D64f < CvSizeBase
+    layout :width, :double,
+           :height, :double
+  end
+
+  class CvPointBase < NiceFFI::Struct
+  end
+
+  class CvPoint < CvPointBase
+    layout :x, :int,
+           :y, :int
+  end
+
+  class CvPoint2D32f < CvPointBase
+    layout :x, :float,
+           :y, :float
+  end
+
+  class CvPoint2D64f < CvPointBase
+    layout :x, :double,
+           :y, :double
+  end
+
+  class CvPoint3DBase < NiceFFI::Struct
+  end
+
+  class CvPoint3D32f < CvPoint3DBase
+    layout :x, :float,
+           :y, :float,
+           :z, :float
+  end
+
+  class CvPoint3D64f < CvPoint3DBase
+    layout :x, :double,
+           :y, :double,
+           :z, :double
+  end
+
+
+  
+  #
+  # CvScalar
+  #
+  class CvScalar < NiceFFI::Struct
+#    layout :val, [:double, 4 ]
+    layout :w, :double,
+           :x, :double,
+           :y, :double,
+           :z, :double
+  end
+
+  #
+  # CvMat
+  #
+  class CvMat < NiceFFI::Struct
+    layout :type, :int,
+           :step, :int,
+           :refcount, :pointer,
+           :hdr_refcount, :int,
+           :data, :pointer,
+           :height, :int,
+           :width, :int
+
+    hidden :refcount, :hdr_refcount
+  end
+
+  #
+  # IplImage
+  #
+  enum :IplDepth, [ :IPL_DEPTH_1U, 1,
+                    :IPL_DEPTH_8U, 8,
+                    :IPL_DEPTH_16U, 16,
+                    :IPL_DEPTH_32F, 32 ]
+
+  class IplImage < NiceFFI::Struct
+    layout :nSize, :int,
+           :ID, :int,
+           :nChannels, :int,
+           :alphaChannel, :int,
+           :depth, :int,
+           :colorModel, [:char, 4],
+           :channelSeq, [:char, 4],
+           :dataOrder, :int,
+           :origin, :int,
+           :align,  :int,
+           :width,  :int,
+           :height, :int,
+           :roi, :pointer,
+           :maskROI, :pointer,
+           :imageId, :pointer,
+           :tileInfo, :pointer,
+           :imageSize, :int,
+           :imageData, :pointer,
+           :widthStep, :int,
+           :BorderMode, [:int, 4],
+           :imageDataOrigin, :pointer
+
+#    def self.release(ptr)
+#      p ptr
+#      CVFFI::cvReleaseData( ptr )
+#    end
+  end
+
+
+  #
+  # CvSeq and assoc
+  #
+  class CvSeqBlock < NiceFFI::Struct
+    layout :prev, NiceFFI::TypedPointer( CvSeqBlock ),
+           :next, NiceFFI::TypedPointer( CvSeqBlock ),
+           :start_index, :int,
+           :count, :int,
+           :data, :pointer
+  end
+
+  class CvMemBlock < NiceFFI::Struct
+    layout :prev, NiceFFI::TypedPointer( CvMemBlock ),
+           :next, NiceFFI::TypedPointer( CvMemBlock )
+  end
+
+  class CvMemStorage < NiceFFI::Struct
+    layout :signature, :int,
+           :bottom, NiceFFI::TypedPointer( CvMemBlock ),
+           :top, NiceFFI::TypedPointer( CvMemBlock ),
+           :parent, NiceFFI::TypedPointer( CvMemStorage ),
+           :block_size, :int,
+           :free_space, :int
+  end
+
+  class CvSeq < NiceFFI::Struct
+    layout :flags, :int,
+           :header_size, :int,
+           :h_prev, NiceFFI::TypedPointer( CvSeq ),
+           :h_next, NiceFFI::TypedPointer( CvSeq ),
+           :v_prev, NiceFFI::TypedPointer( CvSeq ),
+           :v_prev, NiceFFI::TypedPointer( CvSeq ),
+           :total, :int,
+           :elem_size, :int,
+           :block_max, :pointer,
+           :ptr, :pointer,
+           :delta_elems, :int,
+           :storage, NiceFFI::TypedPointer( CvMemStorage ),
+           :free_blocks, NiceFFI::TypedPointer( CvSeqBlock ),
+           :first, NiceFFI::TypedPointer( CvSeqBlock )
+  end
+
+end
+

data/lib/opencv-ffi/cvffi.rb

@@ -0,0 +1,8 @@
+
+require 'nice-ffi'
+
+module CVFFI
+  extend NiceFFI::Library
+
+  @pathset = NiceFFI::PathSet::DEFAULT.prepend( "#{ENV['HOME']}/usr/lib" )
+end

data/lib/opencv-ffi/features2d.rb

@@ -0,0 +1,7 @@
+
+require 'opencv-ffi/features2d/library'
+require 'opencv-ffi/features2d/surf'
+require 'opencv-ffi/features2d/star'
+
+module CVFFI
+end

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

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

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

@@ -0,0 +1,30 @@
+require 'opencv-ffi/cvffi'
+require 'opencv-ffi/core'
+require 'opencv-ffi/features2d/library'
+
+module CVFFI
+
+  class CvStarDetectorParams < NiceFFI::Struct
+    layout :maxSize, :int,                 # maximal size of the features 
+                                           # detected. The following
+                                           # values of the parameter are supported:
+                                           # 4, 6, 8, 11, 12, 16, 22, 23, 32, 45, 46, 64, 90, 128
+           :responseThreshold, :int,       # threshold for the approximatd laplacian,
+                                           # used to eliminate weak features
+           :lineThresholdProjected, :int,  # another threshold for laplacian to
+                                           # eliminate edges
+           :lineThresholdBinarized, :int,  # another threshold for the feature
+                                           # scale to eliminate edges
+           :suppressNonmaxSize, :int       # linear size of a pixel neighborhood
+                                           # for non-maxima suppression
+  end
+
+  class CvStarKeypoint < NiceFFI::Struct
+    layout :pt, CvPoint,
+           :size, :int,
+           :response, :float
+  end
+
+  attach_function :cvGetStarKeypoints, [ :pointer, :pointer, CvStarDetectorParams.by_value ], CvSeq.typed_pointer
+
+end

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

@@ -0,0 +1,38 @@
+
+require 'opencv-ffi/cvffi'
+require 'opencv-ffi/core'
+require 'opencv-ffi/features2d/library'
+
+module CVFFI
+
+
+  class CvSURFParams < NiceFFI::Struct
+    layout :extended,      :int,
+           :upright,       :int,
+           :hessianThreshold, :double,
+           :nOctaves,      :int,
+           :nOctaveLayers, :int
+  end
+
+  class CvSURFPoint < NiceFFI::Struct
+    layout :pt, CvPoint2D32f,
+           :laplacian, :int,
+           :size, :int,
+           :dir,  :float,
+           :hessian, :float 
+  end
+
+  # CVAPI(void) cvExtractSURF( const CvArr* img, 
+  #                            const CvArr* mask,
+  #                            CvSeq** keypoints, 
+  #                            CvSeq** descriptors,
+  #                            CvMemStorage* storage, 
+  #                            CvSURFParams params, 
+  #                            int useProvidedKeyPts CV_DEFAULT(0)  );
+
+  attach_function :cvExtractSURF, [ :pointer, :pointer, 
+                                    :pointer, :pointer, 
+                                    :pointer, 
+                                    CvSURFParams.by_value, :cvBoolean ], :void
+
+end

data/lib/opencv-ffi/highgui.rb

@@ -0,0 +1,31 @@
+
+require 'nice-ffi'
+require 'opencv-ffi/core'
+
+module CVFFI
+  extend NiceFFI::Library
+
+  load_library("opencv_highgui", @pathset)
+
+  CV_LOAD_IMAGE_UNCHANGED  =-1
+  CV_LOAD_IMAGE_GRAYSCALE  = 0
+  CV_LOAD_IMAGE_COLOR      = 1
+
+  attach_function :cvLoadImageMFull, :cvLoadImageM, [ :string, :int ], CvMat.typed_pointer
+  attach_function :cvLoadImageFull,  :cvLoadImage,  [ :string, :int ], IplImage.typed_pointer
+
+  def self.cvLoadImageM( fname, color = CV_LOAD_IMAGE_COLOR )
+    cvLoadImageMFull( fname, color )
+  end
+
+  def self.cvLoadImage( fname, color = CV_LOAD_IMAGE_COLOR )
+    cvLoadImageFull( fname, color )
+  end
+
+  attach_function :cvSaveImageFull, :cvSaveImage, [ :string, :pointer, :pointer ], :int
+
+  def self.cvSaveImage( name, ptr, params = nil )
+    cvSaveImageFull( name, ptr, params )
+  end
+
+end

data/lib/opencv-ffi/imgproc.rb

@@ -0,0 +1,9 @@
+
+require 'opencv-ffi/cvffi'
+require 'opencv-ffi/imgproc/misc'
+require 'opencv-ffi/imgproc/geometric'
+require 'opencv-ffi/imgproc/features'
+
+module CVFFI
+
+end

data/lib/opencv-ffi/imgproc/features.rb

@@ -0,0 +1,37 @@
+
+require 'opencv-ffi/imgproc/library'
+
+module CVFFI
+
+  # CVAPI(void)  cvGoodFeaturesToTrack( const CvArr* image, CvArr* eig_image,
+  #                                     CvArr* temp_image, CvPoint2D32f* corners,
+  #                                     int* corner_count, double  quality_level,
+  #                                     double  min_distance,
+  #                                     const CvArr* mask CV_DEFAULT(NULL),
+  #                                     int block_size CV_DEFAULT(3),
+  #                                     int use_harris CV_DEFAULT(0),
+  #                                     double k CV_DEFAULT(0.04) );
+  attach_function :real_cvGoodFeaturesToTrack, :cvGoodFeaturesToTrack,
+    [:pointer, :pointer, :pointer, :pointer, :pointer, :double, :double, :pointer, :int, :int, :double], :void
+
+  # This version diverges from the OpenCV API because the original returns
+  # an array of Point2D32f in corners ... this functions will provide
+  # is as a return value.
+  #
+  # @param max_corners  The maximum number of corners to return
+  # @return             An array of CvPoint2D32f giving the detected corners.
+  def self.cvGoodFeaturesToTrack( image, eig_image, temp_image, max_corners, quality_level, min_distance, 
+                             mask = nil, block_size = 3, use_harris = false, k = 0.04 )
+
+    corner_count_ptr = FFI::MemoryPointer.new :int
+    corner_count_ptr.write_int max_corners
+    corner_ptr = FFI::MemoryPointer.new CvPoint2D32f, max_corners
+    CVFFI::real_cvGoodFeaturesToTrack( image, eig_image, temp_image, corner_ptr, corner_count_ptr, quality_level, min_distance, mask, block_size, use_harris ? 1 : 0, k ) 
+
+    corner_count = corner_count_ptr.read_int
+    corners = Array.new( corner_count ) { |i|
+      CvPoint2D32f.new( corner_ptr[i] )
+    }
+  end
+
+end

data/lib/opencv-ffi/imgproc/geometric.rb

@@ -0,0 +1,42 @@
+
+
+require 'opencv-ffi/core/types'
+require 'opencv-ffi/imgproc/library'
+
+module CVFFI
+
+  attach_function :cvGetAffineTransform, [ :pointer, :pointer, :pointer ], CvMat.typed_pointer
+
+  @cvWarpFlags = enum :cvWarpFlags, [ :CV_INTER_LINEAR, 1,
+                                      :CV_WARP_FILL_OUTLIERS, 8,
+                                      :CV_WARP_INVERSE_MAP, 16  ]
+  
+  def self.cv_warp_flags_to_i( a )
+    if @cvWarpFlags.symbols.include? a
+      @cvWarpFlags[a] 
+    else
+      raise ::RuntimeError, "Undefined cvWarpFlags value #{a.inspect}"
+    end
+  end
+
+  # CVAPI(void)  cvWarpAffine( const CvArr* src, 
+  #                            CvArr* dst, 
+  #                            const CvMat* map_matrix,
+  #                            int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
+  #                            CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
+  attach_function :cvWarpAffineReal, :cvWarpAffine, [ :pointer, :pointer, :pointer, :int, CvScalar.by_value ], :void
+
+  def self.cvWarpAffine( src, dst, map_matrix, flags = nil, fillval = nil )
+    flags ||= @cvWarpFlags[:CV_INTER_LINEAR]+@cvWarpFlags[:CV_WARP_FILL_OUTLIERS]
+    fillval ||= CVFFI::CvScalar.new( [0,0,0,0] )
+
+    cvWarpAffineReal( src,dst,map_matrix,flags,fillval )
+  end
+
+
+  # CVAPI(CvMat*)  cv2DRotationMatrix( CvPoint2D32f center, 
+  #                                    double angle,
+  #                                    double scale, 
+  #                                    CvMat* map_matrix );
+  attach_function :cv2DRotationMatrix, [ CvPoint2D32f.by_value, :double, :double, :pointer ], :void
+end

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

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

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

@@ -0,0 +1,39 @@
+
+require 'opencv-ffi/imgproc/library'
+
+module CVFFI
+
+  enum :cvCvtCodes, [ :CV_RGB2RGB, 0,
+                     :CV_BGR2BGRA, 0,
+                     :CV_RGBA2RGB,
+                     :CV_BGRA2BGR, 1,
+                     :CV_RGB2BGRA,
+                     :CV_BGR2RGBA, 2,
+                     :CV_RGBA2BGR,
+                     :CV_BGRA2RGB, 3,
+                     :CV_BGR2RGB,
+                     :CV_RGB2BGR, 4,
+                     :CV_BGRA2RGBA,
+                     :CV_RGBA2BGRA, 5,
+                     :CV_BGR2GRAY,
+                     :CV_RGB2GRAY,
+                     :CV_GRAY2BGR,
+                     :CV_GRAY2RGB, 8,
+                     :CV_GRAY2BGRA,
+                     :CV_GRAY2RGBA, 9,
+                     :CV_BGRA2GRAY,
+                     :CV_RGBA2GRAYa ]
+
+  attach_function :cvCvtColor, [ :pointer, :pointer, :cvCvtCodes ], :void
+
+
+  enum :cvInterpolation, [ :CV_INTER_NN, 0,
+                           :CV_INTER_LINEAR,
+                           :CV_INTER_CUBIC,
+                           :CV_INTER_AREA,
+                           :CV_INTER_LANCZOS4 ]
+
+  attach_function :cvResize, [ :pointer, :pointer, :cvInterpolation ], :void 
+
+
+end