opencv-ffi 0.0.1

data/test/ext/test_vector_math.rb

@@ -0,0 +1,85 @@
+
+require 'test/setup'
+require 'opencv-ffi-ext/vector_math'
+require 'opencv-ffi-wrappers/enumerable'
+require 'benchmark'
+
+class TestVectorMath < Test::Unit::TestCase
+
+  def setup
+    @zero_vector = CVFFI::Float64.new( "\0" )
+    @random_vector_one = CVFFI::Float64.new( "\0" )
+    @random_vector_two = CVFFI::Float64.new( "\0" )
+
+    CVFFI::Float64::nElem.times { |i|
+      @zero_vector.d[i] = 0.0
+      @random_vector_one.d[i] = rand
+      @random_vector_two.d[i] = rand
+    }
+  end
+
+
+  def test_L2distance
+    
+    Benchmark.bm(10) do |x|
+      x.report("Zero vector") {
+        assert_equal 0.0, CVFFI::VectorMath::L2distance( @zero_vector, @zero_vector )
+      }
+
+      l2dist = 0.0
+      x.report("64-entry by hand") {
+        l2dist = @random_vector_one.inject_with_index(0.0) { |x, f, i|
+          x + (f - @random_vector_two.d[i])**2
+        }
+      }
+
+      x.report("Random vectors") { 
+        assert_in_delta l2dist, CVFFI::VectorMath::L2distance( @random_vector_one, @random_vector_two ), 1e-3
+      }
+
+    end
+
+  end
+
+  def test_L2distance_8u
+    Benchmark.bm(10) do |x|
+      a = Array.new( 1000 ) { |i| rand(256) }
+      b = Array.new( 1000 ) { |i| rand(256) }
+
+      l2dist = 0.0
+      x.report("1000-entry uint8 in pure ruby") {
+        l2dist = a.inject_with_index(0.0) { |x,f,i| 
+        x + (f-b[i])**2
+      }
+      }
+
+      x.report("With libcv-ffi") {
+        assert_in_delta l2dist, CVFFI::VectorMath::L2distance_8u( a, b )
+      }
+      
+    end
+  end
+
+  class NativeUint8
+    include CVFFI::VectorMath::NativeVectors
+
+    define_vector :uint8, 10, :Uint8Vector
+
+    def self.new_vector 
+      Uint8Vector.new '\0'
+    end
+  end
+
+  def test_native_vectors
+    a = NativeUint8.new_vector
+    p a
+    puts a.length
+
+    b = CVFFI::VectorMath::NativeVectors::ScalarVector.new( :uint8, 5 )
+    p b
+    b[0] = 1
+    p b[0]
+    p b.to_c
+  end
+
+end

data/test/features2d/test_surf.rb

@@ -0,0 +1,63 @@
+
+
+require 'test/setup'
+
+require 'opencv-ffi'
+
+class TestSURF < Test::Unit::TestCase
+
+  def setup
+    @img = CVFFI::cvLoadImage( TEST_IMAGE_FILE, CVFFI::CV_LOAD_IMAGE_COLOR  )
+  end
+
+
+  def test_cvExtractSURF
+    kp_ptr = FFI::MemoryPointer.new :pointer
+    desc_ptr = FFI::MemoryPointer.new :pointer
+
+    mem_storage = CVFFI::cvCreateMemStorage( 0 )
+
+    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 )
+
+    params = CVFFI::CvSURFParams.new( :hessianThreshold => 500.0,
+                                      :upright => 0,
+                                      :extended => 0,
+                                      :nOctaves => 3,
+                                      :nOctaveLayers => 4 )
+    CVFFI::cvExtractSURF( smallGreyImg, nil, kp_ptr, desc_ptr, mem_storage, params, :false )
+
+    assert_not_nil kp_ptr
+    assert_not_nil kp_ptr.read_pointer()
+
+    assert_not_nil desc_ptr
+    assert_not_nil desc_ptr.read_pointer()
+
+    keypoints = CVFFI::CvSeq.new( kp_ptr.read_pointer() )
+    descriptors = CVFFI::CvSeq.new( desc_ptr.read_pointer() )
+
+    #puts "#{keypoints.total} keypoints"
+    #puts "#{descriptors.total} descriptors"
+
+    (0...keypoints.total).each { |i|
+      kp = CVFFI::CvSURFPoint.new( CVFFI::cvGetSeqElem( keypoints.to_ptr, i ) )
+
+      # cvCircle takes a CvPoint(int), but the CvSURFPoint contains CvPoint2D32f, need 
+      # to manually typecast...
+      CVFFI::cvCircle( smallGreyImg, CVFFI::CvPoint.new( :x => kp.pt.x.to_i, :y => kp.pt.y.to_i ), 5,
+                      CVFFI::CvScalar.new( :w=>255, :x=>255, :y=>255, :z=>0 ), -1, 8, 0 )
+    }
+    CVFFI::cvSaveImage( TestSetup::output_filename("greyImagePts.jpg"), smallGreyImg )
+  end
+
+end

