modified some tests, added a test runner

test/helper.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8-unix -*- 
+require 'test/unit'
+require 'digest/md5'
+require 'opencv'
+include OpenCV
+
+class OpenCVTestCase < Test::Unit::TestCase
+  def get_sample(filename, iscolor = nil)
+    IplImage::load('samples/' + filename, iscolor)
+  end
+  
+  def snap(*images)
+    win = []
+    images.size.times { |i| win << GUI::Window.new("snap-#{i}") }
+    win.each_with_index { |w, i| w.show images[i] }
+    
+    GUI::wait_key
+    GUI::Window::destroy_all
+  end
+
+  def hash_img(img)
+    # Compute a hash for an image, useful for image comparisons
+    Digest::MD5.hexdigest(img.data)
+  end
+
+  alias original_assert_in_delta assert_in_delta
+  # alias original_assert_equal assert_equal
+
+  def assert_cvscalar_equal(expected, actual, message = nil)
+    assert_equal(CvScalar, actual.class, message)
+    assert_array_equal(expected.to_ary, actual.to_ary, message)
+  end
+
+  def assert_array_equal(expected, actual, message = nil)
+    assert_equal(expected.size, actual.size, message)
+    expected.zip(actual) { |e, a|
+      assert_equal(e, a, message)
+    }
+  end
+  
+  def assert_in_delta(expected, actual, delta)
+    if expected.is_a? CvScalar or actual.is_a? CvScalar
+      expected = expected.to_ary if expected.is_a? CvScalar
+      actual = actual.to_ary if actual.is_a? CvScalar
+      assert_in_delta(expected, actual ,delta)
+    elsif expected.is_a? Array and actual.is_a? Array
+      assert_equal(expected.size, actual.size)
+      expected.zip(actual) { |e, a|
+        original_assert_in_delta(e, a, delta)
+      }
+    else
+      original_assert_in_delta(expected, actual, delta)
+    end
+  end
+
+  def create_cvmat(height, width, depth = :cv8u, channel = 4, &block)
+    m = CvMat.new(height, width, depth, channel)
+    block = lambda { |j, i, c| CvScalar.new(*([c + 1] * channel)) } unless block_given?
+    count = 0
+    height.times { |j|
+      width.times { |i|
+        m[i, j] = block.call(j, i, count)
+        count += 1
+      }
+    }
+    m
+  end
+end
+

test/runner.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8-unix -*- 
+require 'test/unit'
+
+if Test::Unit.methods.include? :setup_argv
+  src_testdir = File.dirname(File.expand_path(__FILE__))
+  srcdir = File.dirname(src_testdir)
+  Test::Unit.setup_argv {|files|
+    if files.empty?
+      [src_testdir]
+    else
+      files.map {|f|
+        if File.exist? "#{src_testdir}/#{f}"
+          "#{src_testdir}/#{f}"
+        elsif File.exist? "#{srcdir}/#{f}"
+          "#{srcdir}/#{f}"
+        elsif File.exist? f
+          f
+        else
+          raise ArgumentError, "not found: #{f}"
+        end
+      }
+    end
+  }
+elsif Test::Unit.constants.include? 'AutoRunner'
+  Test::Unit::AutoRunner.run(true, './')
+else
+  raise Error, 'Test runner not found'
+end
+

test/test_cvmat.rb

@@ -1,27 +1,14 @@
 #!/usr/bin/env ruby
 # -*- mode: ruby; coding: utf-8-unix -*- 
-
 require 'test/unit'
 require 'opencv'
 require 'pp'
-require File.expand_path(File.dirname(__FILE__)) + '/test_opencv'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
 
 include OpenCV
 
 # Tests for OpenCV::CvMat
