ruby-opencv 0.0.8-x86-mingw32 → 0.0.9.pre2-x86-mingw32

data/test/test_cvrect.rb

@@ -1,144 +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
-
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+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
+

data/test/test_cvscalar.rb

@@ -1,113 +1,113 @@
-#!/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::CvScalar
-class TestCvScalar < OpenCVTestCase
-  def test_initialize
-    s = CvScalar.new
-    assert_in_delta([0, 0, 0, 0], s, 0.01)
-
-    s = CvScalar.new(1.1)
-    assert_in_delta([1.1, 0, 0, 0], s, 0.01)
-
-    s = CvScalar.new(1.1, 2.2)
-    assert_in_delta([1.1, 2.2, 0, 0], s, 0.01)
-
-    s = CvScalar.new(1.1, 2.2, 3.3)
-    assert_in_delta([1.1, 2.2, 3.3, 0], s, 0.01)
-
-    s = CvScalar.new(1.1, 2.2, 3.3, 4.4)
-    assert_in_delta([1.1, 2.2, 3.3, 4.4], s, 0.01)
-  end
-  
-  def test_aref
-    assert_in_delta([0, 0, 0, 0], CvScalar.new, 0.01)
-    assert_in_delta([10, 20, 30, 40], CvScalar.new(10, 20, 30, 40), 0.01)
-    assert_in_delta([0.1, 0.2, 0.3, 0.4], CvScalar.new(0.1, 0.2, 0.3, 0.4), 0.01)
-  end
-
-  def test_aset
-    s = CvScalar.new
-    [10, 20, 30, 40].each_with_index { |x, i|
-      s[i] = x
-    }
-    assert_in_delta([10, 20, 30, 40], s, 0.01)
-
-    s = CvScalar.new
-    [0.1, 0.2, 0.3, 0.4].each_with_index { |x, i|
-      s[i] = x
-    }
-    assert_in_delta([0.1, 0.2, 0.3, 0.4], s, 0.01)
-  end
-
-  def test_sub
-    s1 = CvScalar.new(10, 20, 30, 40)
-    s2 = CvScalar.new(2, 4, 6, 8)
-    [s1.sub(s2), s1 - s2].each { |s|
-      assert_in_delta([8, 16, 24, 32], s, 0.01)
-    }
-
-    s3 = CvScalar.new(0.2, 0.4, 0.6, 0.8)
-    [s2.sub(s3), s2 - s3].each { |s|
-      assert_in_delta([1.8, 3.6, 5.4, 7.2], s, 0.01)
-    }
-
-    mat = CvMat.new(5, 5)
-    mask = CvMat.new(5, 5, :cv8u, 1)
-    mat.height.times { |j|
-      mat.width.times { |i|
-        mat[i, j] = CvScalar.new(1.5)
-        mask[i, j] = (i < 2 and j < 3) ? 1 : 0
-      }
-    }
-    mat = CvScalar.new(0.1).sub(mat, mask)
-
-    [CvMat.new(5, 5, :cv16u, 1), CvMat.new(5, 5, :cv8u, 3)].each { |msk|
-      assert_raise(TypeError) {
-        CvScalar.new.sub(mat, msk)
-      }
-    }
-  end
-
-  def test_to_s
-    assert_equal("<OpenCV::CvScalar:10,20,30,40>", CvScalar.new(10, 20, 30, 40).to_s)
-    assert_equal("<OpenCV::CvScalar:0.1,0.2,0.3,0.4>", CvScalar.new(0.1, 0.2, 0.3, 0.4).to_s)
-  end
-
-  def test_to_ary
-    [[10, 20, 30, 40], [0.1, 0.2, 0.3, 0.4]].each { |a|
-      s = CvScalar.new(*a)
-      b = s.to_ary
-      c = s.to_a # Alias
-      [b, c].each { |x|
-        assert_equal(Array, x.class)
-        assert_in_delta(a, x, 0.01)
-      }
-    }
-  end
-
-  def test_cvcolor
-    assert_cvscalar_equal(CvColor::Black, CvScalar.new(0x0, 0x0, 0x0, 0))
-    assert_cvscalar_equal(CvColor::Silver, CvScalar.new(0x0c, 0x0c, 0x0c, 0))
-    assert_cvscalar_equal(CvColor::Gray, CvScalar.new(0x80, 0x80, 0x80, 0))
-    assert_cvscalar_equal(CvColor::White, CvScalar.new(0xff, 0xff, 0xff, 0))
-    assert_cvscalar_equal(CvColor::Maroon, CvScalar.new(0x0, 0x0, 0x80, 0))
-    assert_cvscalar_equal(CvColor::Red, CvScalar.new(0x0, 0x0, 0xff, 0))
-    assert_cvscalar_equal(CvColor::Purple, CvScalar.new(0x80, 0x0, 0x80, 0))
-    assert_cvscalar_equal(CvColor::Fuchsia, CvScalar.new(0xff, 0x0, 0xff, 0))
-    assert_cvscalar_equal(CvColor::Green, CvScalar.new(0x0, 0x80, 0x0, 0))
-    assert_cvscalar_equal(CvColor::Lime, CvScalar.new(0x0, 0xff, 0x0, 0))
-    assert_cvscalar_equal(CvColor::Olive, CvScalar.new(0x0, 0x80, 0x80, 0))
-    assert_cvscalar_equal(CvColor::Yellow, CvScalar.new(0x0, 0xff, 0xff, 0))
-    assert_cvscalar_equal(CvColor::Navy, CvScalar.new(0x80, 0x0, 0x0, 0))
-    assert_cvscalar_equal(CvColor::Blue, CvScalar.new(0xff, 0x0, 0x0, 0))
-    assert_cvscalar_equal(CvColor::Teal, CvScalar.new(0x80, 0x80, 0x0, 0))
-    assert_cvscalar_equal(CvColor::Aqua, CvScalar.new(0xff, 0xff, 0x0, 0))
-  end
-end
-
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+require 'test/unit'
+require 'opencv'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
+
+include OpenCV
+
+# Tests for OpenCV::CvScalar
+class TestCvScalar < OpenCVTestCase
+  def test_initialize
+    s = CvScalar.new
+    assert_in_delta([0, 0, 0, 0], s, 0.01)
+
+    s = CvScalar.new(1.1)
+    assert_in_delta([1.1, 0, 0, 0], s, 0.01)
+
+    s = CvScalar.new(1.1, 2.2)
+    assert_in_delta([1.1, 2.2, 0, 0], s, 0.01)
+
+    s = CvScalar.new(1.1, 2.2, 3.3)
+    assert_in_delta([1.1, 2.2, 3.3, 0], s, 0.01)
+
+    s = CvScalar.new(1.1, 2.2, 3.3, 4.4)
+    assert_in_delta([1.1, 2.2, 3.3, 4.4], s, 0.01)
+  end
+  
+  def test_aref
+    assert_in_delta([0, 0, 0, 0], CvScalar.new, 0.01)
+    assert_in_delta([10, 20, 30, 40], CvScalar.new(10, 20, 30, 40), 0.01)
+    assert_in_delta([0.1, 0.2, 0.3, 0.4], CvScalar.new(0.1, 0.2, 0.3, 0.4), 0.01)
+  end
+
+  def test_aset
+    s = CvScalar.new
+    [10, 20, 30, 40].each_with_index { |x, i|
+      s[i] = x
+    }
+    assert_in_delta([10, 20, 30, 40], s, 0.01)
+
+    s = CvScalar.new
+    [0.1, 0.2, 0.3, 0.4].each_with_index { |x, i|
+      s[i] = x
+    }
+    assert_in_delta([0.1, 0.2, 0.3, 0.4], s, 0.01)
+  end
+
+  def test_sub
+    s1 = CvScalar.new(10, 20, 30, 40)
+    s2 = CvScalar.new(2, 4, 6, 8)
+    [s1.sub(s2), s1 - s2].each { |s|
+      assert_in_delta([8, 16, 24, 32], s, 0.01)
+    }
+
+    s3 = CvScalar.new(0.2, 0.4, 0.6, 0.8)
+    [s2.sub(s3), s2 - s3].each { |s|
+      assert_in_delta([1.8, 3.6, 5.4, 7.2], s, 0.01)
+    }
+
+    mat = CvMat.new(5, 5)
+    mask = CvMat.new(5, 5, :cv8u, 1)
+    mat.height.times { |j|
+      mat.width.times { |i|
+        mat[i, j] = CvScalar.new(1.5)
+        mask[i, j] = (i < 2 and j < 3) ? 1 : 0
+      }
+    }
+    mat = CvScalar.new(0.1).sub(mat, mask)
+
+    [CvMat.new(5, 5, :cv16u, 1), CvMat.new(5, 5, :cv8u, 3)].each { |msk|
+      assert_raise(TypeError) {
+        CvScalar.new.sub(mat, msk)
+      }
+    }
+  end
+
+  def test_to_s
+    assert_equal("<OpenCV::CvScalar:10,20,30,40>", CvScalar.new(10, 20, 30, 40).to_s)
+    assert_equal("<OpenCV::CvScalar:0.1,0.2,0.3,0.4>", CvScalar.new(0.1, 0.2, 0.3, 0.4).to_s)
+  end
+
+  def test_to_ary
+    [[10, 20, 30, 40], [0.1, 0.2, 0.3, 0.4]].each { |a|
+      s = CvScalar.new(*a)
+      b = s.to_ary
+      c = s.to_a # Alias
+      [b, c].each { |x|
+        assert_equal(Array, x.class)
+        assert_in_delta(a, x, 0.01)
+      }
+    }
+  end
+
+  def test_cvcolor
+    assert_cvscalar_equal(CvColor::Black, CvScalar.new(0x0, 0x0, 0x0, 0))
+    assert_cvscalar_equal(CvColor::Silver, CvScalar.new(0x0c, 0x0c, 0x0c, 0))
+    assert_cvscalar_equal(CvColor::Gray, CvScalar.new(0x80, 0x80, 0x80, 0))
+    assert_cvscalar_equal(CvColor::White, CvScalar.new(0xff, 0xff, 0xff, 0))
+    assert_cvscalar_equal(CvColor::Maroon, CvScalar.new(0x0, 0x0, 0x80, 0))
+    assert_cvscalar_equal(CvColor::Red, CvScalar.new(0x0, 0x0, 0xff, 0))
+    assert_cvscalar_equal(CvColor::Purple, CvScalar.new(0x80, 0x0, 0x80, 0))
+    assert_cvscalar_equal(CvColor::Fuchsia, CvScalar.new(0xff, 0x0, 0xff, 0))
+    assert_cvscalar_equal(CvColor::Green, CvScalar.new(0x0, 0x80, 0x0, 0))
+    assert_cvscalar_equal(CvColor::Lime, CvScalar.new(0x0, 0xff, 0x0, 0))
+    assert_cvscalar_equal(CvColor::Olive, CvScalar.new(0x0, 0x80, 0x80, 0))
+    assert_cvscalar_equal(CvColor::Yellow, CvScalar.new(0x0, 0xff, 0xff, 0))
+    assert_cvscalar_equal(CvColor::Navy, CvScalar.new(0x80, 0x0, 0x0, 0))
+    assert_cvscalar_equal(CvColor::Blue, CvScalar.new(0xff, 0x0, 0x0, 0))
+    assert_cvscalar_equal(CvColor::Teal, CvScalar.new(0x80, 0x80, 0x0, 0))
+    assert_cvscalar_equal(CvColor::Aqua, CvScalar.new(0xff, 0xff, 0x0, 0))
+  end
+end
+