afeld-opencv 0.0.8

data/test/test_cvavgcomp.rb

@@ -0,0 +1,24 @@
+#!/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::CvAvgComp
+class TestCvAvgComp < OpenCVTestCase
+  def setup
+    @avgcomp = CvAvgComp.new
+  end
+
+  def test_initialize
+    assert_equal(CvAvgComp, @avgcomp.class)
+    assert(@avgcomp.is_a? CvRect)
+  end
+
+  def test_neighbors
+    assert_equal(Fixnum, @avgcomp.neighbors.class)
+  end
+end
+

data/test/test_cvbox2d.rb

@@ -0,0 +1,76 @@
+#!/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::CvBox2D
+class TestCvBox2D < OpenCVTestCase
+  class MyPoint; end
+  def test_initialize
+    box = CvBox2D.new
+    assert_in_delta(0, box.center.x, 0.001)
+    assert_in_delta(0, box.center.y, 0.001)
+    assert_in_delta(0, box.size.width, 0.001)
+    assert_in_delta(0, box.size.height, 0.001)
+    assert_in_delta(0, box.angle, 0.001)
+
+    box = CvBox2D.new(CvPoint2D32f.new(1.1, 2.2), CvSize2D32f.new(3.3, 4.4), 5.5)
+    assert_in_delta(1.1, box.center.x, 0.001)
+    assert_in_delta(2.2, box.center.y, 0.001)
+    assert_in_delta(3.3, box.size.width, 0.001)
+    assert_in_delta(4.4, box.size.height, 0.001)
+    assert_in_delta(5.5, box.angle, 0.001)
+  end
+
+  def test_center
+    box = CvBox2D.new
+    box.center = CvPoint2D32f.new(1.1, 2.2)
+    assert_in_delta(1.1, box.center.x, 0.001)
+    assert_in_delta(2.2, box.center.y, 0.001)
+
+    box.center.x = 3.3
+    box.center.y = 4.4
+    assert_in_delta(3.3, box.center.x, 0.001)
+    assert_in_delta(4.4, box.center.y, 0.001)
+  end
+  
+  def test_size
+    box = CvBox2D.new
+    box.size = CvSize2D32f.new(1.1, 2.2)
+    assert_in_delta(1.1, box.size.width, 0.001)
+    assert_in_delta(2.2, box.size.height, 0.001)
+
+    box.size.width = 3.3
+    box.size.height = 4.4
+    assert_in_delta(3.3, box.size.width, 0.001)
+    assert_in_delta(4.4, box.size.height, 0.001)
+  end
+
+  def test_angle
+    box = CvBox2D.new
+    box.angle = 1.1
+    assert_in_delta(1.1, box.angle, 0.001)
+  end
+
+  def test_points
+    box = CvBox2D.new
+    box.center = CvPoint2D32f.new(10, 20)
+    box.size = CvSize2D32f.new(5, 7)
+    pt = box.points
+
+    assert_equal(4, pt.size)
+    assert_in_delta(7.5, pt[0].x, 0.001)
+    assert_in_delta(23.5, pt[0].y, 0.001)
+    assert_in_delta(7.5, pt[1].x, 0.001)
+    assert_in_delta(16.5, pt[1].y, 0.001)
+    assert_in_delta(12.5, pt[2].x, 0.001)
+    assert_in_delta(16.5, pt[2].y, 0.001)
+    assert_in_delta(12.5, pt[3].x, 0.001)
+    assert_in_delta(23.5, pt[3].y, 0.001)
+  end
+end
+
+

data/test/test_cvcapture.rb