-class TestCvMat < TestOpenCV
+class TestCvMat < OpenCVTestCase
-  def make_cvmat(h, w, depth = :cv8u, channel = 4)
-    m = CvMat.new(h, w, depth, channel)
-    count = 1
-    h.times { |j|
-      w.times { |i|
-        m[i, j] = CvScalar.new(*([count] * channel))
-        count += 1
-      }
-    }
-    m
-  end
-  
   def test_DRAWING_OPTION
     CvMat::DRAWING_OPTION[:color].to_ary.each { |c|
       assert_in_delta(0, c, 0.01)
@@ -141,26 +128,31 @@ class TestCvMat < TestOpenCV
   end
 
   def test_clone
-    m1 = make_cvmat(10, 20)
+    m1 = create_cvmat(10, 20)
     m2 = m1.clone
     assert_equal(m1.data, m2.data)
   end
 
   def test_copy
-    m1 = make_cvmat(10, 20, CV_32F, 1)
+    m1 = create_cvmat(10, 20, CV_32F, 1)
 
     m2 = m1.copy
     assert_equal(m1.data, m2.data)
     
     m2 = CvMat.new(10, 20, CV_32F, 1)
     m1.copy(m2)
+    assert_equal(m1.data, m2.data)
+    
+    a = m1.copy(2)
+    assert_equal(2, a.size)
+    a.each { |m|
       m1.height.times { |j|
         m1.width.times { |i|
-        assert(is_same_float_array(m1[i, j].to_ary, m2[i, j].to_ary))
+          assert_cvscalar_equal(m1[i, j], m[i, j])
         }
       }
-
+    }
-    assert_equal(m1.data, m2.data)
+    assert_nil(m1.copy(-1))
 
     flunk('FIXME: CvUnmatchedSizes and CvUnmatchedFormats are not implemented yet')
     m2 = CvMat.new(1, 2, CV_32F, 1)
@@ -176,17 +168,6 @@ class TestCvMat < TestOpenCV
     assert_raise(CvUnmatchedFormats) {
       m1.copy(m2)
     }
-    
-    a = m1.copy(2)
-    assert_equal(2, a.size)
-    a.each { |m|
-      m1.height.times { |j|
-        m1.width.times { |i|
-          assert(is_same_float_array(m1[i, j].to_ary, m[i, j].to_ary))
-        }
-      }
-    }
-    assert_nil(m1.copy(-1))
   end
 
   def test_convert_depth
@@ -223,7 +204,7 @@ class TestCvMat < TestOpenCV
   end
 
   def test_sub_rect
-    m1 = make_cvmat(10, 10)
+    m1 = create_cvmat(10, 10)
 
     assert_raise(ArgumentError) {
       m1.sub_rect
@@ -234,7 +215,7 @@ class TestCvMat < TestOpenCV
     assert_equal(3, m2.height)
     m2.height.times { |j|
       m2.width.times { |i|
-        assert(is_same_float_array(m1[i, j].to_ary, m2[i, j].to_ary))
+        assert_cvscalar_equal(m1[i, j], m2[i, j])
       }
     }
     
@@ -244,7 +225,7 @@ class TestCvMat < TestOpenCV
     assert_equal(5, m2.height)
     m2.height.times { |j|
       m2.width.times { |i|
-        assert(is_same_float_array(m1[topleft.x + i, topleft.y + j].to_ary, m2[i, j].to_ary))
+        assert_cvscalar_equal(m1[topleft.x + i, topleft.y + j], m2[i, j])
       }
     }
 
@@ -254,7 +235,7 @@ class TestCvMat < TestOpenCV
     assert_equal(4, m2.height)
     m2.height.times { |j|
       m2.width.times { |i|
-        assert(is_same_float_array(m1[topleft.x + i, topleft.y + j].to_ary, m2[i, j].to_ary))
+        assert_cvscalar_equal(m1[topleft.x + i, topleft.y + j], m2[i, j])
       }
     }
 
@@ -264,13 +245,13 @@ class TestCvMat < TestOpenCV
     assert_equal(3, m2.height)
     m2.height.times { |j|
       m2.width.times { |i|
-        assert(is_same_float_array(m1[i, j].to_ary, m2[i, j].to_ary))
+        assert_cvscalar_equal(m1[i, j], m2[i, j])
       }
     }
   end
 
   def test_slice_width
-    m1 = make_cvmat(10, 40, :cv32f, 1)
+    m1 = create_cvmat(10, 40, :cv32f, 1)
     ml, mr = m1.slice_width(2)
     [ml, mr].each { |m|
       assert_equal(10, m.height)
@@ -281,14 +262,14 @@ class TestCvMat < TestOpenCV
 
     ml.height.times { |j|
       ml.width.times { |i|
-        assert(is_same_float_array(m1[i, j].to_ary, ml[i, j].to_ary))
+        assert_cvscalar_equal(m1[i, j], ml[i, j])
-        assert(is_same_float_array(m1[20 + i, j].to_ary, mr[i, j].to_ary))
+        assert_cvscalar_equal(m1[(m1.width / 2) + i, j], mr[i, j])
       }
     }
   end
 
   def test_slice_height
-    m1 = make_cvmat(10, 20, :cv32f, 1)
+    m1 = create_cvmat(10, 20, :cv32f, 1)
     mt, mb = m1.slice_height(2)
     [mt, mb].each { |m|
       assert_equal(5, m.height)
@@ -299,20 +280,20 @@ class TestCvMat < TestOpenCV
 
     mt.height.times { |j|
       mt.width.times { |i|
-        assert(is_same_float_array(m1[i, j].to_ary, mt[i, j].to_ary))
+        assert_cvscalar_equal(m1[i, j], mt[i, j])
-        assert(is_same_float_array(m1[i, 5 + j].to_ary, mb[i, j].to_ary))
+        assert_cvscalar_equal(m1[i, (m1.height / 2) + j], mb[i, j])
       }
     }
   end
   
   def test_row
-    m1 = make_cvmat(10, 20)
+    m1 = create_cvmat(10, 20)
 
     m2 = m1.row(2)
     assert_equal(1, m2.height)
     assert_equal(m1.width, m2.width)
     m1.width.times { |i|
-      assert(is_same_float_array(m1[i, 2].to_ary, m2[i].to_ary))
+      assert_cvscalar_equal(m1[i, 2], m2[i])
     }
 
     m2, m3 = m1.row(1, 2)
@@ -321,19 +302,19 @@ class TestCvMat < TestOpenCV
       assert_equal(m1.width, m.width)
     }
     m1.width.times { |i|
-      assert(is_same_float_array(m1[i, 1].to_ary, m2[i].to_ary))
+      assert_cvscalar_equal(m1[i, 1], m2[i])
-      assert(is_same_float_array(m1[i, 2].to_ary, m3[i].to_ary))
+      assert_cvscalar_equal(m1[i, 2], m3[i])
     }
   end
 
   def test_col
-    m1 = make_cvmat(10, 20)
+    m1 = create_cvmat(10, 20)
 
     m2 = m1.col(2)
     assert_equal(1, m2.width)
     assert_equal(m1.height, m2.height)
     m1.height.times { |j|
-      assert(is_same_float_array(m1[2, j].to_ary, m2[j].to_ary))
+      assert_cvscalar_equal(m1[2, j], m2[j])
     }
 
     m2, m3 = m1.col(1, 2)
@@ -342,13 +323,13 @@ class TestCvMat < TestOpenCV
       assert_equal(m1.height, m.height)
     }
     m1.height.times { |j|
-      assert(is_same_float_array(m1[1, j].to_ary, m2[j].to_ary))
+      assert_cvscalar_equal(m1[1, j], m2[j])
-      assert(is_same_float_array(m1[2, j].to_ary, m3[j].to_ary))
+      assert_cvscalar_equal(m1[2, j], m3[j])
     }
   end
 
   def test_each_row
-    m1 = make_cvmat(2, 3)
+    m1 = create_cvmat(2, 3)
     a = [[1, 2, 3], [4, 5, 6]]
     a.map! { |a1|
       a1.map! { |a2|
@@ -359,14 +340,14 @@ class TestCvMat < TestOpenCV
     j = 0
     m1.each_row { |r|
       a[j].size.times { |i|
-        assert(is_same_float_array(a[j][i].to_ary, r[i].to_ary))
+        assert_cvscalar_equal(a[j][i], r[i])
       }
       j += 1
     }
   end
 
   def test_each_col
-    m1 = make_cvmat(2, 3)
+    m1 = create_cvmat(2, 3)
     a = [[1, 4], [2, 5], [3, 6]]
     a.map! { |a1|
       a1.map! { |a2|
@@ -377,7 +358,7 @@ class TestCvMat < TestOpenCV
     j = 0
     m1.each_col { |c|
       a[j].size.times { |i|
-        assert(is_same_float_array(a[j][i].to_ary, c[i].to_ary))
+        assert_cvscalar_equal(a[j][i], c[i])
       }
       j += 1
     }
@@ -386,42 +367,38 @@ class TestCvMat < TestOpenCV
     j = 0
     m1.each_column { |c|
       a[j].size.times { |i|
-        assert(is_same_float_array(a[j][i].to_ary, c[i].to_ary))
+        assert_cvscalar_equal(a[j][i], c[i])
       }
       j += 1
     }
   end
 
   def test_diag
-    m = make_cvmat(5, 5)
+    m = create_cvmat(5, 5)
-    # a = [1.1, 7.7, 14.3, 20.9, 27.5].map { |x| CvScalar.new(x, x, x, x) }
     a = [1, 7, 13, 19, 25].map { |x| CvScalar.new(x, x, x, x) }
     d = m.diag
 
     a.each_with_index { |s, i|
-      assert(is_same_float_array(s.to_ary, d[i].to_ary))
+      assert_cvscalar_equal(s, d[i])
     }
 
-    # a = [2.2, 8.8, 15.4, 22.0].map { |x| CvScalar.new(x, x, x, x) }
     a = [2, 8, 14, 20].map { |x| CvScalar.new(x, x, x, x) }
     d = m.diag(1)
     a.each_with_index { |s, i|
-      assert(is_same_float_array(s.to_ary, d[i].to_ary))
+      assert_cvscalar_equal(s, d[i])
     }
 
-    # a = [6.6, 13.2, 19.8, 26.4].map { |x| CvScalar.new(x, x, x, x) }
     a = [6, 12, 18, 24].map { |x| CvScalar.new(x, x, x, x) }
     d = m.diag(-1)
     a.each_with_index { |s, i|
-      assert(is_same_float_array(s.to_ary, d[i].to_ary))
+      assert_cvscalar_equal(s, d[i])
     }
 
     # Alias
-    # a = [1.1, 7.7, 14.3, 20.9, 27.5].map { |x| CvScalar.new(x, x, x, x) }
     a = [1, 7, 13, 19, 25].map { |x| CvScalar.new(x, x, x, x) }
     d = m.diagonal
     a.each_with_index { |s, i|
-      assert(is_same_float_array(s.to_ary, d[i].to_ary))
+      assert_cvscalar_equal(s, d[i])
     }
   end
 
@@ -443,41 +420,41 @@ class TestCvMat < TestOpenCV
   end
 
   def test_aref
-    m = make_cvmat(2, 3)
+    m = create_cvmat(2, 3)
-    assert(is_same_float_array([1, 1, 1, 1], m[0]))
+    assert_cvscalar_equal(CvScalar.new(1, 1, 1, 1), m[0])
-    assert(is_same_float_array([5, 5, 5, 5], m[4]))
+    assert_cvscalar_equal(CvScalar.new(5, 5, 5, 5), m[4])
-    assert(is_same_float_array([2, 2, 2, 2], m[1, 0]))
+    assert_cvscalar_equal(CvScalar.new(2, 2, 2, 2), m[1, 0])
-    assert(is_same_float_array([4, 4, 4, 4], m[0, 1]))
+    assert_cvscalar_equal(CvScalar.new(4, 4, 4, 4), m[0, 1])
 
     # Alias
-    assert(is_same_float_array([1, 1, 1, 1], m.at(0)))
+    assert_cvscalar_equal(CvScalar.new(1, 1, 1, 1), m.at(0))
 
     flunk('FIXME: cvGetND cases do not seem to work well')
   end
 
   def test_aset
-    m = make_cvmat(2, 3)
+    m = create_cvmat(2, 3)
     m[0] = CvScalar.new(10, 10, 10, 10)
-    assert(is_same_float_array([10, 10, 10, 10], m[0]))
+    assert_cvscalar_equal(CvScalar.new(10, 10, 10, 10), m[0])
 
     m[1, 0] = CvScalar.new(20, 20, 20, 20)
-    assert(is_same_float_array([20, 20, 20, 20], m[1, 0]))
+    assert_cvscalar_equal(CvScalar.new(20, 20, 20, 20), m[1, 0])
 
     flunk('FIXME: cvSetND cases do not seem to work well')
   end
 
   def test_fill
-    m1 = make_cvmat(2, 3)
+    m1 = create_cvmat(2, 3)
     m2 = m1.fill(CvScalar.new(1, 2, 3, 4))
     m1.fill!(CvScalar.new(1, 2, 3, 4))
     m2.height.times { |j|
       m2.width.times { |i|
-        assert(is_same_float_array([1, 2, 3, 4], m1[i, j]))
+        assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), m1[i, j])
-        assert(is_same_float_array([1, 2, 3, 4], m2[i, j]))
+        assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), m2[i, j])
       }
     }
 
-    m1 = make_cvmat(5, 5)
+    m1 = create_cvmat(5, 5)
     m0 = m1.clone
     mask = CvMat.new(m1.height, m1.width, :cv8u, 1).clear
     2.times { |j|
@@ -491,27 +468,27 @@ class TestCvMat < TestOpenCV
     m2.height.times { |j|
       m2.width.times { |i|
         if i < 2 and j < 2
-          assert(is_same_float_array([1, 2, 3, 4], m1[i, j]))
+          assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), m1[i, j])
-          assert(is_same_float_array([1, 2, 3, 4], m2[i, j]))
+          assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), m2[i, j])
         else
-          assert(is_same_float_array(m0[i, j], m1[i, j]))
+          assert_cvscalar_equal(m0[i, j], m1[i, j])
-          assert(is_same_float_array(m0[i, j], m2[i, j]))
+          assert_cvscalar_equal(m0[i, j], m2[i, j])
         end
       }
     }
     
     # Alias