data/test/imgproc/test_goodfeatures.rb

@@ -0,0 +1,18 @@
+require 'test/setup'
+require 'opencv-ffi'
+require 'find'
+
+class TestGoodFeaturesToTrack < Test::Unit::TestCase
+
+  def test_goodFeaturesToTrack
+    # First, the "verbatim" approach, with some rubbish data
+    img = TestSetup::grey_test_image
+    eigImage = CVFFI::cvCreateMat( img.width, img.height, :CV_32F )
+    tmpImage = CVFFI::cvCreateMat( img.width, img.height, :CV_32F )
+
+    max_corners = 100
+    corners = CVFFI::cvGoodFeaturesToTrack( img, eigImage, tmpImage, max_corners, 0.5, 5 )
+
+    assert corners.length <= max_corners
+  end
+end

data/test/setup.rb

@@ -0,0 +1,65 @@
+# This must be the first require called, otherwise the
+# results will be inaccurate
+require 'simplecov'
+SimpleCov.start
+
+require 'test/unit'
+require 'pp'
+
+require 'opencv-ffi/highgui'
+require 'opencv-ffi/imgproc'
+
+
+TEST_IMAGE_FILE = "test/test_files/images/IMG_7089.JPG"
+SMALL_TEST_IMAGE_FILE = "test/test_files/images/IMG_7089_small.JPG"
+TEST_IMAGE_FILE_TWO = "test/test_files/images/IMG_7088.JPG"
+
+def recursive_test name
+  dirname = [ 'test', name] .join('/')
+  if File.directory? dirname
+    Find.find( dirname ) { |f|
+      require f if File.basename(f).match( "^test_[\w]*" )
+    }
+  end
+end
+
+module TestSetup
+  
+  @dirname = "/tmp/opencv-ffi-test"
+
+  def self.test_image
+    CVFFI::cvLoadImage( TEST_IMAGE_FILE, CVFFI::CV_LOAD_IMAGE_COLOR  )
+  end
+
+  def self.small_test_image
+    CVFFI::cvLoadImage( TEST_IMAGE_FILE, CVFFI::CV_LOAD_IMAGE_COLOR  )
+  end
+
+
+  def self.grey_test_image
+    img = test_image
+    greyImg = CVFFI::cvCreateImage( CVFFI::CvSize.new( { :height => img.height, 
+                                                      :width => img.width }), 
+                                                      :IPL_DEPTH_8U, 1 )
+    CVFFI::cvCvtColor( img, greyImg, :CV_BGR2GRAY )
+    greyImg
+  end
+
+  def self.second_test_image
+    CVFFI::cvLoadImage( TEST_IMAGE_FILE_TWO, CVFFI::CV_LOAD_IMAGE_COLOR  )
+  end
+
+  def self.save_image( fname, img )
+    fname += ".jpg" unless fname.match('\.')
+    CVFFI::cvSaveImage( output_filename(fname), img )
+  end
+
+  def self.output_filename( s )
+    FileUtils.mkdir_p @dirname unless FileTest::directory? @dirname    
+    @dirname + '/' + s
+  end
+
+  EPSILON = 1e-3
+
+end
+

data/test/test_calib3d.rb