@@ -0,0 +1,183 @@
+#!/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::CvCapture
+class TestCvCapture < OpenCVTestCase
+  def setup
+    @cap = CvCapture.open(AVI_SAMPLE)
+    @cap.query
+  end
+
+  def teardown
+    @cap = nil
+  end
+
+  def test_INTERFACE
+    assert_equal(CvCapture::INTERFACE[:any], 0)
+    assert_equal(CvCapture::INTERFACE[:mil], 100)
+    assert_equal(CvCapture::INTERFACE[:vfw], 200)
+    assert_equal(CvCapture::INTERFACE[:v4l], 200)
+    assert_equal(CvCapture::INTERFACE[:v4l2], 200)
+    assert_equal(CvCapture::INTERFACE[:fireware], 300)
+    assert_equal(CvCapture::INTERFACE[:ieee1394], 300)
+    assert_equal(CvCapture::INTERFACE[:dc1394], 300)
+    assert_equal(CvCapture::INTERFACE[:cmu1394], 300)
+    assert_equal(CvCapture::INTERFACE[:stereo], 400)
+    assert_equal(CvCapture::INTERFACE[:tyzx], 400)
+    assert_equal(CvCapture::INTERFACE[:tyzx_left], 400)
+    assert_equal(CvCapture::INTERFACE[:tyzx_right], 401)
+    assert_equal(CvCapture::INTERFACE[:tyzx_color], 402)
+    assert_equal(CvCapture::INTERFACE[:tyzx_z], 403)
+    assert_equal(CvCapture::INTERFACE[:qt], 500)
+    assert_equal(CvCapture::INTERFACE[:quicktime], 500)
+  end
+
+  def test_open
+    cap1 = CvCapture.open(AVI_SAMPLE)
+    assert_equal(CvCapture, cap1.class)
+
+    # Uncomment the following lines to test capturing from camera
+    # cap2 = CvCapture.open(0)
+    # assert_equal(CvCapture, cap2.class)
+    # CvCapture::INTERFACE.each { |k, v|
+    #   cap3 = CvCapture.open(k)
+    #   assert_equal(CvCapture, cap3.class)
+    # }
+  end
+
+  def test_grab
+    assert(@cap.grab)
+  end
+
+  def test_retrieve
+    @cap.grab
+    img = @cap.retrieve
+    assert_equal(IplImage, img.class)
+  end
+
+  def test_query
+    img = @cap.query
+    assert_equal(IplImage, img.class)
+  end
+
+  def test_millisecond
+    @cap.millisecond = 10
+    assert(@cap.millisecond.is_a? Numeric)
+    # assert_equal(10, @cap.millisecond)
+    @cap.millisecond = 20
+    assert(@cap.millisecond.is_a? Numeric)
+    # assert_equal(20, @cap.millisecond)
+  end
+
+  def test_frames
+    @cap.frames = 10
+    assert(@cap.frames.is_a? Numeric)
+    # assert_equal(10, @cap.frames)
+    @cap.frames = 20
+    assert(@cap.frames.is_a? Numeric)
+    # assert_equal(20, @cap.frames)
+  end
+
+  def test_avi_ratio
+    @cap.avi_ratio = 0.1
+    assert(@cap.avi_ratio.is_a? Numeric)
+    # assert_equal(0.1, @cap.avi_ratio)
+    @cap.avi_ratio = 0.8
+    assert(@cap.avi_ratio.is_a? Numeric)
+    # assert_equal(0.8, @cap.avi_ratio)
+  end
+
+  def test_size
+    @cap.size = CvSize.new(320, 240)
+    assert_equal(CvSize, @cap.size.class)
+    # assert_equal(320, @cap.size.width)
+    # assert_equal(240, @cap.size.height)
+
+    @cap.size = CvSize.new(640, 480)
+    assert_equal(CvSize, @cap.size.class)
+    # assert_equal(640, @cap.size.width)
+    # assert_equal(480, @cap.size.height)
+  end
+
+  def test_width
+    @cap.width = 320
+    assert(@cap.width.is_a? Numeric)
+    # assert_equal(320, @cap.width)
+    @cap.width = 640
+    assert(@cap.width.is_a? Numeric)
+    # assert_equal(640, @cap.width)
+  end
+
+  def test_height
+    @cap.height = 240
+    assert(@cap.height.is_a? Numeric)
+    # assert_equal(240, @cap.height)
+    @cap.height = 480
+    assert(@cap.height.is_a? Numeric)
+    # assert_equal(480, @cap.height)
+  end
+
+  def test_fps
+    @cap.fps = 15
+    assert(@cap.fps.is_a? Numeric)
+    # assert_equal(15, @cap.fps)
+    @cap.fps = 30
+    assert(@cap.fps.is_a? Numeric)
+    # assert_equal(30, @cap.fps)
+  end
+
+  def test_fourcc
+    assert_equal(String, @cap.fourcc.class)
+  end
+
+  def test_frame_count
+    assert(@cap.frame_count.is_a? Numeric)
+  end
+
+  def test_format
+    assert(@cap.format.is_a? Numeric)
+  end
+
+  def test_mode
+    assert(@cap.mode.is_a? Numeric)
+  end
+
+  def test_brightness
+    assert(@cap.brightness.is_a? Numeric)
+  end
+
+  def test_contrast
+    assert(@cap.contrast.is_a? Numeric)
+  end
+
+  def test_saturation
+    assert(@cap.saturation.is_a? Numeric)
+  end
+
+  def test_hue
+    assert(@cap.hue.is_a? Numeric)
+  end
+
+  def test_gain
+    assert(@cap.gain.is_a? Numeric)
+  end
+
+  def test_exposure
+    assert(@cap.exposure.is_a? Numeric)
+  end
+
+  def test_convert_rgb
+    assert((@cap.convert_rgb == true) ||
+           (@cap.convert_rgb == false))
+  end
+
+  def test_rectification
+    assert(@cap.rectification.is_a? Numeric)
+  end
+end
+

