ruby-opencv 0.0.8.pre-x86-mingw32

data/test/test_cvmat_matching.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8-unix -*- 
+require 'test/unit'
+require 'opencv'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
+
+include OpenCV
+
+# Tests for matching functions of OpenCV::CvMat
+class TestCvMat_matching < OpenCVTestCase
+  def setup
+    @query = read_test_image('query.png')
+    @images = ['1.png', '2.png', '3.png'].map{|f| read_test_image('train', f)}
+  end
+
+  def data_dir
+    File.join(File.dirname(__FILE__), '..', 'examples', 'matching_to_many_images')
+  end
+
+  def read_test_image(*path)
+    IplImage.load File.join(data_dir, *path), CV_LOAD_IMAGE_GRAYSCALE
+  end
+
+  def test_match_descriptors
+    matchs = @query.match_descriptors(@images)
+    match_index, count = matchs.max_by {|image_index, count| count}
+    assert_equal 2, match_index
+  end
+
+  def test_match_descriptors_with_empty_image_array
+    assert_equal({}, @query.match_descriptors([]))
+  end
+
+  def test_match_descriptors_with_wrong_detector_type_argument
+    assert_raise ArgumentError do
+      @query.match_descriptors(@images, "Wrong")
+    end
+  end
+
+  def test_match_descriptors_with_wrong_descriptor_type_argument
+    assert_raise ArgumentError do
+      @query.match_descriptors(@images, "SURF", "wrong")
+    end
+  end
+
+  def test_match_descriptors_with_wrong_matcher_type_argument
+    assert_raise ArgumentError do
+      @query.match_descriptors(@images, "SURF", "SURF", "wrong")
+    end
+  end
+
+  def test_match_descriptors_with_invalid_image_array
+    assert_raise TypeError do
+      @query.match_descriptors([DUMMY_OBJ, DUMMY_OBJ])
+    end
+  end
+end

data/test/test_cvmoments.rb