@@ -0,0 +1,38 @@
+
+require 'test/setup'
+require 'opencv-ffi/calib3d'
+require 'opencv-ffi-wrappers/misc'
+require 'find'
+
+recursive_test 'calib3d'
+
+class TestCalib3d < Test::Unit::TestCase
+
+  def test_cvFundamentalMatrix
+    # First, the "verbatim" approach, with some rubbish data
+
+    points = 20
+    pointsOne = CVFFI::cvCreateMat( points, 2, :CV_32F )
+    pointsTwo = CVFFI::cvCreateMat( points, 2, :CV_32F )
+
+    points.times { |i|
+      u = CVFFI::CvScalar.new( :w => rand, :x => 0.0, :y => 0.0, :z => 0.0 )
+      v = CVFFI::CvScalar.new( :w => rand, :x => 0.0, :y => 0.0, :z => 0.0 )
+      w = CVFFI::CvScalar.new( :w => rand, :x => 0.0, :y => 0.0, :z => 0.0 )
+      x = CVFFI::CvScalar.new( :w => rand, :x => 0.0, :y => 0.0, :z => 0.0 )
+      CVFFI::cvSet2D( pointsOne, i, 0, u )
+      CVFFI::cvSet2D( pointsOne, i, 1, v )
+      CVFFI::cvSet2D( pointsTwo, i, 0, w )
+      CVFFI::cvSet2D( pointsTwo, i, 1, x )
+    }
+
+    fundamental = CVFFI::cvCreateMat( 3,3, :CV_32F )
+    status  = CVFFI::cvCreateMat( points, 1, :CV_8U )
+
+    result = CVFFI::cvFindFundamentalMat( pointsOne, pointsTwo, fundamental, :CV_FM_RANSAC, 1.0, 0.99, status )
+
+    CVFFI::print_matrix fundamental, {:caption=>"Fundamental = "}
+    #CVFFI::print_matrix status, {:caption=>"Status = "}
+
+  end
+end

data/test/test_core.rb

@@ -0,0 +1,26 @@
+require 'test/setup'
+require 'opencv-ffi/core'
+require 'find'
+
+recursive_test 'core'
+
+class TestCore < Test::Unit::TestCase
+
+  def test_cvPoint
+    p = CVFFI::CvPoint.new( {:x => 1, :y => 2} )
+
+    assert_not_nil p
+    assert_equal 1, p.x
+    assert_equal 2, p.y
+  end
+
+  def test_createImg
+    img = CVFFI::cvCreateImage( CVFFI::CvSize.new( :width=>100, :height=>100 ), 8, 1 )
+
+    assert_not_nil img
+    assert_equal 1, img.nChannels
+    assert_equal 8, img.depth
+
+  end
+
+end

data/test/test_ext.rb

@@ -0,0 +1,8 @@
+require 'test/setup'
+require 'find'
+
+recursive_test 'ext'
+
+class TestExt < Test::Unit::TestCase
+
+end

data/test/test_features2d.rb

@@ -0,0 +1,9 @@
+require 'test/setup'
+require 'opencv-ffi/features2d'
+require 'find'
+
+recursive_test 'features2d'
+
+class TestFeatures2d < Test::Unit::TestCase
+
+end

data/test/test_highgui.rb

@@ -0,0 +1,26 @@
+
+require 'test/setup'
+require 'opencv-ffi/highgui'
+
+class TestFFI < Test::Unit::TestCase
+
+  def test_cvLoadImageM_cvSaveImage
+    cvmat = CVFFI::cvLoadImageM( TEST_IMAGE_FILE, CVFFI::CV_LOAD_IMAGE_COLOR  )
+
+    assert_not_nil cvmat
+    assert_equal cvmat.width, 3888
+    assert_equal cvmat.height, 2592
+
+    CVFFI::cvSaveImage( TestSetup::output_filename("asCvMat.jpg"), iplimage.to_ptr )
+  end
+
+  def test_cvLoadImageM_cvSaveImage
+    iplimage = CVFFI::cvLoadImage( TEST_IMAGE_FILE, CVFFI::CV_LOAD_IMAGE_COLOR  )
+
+    assert_not_nil iplimage
+    assert_equal iplimage.width, 3888
+    assert_equal iplimage.height, 2592
+
+    CVFFI::cvSaveImage( TestSetup::output_filename("asIplImage.jpg"), iplimage.to_ptr )
+  end
+end

data/test/test_imgproc.rb

