afeld-opencv 0.0.8

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
+
+

data/test/test_cvrect.rb

@@ -0,0 +1,144 @@
+#!/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::CvRect
+class TestCvRect < OpenCVTestCase
+  class MyRect; end
+
+  def test_x
+    rect = CvRect.new
+    rect.x = 100
+    assert_equal(100, rect.x)
+    rect.x = 200
+    assert_equal(200, rect.x)
+  end
+
+  def test_y
+    rect = CvRect.new
+    rect.y = 100
+    assert_equal(100, rect.y)
+    rect.y = 200
+    assert_equal(200, rect.y)
+  end
+
+  def test_width
+    rect = CvRect.new
+    rect.width = 100
+    assert_equal(100, rect.width)
+    rect.width = 200
+    assert_equal(200, rect.width)
+  end
+
+  def test_height
+    rect = CvRect.new
+    rect.height = 100
+    assert_equal(100, rect.height)
+    rect.height = 200
+    assert_equal(200, rect.height)
+  end
+
+  def test_compatible
+    assert(!(CvRect.compatible? MyRect.new))
+    MyRect.class_eval { def x; end }
+    assert(!(CvRect.compatible? MyRect.new))
+    MyRect.class_eval { def y; end }
+    assert(!(CvRect.compatible? MyRect.new))
+    MyRect.class_eval { def width; end }
+    assert(!(CvRect.compatible? MyRect.new))
+    MyRect.class_eval { def height; end }
+    assert(CvRect.compatible? MyRect.new)
+    assert(CvRect.compatible? CvRect.new)
+  end
+
+  def test_initialize
+    rect = CvRect.new
+    assert_equal(0, rect.x)
+    assert_equal(0, rect.y)
+    assert_equal(0, rect.width)
+    assert_equal(0, rect.height)
+
+    rect = CvRect.new(10, 20, 30, 40)
+    assert_equal(10, rect.x)
+    assert_equal(20, rect.y)
+    assert_equal(30, rect.width)
+    assert_equal(40, rect.height)
+
+    rect = CvRect.new(CvRect.new(10, 20, 30, 40))
+    assert_equal(10, rect.x)
+    assert_equal(20, rect.y)
+    assert_equal(30, rect.width)
+    assert_equal(40, rect.height)
+
+    assert_raise(TypeError) {
+      CvRect.new(DUMMY_OBJ)
+    }
+    assert_raise(ArgumentError) {
+      CvRect.new(1, 2)
+    }
+    assert_raise(ArgumentError) {
+      CvRect.new(1, 2, 3)
+    }
+    assert_raise(ArgumentError) {
+      CvRect.new(1, 2, 3, 4, 5)
+    }
+  end
+
+  def test_center
+    center = CvRect.new(10, 20, 35, 45).center
+    assert_in_delta(27.5, center.x, 0.01)
+    assert_in_delta(42.5, center.y, 0.01)
+  end
+
+  def test_points
+    points = CvRect.new(10, 20, 35, 45).points
+    assert_equal(4, points.size)
+    assert_in_delta(10, points[0].x, 0.01)
+    assert_in_delta(20, points[0].y, 0.01)
+    assert_in_delta(10, points[1].x, 0.01)
+    assert_in_delta(65, points[1].y, 0.01)
+    assert_in_delta(45, points[2].x, 0.01)
+    assert_in_delta(65, points[2].y, 0.01)
+    assert_in_delta(45, points[3].x, 0.01)
+    assert_in_delta(20, points[3].y, 0.01)
+  end
+
+  def test_top_left
+    tl = CvRect.new(10, 20, 35, 45).top_left
+    assert_equal(10, tl.x)
+    assert_equal(20, tl.y)
+  end
+
+  def test_top_right
+    tr = CvRect.new(10, 20, 35, 45).top_right
+    assert_equal(45, tr.x)
+    assert_equal(20, tr.y)
+  end
+
+  def test_bottom_left
+    bl = CvRect.new(10, 20, 35, 45).bottom_left
+    assert_equal(10, bl.x)
+    assert_equal(65, bl.y)
+  end
+
+  def test_bottom_right
+    br = CvRect.new(10, 20, 35, 45).bottom_right
+    assert_equal(45, br.x)
+    assert_equal(65, br.y)
+  end
+
+  def test_max_rect
+    rect1 = CvRect.new(10, 20, 30, 40)
+    rect2 = CvRect.new(30, 40, 70, 80)
+    rect3 = CvRect.max_rect(rect1, rect2)
+    assert_equal(10, rect3.x)
+    assert_equal(20, rect3.y)
+    assert_equal(90, rect3.width)
+    assert_equal(100, rect3.height)
+  end
+end
+