opencv-ffi 0.0.1

data/lib/opencv-ffi/version.rb

@@ -0,0 +1,3 @@
+module CVFFI
+  VERSION = "0.0.1"
+end

data/opencv-ffi.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "opencv-ffi/version"
+
+Gem::Specification.new do |s|
+  s.name        = "opencv-ffi"
+  s.version     = CVFFI::VERSION
+  s.authors     = ["Aaron Marburg"]
+  s.email       = ["aaron.marburg@pg.canterbury.ac.nz"]
+  s.homepage    = "http://github.com/amarburg/opencv-ffi"
+  s.summary     = %q{A wrapper around OpenCV's C interface using Ruby FFI.  Very preliminary.}
+  s.description = %q{A wrapper around OpenCV's C interface using Ruby FFI.}
+
+  s.rubyforge_project = "opencv-ffi"
+
+  s.files         = `git ls-files`.split("\n")
+  s.extensions    = "ext/mkrf_conf.rb"
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.has_rdoc = true
+
+  s.add_dependency "nice-ffi"
+  s.add_dependency "mkrf"
+end

data/test/core/test_draw.rb

@@ -0,0 +1,46 @@
+
+
+require 'test/setup'
+
+class TestcvCircle < Test::Unit::TestCase
+
+  def setup
+    @img = TestSetup::test_image
+  end
+
+
+  def test_cvCircle
+    center = CVFFI::CvPoint.new( :x => 500, :y => 500 )
+    radius = 100
+    color = CVFFI::CvScalar.new( {:w=>255, :x=>255, :y=>255, :z=>0} )
+
+    CVFFI::cvCircle( @img, center, radius, color, -1, 8, 0 )
+
+    # Spot check a few points within the radius
+    pts = [ [500,500], [550,500], [450, 500] ]
+    pts.each { |pt| 
+      c = CVFFI::cvGet2D( @img, pt[0],pt[1] )
+
+      assert_equal 255, c.w
+      assert_equal 255, c.x
+      assert_equal 255, c.y
+      assert_equal 0, c.z
+    }
+
+    TestSetup::save_image( "test_cvCircle", @img )
+  end
+
+  def test_cvLine
+
+    pointA = CVFFI::CvPoint.new( :x => 50, :y => 50 )
+    pointB = CVFFI::CvPoint.new( :x => @img.width-50, :y => @img.height-50 )
+
+    color = CVFFI::CvScalar.new( {:w=>255, :x=>0, :y=>255, :z=>0} )
+
+    CVFFI::cvLine( @img, pointA, pointB, color, 10, 8, 0 )
+
+    TestSetup::save_image( "text_cvLine", @img )
+  end
+
+
+end

data/test/core/test_operations.rb

@@ -0,0 +1,135 @@
+
+require 'test/setup'
+require 'opencv-ffi/core'
+require 'opencv-ffi/highgui'
+
+
+class TestCoreOperations < 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
+    @center = CVFFI::CvPoint.new( :x => 50, :y => 50 )
+    @radius = 50
+  end
+
+
+  def assert_color_at_point( img, point, color )
+    c = CVFFI::cvGet2D( img, point.x, point.y )
+    assert_equal color.w, c.w, "First channel mismatch"
+    assert_equal color.x, c.x, "Second channel mismatch" if img.nChannels > 1
+    assert_equal color.y, c.y, "Third channel mismatch"  if img.nChannels > 2
+    assert_equal color.z, c.z, "Fourth channel mismatch" if img.nChannels > 3
+  end
+  
+  def test_cvReleaseImage
+    imgOne = CVFFI::cvCreateImage( CVFFI::CvSize.new( :width=>100, :height=>100 ), 8, 1 )
+    CVFFI::cvReleaseImage( imgOne )
+  end
+
+
+  def test_imageOperations
+    imgOne = CVFFI::cvCreateImage( CVFFI::CvSize.new( :width=>100, :height=>100 ), 8, 1 )
+    CVFFI::cvSet( imgOne, BLACK, nil )
+
+    imgTwo = CVFFI::cvCloneImage( imgOne )
+
+    assert_equal imgOne.nChannels, imgTwo.nChannels
+    assert_equal imgOne.depth,     imgTwo.depth
+    assert_equal imgOne.width,     imgTwo.width
+    assert_equal imgOne.height,    imgTwo.height
+
+    assert_color_at_point imgOne, @center, BLACK
+    assert_color_at_point imgTwo, @center, BLACK
+
+    # Draw a circle on one
+    CVFFI::cvCircle( imgOne, @center, @radius, WHITE, -1, 8, 0 )
+
+    assert_color_at_point imgOne, @center, WHITE
+    assert_color_at_point imgTwo, @center, BLACK
+
+    # Now copy
+    CVFFI::cvCopy( imgOne, imgTwo, nil )
+
+    assert_color_at_point imgOne, @center, WHITE
+    assert_color_at_point imgTwo, @center, WHITE
+  end
+
+  def test_roiOperations
+    imgOne = CVFFI::cvCreateImage( CVFFI::CvSize.new( :width=>100, :height=>100 ), 8, 1 )
+    CVFFI::cvSet( imgOne, BLACK, nil )
+    CVFFI::cvCircle( imgOne, @center, @radius, WHITE, -1, 8, 0 )
+
+    imgTwo = CVFFI::cvCreateImage( CVFFI::CvSize.new( :width=>200, :height=>200 ), 8, 1 )
+    CVFFI::cvSet( imgTwo, BLACK, nil )
+
+    0.upto(100) { |i|
+      if i%25 == 0
+
+        roi = CVFFI::CvRect.new( :width => 100, :height => 100, :x => i, :y => i )
+        CVFFI::cvSetImageROI( imgTwo, roi )
+
+        r = CVFFI::CvRect.new CVFFI::cvGetImageROI( imgTwo )
+
+        assert_equal r.width, roi.width
+        assert_equal r.height, roi.height
+        assert_equal r.x, roi.x
+        assert_equal r.y, roi.y
+
+        CVFFI::cvCopy( imgOne, imgTwo, nil )
+
+      end
+    }
+
+    CVFFI::cvResetImageROI( imgTwo )
+
+    TestSetup::save_image( "test_roi", imgTwo )
+
+  end
+
+  def test_transpose
+    m = CVFFI::cvCreateMat( 3,3, :CV_32F )
+    CVFFI::cvSetZero( m )
+    CVFFI::cvSetReal2D( m, 0, 2, 1.0 )
+
+    assert_equal CVFFI::cvGetReal2D( m, 0, 2 ), 1.0
+    assert_equal CVFFI::cvGetReal2D( m, 2, 0 ), 0.0
+
+    t = CVFFI::cvCreateMat( 3,3, :CV_32F )
+    CVFFI::cvTranspose( m, t )
+
+    assert_equal CVFFI::cvGetReal2D( m, 0, 2 ), 1.0
+    assert_equal CVFFI::cvGetReal2D( m, 2, 0 ), 0.0
+
+    assert_equal CVFFI::cvGetReal2D( t, 0, 2 ), 0.0
+    assert_equal CVFFI::cvGetReal2D( t, 2, 0 ), 1.0
+  end
+
+  def test_solve_cubic
+    c = CVFFI::cvCreateMat( 1,4, :CV_32F )
+    r = CVFFI::cvCreateMat( 1,3, :CV_32F )
+    CVFFI::cvSetZero( r )
+
+    # The roots of x^3 - 6x^2 + 11x - 6
+    # are 1,2,3
+    [1,-6,11,-6].each_with_index { |x,i|
+      CVFFI::cvSetReal1D(c,i,x)
+    }
+
+    CVFFI::cvSolveCubic( c, r )
+
+    # For siplicity, dump to an array I can sort
+    r = Array.new(3) { |i|
+      CVFFI::cvGetReal1D(r,i)
+    }.sort
+    
+    3.times { |i|
+      assert_in_delta i+1, r[i], 1e-06
+    }
+  end
+
+
+
+
+end

data/test/core/test_size.rb

@@ -0,0 +1,14 @@
+
+require 'test/setup'
+
+class TestCoreSize < Test::Unit::TestCase
+
+  def test_cvSize
+    p = CVFFI::CvSize.new( {:width => 1, :height => 1} )
+
+    assert_not_nil p
+    assert_equal 1, p.width
+    assert_equal 1, p.height
+  end
+
+end

data/test/core/test_text.rb

@@ -0,0 +1,52 @@
+
+require 'test/setup'
+require 'lib/opencv-ffi/core'
+
+class TestCoreTextFunctions < Test::Unit::TestCase
+
+  def setup
+    @img = CVFFI::cvLoadImageM( TEST_IMAGE_FILE, CVFFI::CV_LOAD_IMAGE_COLOR  )
+  end
+
+
+  def test_cvInitFont
+    font = CVFFI::CvFont.new '\0'
+    CVFFI::cvInitFont( font, :CV_FONT_HERSHEY_PLAIN, 2.0, 2.0, 0.0, 1, 8 )
+
+    assert_equal CVFFI::CvFontDefines[:CV_FONT_HERSHEY_PLAIN], font.font_face
+    assert_equal 2.0, font.hscale
+    assert_equal 2.0, font.vscale
+    assert_equal 1, font.thickness
+    assert_equal 0.0, font.shear
+    assert_equal 8, font.line_type
+  end
+
+  def test_putText
+    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::CvScalar.new( :w => 0 , :x => 255, :y => 0, :z => 0 )
+    point = CVFFI::CvPoint.new( :x => 100, :y => 100 )
+
+    a = "TEST TEST!"
+    CVFFI::cvPutText( img, a, point, font, color )
+
+    CVFFI::cvSaveImage( TestSetup::output_filename("fontTest.tif"), img )
+
+
+    size = CVFFI::CvSize.new :height => 0, :width => 0
+    objptr = FFI::MemoryPointer.new :int
+    CVFFI::cvGetTextSize( a, font, size, objptr )
+    baseline = objptr.read_int
+
+    ## These are pre-calculated values
+    assert_equal 12, baseline
+    assert_equal 191, size.width
+    assert_equal 21, size.height
+  end
+
+
+
+end

data/test/ext/test_eigen.rb

@@ -0,0 +1,105 @@
+
+require 'test/setup'
+require 'opencv-ffi/core'
+require 'opencv-ffi-ext/eigen'
+require 'matrix'
+
+class TestEigen < Test::Unit::TestCase
+
+  def setup
+    @a = CVFFI::cvCreateMat( 3,3, :CV_32F )
+    3.times {|i| 3.times {|j|
+      @a.set_f( i,j,3*i+j+1)
+    }}
+    @epsilon = 1e-3
+  end
+
+  def random_matrix( x, y )
+    a = CVFFI::CvMat.new CVFFI::cvCreateMat( x, y, :CV_32F )
+    x.times { |i|
+      y.times { |j|
+        CVFFI::cvSetReal2D( a, i, j, rand )
+      }
+    }
+    a
+  end
+
+  def test_svd
+    # Test matrix [ 1,2,3
+    #               4,5,6
+    #               7,8,9 ]
+    a = @a
+    u,d,v = CVFFI::Eigen::svd( a )
+
+    CVFFI::print_matrix a, {:caption => "a"}
+    CVFFI::print_matrix u, {:caption => "w"}
+    CVFFI::print_matrix d, {:caption => "u"}
+    CVFFI::print_matrix v, {:caption => "v"}
+
+
+    ## Test results from alpha
+    uans = Matrix.rows( [ [0.214837 , 0.887231 , 0.408248 ],
+                       [0.520587 , 0.249644 , -0.816497 ],
+                       [0.826338 , -0.387943 , 0.408248 ] ] )
+    dans = [16.8481 , 1.06837 , 0.0 ]
+    vans = Matrix.rows( [ [0.479671 , -0.776691 , 0.408248 ],
+                       [0.572368 , -0.0756865 , -0.816497],
+                       [0.665064 , 0.625318 , 0.408248] ] )
+
+    # Check the SVDs
+    dans.each_with_index { |dans,i| assert_in_delta d.at_f(i,0), dans, @epsilon }
+
+    3.times{ |j| 
+      # Check the original matrix
+      3.times { |i|
+        assert_equal a.at_f( i,j ), 3*i+j+1 
+      }
+      2.times { |i|
+        # Because there's scalar ambiguity in the third column
+        # check ratios instead
+        assert_in_delta u.at_f(i,j)/u.at_f(i+1,j), uans[i,j]/uans[i+1,j], @epsilon
+        assert_in_delta v.at_f(i,j)/v.at_f(i+1,j), vans[i,j]/vans[i+1,j], @epsilon
+      }
+    }
+  end
+
+  def test_eigen
+    a = @a
+    d,v = CVFFI::Eigen::eigen(a)
+
+    CVFFI::print_matrix d, {:caption=>"d"}
+    CVFFI::print_matrix v, {:caption=>"v"}
+
+    # From Wolfram alpha
+    dans = [ 16.1168, -1.11684, 0 ]
+    vans = [[0.283349, 0.641675, 1.0], [-1.28335, -0.141675, 1.0], [1.0, -2.0, 1.0 ] ]
+
+    3.times { |i|
+      assert_in_delta d.at_f(i,0), dans[i], @epsilon
+
+      # Ratio test on elements of eigenvectors
+      assert_in_delta v.at_f(0,i)/v.at_f(1,i), vans[i][0]/vans[i][1], @epsilon
+      assert_in_delta v.at_f(0,i)/v.at_f(2,i), vans[i][0]/vans[i][2], @epsilon
+    }
+
+
+
+  end
+
+  def test_poly
+
+    # Should be coefficients for (t-1)(t-2)...(t-6) in ascending
+    # coefficient order...
+    coeffs = [ 720.0, -1764.0, 1624.0, -735.0, 175.0, -21.0, 1.0 ]
+    # Eigen expects polynomial in ascending order
+    roots = CVFFI::Eigen::polySolver( coeffs )
+    roots.sort!
+
+
+    6.times { |i|
+      assert_in_delta roots[i], (i+1).to_f,  @epsilon
+    }
+
+  end
+
+end

data/test/ext/test_opensurf.rb

@@ -0,0 +1,35 @@
+
+
+require 'test/setup'
+
+require 'opencv-ffi'
+require 'opencv-ffi-ext/opensurf'
+
+class TestOpenSURF < Test::Unit::TestCase
+
+  def setup
+  end
+
+
+  def test_openSurfDetect
+    img = TestSetup::test_image
+
+    params = CVFFI::OpenSURF::Params.new
+
+    # This should test the auto=conversion to greyscale
+    surf = CVFFI::OpenSURF::detect( img, params )
+
+    assert_not_nil surf
+
+    surf.mark_on_image( img, {:radius=>5, :thickness=>-1} )
+    CVFFI::cvSaveImage( TestSetup::output_filename("openSurfPts.jpg"), img )
+
+    puts "OpenSURF detected #{surf.length} points"
+
+
+    descriptors = CVFFI::OpenSURF::describe( img, surf, params )
+
+    puts "After description #{descriptors.length} points"
+ end
+
+end

data/test/ext/test_sift.rb

@@ -0,0 +1,26 @@
+
+require 'test/setup'
+
+require 'opencv-ffi'
+require 'opencv-ffi-ext/sift'
+
+class TestSIFT < Test::Unit::TestCase
+
+  def setup
+  end
+
+
+  def test_siftDetect
+    img = TestSetup::small_test_image
+
+    params = CVFFI::SIFT::Params.new( octaves: 1 )
+
+    # This should test the auto=conversion to greyscale
+    sift = CVFFI::SIFT::detect( img, params )
+
+    assert_not_nil sift
+
+    puts "SIFT detected #{sift.length} points."
+ end
+
+end