-    m1 = make_cvmat(2, 3)
+    m1 = create_cvmat(2, 3)
     m2 = m1.set(CvScalar.new(1, 2, 3, 4))
     m1.set!(CvScalar.new(1, 2, 3, 4))
     m2.height.times { |j|
       m2.width.times { |i|
-        assert(is_same_float_array([1, 2, 3, 4], m1[i, j]))
+        assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), m1[i, j])
-        assert(is_same_float_array([1, 2, 3, 4], m2[i, j]))
+        assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), m2[i, j])
       }
     }
 
-    m1 = make_cvmat(5, 5)
+    m1 = create_cvmat(5, 5)
     m0 = m1.clone
     mask = CvMat.new(m1.height, m1.width, CV_8U, 1).clear
     2.times { |j|
@@ -525,51 +502,51 @@ class TestCvMat < TestOpenCV
     m2.height.times { |j|
       m2.width.times { |i|
         if i < 2 and j < 2
-          assert(is_same_float_array([1, 2, 3, 4], m1[i, j]))
+          assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), m1[i, j])
-          assert(is_same_float_array([1, 2, 3, 4], m2[i, j]))
+          assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), m2[i, j])
         else
-          assert(is_same_float_array(m0[i, j], m1[i, j]))
+          assert_cvscalar_equal(m0[i, j], m1[i, j])
-          assert(is_same_float_array(m0[i, j], m2[i, j]))
+          assert_cvscalar_equal(m0[i, j], m2[i, j])
         end
       }
     }
   end
 
   def test_clear