@@ -0,0 +1,180 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8-unix -*- 
+require 'test/unit'
+require 'opencv'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
+
+include OpenCV
+
+# Tests for OpenCV::CvMoment
+class TestCvMoments < OpenCVTestCase
+  def setup
+    @mat = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      if j >= 32 and j < 96 and i >= 16 and i < 112
+        CvScalar.new(0)
+      elsif j >= 16 and j < 112 and i >= 16 and i < 112
+        CvScalar.new(128)
+      else
+        CvScalar.new(255)
+      end
+    }
+    @moment1 = CvMoments.new
+    @moment2 = CvMoments.new(nil, true)
+    @moment3 = CvMoments.new(@mat)
+    @moment4 = CvMoments.new(@mat, true)
+  end
+  
+  def test_initialize
+    [@moment1, @moment2, @moment3, @moment4].each { |m|
+      assert_not_nil(m)
+      assert_equal(CvMoments, m.class)
+    }
+
+    assert_raise(TypeError) {
+      CvMoments.new('foo')
+    }
+  end
+
+  def test_spatial
+    assert_in_delta(0, @moment1.spatial(0, 0), 0.1)
+    assert_in_delta(0, @moment2.spatial(0, 0), 0.1)
+    assert_in_delta(2221056, @moment3.spatial(0, 0), 0.1)
+    assert_in_delta(10240, @moment4.spatial(0, 0), 0.1)
+  end
+
+  def test_central
+    assert_in_delta(0, @moment1.central(0, 0), 0.1)
+    assert_in_delta(0, @moment2.central(0, 0), 0.1)
+    assert_in_delta(2221056, @moment3.central(0, 0), 0.1)
+    assert_in_delta(10240, @moment4.central(0, 0), 0.1)
+  end
+
+  def test_normalized_central
+    assert_in_delta(0, @moment1.normalized_central(0, 0), 0.1)
+    assert_in_delta(0, @moment2.normalized_central(0, 0), 0.1)
+    assert_in_delta(1, @moment3.normalized_central(0, 0), 0.1)
+    assert_in_delta(1, @moment4.normalized_central(0, 0), 0.1)
+  end
+
+  def test_hu
+    hu_moments = @moment1.hu
+    assert_equal(CvHuMoments, hu_moments.class)
+    hu_moments.to_a.each { |hu|
+      assert_in_delta(0.0, hu, 0.000001)
+    }
+
+    hu_moments = @moment2.hu
+    assert_equal(CvHuMoments, hu_moments.class)
+    hu_moments.to_a.each { |hu|
+      assert_in_delta(0.0, hu, 0.000001)
+    }
+    
+    hu_moments = @moment3.hu
+    assert_equal(CvHuMoments, hu_moments.class)
+    assert_in_delta(0.001771, hu_moments.hu1, 0.000001)
+    hu_moments.to_a[1..7].each { |hu|
+      assert_in_delta(0.0, hu, 0.000001)
+    }
+
+    hu_moments = @moment4.hu
+    assert_equal(CvHuMoments, hu_moments.class)
+    assert_in_delta(0.361650, hu_moments.hu1, 0.000001)
+    assert_in_delta(0.000625, hu_moments.hu2, 0.000001)
+    hu_moments.to_a[2..7].each { |hu|
+      assert_in_delta(0.0, hu, 0.000001)
+    }
+  end
+
+  def test_gravity_center
+    center = @moment1.gravity_center
+    assert_equal(CvPoint2D32f, center.class)
+    assert(center.x.nan?)
+    assert(center.y.nan?)
+
+    center = @moment2.gravity_center
+    assert_equal(CvPoint2D32f, center.class)
+    assert(center.x.nan?)
+    assert(center.y.nan?)
+
+    center = @moment3.gravity_center
+    assert_equal(CvPoint2D32f, center.class)
+    assert_in_delta(63.5, center.x, 0.001)
+    assert_in_delta(63.5, center.y, 0.001)
+
+    center = @moment4.gravity_center
+    assert_equal(CvPoint2D32f, center.class)
+    assert_in_delta(63.5, center.x, 0.001)
+    assert_in_delta(63.5, center.y, 0.001)
+  end
+
+  def test_angle
+    [@moment1, @moment2].each { |m|
+      assert_nil(m.angle)
+    }
+    [@moment3, @moment4].each { |m|
+      assert_in_delta(0, m.angle, 0.001)
+    }
+  end
+
+  def test_mXX
+    [@moment1, @moment2].each { |m|
+      assert_in_delta(0, m.m00, 0.001)
+      assert_in_delta(0, m.m10, 0.001)
+      assert_in_delta(0, m.m01, 0.001)
+      assert_in_delta(0, m.m20, 0.001)
+      assert_in_delta(0, m.m11, 0.001)
+      assert_in_delta(0, m.m02, 0.001)
+      assert_in_delta(0, m.m30, 0.001)
+      assert_in_delta(0, m.m21, 0.001)
+      assert_in_delta(0, m.m12, 0.001)
+      assert_in_delta(0, m.m03, 0.001)
+      assert_in_delta(0, m.mu20, 0.001)
+      assert_in_delta(0, m.mu11, 0.001)
+      assert_in_delta(0, m.mu02, 0.001)
+      assert_in_delta(0, m.mu30, 0.001)
+      assert_in_delta(0, m.mu21, 0.001)
+      assert_in_delta(0, m.mu12, 0.001)
+      assert_in_delta(0, m.mu03, 0.001)
+      assert_in_delta(0, m.inv_sqrt_m00, 0.001)
+    }
+
+    assert_in_delta(2221056, @moment3.m00, 0.001)
+    assert_in_delta(141037056, @moment3.m10, 0.001)
+    assert_in_delta(141037056, @moment3.m01, 0.001)
+    assert_in_delta(13157049856, @moment3.m20, 0.001)
+    assert_in_delta(8955853056, @moment3.m11, 0.001)
+    assert_in_delta(13492594176, @moment3.m02, 0.001)
+    assert_in_delta(1369024659456, @moment3.m30, 0.001)
+    assert_in_delta(835472665856, @moment3.m21, 0.001)
+    assert_in_delta(856779730176, @moment3.m12, 0.001)
+    assert_in_delta(1432945852416, @moment3.m03, 0.001)
+    assert_in_delta(4201196800, @moment3.mu20, 0.001)
+    assert_in_delta(0, @moment3.mu11, 0.001)
+    assert_in_delta(4536741120, @moment3.mu02, 0.001)
+    assert_in_delta(0, @moment3.mu30, 0.001)
+    assert_in_delta(0, @moment3.mu21, 0.001)
+    assert_in_delta(0, @moment3.mu12, 0.001)
+    assert_in_delta(0, @moment3.mu03, 0.001)
+    assert_in_delta(0.000671, @moment3.inv_sqrt_m00, 0.000001)
+
+    assert_in_delta(10240, @moment4.m00, 0.001)
+    assert_in_delta(650240, @moment4.m10, 0.001)
+    assert_in_delta(650240, @moment4.m01, 0.001)
+    assert_in_delta(58940416, @moment4.m20, 0.001)
+    assert_in_delta(41290240, @moment4.m11, 0.001)
+    assert_in_delta(61561856, @moment4.m02, 0.001)
+    assert_in_delta(5984288768, @moment4.m30, 0.001)
+    assert_in_delta(3742716416, @moment4.m21, 0.001)
+    assert_in_delta(3909177856, @moment4.m12, 0.001)
+    assert_in_delta(6483673088, @moment4.m03, 0.001)
+    assert_in_delta(17650176, @moment4.mu20, 0.001)
+    assert_in_delta(0, @moment4.mu11, 0.001)
+    assert_in_delta(20271616, @moment4.mu02, 0.001)
+    assert_in_delta(0, @moment4.mu30, 0.001)
+    assert_in_delta(0, @moment4.mu21, 0.001)
+    assert_in_delta(0, @moment4.mu12, 0.001)
+    assert_in_delta(0, @moment4.mu03, 0.001)
+    assert_in_delta(0.009882, @moment4.inv_sqrt_m00, 0.000001)
+  end
+end
+