@@ -0,0 +1,35 @@
+require 'test/setup'
+require 'opencv-ffi/imgproc'
+require 'opencv-ffi/core'
+require 'find'
+
+recursive_test 'imgproc'
+
+class TestImgproc < Test::Unit::TestCase
+
+  def test_cv2DRotationMatrix
+
+    center = CVFFI::CvPoint2D32f.new( :x => 0.0, :y => 0.0 )
+    mat = CVFFI::cvCreateMat( 2,3, :CV_32F )
+
+    CVFFI::cv2DRotationMatrix( center, 0.0, 1.0, mat )
+
+    # With 0 rotation, some elements should be 0.0
+   
+    assert_in_delta 0.0, CVFFI::cvGetReal2D( mat, 0, 1 ), TestSetup::EPSILON
+    assert_in_delta 0.0, CVFFI::cvGetReal2D( mat, 1, 0 ), TestSetup::EPSILON
+    assert_in_delta CVFFI::cvGetReal2D( mat, 0, 0), CVFFI::cvGetReal2D( mat, 1, 1 ), TestSetup::EPSILON
+
+    a = []
+    0.upto(1) { |i|
+      b = []
+      0.upto(2) { |j|
+        b << CVFFI::cvGetReal2D( mat, i,j )
+      }
+      a << b
+    }
+
+p a
+  end
+
+end

data/test/test_wrappers.rb

@@ -0,0 +1,8 @@
+require 'test/setup'
+require 'find'
+
+recursive_test 'wrappers'
+
+class TestWrappers < Test::Unit::TestCase
+
+end

data/test/wrappers/core/test_draw.rb

@@ -0,0 +1,41 @@
+
+
+require 'test/setup'
+require 'opencv-ffi-wrappers/core/misc_draw'
+
+class TestDrawWrappers < Test::Unit::TestCase
+
+  def setup
+    @img = TestSetup.test_image
+  end
+
+  def test_draw_point
+    p = CVFFI::Point.new( 500.0, 500.0 )
+
+    opts = { :radius => 50 }
+    CVFFI::draw_point( @img, p, opts)
+
+    TestSetup::save_image( "test_DrawPointWrapper", @img )
+  end
+
+  def test_put_text
+    font = CVFFI::CvFont.new '\0'
+    CVFFI::cvInitFont( font, :CV_FONT_HERSHEY_PLAIN, 2.0, 2.0, 0.0, 5, 8 )
+    img = CVFFI::cvCreateImage( CVFFI::CvSize.new( :height=>480, :width=>640), :IPL_DEPTH_32F, 3 )
+
+    color = CVFFI::Scalar.new( 0, 255, 0, 0, )
+    point = CVFFI::Point.new( 100, 100 )
+
+    a = "TEST TEST!"
+    CVFFI::put_text( img, a, point, { :font => font, :color => color } )
+
+    color[:r] = 255
+    CVFFI::put_text( img, a, point*2, { :face => :CV_FONT_HERSHEY_SIMPLEX,
+                                        :scale => 2.0,
+                                        :color => color } )
+
+    TestSetup::save_image( "test_FontWrapper", img )
+  end
+
+
+end

data/test/wrappers/core/test_mat.rb

@@ -0,0 +1,40 @@
+
+require 'test/setup'
+require 'opencv-ffi/core'
+require 'opencv-ffi-wrappers/core'
+
+class TestCoreMat < Test::Unit::TestCase
+
+  def test_MatInitializerDefaultType
+    # Default type is 32F
+    a = CVFFI::Mat.new( 5,5 )
+
+    a[1,2] = 1.0
+    assert_equal 1.0, a[1,2]
+  end
+
+
+  def test_MatInitializerIntType
+    a = CVFFI::Mat.new( 5,5, :CV_8U )
+
+    a[1,2] = 1.0
+    assert_equal 1, a[1,2]
+  end
+
+  def test_MatInitializeFromRows
+    a = [ [1,2,3],[4,5,6],[7,8,9] ]
+    m = CVFFI::Mat.rows( a, :CV_8U )
+
+    m.each_with_indices { |d,i,j|
+      assert_equal a[i][j], d
+    }
+  end
+
+  def test_MatEye
+    a = CVFFI::Mat.eye( 5, :CV_8U )
+
+    a.each_with_indices { |d, i,j|
+      assert_equal ( i==j ? 1 : 0 ),  d
+    }
+  end
+end