data/test/test_cvchain.rb

@@ -0,0 +1,108 @@
+#!/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::CvChain
+class TestCvChain < OpenCVTestCase
+  def test_APPROX_OPTION
+    assert_equal(:approx_simple, CvChain::APPROX_CHAIN_OPTION[:method])
+    assert_equal(0, CvChain::APPROX_CHAIN_OPTION[:parameter])
+    assert_equal(0, CvChain::APPROX_CHAIN_OPTION[:minimal_perimeter])
+    assert_false(CvChain::APPROX_CHAIN_OPTION[:recursive])
+  end
+  
+  def test_initialize
+    chain = CvChain.new
+    assert_not_nil(chain)
+    assert_equal(CvChain, chain.class)
+    assert(chain.is_a? CvSeq)
+  end
+
+  def test_origin
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    chain = mat0.find_contours(:mode => CV_RETR_EXTERNAL, :method => CV_CHAIN_CODE)
+    assert_equal(CvChain, chain.class)
+    assert_equal(64, chain.origin.x)
+    assert_equal(32, chain.origin.y)
+
+    chain.origin = CvPoint.new(32, 64)
+    assert_equal(32, chain.origin.x)
+    assert_equal(64, chain.origin.y)
+  end
+
+  def test_codes
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    chain = mat0.find_contours(:mode => CV_RETR_EXTERNAL, :method => CV_CHAIN_CODE)
+    assert_equal(Array, chain.codes.class)
+    assert(chain.codes.all? { |a| (a.class == Fixnum) and (a >= 0 and a <= 7) })
+  end
+
+  def test_points
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    chain = mat0.find_contours(:mode => CV_RETR_EXTERNAL, :method => CV_CHAIN_CODE)
+    assert_equal(Array, chain.points.class)
+    assert(chain.points.all? { |a| a.class == CvPoint })
+  end
+
+  def test_approx_chains
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    chain = mat0.find_contours(:mode => CV_RETR_EXTERNAL, :method => CV_CHAIN_CODE)
+
+    contours = chain.approx_chains
+    assert_equal(CvChain, contours.class)
+    assert(contours.size > 0)
+    assert(contours.all? { |c| c.class == CvPoint })
+
+    [CV_CHAIN_APPROX_NONE, CV_CHAIN_APPROX_SIMPLE,
+     CV_CHAIN_APPROX_TC89_L1, CV_CHAIN_APPROX_TC89_KCOS,
+     :approx_none, :approx_simple, :approx_tc89_l1, :approx_tc89_kcos].each { |method|
+      contours = chain.approx_chains(:method => method)
+      assert_equal(CvChain, contours.class)
+      assert(contours.size > 0)
+      assert(contours.all? { |c| c.class == CvPoint })
+    }
+
+    contours = chain.approx_chains(:minimal_parameter => 10)
+    assert_equal(CvChain, contours.class)
+    assert(contours.size > 0)
+    assert(contours.all? { |c| c.class == CvPoint })
+
+    contours = chain.approx_chains(:minimal_perimeter => (32 * 2 * Math::PI).ceil)
+    assert_nil(contours)
+
+    [true, false].each { |recursive|
+      contours = chain.approx_chains(:recursive => recursive)
+      assert_equal(CvChain, contours.class)
+      assert(contours.size > 0)
+      assert(contours.all? { |c| c.class == CvPoint })
+    }
+
+    contours = chain.approx_chains(:method => :approx_simple,
+                                  :minimal_parameter => 100, :recursive => false)
+    assert_equal(CvChain, contours.class)
+    assert(contours.size > 0)
+    assert(contours.all? { |c| c.class == CvPoint })
+
+    # Uncomment the following lines to show the result
+    # contours = chain.approx_chains
+    # dst = mat0.clone.zero
+    # begin
+    #   dst.draw_contours!(contours, CvColor::White, CvColor::Black, 2,
+    #                      :thickness => 1, :line_type => :aa)
+    # end while (contours = contours.h_next)
+    # snap dst
+  end
+end
+