-    m1 = make_cvmat(2, 3)
+    m1 = create_cvmat(2, 3)
     m2 = m1.clear
     m1.clear!
     m2.height.times { |j|
       m2.width.times { |i|
-        assert(is_same_float_array([0, 0, 0, 0], m1[i, j]))
+        assert_cvscalar_equal(CvScalar.new(0, 0, 0, 0), m1[i, j])
-        assert(is_same_float_array([0, 0, 0, 0], m2[i, j]))
+        assert_cvscalar_equal(CvScalar.new(0, 0, 0, 0), m2[i, j])
       }
     }
 
     # Alias
-    m1 = make_cvmat(2, 3)
+    m1 = create_cvmat(2, 3)
     m2 = m1.set_zero
     m1.set_zero!
     m2.height.times { |j|
       m2.width.times { |i|
-        assert(is_same_float_array([0, 0, 0, 0], m1[i, j]))
+        assert_cvscalar_equal(CvScalar.new(0, 0, 0, 0), m1[i, j])
-        assert(is_same_float_array([0, 0, 0, 0], m2[i, j]))
+        assert_cvscalar_equal(CvScalar.new(0, 0, 0, 0), m2[i, j])
       }
     }
   end
 
   def test_identity
-    m1 = make_cvmat(5, 5)
+    m1 = create_cvmat(5, 5)
     m2 = m1.identity
     m1.identity!
     m2.height.times { |j|
       m2.width.times { |i|
         if i == j
-          assert(is_same_float_array([1, 0, 0, 0], m1[i, j].to_ary))
+          assert_cvscalar_equal(CvScalar.new(1, 0, 0, 0), m1[i, j])
-          assert(is_same_float_array([1, 0, 0, 0], m2[i, j].to_ary))
+          assert_cvscalar_equal(CvScalar.new(1, 0, 0, 0), m2[i, j])
         else
-          assert(is_same_float_array([0, 0, 0, 0], m1[i, j].to_ary))
+          assert_cvscalar_equal(CvScalar.new(0, 0, 0, 0), m1[i, j])
-          assert(is_same_float_array([0, 0, 0, 0], m2[i, j].to_ary))
+          assert_cvscalar_equal(CvScalar.new(0, 0, 0, 0), m2[i, j])
         end
       }
     }
