opencv-ffi 0.0.1

data/test/wrappers/core/test_operations.rb

@@ -0,0 +1,35 @@
+
+require 'test/setup'
+require 'opencv-ffi-wrappers/core'
+
+
+class TestCoreWrapperOperations < Test::Unit::TestCase
+
+    WHITE  = CVFFI::CvScalar.new( {:w=>255, :x=>255, :y=>255, :z=>0} )
+    BLACK = CVFFI::CvScalar.new( {:w=>0, :x=>0, :y=>0, :z=>0} )
+
+  def setup
+  end
+
+  def test_solve_cubic
+    # The roots of x^3 - 6x^2 + 11x - 6
+    # are 1,2,3
+    c = Vector[1,-6,11,-6]
+    r = CVFFI::solveCubic( c )
+
+    p r
+    assert r.is_a?(Vector)
+    assert_equal 3, r.size
+
+    # For simplicity, dump to an array I can sort
+    r = r.covector.sort
+
+    3.times { |i|
+      assert_in_delta i+1, r[i], 1e-06
+    }
+  end
+
+
+
+
+end

data/test/wrappers/core/test_types.rb

@@ -0,0 +1,235 @@
+
+require 'test/setup'
+require 'opencv-ffi/core'
+require 'opencv-ffi-wrappers/core'
+
+class TestCoreTypesWrappers < Test::Unit::TestCase
+
+  def test_cvSizeWrappers
+    p = CVFFI::CvSize.new( {:width => 1, :height => 2} )
+
+    assert_equal 1, p.x
+    assert_equal 2, p.y
+
+    assert_equal 1, p.width
+    assert_equal 2, p.height
+
+    p.x = 3
+
+    assert_equal 3, p.width
+    assert_equal 2, p.height
+    assert_equal 3, p.x
+    assert_equal 2, p.y
+
+    r = p.to_CvSize
+    assert_equal p,r
+
+    q = p.to_CvSize2D32f
+    assert_in_delta 3.0, q.width, TestSetup::EPSILON
+    assert_in_delta 2.0, q.height, TestSetup::EPSILON
+  end
+
+  def test_point
+    p = CVFFI::Point.new( 4.0, 5.0 )
+    assert_equal 4.0, p.x
+    assert_equal 5.0, p.y
+
+    q = p.to_CvPoint
+    assert_equal 4.0, q.x
+    assert_equal 5.0, q.y
+
+    a = p.to_a
+    assert a.is_a?(Array)
+    assert_equal 3, a.length
+    assert_equal 4.0, a[0]
+    assert_equal 5.0, a[1]
+    assert_equal 1.0, a[2]
+
+    a = p.to_a(false)
+    assert a.is_a?(Array)
+    assert_equal 2, a.length
+    assert_equal 4.0, a[0]
+    assert_equal 5.0, a[1]
+
+  end
+
+  def test_size
+    p = CVFFI::Size.new( [4.0, 5.0] )
+
+    assert_equal 4.0, p.width
+    assert_equal 5.0, p.height
+
+    assert_in_delta 20.0, p.area, TestSetup::EPSILON
+
+    q = p.to_CvSize2D32f
+    assert q.is_a?( CVFFI::CvSize2D32f )
+    assert_in_delta 4.0, q.width, TestSetup::EPSILON
+    assert_in_delta 5.0, q.height, TestSetup::EPSILON
+
+    r = CVFFI::Size.new p
+    assert_equal 4.0, r.width
+    assert_equal 5.0, r.height
+
+    s = p/2.0
+    assert_equal 2.0, s.width
+    assert_equal 2.5, s.height
+
+    p *= 2.0
+    assert_equal 8.0, p.width
+    assert_equal 10.0, p.height
+  end
+
+  def test_point
+    p = CVFFI::Point.new( 10.0, 0.0 )
+    r = CVFFI::Point.new( 0.0, 0.0 )
+
+    assert_equal 10.0, p.x
+    assert_equal  0.0, p.y
+
+    q = p.rotate( 0.0 )
+    assert_equal 10.0, q.x
+    assert_equal  0.0, q.y
+
+    q = p.rotate( Math::PI/2.0 )
+    assert_in_delta 0.0, q.x, TestSetup::EPSILON
+    assert_in_delta 10.0, q.y, TestSetup::EPSILON
+
+    assert p.neighbor?( r, 10.01 )
+    assert p.neighbor?( r, 9.99 ) == false
+
+    assert p.neighbor_rsquared?( r, 100.01 )
+    assert p.neighbor_rsquared?( r, 99.9 ) == false
+
+    assert_in_delta 10.0, p.l2distance( r ),  TestSetup::EPSILON
+    assert_in_delta 100.0, p.l2_squared_distance( r ),  TestSetup::EPSILON
+
+  end
+
+  def test_iplimage
+    img = CVFFI::cvCreateImage( CVFFI::CvSize.new( :width=>100, :height=>100 ), 8, 1 )
+
+    size = img.image_size
+
+    assert_not_nil size
+    assert_equal 100, size.width
+    assert_equal 100, size.height
+
+    clone = img.clone
+
+
+    twin = img.twin
+    assert_equal img.image_size, twin.image_size
+    assert_equal img.depth,      twin.depth
+    assert_equal img.nChannels,  twin.nChannels
+
+  end
+
+  def test_rect
+    r = CVFFI::Rect.new( :center => CVFFI::Point.new( 0.0, 0.0 ),
+                        :size   => CVFFI::Size.new(  10.0, 10.0 ) )
+
+    assert_equal -5.0, r.origin.x
+    assert_equal -5.0, r.origin.y
+    assert_equal 10.0, r.size.width
+    assert_equal 10.0, r.size.height
+
+    cv = r.to_CvRect
+
+    assert_equal -5.0, cv.x
+    assert_equal -5.0, cv.y
+    assert_equal 10.0, cv.width
+    assert_equal 10.0, cv.height
+  end
+
+  def test_mat
+    m = CVFFI::CvMat.eye( 3 )
+
+    3.times { |i|
+      3.times { |j|
+assert_equal m.at_f(i,j), ( i==j ? 1.0 : 0.0 )
+      }
+    }
+
+    mat = m.to_Matrix
+    assert_not_nil mat
+    assert_equal  mat[0,0], 1.0
+    assert_equal mat[0,0], m.at_f(0,0)
+
+    r = m.clone
+    assert_equal m.height, r.height
+    assert_equal m.width, r.width
+    assert_equal m.type, r.type
+    assert_equal m.at_f(0,0), r.at_f(0,0)
+
+    q = m.twin
+    assert_equal m.height, q.height
+    assert_equal m.width, q.width
+    assert_equal m.type, q.type
+    assert_not_equal m.at_f(0,0), q.at_f(0,0)
+  end
+
+  def test_vector
+    m = CVFFI::cvCreateMat( 1, 5, :CV_32F )
+    n = CVFFI::cvCreateMat( 5, 1, :CV_32F )
+
+    5.times { |i|
+      m.set_f(0,i,i)
+      n.set_f(i,0,i)
+    }
+
+    mv = m.to_Vector
+    nv = n.to_Vector
+
+    5.times { |i|
+      assert_equal i, mv[i]
+      assert_equal i, nv[i]
+    }
+  end
+
+  def test_mat_transpose
+    m = CVFFI::cvCreateMat( 3,3,:CV_32F)
+    m.zero
+    m.set_f( 0, 2, 1.0 )
+
+    assert_equal m.at_f( 0, 2 ), 1.0
+    assert_equal m.at_f( 2, 0 ), 0.0
+
+    t = m.transpose
+    assert_equal m.at_f( 0, 2 ), 1.0
+    assert_equal m.at_f( 2, 0 ), 0.0
+
+    assert_equal t.at_f( 0, 2 ), 0.0
+    assert_equal t.at_f( 2, 0 ), 1.0
+  end
+
+  def test_mat_coercion
+    a = Matrix.rows( [ [ 1,0,0 ], [0,2,0], [0,0,3] ] )
+    b = CVFFI::CvMat.eye( 3 )
+
+    c = nil
+    assert_nothing_raised {
+      c = a*b
+    }
+    assert c.is_a?(Matrix)
+    assert_equal 1, c[0,0]
+    assert_equal 2, c[1,1]
+    assert_equal 3, c[2,2]
+  end
+
+  def test_scalar
+    # Test each expected initializer pattern
+    # Default ordering is BGRA
+    [ CVFFI::Scalar.new( 1,2,0,4 ),
+      CVFFI::Scalar.new( :w => 1, :x => 2, :z => 4),
+      CVFFI::Scalar.new( :A => 4, :g => 2, :B => 1) ].each { |m|
+
+      [ [1,2,0,4], [:w,:x,:y,:z], [:B,:G,:R,:A], [:b,:g,:r,:a ] ].transpose.each { |i,j,k,p|
+        assert_equal i, m[j], "m[:#{j.to_s}] != #{i} for #{m.to_s}"
+        assert_equal i, m[k], "m[:#{k.to_s}] != #{i} for #{m.to_s}"
+        assert_equal i, m[p], "m[:#{p.to_s}] != #{i} for #{m.to_s}"
+      }
+    }
+
+
+  end
+end