data/test/test_cvpoint.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8-unix -*- 
+require 'test/unit'
+require 'opencv'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
+
+include OpenCV
+
+# Tests for OpenCV::CvPoint
+class TestCvPoint < OpenCVTestCase
+  class MyPoint; end
+  def test_x
+    point = CvPoint.new
+    point.x = 100
+    assert_equal(100, point.x)
+    point.x = 200
+    assert_equal(200, point.x)
+  end
+
+  def test_y
+    point = CvPoint.new
+    point.y = 100
+    assert_equal(100, point.y)
+    point.y = 200
+    assert_equal(200, point.y)
+  end
+  
+  def test_compatible
+    assert(!(CvPoint.compatible? MyPoint.new))
+    MyPoint.class_eval { def x; end }
+    assert(!(CvPoint.compatible? MyPoint.new))
+    MyPoint.class_eval { def y; end }
+    assert(CvPoint.compatible? MyPoint.new)
+    assert(CvPoint.compatible? CvPoint.new)
+  end
+
+  def test_initialize
+    point = CvPoint.new
+    assert_equal(0, point.x)
+    assert_equal(0, point.y)
+
+    point = CvPoint.new(10, 20)
+    assert_equal(10, point.x)
+    assert_equal(20, point.y)
+
+    point = CvPoint.new(CvPoint.new(10, 20))
+    assert_equal(10, point.x)
+    assert_equal(20, point.y)
+
+    assert_raise(TypeError) {
+      CvPoint.new(DUMMY_OBJ)
+    }
+    assert_raise(ArgumentError) {
+      CvPoint.new(1, 2, 3)
+    }
+  end
+
+  def test_to_s
+    point = CvPoint.new(10, 20)
+    assert_equal('<OpenCV::CvPoint:(10,20)>', point.to_s)
+  end
+
+  def test_to_ary
+    a = CvPoint.new(10, 20).to_ary
+    assert_equal(10, a[0])
+    assert_equal(20, a[1])
+
+    # Alias
+    a = CvPoint.new(10, 20).to_a
+    assert_equal(10, a[0])
+    assert_equal(20, a[1])
+  end
+end
+
+

data/test/test_cvpoint2d32f.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8-unix -*- 
+require 'test/unit'
+require 'opencv'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
+
+include OpenCV
+
+# Tests for OpenCV::CvPoint2D32f
+class TestCvPoint2D32f < OpenCVTestCase
+  class MyPoint; end
+  def test_x
+    point = CvPoint2D32f.new
+    point.x = 1.1
+    assert_in_delta(1.1, point.x, 0.001)
+    point.x = 2.2
+    assert_in_delta(2.2, point.x, 0.001)
+  end
+
+  def test_y
+    point = CvPoint2D32f.new
+    point.y = 1.1
+    assert_in_delta(1.1, point.y, 0.001)
+    point.y = 2.2
+    assert_in_delta(2.2, point.y, 0.001)
+  end
+  
+  def test_compatible
+    assert(!(CvPoint2D32f.compatible? MyPoint.new))
+    MyPoint.class_eval { def x; end }
+    assert(!(CvPoint2D32f.compatible? MyPoint.new))
+    MyPoint.class_eval { def y; end }
+    assert(CvPoint2D32f.compatible? MyPoint.new)
+    assert(CvPoint2D32f.compatible? CvPoint2D32f.new)
+  end
+
+  def test_initialize
+    point = CvPoint2D32f.new
+    assert_in_delta(0, point.x, 0.001)
+    assert_in_delta(0, point.y, 0.001)
+
+    point = CvPoint2D32f.new(1.1, 2.2)
+    assert_in_delta(1.1, point.x, 0.001)
+    assert_in_delta(2.2, point.y, 0.001)
+
+    point = CvPoint2D32f.new(CvPoint2D32f.new(1.1, 2.2))
+    assert_in_delta(1.1, point.x, 0.001)
+    assert_in_delta(2.2, point.y, 0.001)
+
+    assert_raise(TypeError) {
+      CvPoint2D32f.new(DUMMY_OBJ)
+    }
+    assert_raise(ArgumentError) {
+      CvPoint2D32f.new(1, 2, 3)
+    }
+  end
+
+  def test_to_s
+    point = CvPoint2D32f.new(1.1, 2.2)
+    assert_equal('<OpenCV::CvPoint2D32f:(1.1,2.2)>', point.to_s)
+  end
+
+  def test_to_ary
+    a = CvPoint2D32f.new(1.1, 2.2).to_ary
+    assert_in_delta(1.1, a[0], 0.001)
+    assert_in_delta(2.2, a[1], 0.001)
+
+    # Alias
+    a = CvPoint2D32f.new(1.1, 2.2).to_a
+    assert_in_delta(1.1, a[0], 0.001)
+    assert_in_delta(2.2, a[1], 0.001)
+  end
+end
+
+