@@ -580,13 +557,13 @@ class TestCvMat < TestOpenCV
     m2 = m1.range(0, m1.cols)
     m1.range!(0, m1.cols)
     m2.width.times { |i|
-      assert(is_same_float_array([i, 0, 0, 0], m1[i, 0].to_ary))
+      assert_cvscalar_equal(CvScalar.new(i, 0, 0, 0), m1[i, 0])
-      assert(is_same_float_array([i, 0, 0, 0], m2[i, 0].to_ary))
+      assert_cvscalar_equal(CvScalar.new(i, 0, 0, 0), m2[i, 0])
     }
   end
 
   def test_reshape
-    m = make_cvmat(2, 3, CV_8U, 3)
+    m = create_cvmat(2, 3, CV_8U, 3)
     assert_raise(TypeError) {
       m.reshape(1)
     }
@@ -596,7 +573,7 @@ class TestCvMat < TestOpenCV
     assert_equal(1, vec.height)
     size = m.width * m.height
     size.times { |i|
-      assert(is_same_float_array(m[i].to_ary, vec[i].to_ary))
+      assert_cvscalar_equal(m[i], vec[i])
     }
 
     ch1 = m.reshape(:channel => 1)
@@ -608,13 +585,13 @@ class TestCvMat < TestOpenCV
         s1 = ch1[i * 3, j][0]
         s2 = ch1[i * 3 + 1, j][0]
         s3 = ch1[i * 3 + 2, j][0]
-        assert(is_same_float_array(m[i, j].to_ary, [s1, s2, s3, 0]))
+        assert_cvscalar_equal(m[i, j], CvScalar.new(s1, s2, s3, 0))
       }
     }
   end
 
   def test_repeat
-    m1 = make_cvmat(2, 3)
+    m1 = create_cvmat(2, 3)
     assert_raise(TypeError) {
       m1.repeat(1)
     }
@@ -622,11 +599,10 @@ class TestCvMat < TestOpenCV
     m2 = m1.repeat(m2)
     m2.height.times { |j|
       m2.width.times { |i|
-        a = m1[i % m1.width, j % m1.height].to_ary
+        a = m1[i % m1.width, j % m1.height]
-        assert(is_same_float_array(m2[i, j].to_ary, a))
+        assert_cvscalar_equal(m2[i, j], a)
       }
     }
-    
   end
   
   # def test_avg_sdv