data/test/wrappers/features2d/test_image_patch.rb

@@ -0,0 +1,108 @@
+
+
+require 'test/setup'
+
+require 'opencv-ffi'
+require 'opencv-ffi-wrappers'
+require 'opencv-ffi-wrappers/features2d/image_patch'
+
+class TestImagePatch < Test::Unit::TestCase
+
+  def setup
+    @img = TestSetup::test_image
+
+    # Generate an aritificial image, a 300x300 black field
+    # With a 100-wide grey stripe down the center
+    # and a white X corner-to-corner
+    img = CVFFI::cvCreateImage( CVFFI::CvSize.new( [ 300,300 ] ), 8, 1 )
+    CVFFI::cvSet( img, CVFFI::Scalar.new( 0,0,0,0 ).to_CvScalar, nil )
+    CVFFI::cvSetImageROI( img, CVFFI::Rect.new( [100,0,100,300] ).to_CvRect )
+    CVFFI::cvSet( img, CVFFI::Scalar.new( 128,0,0,0 ).to_CvScalar, nil )
+    CVFFI::cvResetImageROI( img )
+    CVFFI::draw_line( img, CVFFI::Point.new(0,0), CVFFI::Point.new(300,300),
+                      { thickness: 2 } )
+    CVFFI::draw_line( img, CVFFI::Point.new(300,0), CVFFI::Point.new(0,300),
+                      { thickness: 2 } )
+    @testimg = img
+  end
+
+
+  def test_cvExtractImagePatch
+
+    params = CVFFI::ImagePatch::Params.new( size: 9 )
+
+    puts "Image size = #{@img.width} x #{@img.height}"
+    # With a 9x9 patch, (4,4) should be OK, but (3,4) shouldn't
+    # Similarly width-5 should be OK, but width-4 shouldn't
+    kp = [ [100,100],
+           [150,150],
+           [100,100],
+           [4,4],
+           [3,4],
+           [@img.width-5,100], 
+           [@img.width-4,100] ].map { |i| CVFFI::Point.new i }
+    duds = 2
+
+    patches = CVFFI::ImagePatch::describe( @img, kp, params )
+    assert_not_nil patches
+
+    assert_equal kp.length-duds, patches.length
+
+    # KPs 0 and 2 should be identical
+    assert_equal patches[0], patches[2]
+    
+    patch_index = patches.draw_index_image
+    TestSetup::save_image( "test_cvExtractImagePatch", patch_index )
+  end
+
+  def test_cvExtractCircularOrientedImagePatch
+    kp = [ [100,100], [150,150], [199,199] ].map { |i| CVFFI::Point.new i }
+    orientation = [ 5.35, 5.497, 5.35 ]
+
+    params = CVFFI::ImagePatch::Params.new( size: 15,
+                                            oriented: true,
+                                            shape: :circle)
+
+    patches = CVFFI::ImagePatch.describe( @testimg, kp, params )
+
+    patches.each_with_index { |patch,i|
+      assert_in_delta patch.angle, orientation[i],  0.1, "For orientation #{i}"
+    }
+
+    # Expect the first and last to be roughly the same
+    assert_in_delta orientation.first, orientation.last, 0.1
+
+    patch_index = patches.draw_index_image
+    TestSetup::save_image( "test_cvExtractCircularOrientedImagePatch", patch_index )
+  end
+
+
+
+
+  def test_cvExtractOrientedImagePatch
+
+    TestSetup::save_image( "oriented_image_patch", @testimg )
+
+    kp = [ [100,100], [150,150], [199,199] ].map { |i| CVFFI::Point.new i }
+    orientation = [ 5.35, 4.712, 5.35 ]
+
+    params = CVFFI::ImagePatch::Params.new( size: 15,
+                                            oriented: true )
+
+    patches = CVFFI::ImagePatch.describe( @testimg, kp, params )
+
+    patches.each_with_index { |patch,i|
+      assert_in_delta patch.angle, orientation[i],  0.1, "For orientation #{i}"
+    }
+
+    # Expect the first and last to be roughly the same
+    assert_in_delta orientation.first, orientation.last, 0.1
+
+    # First and last should be relatively similar
+    puts "Distance = #{ patches.first.distance_to( patches.last ) }"
+
+    patch_index = patches.draw_index_image
+    TestSetup::save_image( "test_cvOrientedExtractImagePatch", patch_index )
+  end
+
+end