data/test/test_cvpoint3d32f.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8-unix -*- 
+require 'test/unit'
+require 'opencv'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
+
+include OpenCV
+
+# Tests for OpenCV::CvPoint3D32f
+class TestCvPoint3D32f < OpenCVTestCase
+  class MyPoint; end
+  def test_x
+    point = CvPoint3D32f.new
+    point.x = 1.1
+    assert_in_delta(1.1, point.x, 0.001)
+    point.x = 2.2
+    assert_in_delta(2.2, point.x, 0.001)
+  end
+
+  def test_y
+    point = CvPoint3D32f.new
+    point.y = 1.1
+    assert_in_delta(1.1, point.y, 0.001)
+    point.y = 2.2
+    assert_in_delta(2.2, point.y, 0.001)
+  end
+
+  def test_z
+    point = CvPoint3D32f.new
+    point.z = 1.1
+    assert_in_delta(1.1, point.z, 0.001)
+    point.z = 2.2
+    assert_in_delta(2.2, point.z, 0.001)
+  end
+  
+  def test_compatible
+    assert(!(CvPoint3D32f.compatible? MyPoint.new))
+    MyPoint.class_eval { def x; end }
+    assert(!(CvPoint3D32f.compatible? MyPoint.new))
+    MyPoint.class_eval { def y; end }
+    assert(!(CvPoint3D32f.compatible? MyPoint.new))
+    MyPoint.class_eval { def z; end }
+    assert(CvPoint3D32f.compatible? MyPoint.new)
+    assert(CvPoint3D32f.compatible? CvPoint3D32f.new)
+  end
+
+  def test_initialize
+    point = CvPoint3D32f.new
+    assert_in_delta(0, point.x, 0.001)
+    assert_in_delta(0, point.y, 0.001)
+    assert_in_delta(0, point.z, 0.001)
+
+    point = CvPoint3D32f.new(1.1, 2.2, 3.3)
+    assert_in_delta(1.1, point.x, 0.001)
+    assert_in_delta(2.2, point.y, 0.001)
+    assert_in_delta(3.3, point.z, 0.001)
+
+    point = CvPoint3D32f.new(CvPoint3D32f.new(1.1, 2.2, 3.3))
+    assert_in_delta(1.1, point.x, 0.001)
+    assert_in_delta(2.2, point.y, 0.001)
+    assert_in_delta(3.3, point.z, 0.001)
+
+    assert_raise(TypeError) {
+      CvPoint3D32f.new(DUMMY_OBJ)
+    }
+    assert_raise(ArgumentError) {
+      CvPoint3D32f.new(1, 2)
+    }
+    assert_raise(ArgumentError) {
+      CvPoint3D32f.new(1, 2, 3, 4)
+    }
+  end
+
+  def test_to_s
+    point = CvPoint3D32f.new(1.1, 2.2, 3.3)
+    assert_equal('<OpenCV::CvPoint3D32f:(1.1,2.2,3.3)>', point.to_s)
+  end
+
+  def test_to_ary
+    a = CvPoint3D32f.new(1.1, 2.2, 3.3).to_ary
+    assert_in_delta(1.1, a[0], 0.001)
+    assert_in_delta(2.2, a[1], 0.001)
+    assert_in_delta(3.3, a[2], 0.001)
+
+    # Alias
+    a = CvPoint3D32f.new(1.1, 2.2, 3.3).to_a
+    assert_in_delta(1.1, a[0], 0.001)
+    assert_in_delta(2.2, a[1], 0.001)
+    assert_in_delta(3.3, a[2], 0.001)
+  end
+end
+
+