@@ -640,8 +616,6 @@ class TestCvMat < TestOpenCV
   #   assert_in_delta(avg[0], 5.0, 0.01)
   #   assert_in_delta(sdv[0], 2.0, 0.01)
   # end
-
 end
 
 
-

test/test_cvscalar.rb

@@ -2,25 +2,16 @@
 # -*- mode: ruby; coding: utf-8-unix -*- 
 require 'test/unit'
 require 'opencv'
-require File.expand_path(File.dirname(__FILE__)) + '/test_opencv'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
 
 include OpenCV
 
 # Tests for OpenCV::CvScalar
-class TestCvScalar < TestOpenCV
+class TestCvScalar < OpenCVTestCase
   def test_aref
-    s = CvScalar.new
+    assert_in_delta([0, 0, 0, 0], CvScalar.new, 0.01)
-    4.times { |i| assert_in_delta(0, s[i], 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)
-    s = CvScalar.new(10, 20, 30, 40)
-    [10, 20, 30, 40].each_with_index { |x, i|
-      assert_in_delta(x, s[i], 0.01)
-    }
-
-    s = CvScalar.new(0.1, 0.2, 0.3, 0.4)
-    [0.1, 0.2, 0.3, 0.4].each_with_index { |x, i|
-      assert_in_delta(x, s[i], 0.01)
-    }
   end
 
   def test_aset
@@ -28,35 +19,25 @@ class TestCvScalar < TestOpenCV
     [10, 20, 30, 40].each_with_index { |x, i|
       s[i] = x
     }
-    [10, 20, 30, 40].each_with_index { |x, i|
+    assert_in_delta([10, 20, 30, 40], s, 0.01)
-      assert_in_delta(x, s[i], 0.01)
-    }
 
     s = CvScalar.new
     [0.1, 0.2, 0.3, 0.4].each_with_index { |x, i|
       s[i] = x
     }
-    [0.1, 0.2, 0.3, 0.4].each_with_index { |x, i|
+    assert_in_delta([0.1, 0.2, 0.3, 0.4], s, 0.01)
-      assert_in_delta(x, s[i], 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, s[0], 0.01)
+      assert_in_delta([8, 16, 24, 32], s, 0.01)
-      assert_in_delta(16, s[1], 0.01)
-      assert_in_delta(24, s[2], 0.01)
-      assert_in_delta(32, s[3], 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, s[0], 0.01)
+      assert_in_delta([1.8, 3.6, 5.4, 7.2], s, 0.01)
-      assert_in_delta(3.6, s[1], 0.01)
-      assert_in_delta(5.4, s[2], 0.01)
-      assert_in_delta(7.2, s[3], 0.01)
     }
 
     mat = CvMat.new(5, 5)
@@ -86,29 +67,27 @@ class TestCvScalar < TestOpenCV
       s = CvScalar.new(*a)
       b = s.to_ary
       assert_equal(Array, b.class)
-      a.each_with_index { |x, i|
+      assert_in_delta(a, b, 0.01)
-        assert_in_delta(x, b[i], 0.01)
-      }
     }
   end
 
   def test_cvcolor