data/test/wrappers/test_imgproc.rb

@@ -0,0 +1,87 @@
+
+
+require 'test/setup'
+require 'opencv-ffi-wrappers/core'
+require 'opencv-ffi-wrappers/imgproc'
+require 'opencv-ffi-wrappers/misc'
+
+class TestImgprocWrappers < Test::Unit::TestCase
+
+  def setup
+        @img = TestSetup::test_image
+  end
+
+  def test_getAffineTransform
+    src = Array.new(5) { |i|
+      CVFFI::Point.new( 1.1, i*1.0 )
+    }
+    dst = Array.new(5) { |i|
+      CVFFI::Point.new( i*1.0, i* -1.0 )
+    }
+
+    result = CVFFI::get_affine_transform(src,dst)
+
+    assert_not_nil result
+
+    CVFFI::print_matrix(result, :format => :e)
+
+ end
+
+  def test_warpAffine
+    warp = CVFFI::CvMat.new CVFFI::cvCreateMat(2,3,:CV_32F)
+    CVFFI::cvSetReal2D(warp, 0,0,1.0)
+    CVFFI::cvSetReal2D(warp, 0,1,0.0)
+    CVFFI::cvSetReal2D(warp, 0,2,0.0)
+    CVFFI::cvSetReal2D(warp, 1,0,0.0)
+    CVFFI::cvSetReal2D(warp, 1,1,1.0)
+    CVFFI::cvSetReal2D(warp, 1,2,0.0)
+
+    dst = CVFFI::cvCreateImage( @img.image_size.to_CvSize, @img.depth, @img.nChannels ) 
+
+    out = CVFFI::warp_affine( @img.to_IplImage, dst, warp )
+
+    TestSetup::save_image("affineWarped.jpg", dst )
+
+  end
+
+
+  def corner_common_tests( corners, img, params = nil )
+
+    if params
+     assert corners.length <= params.max_corners
+    end
+   
+   # Hm, what can I test?
+    corners.each { |c|
+      assert c.x >= 0.0
+      assert c.x < img.width
+      assert c.y >= 0.0
+      assert c.y < img.height
+    }
+  end
+ 
+  def test_goodFeaturesToTrack_default_params
+    corners = CVFFI::goodFeaturesToTrack( @img )
+    corner_common_tests( corners, @img )
+
+    params = CVFFI::GoodFeaturesParams.new( use_harris: true )
+    harris_corners = CVFFI::goodFeaturesToTrack( @img, params )
+    corner_common_tests( harris_corners, @img, params )
+
+    assert harris_corners != corners
+ end
+
+  def test_goodFeaturesToTrack_shitomasi_with_params
+    params = CVFFI::GoodFeaturesParams.new( quality_level: 0.7,
+                                        min_distance: 10 )
+    corners = CVFFI::goodFeaturesToTrack( @img, params )
+    corner_common_tests( corners, @img, params )
+  end
+
+  def test_goodFeaturesToTrack_harris_with_params
+  end 
+  
+
+
+
+end