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

data/test/test_cvcontourtree.rb

@@ -1,43 +1,43 @@
-#!/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::CvContourTree
-class TestCvContourTree < OpenCVTestCase
-  def setup
-    @tree = CvContourTree.new(CvPoint)
-  end
-
-  def test_initialize
-    tree = CvContourTree.new(CvPoint)
-    assert_equal(CvContourTree, tree.class)
-    assert(tree.is_a? CvSeq)
-  end
-
-  def test_p1
-    assert_equal(CvPoint, @tree.p1.class)
-  end
-
-  def test_p2
-    assert_equal(CvPoint, @tree.p2.class)
-  end
-
-  def test_contour
-    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
-      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
-    }
-    contour = mat0.find_contours
-    tree = contour.create_tree
-    contour = tree.contour(CvTermCriteria.new(100, 0.01))
-    assert_equal(CvContour, contour.class)
-
-    assert_raise(CvStsBadArg) {
-      tree.contour(CvTermCriteria.new(0, 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::CvContourTree
+class TestCvContourTree < OpenCVTestCase
+  def setup
+    @tree = CvContourTree.new(CvPoint)
+  end
+
+  def test_initialize
+    tree = CvContourTree.new(CvPoint)
+    assert_equal(CvContourTree, tree.class)
+    assert(tree.is_a? CvSeq)
+  end
+
+  def test_p1
+    assert_equal(CvPoint, @tree.p1.class)
+  end
+
+  def test_p2
+    assert_equal(CvPoint, @tree.p2.class)
+  end
+
+  def test_contour
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    contour = mat0.find_contours
+    tree = contour.create_tree
+    contour = tree.contour(CvTermCriteria.new(100, 0.01))
+    assert_equal(CvContour, contour.class)
+
+    assert_raise(CvStsBadArg) {
+      tree.contour(CvTermCriteria.new(0, 0))
+    }
+  end
+end
+

data/test/test_cverror.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# -*- mode: ruby; coding: utf-8-unix -*- 
+# -*- mode: ruby; coding: utf-8 -*-
 require 'test/unit'
 require 'opencv'
 require File.expand_path(File.dirname(__FILE__)) + '/helper'

data/test/test_cvfeaturetree.rb

@@ -1,65 +1,65 @@
-#!/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::CvFeatureTree
-class TestCvFeatureTree < OpenCVTestCase
-  def test_initialize
-    desc = CvMat.new(1, 1, :cv32f, 1)
-    ft = CvFeatureTree.new(desc)
-    assert_equal(CvFeatureTree, ft.class)
-    
-    assert_raise(TypeError) {
-      CvFeatureTree.new(DUMMY_OBJ)
-    }
-  end
-
-  def test_find_feature
-    dim = 2
-    points = []
-    points << [99, 51]
-    points << [52, 57]
-    points << [57, 42]
-    points << [13, 39]
-    points << [15, 68]
-    points << [75, 11]
-    points << [69, 62]
-    points << [52, 46]
-    points << [0, 64]
-    points << [67, 16]
-
-    desc1 = CvMat.new(points.size, dim, :cv32f, 1)
-    desc1.set_data(points)
-
-    pt = [[50, 50], [11, 40]]
-    desc2 = CvMat.new(pt.size, dim, :cv32f, 1)
-    desc2.set_data(pt)
-
-    ft = CvFeatureTree.new(desc1)
-    results, dist = ft.find_features(desc2, 1, 10)
-
-    assert_equal(CvMat, results.class)
-    assert_equal(CvMat, dist.class)
-
-    assert_equal(7, results[0][0].to_i)
-    assert_in_delta(4.472, dist[0][0], 0.001)
-
-    assert_equal(3, results[1][0].to_i)
-    assert_in_delta(2.236, dist[1][0], 0.001)
-
-    assert_raise(TypeError) {
-      ft.find_features(DUMMY_OBJ, 1, 10)
-    }
-    assert_raise(TypeError) {
-      ft.find_features(desc2, DUMMY_OBJ, 10)
-    }
-    assert_raise(TypeError) {
-      ft.find_features(desc2, 1, DUMMY_OBJ)
-    }
-  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::CvFeatureTree
+class TestCvFeatureTree < OpenCVTestCase
+  def test_initialize
+    desc = CvMat.new(1, 1, :cv32f, 1)
+    ft = CvFeatureTree.new(desc)
+    assert_equal(CvFeatureTree, ft.class)
+    
+    assert_raise(TypeError) {
+      CvFeatureTree.new(DUMMY_OBJ)
+    }
+  end
+
+  def test_find_feature
+    dim = 2
+    points = []
+    points << [99, 51]
+    points << [52, 57]
+    points << [57, 42]
+    points << [13, 39]
+    points << [15, 68]
+    points << [75, 11]
+    points << [69, 62]
+    points << [52, 46]
+    points << [0, 64]
+    points << [67, 16]
+
+    desc1 = CvMat.new(points.size, dim, :cv32f, 1)
+    desc1.set_data(points)
+
+    pt = [[50, 50], [11, 40]]
+    desc2 = CvMat.new(pt.size, dim, :cv32f, 1)
+    desc2.set_data(pt)
+
+    ft = CvFeatureTree.new(desc1)
+    results, dist = ft.find_features(desc2, 1, 10)
+
+    assert_equal(CvMat, results.class)
+    assert_equal(CvMat, dist.class)
+
+    assert_equal(7, results[0][0].to_i)
+    assert_in_delta(4.472, dist[0][0], 0.001)
+
+    assert_equal(3, results[1][0].to_i)
+    assert_in_delta(2.236, dist[1][0], 0.001)
+
+    assert_raise(TypeError) {
+      ft.find_features(DUMMY_OBJ, 1, 10)
+    }
+    assert_raise(TypeError) {
+      ft.find_features(desc2, DUMMY_OBJ, 10)
+    }
+    assert_raise(TypeError) {
+      ft.find_features(desc2, 1, DUMMY_OBJ)
+    }
+  end
+end
+

data/test/test_cvfont.rb

@@ -1,58 +1,58 @@
-#!/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::CvFont
-class TestCvFont < OpenCVTestCase
-  def test_FACE
-    assert_equal(0, CvFont::FACE[:simplex])
-    assert_equal(1, CvFont::FACE[:plain])
-    assert_equal(2, CvFont::FACE[:duplex])
-    assert_equal(4, CvFont::FACE[:triplex])
-    assert_equal(5, CvFont::FACE[:complex_small])
-    assert_equal(6, CvFont::FACE[:script_simplex])
-    assert_equal(7, CvFont::FACE[:script_complex])
-  end
-
-  def test_FONT_OPTION
-    assert_equal(1.0, CvFont::FONT_OPTION[:hscale])
-    assert_equal(1.0, CvFont::FONT_OPTION[:vscale])
-    assert_equal(0, CvFont::FONT_OPTION[:shear])
-    assert_equal(1, CvFont::FONT_OPTION[:thickness])
-    assert_equal(8, CvFont::FONT_OPTION[:line_type])
-  end
-
-  def test_initialize
-    font = CvFont.new(:simplex)
-    assert_equal(0, font.face)
-    assert_equal(1.0, font.hscale)
-    assert_equal(1.0, font.vscale)
-    assert_equal(0, font.shear)
-    assert_equal(1, font.thickness)
-    assert_equal(8, font.line_type)
-    assert_false(font.italic)
-
-    font = CvFont.new(:plain, :hscale => 2.5, :vscale => 3.5,
-                      :shear => 0.5, :thickness => 3, :line_type => 2, :italic => false)
-    assert_equal(1, font.face)
-    assert_equal(2.5, font.hscale)
-    assert_equal(3.5, font.vscale)
-    assert_equal(0.5, font.shear)
-    assert_equal(3, font.thickness)
-    assert_equal(2, font.line_type)
-    assert_false(font.italic)
-
-    font = CvFont.new(:simplex, :italic => true)
-    assert_equal(16, font.face)
-    assert(font.italic)
-
-    assert_raise(ArgumentError) {
-      CvFont.new(:foo)
-    }
-  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::CvFont
+class TestCvFont < OpenCVTestCase
+  def test_FACE
+    assert_equal(0, CvFont::FACE[:simplex])
+    assert_equal(1, CvFont::FACE[:plain])
+    assert_equal(2, CvFont::FACE[:duplex])
+    assert_equal(4, CvFont::FACE[:triplex])
+    assert_equal(5, CvFont::FACE[:complex_small])
+    assert_equal(6, CvFont::FACE[:script_simplex])
+    assert_equal(7, CvFont::FACE[:script_complex])
+  end
+
+  def test_FONT_OPTION
+    assert_equal(1.0, CvFont::FONT_OPTION[:hscale])
+    assert_equal(1.0, CvFont::FONT_OPTION[:vscale])
+    assert_equal(0, CvFont::FONT_OPTION[:shear])
+    assert_equal(1, CvFont::FONT_OPTION[:thickness])
+    assert_equal(8, CvFont::FONT_OPTION[:line_type])
+  end
+
+  def test_initialize
+    font = CvFont.new(:simplex)
+    assert_equal(0, font.face)
+    assert_equal(1.0, font.hscale)
+    assert_equal(1.0, font.vscale)
+    assert_equal(0, font.shear)
+    assert_equal(1, font.thickness)
+    assert_equal(8, font.line_type)
+    assert_false(font.italic)
+
+    font = CvFont.new(:plain, :hscale => 2.5, :vscale => 3.5,
+                      :shear => 0.5, :thickness => 3, :line_type => 2, :italic => false)
+    assert_equal(1, font.face)
+    assert_equal(2.5, font.hscale)
+    assert_equal(3.5, font.vscale)
+    assert_equal(0.5, font.shear)
+    assert_equal(3, font.thickness)
+    assert_equal(2, font.line_type)
+    assert_false(font.italic)
+
+    font = CvFont.new(:simplex, :italic => true)
+    assert_equal(16, font.face)
+    assert(font.italic)
+
+    assert_raise(ArgumentError) {
+      CvFont.new(:foo)
+    }
+  end
+end
+

data/test/test_cvhaarclassifiercascade.rb

@@ -1,63 +1,63 @@
-#!/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::CvHaarClassifierCascade
-class TestCvHaarClassifierCascade < OpenCVTestCase
-  def setup
-    @cascade = CvHaarClassifierCascade.load(HAARCASCADE_FRONTALFACE_ALT)
-  end
-
-  def test_load
-    assert_equal(CvHaarClassifierCascade, @cascade.class)
-    assert_raise(ArgumentError) {
-      CvHaarClassifierCascade.load('not/exist.xml')
-    }
-  end
-  
-  def test_detect_objects
-    img = CvMat.load(FILENAME_LENA256x256)
-
-    detected = @cascade.detect_objects(img)
-    assert_equal(CvSeq, detected.class)
-    assert_equal(1, detected.size)
-    assert_equal(CvAvgComp, detected[0].class)
-    assert_equal(106, detected[0].x)
-    assert_equal(100, detected[0].y)
-    assert_equal(89, detected[0].width)
-    assert_equal(89, detected[0].height)
-    assert_equal(48, detected[0].neighbors)
-
-    detected = @cascade.detect_objects(img) { |face|
-      assert_equal(106, face.x)
-      assert_equal(100, face.y)
-      assert_equal(89, face.width)
-      assert_equal(89, face.height)
-      assert_equal(48, face.neighbors)
-    }
-    assert_equal(CvSeq, detected.class)
-    assert_equal(1, detected.size)
-    assert_equal(CvAvgComp, detected[0].class)
-
-    detected = @cascade.detect_objects(img, :scale_factor => 2.0, :flags => CV_HAAR_DO_CANNY_PRUNING,
-                                       :min_neighbors => 5, :min_size => CvSize.new(10, 10),
-                                       :max_size => CvSize.new(100, 100))
-    assert_equal(CvSeq, detected.class)
-    assert_equal(1, detected.size)
-    assert_equal(CvAvgComp, detected[0].class)
-    assert_equal(109, detected[0].x)
-    assert_equal(102, detected[0].y)
-    assert_equal(80, detected[0].width)
-    assert_equal(80, detected[0].height)
-    assert_equal(7, detected[0].neighbors)
-
-    assert_raise(TypeError) {
-      @cascade.detect_objects('foo')
-    }
-  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::CvHaarClassifierCascade
+class TestCvHaarClassifierCascade < OpenCVTestCase
+  def setup
+    @cascade = CvHaarClassifierCascade.load(HAARCASCADE_FRONTALFACE_ALT)
+  end
+
+  def test_load
+    assert_equal(CvHaarClassifierCascade, @cascade.class)
+    assert_raise(ArgumentError) {
+      CvHaarClassifierCascade.load('not/exist.xml')
+    }
+  end
+  
+  def test_detect_objects
+    img = CvMat.load(FILENAME_LENA256x256)
+
+    detected = @cascade.detect_objects(img)
+    assert_equal(CvSeq, detected.class)
+    assert_equal(1, detected.size)
+    assert_equal(CvAvgComp, detected[0].class)
+    assert_equal(106, detected[0].x)
+    assert_equal(100, detected[0].y)
+    assert_equal(89, detected[0].width)
+    assert_equal(89, detected[0].height)
+    assert_equal(48, detected[0].neighbors)
+
+    detected = @cascade.detect_objects(img) { |face|
+      assert_equal(106, face.x)
+      assert_equal(100, face.y)
+      assert_equal(89, face.width)
+      assert_equal(89, face.height)
+      assert_equal(48, face.neighbors)
+    }
+    assert_equal(CvSeq, detected.class)
+    assert_equal(1, detected.size)
+    assert_equal(CvAvgComp, detected[0].class)
+
+    detected = @cascade.detect_objects(img, :scale_factor => 2.0, :flags => CV_HAAR_DO_CANNY_PRUNING,
+                                       :min_neighbors => 5, :min_size => CvSize.new(10, 10),
+                                       :max_size => CvSize.new(100, 100))
+    assert_equal(CvSeq, detected.class)
+    assert_equal(1, detected.size)
+    assert_equal(CvAvgComp, detected[0].class)
+    assert_equal(109, detected[0].x)
+    assert_equal(102, detected[0].y)
+    assert_equal(80, detected[0].width)
+    assert_equal(80, detected[0].height)
+    assert_equal(7, detected[0].neighbors)
+
+    assert_raise(TypeError) {
+      @cascade.detect_objects('foo')
+    }
+  end
+end
+