-    assert(is_same_float_array(CvColor::Black, CvScalar.new(0x0, 0x0, 0x0, 0)))
+    assert_cvscalar_equal(CvColor::Black, CvScalar.new(0x0, 0x0, 0x0, 0))
-    assert(is_same_float_array(CvColor::Silver, CvScalar.new(0x0c, 0x0c, 0x0c, 0)))
+    assert_cvscalar_equal(CvColor::Silver, CvScalar.new(0x0c, 0x0c, 0x0c, 0))
-    assert(is_same_float_array(CvColor::Gray, CvScalar.new(0x80, 0x80, 0x80, 0)))
+    assert_cvscalar_equal(CvColor::Gray, CvScalar.new(0x80, 0x80, 0x80, 0))
-    assert(is_same_float_array(CvColor::White, CvScalar.new(0xff, 0xff, 0xff, 0)))
+    assert_cvscalar_equal(CvColor::White, CvScalar.new(0xff, 0xff, 0xff, 0))
-    assert(is_same_float_array(CvColor::Maroon, CvScalar.new(0x0, 0x0, 0x80, 0)))
+    assert_cvscalar_equal(CvColor::Maroon, CvScalar.new(0x0, 0x0, 0x80, 0))
-    assert(is_same_float_array(CvColor::Red, CvScalar.new(0x0, 0x0, 0xff, 0)))
+    assert_cvscalar_equal(CvColor::Red, CvScalar.new(0x0, 0x0, 0xff, 0))
-    assert(is_same_float_array(CvColor::Purple, CvScalar.new(0x80, 0x0, 0x80, 0)))
+    assert_cvscalar_equal(CvColor::Purple, CvScalar.new(0x80, 0x0, 0x80, 0))
-    assert(is_same_float_array(CvColor::Fuchsia, CvScalar.new(0xff, 0x0, 0xff, 0)))
+    assert_cvscalar_equal(CvColor::Fuchsia, CvScalar.new(0xff, 0x0, 0xff, 0))
-    assert(is_same_float_array(CvColor::Green, CvScalar.new(0x0, 0x80, 0x0, 0)))
+    assert_cvscalar_equal(CvColor::Green, CvScalar.new(0x0, 0x80, 0x0, 0))
-    assert(is_same_float_array(CvColor::Lime, CvScalar.new(0x0, 0xff, 0x0, 0)))
+    assert_cvscalar_equal(CvColor::Lime, CvScalar.new(0x0, 0xff, 0x0, 0))
-    assert(is_same_float_array(CvColor::Olive, CvScalar.new(0x0, 0x80, 0x80, 0)))
+    assert_cvscalar_equal(CvColor::Olive, CvScalar.new(0x0, 0x80, 0x80, 0))
-    assert(is_same_float_array(CvColor::Yellow, CvScalar.new(0x0, 0xff, 0xff, 0)))
+    assert_cvscalar_equal(CvColor::Yellow, CvScalar.new(0x0, 0xff, 0xff, 0))
-    assert(is_same_float_array(CvColor::Navy, CvScalar.new(0x80, 0x0, 0x0, 0)))
+    assert_cvscalar_equal(CvColor::Navy, CvScalar.new(0x80, 0x0, 0x0, 0))
-    assert(is_same_float_array(CvColor::Blue, CvScalar.new(0xff, 0x0, 0x0, 0)))
+    assert_cvscalar_equal(CvColor::Blue, CvScalar.new(0xff, 0x0, 0x0, 0))
-    assert(is_same_float_array(CvColor::Teal, CvScalar.new(0x80, 0x80, 0x0, 0)))
+    assert_cvscalar_equal(CvColor::Teal, CvScalar.new(0x80, 0x80, 0x0, 0))
-    assert(is_same_float_array(CvColor::Aqua, CvScalar.new(0xff, 0xff, 0x0, 0)))
+    assert_cvscalar_equal(CvColor::Aqua, CvScalar.new(0xff, 0xff, 0x0, 0))
   end
 end
 

test/test_opencv.rb

@@ -1,66 +1,12 @@
 #!/usr/bin/env ruby
 # -*- mode: ruby; coding: utf-8-unix -*- 
-
 require 'test/unit'
-require 'digest/md5'
 require 'opencv'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
 
 include OpenCV
 
-class TestOpenCV < Test::Unit::TestCase
+class TestOpenCV < OpenCVTestCase
-  # mat_types = [CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4,
-  #              CV_8SC1, CV_8SC2, CV_8SC3,  CV_8SC4,
-  #              CV_16UC1, CV_16UC2, CV_16UC3, CV_16UC4,
-  #              CV_16SC1, CV_16SC2, CV_16SC3, CV_16SC4,
-  #              CV_32SC1, CV_32SC2, CV_32SC3, CV_32SC4,
-  #              CV_32FC1, CV_32FC2, CV_32FC3, CV_32FC4,
-  #              CV_64FC1, CV_64FC2, CV_64FC3, CV_64FC4]
-
-  # mat_types_single = [CV_8UC1, CV_8SC1,
-  #                     CV_16UC1, CV_16SC1,
-  #                     CV_32SC1, CV_32FC1,
-  #                     CV_64FC1]
-
-  def setup
-    @depths = [CV_8U, CV_8S,
-               CV_16U, CV_16S,
-               CV_32S, CV_32F,
-               CV_64F]
-    @depthsize = {
-      CV_8U => 1,
-      CV_8S => 1,
-      CV_16U => 2,
-      CV_16S => 2,
-      CV_32S => 4,
-      CV_32F => 4,
-      CV_64F => 8
-    }
-  end
-
-  def get_sample(filename, iscolor = nil)
-    IplImage::load('samples/' + filename, iscolor)
-  end
-  
-  def snap(*images)
-    win = []
-    images.size.times { |i| win << GUI::Window.new("snap-#{i}") }
-    win.each_with_index { |w, i| w.show images[i] }
-    
-    GUI::wait_key
-    GUI::Window::destroy_all
-  end
-
-  def hash_img(img)
-    # Compute a hash for an image, useful for image comparisons
-    Digest::MD5.hexdigest(img.data)
-  end
-
-  def is_same_float_array(a, b, delta = 0.01)
-    4.times { |i|
-      return false unless (a[i].to_f - b[i].to_f).abs <= delta.to_f
-    }
-    true
-  end
 end
 
 

test/test_preliminary.rb

@@ -1,15 +1,90 @@
 #!/usr/bin/env ruby
 # -*- mode: ruby; coding: utf-8-unix -*- 
-
 require 'test/unit'
 require 'digest/md5'
 require 'opencv'
-require File.expand_path(File.dirname(__FILE__)) + '/test_opencv'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
 
 include OpenCV
 
 # Tests to run first; check the handful of basic operations that the later tests rely on