data/test/test_cvcircle32f.rb

@@ -0,0 +1,41 @@
+#!/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::CvCircle32f
+class TestCvCircle32f < OpenCVTestCase
+  def setup
+    @circle = CvCircle32f.new
+  end
+  
+  def test_initialize
+    assert_equal(CvCircle32f, @circle.class)
+  end
+
+  def test_center
+    assert_equal(CvPoint2D32f, @circle.center.class)
+  end
+
+  def test_radius
+    assert_equal(Float, @circle.radius.class)
+  end
+
+  def test_aref
+    assert_equal(Float, @circle[0].class)
+    assert_equal(Float, @circle[1].class)
+    assert_equal(Float, @circle[2].class)
+    assert_raise(IndexError) {
+      @circle[3]
+    }
+  end
+
+  def test_to_ary
+    assert_equal(Array, @circle.to_ary.class)
+    assert_equal(2, @circle.to_ary.size)
+  end
+end
+

data/test/test_cvconnectedcomp.rb

@@ -0,0 +1,61 @@
+#!/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::CvConnectedComp
+class TestCvConnectedComp < OpenCVTestCase
+  def setup
+    @connected_comp = CvConnectedComp.new(9216, CvScalar.new(1, 2, 3, 4),
+                                          CvRect.new(1, 2, 3, 4), CvSeq.new(CvPoint))
+  end
+  
+  def test_initialize
+    connected_comp = CvConnectedComp.new
+    assert_equal(CvConnectedComp, connected_comp.class)
+    assert_not_nil(connected_comp.area)
+    assert_not_nil(connected_comp.value)
+    assert_not_nil(connected_comp.rect)
+    assert_not_nil(connected_comp.contour)
+
+    connected_comp = CvConnectedComp.new(100, CvScalar.new(1, 2, 3, 4),
+                                         CvRect.new(1, 2, 3, 4), CvSeq.new(CvPoint))
+    assert_equal(CvConnectedComp, connected_comp.class)
+    assert_not_nil(connected_comp.area)
+    assert_not_nil(connected_comp.value)
+    assert_not_nil(connected_comp.rect)
+    assert_not_nil(connected_comp.contour)
+  end
+
+  def test_area
+    assert_in_delta(9216.0, @connected_comp.area, 0.01)
+  end
+
+  def test_value
+    assert_equal(CvScalar, @connected_comp.value.class)
+    assert_cvscalar_equal(CvScalar.new(1, 2, 3, 4), @connected_comp.value)
+  end
+
+  def test_rect
+    assert_equal(CvRect, @connected_comp.rect.class)
+    assert_equal(1, @connected_comp.rect.x)
+    assert_equal(2, @connected_comp.rect.y)
+    assert_equal(3, @connected_comp.rect.width)
+    assert_equal(4, @connected_comp.rect.height)
+
+    @connected_comp.rect = CvRect.new(10, 20, 30, 40);
+    assert_equal(10, @connected_comp.rect.x)
+    assert_equal(20, @connected_comp.rect.y)
+    assert_equal(30, @connected_comp.rect.width)
+    assert_equal(40, @connected_comp.rect.height)
+  end
+
+  def test_contour
+    assert_equal(CvContour, @connected_comp.contour.class)
+    assert_not_nil(@connected_comp.contour)
+  end
+end
+