-class TestPreliminary < TestOpenCV
+class TestPreliminary < OpenCVTestCase
+  def test_assert_array_equal
+    assert_array_equal([1, 2, 3, 4], [1, 2, 3, 4])
+
+    # Uncomment the following line to check the fail case
+    # assert_array_equal([1, 2, 3, 4], [1, 2, 3, 0])
+  end
+
+  def test_assert_cvscalar_equal
+    assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), CvScalar.new(1, 2, 3, 4))
+    assert_cvscalar_equal(CvScalar.new(0.1, 0.2, 0.3, 0.4), CvScalar.new(0.1, 0.2, 0.3, 0.4))
+
+    # Uncomment the following lines to check the fail cases
+    # assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), CvScalar.new(1, 2, 3, 0))
+    # assert_cvscalar_equal(CvScalar.new(0.1, 0.2, 0.3, 0.4), CvScalar.new(0.1, 0.2, 0.3, 0.0))
+  end
+  
+  def test_assert_in_delta
+    assert_in_delta(1, 0.9999, 0.1)
+    assert_in_delta(CvScalar.new(1, 2, 3, 4), CvScalar.new(1.01, 2.01, 3.01, 4.01), 0.1)
+    assert_in_delta(CvScalar.new(1, 2, 3, 4), [1.01, 2.01, 3.01, 4.01], 0.1)
+    assert_in_delta([1, 2, 3, 4], CvScalar.new(1.01, 2.01, 3.01, 4.01), 0.1)
+    assert_in_delta([1, 2, 3, 4], [1.01, 2.01, 3.01, 4.01], 0.1)
+
+    # Uncomment the following lines to check the fail cases
+    # assert_in_delta(1, 0.009, 0.1)
+    # assert_in_delta(CvScalar.new(1, 2, 3, 4), CvScalar.new(1.01, 2.01, 3.01, 4.01), 0.001)
+    # assert_in_delta(CvScalar.new(1, 2, 3, 4), [1.01, 2.01, 3.01, 4.01], 0.001)
+    # assert_in_delta([1, 2, 3, 4], CvScalar.new(1.01, 2.01, 3.01, 4.01), 0.001)
+    # assert_in_delta([1, 2, 3, 4], [1.01, 2.01, 3.01, 4.01], 0.001)
+  end
+
+  def test_create_cvmat
+    mat = create_cvmat(3, 4)
+    assert_equal(3, mat.height)
+    assert_equal(4, mat.width)
+    assert_equal(:cv8u, mat.depth)
+    assert_equal(4, mat.channel)
+    c = 1
+    mat.height { |j|
+      mat.width { |i|
+        assert_cvscalar_equal(CvScalar.new(c, c, c, c), mat[i, j])
+        c += 1
+      }
+    }
+
+    mat = create_cvmat(2, 3, :cv16s, 2)
+    assert_equal(2, mat.height)
+    assert_equal(3, mat.width)
+    assert_equal(:cv16s, mat.depth)
+    assert_equal(2, mat.channel)
+    c = 1
+    mat.height { |j|
+      mat.width { |i|
+        assert_cvscalar_equal(CvScalar.new(c, c, 0, 0), mat[i, j])
+        c += 1
+      }
+    }
+
+    mat = create_cvmat(2, 3, :cv16u, 3) { |j, i, c|
+      n = j + i + c
+      CvScalar.new(n, n, n, 0)
+    }
+    assert_equal(2, mat.height)
+    assert_equal(3, mat.width)
+    assert_equal(:cv16u, mat.depth)
+    assert_equal(3, mat.channel)
+    c = 1
+    mat.height { |j|
+      mat.width { |i|
+        n = j + i + c
+        assert_cvscalar_equal(CvScalar.new(n, n, n, 0), mat[i, j])
+        c += 1
+      }
+    }
+  end
+  
   def test_lena
     # Check that the lena jpg image has loaded correctly
     img = get_sample('lena.jpg', false)
@@ -28,25 +103,5 @@ class TestPreliminary < TestOpenCV
     assert_equal(IplImage.new(7, 5, CV_8U, 1).class, IplImage)
     assert_equal(CvMat.new(5, 7, CV_32F).class, CvMat)
   end
-
-  def test_to_s
-    [1, 4, 64, 512, 640].each { |w|
-      [1, 4, 64, 480, 512].each { |h|
-        [1, 2, 3, 4].each { |c|
-          @depths.each { |d|
-            expected_size = w * h * c * @depthsize[d]
-
-            mat = CvMat.new(w, h, d, c)
-            assert_equal(expected_size, mat.data.size)
-
-            # img = IplImage.new(w, h, d, c)
-            # expected_size += 4 - (expected_size % 4) unless (expected_size % 4) == 0
-            # assert_equal(expected_size, img.data.to_s.size)
-          }
-        }
-      }
-    }
-  end
 end
 
-