afeld-opencv 0.0.8

data/test/test_cvsize2d32f.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::CvSize2D32f
+class TestCvSize2D32f < OpenCVTestCase
+  class MySize; end
+
+  def test_width
+    size = CvSize2D32f.new
+    size.width = 1.1
+    assert_in_delta(1.1, size.width, 0.001)
+    size.width = 2.2
+    assert_in_delta(2.2, size.width, 0.001)
+  end
+
+  def test_height
+    size = CvSize2D32f.new
+    size.height = 1.1
+    assert_in_delta(1.1, size.height, 0.001)
+    size.height = 2.2
+    assert_in_delta(2.2, size.height, 0.001)
+  end
+
+  def test_compatible
+    assert(!(CvSize2D32f.compatible? MySize.new))
+    MySize.class_eval { def width; end }
+    assert(!(CvSize2D32f.compatible? MySize.new))
+    MySize.class_eval { def height; end }
+    assert(CvSize2D32f.compatible? MySize.new)
+    assert(CvSize2D32f.compatible? CvSize2D32f.new)
+  end
+
+  def test_initialize
+    size = CvSize2D32f.new
+    assert_in_delta(0, size.width, 0.001)
+    assert_in_delta(0, size.height, 0.001)
+
+    size = CvSize2D32f.new(1.1, 2.2)
+    assert_in_delta(1.1, size.width, 0.001)
+    assert_in_delta(2.2, size.height, 0.001)
+
+    size = CvSize2D32f.new(CvSize2D32f.new(1.1, 2.2))
+    assert_in_delta(1.1, size.width, 0.001)
+    assert_in_delta(2.2, size.height, 0.001)
+
+    assert_raise(TypeError) {
+      CvSize2D32f.new(DUMMY_OBJ)
+    }
+    assert_raise(ArgumentError) {
+      CvSize2D32f.new(1, 2, 3)
+    }
+  end
+
+  def test_to_s
+    size = CvSize2D32f.new(1.1, 2.2)
+    assert_equal('<OpenCV::CvSize2D32f:1.1x2.2>', size.to_s)
+  end
+
+  def test_to_ary
+    a = CvSize2D32f.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 = CvSize2D32f.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_cvslice.rb

@@ -0,0 +1,31 @@
+#!/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::CvSlice
+class TestCvSlice < OpenCVTestCase
+  def setup
+    @slice = CvSlice.new(2, 4)
+  end
+
+  def test_initialize
+    assert_equal(CvSlice, @slice.class)
+  end
+
+  def test_start_index
+    assert_equal(2, @slice.start_index)
+    @slice.start_index = 3
+    assert_equal(3, @slice.start_index)
+  end
+
+  def test_end_index
+    assert_equal(4, @slice.end_index)
+    @slice.end_index = 5
+    assert_equal(5, @slice.end_index)
+  end
+end
+

data/test/test_cvsurfparams.rb

@@ -0,0 +1,57 @@
+#!/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::CvSURFParams
+class TestCvSURFParams < OpenCVTestCase
+  def setup
+    @surf_param1 = CvSURFParams.new(345.6)
+  end
+  
+  def test_initialize
+    sp1 = CvSURFParams.new(345.6)
+    assert_equal(false, sp1.extended)
+    assert_in_delta(345.6, sp1.hessian_threshold, 0.001)
+    assert_equal(3, sp1.n_octaves)
+    assert_equal(4, sp1.n_octave_layers)
+
+    sp2 = CvSURFParams.new(456.7, true, 4, 5)
+    assert_equal(true, sp2.extended)
+    assert_in_delta(456.7, sp2.hessian_threshold, 0.001)
+    assert_equal(4, sp2.n_octaves)
+    assert_equal(5, sp2.n_octave_layers)
+  end
+
+  def test_extended
+    assert_equal(false, @surf_param1.extended)
+
+    @surf_param1.extended = true
+    assert_equal(true, @surf_param1.extended)
+  end
+
+  def test_hessian_threshold
+    assert_in_delta(345.6, @surf_param1.hessian_threshold, 0.001)
+
+    @surf_param1.hessian_threshold = 456.7
+    assert_in_delta(456.7, @surf_param1.hessian_threshold, 0.001)
+  end
+
+  def test_n_octaves
+    assert_equal(3, @surf_param1.n_octaves)
+
+    @surf_param1.n_octaves = 4
+    assert_equal(4, @surf_param1.n_octaves)
+  end
+
+  def test_n_octave_layers
+    assert_equal(4, @surf_param1.n_octave_layers)
+
+    @surf_param1.n_octave_layers = 5
+    assert_equal(5, @surf_param1.n_octave_layers)
+  end
+end
+

data/test/test_cvsurfpoint.rb

@@ -0,0 +1,66 @@
+#!/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::CvSURFPoint
+class TestCvSURFPoint < OpenCVTestCase
+  def setup
+    @surf_point1 = CvSURFPoint.new(CvPoint2D32f.new(0, 0), 0, 0, 0, 0)
+  end
+  
+  def test_initialize
+    sp1 = CvSURFPoint.new(CvPoint2D32f.new(1.1, 2.2), 1, 10, 12.3, 45.6)
+    assert_in_delta(1.1, sp1.pt.x, 0.001)
+    assert_in_delta(2.2, sp1.pt.y, 0.001)
+    assert_equal(1, sp1.laplacian)
+    assert_equal(10, sp1.size)
+    assert_in_delta(12.3, sp1.dir, 0.001)
+    assert_in_delta(45.6, sp1.hessian, 0.001)
+  end
+
+  def test_pt
+    assert_in_delta(0, @surf_point1.pt.x, 0.001)
+    assert_in_delta(0, @surf_point1.pt.y, 0.001)
+
+    @surf_point1.pt = CvPoint2D32f.new(12.3, 45.6)
+    assert_in_delta(12.3, @surf_point1.pt.x, 0.001)
+    assert_in_delta(45.6, @surf_point1.pt.y, 0.001)
+
+    assert_raise(TypeError) {
+      @surf_point1.pt = DUMMY_OBJ
+    }
+  end
+
+  def test_laplacian
+    assert_equal(0, @surf_point1.laplacian)
+
+    @surf_point1.laplacian = -1
+    assert_equal(-1, @surf_point1.laplacian)
+  end
+
+  def test_size
+    assert_equal(0, @surf_point1.size)
+    
+    @surf_point1.size = 10
+    assert_equal(10, @surf_point1.size)
+  end
+
+  def test_dir
+    assert_in_delta(0, @surf_point1.dir, 0.001)
+
+    @surf_point1.dir = 23.4
+    assert_in_delta(23.4, @surf_point1.dir, 0.001)
+  end
+
+  def test_hessian
+    assert_in_delta(0, @surf_point1.hessian, 0.001)
+
+    @surf_point1.hessian = 2.1
+    assert_in_delta(2.1, @surf_point1.hessian, 0.001)
+  end
+end
+

data/test/test_cvtermcriteria.rb

@@ -0,0 +1,56 @@
+#!/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::CvTermCriteria
+class TestCvTermCriteria < OpenCVTestCase
+  def setup
+    @criteria1 = CvTermCriteria.new
+    @criteria2 = CvTermCriteria.new(100)
+    @criteria3 = CvTermCriteria.new(nil, 0.01)
+    @criteria4 = CvTermCriteria.new(100, 0.01)
+  end
+  
+  def test_initialize
+    assert_not_nil(@criteria1)
+    assert_equal(CvTermCriteria, @criteria1.class)
+    assert_not_nil(@criteria2)
+    assert_equal(CvTermCriteria, @criteria2.class)
+    assert_not_nil(@criteria3)
+    assert_equal(CvTermCriteria, @criteria3.class)
+    assert_not_nil(@criteria4)
+    assert_equal(CvTermCriteria, @criteria4.class)
+  end
+
+  def test_type
+    assert_equal(0, @criteria1.type)
+    assert_equal(CV_TERMCRIT_ITER, @criteria2.type)
+    assert_equal(CV_TERMCRIT_EPS, @criteria3.type)
+    assert_equal(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, @criteria4.type)
+  end
+
+  def test_max
+    assert_nil(@criteria1.max)
+    assert_equal(100, @criteria2.max)
+    assert_nil(@criteria3.max)
+    assert_equal(100, @criteria4.max)
+
+    @criteria1.max = 999
+    assert_equal(999, @criteria1.max)
+  end
+
+  def test_eps
+    assert_nil(@criteria1.eps)
+    assert_nil(@criteria2.eps)
+    assert_in_delta(0.01, @criteria3.eps, 0.001)
+    assert_in_delta(0.01, @criteria4.eps, 0.001)
+
+    @criteria1.eps = 3.14
+    assert_in_delta(3.14, @criteria1.eps, 0.001)
+  end
+end
+

data/test/test_cvtwopoints.rb

@@ -0,0 +1,40 @@
+#!/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::CvTwoPoints
+class TestCvTwoPoints < OpenCVTestCase
+  def setup
+    @twopoints = CvTwoPoints.new
+  end
+  
+  def test_initialize
+    assert_not_nil(@twopoints)
+    assert_equal(CvTwoPoints, @twopoints.class)
+  end
+
+  def test_point
+    assert_not_nil(@twopoints.point1)
+    assert_not_nil(@twopoints.point2)
+    assert_equal(CvPoint, @twopoints.point1.class)
+    assert_equal(CvPoint, @twopoints.point2.class)
+  end
+
+  def test_aref
+    assert_not_nil(@twopoints[0])
+    assert_not_nil(@twopoints[1])
+    assert_equal(CvPoint, @twopoints[0].class)
+    assert_equal(CvPoint, @twopoints[1].class)
+  end
+
+  def test_to_ary
+    assert_equal(Array, @twopoints.to_ary.class)
+    assert_equal(2, @twopoints.to_ary.size)
+    assert_equal(2, @twopoints.to_a.size)
+  end
+end
+

data/test/test_cvvideowriter.rb

@@ -0,0 +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::CvVideoWriter
+class TestCvVideoWriter < OpenCVTestCase
+  OUTPUT_FILENAME = 'videowriter_result.avi'
+  
+  def test_initialize
+    vw = CvVideoWriter.new(OUTPUT_FILENAME, 'MJPG', 15, CvSize.new(320, 240))
+    assert_equal(CvVideoWriter, vw.class)
+    vw.close
+
+    vw = CvVideoWriter.new(OUTPUT_FILENAME, 'MJPG', 15, CvSize.new(320, 240), false)
+    assert_equal(CvVideoWriter, vw.class)
+    vw.close
+
+    ## Supported only Windows(?)
+    # vw = CvVideoWriter.new(OUTPUT_FILENAME, nil, 15, CvSize.new(320, 240), false)
+    # assert_equal(CvVideoWriter, vw.class)
+    # vw.close
+
+    CvVideoWriter.new(OUTPUT_FILENAME, 'MJPG', 15, CvSize.new(320, 240)) { |vw|
+      assert_equal(CvVideoWriter, vw.class)      
+    }
+
+    assert_raise(TypeError) {
+      vw = CvVideoWriter.new(123, 'MJPG', 15, CvSize.new(320, 240), false)
+    }
+  end
+
+  def test_write
+    img = IplImage.load(FILENAME_LENA256x256)
+    vw = CvVideoWriter.new(OUTPUT_FILENAME, 'MJPG', 15, CvSize.new(256, 256))
+    vw.write img
+    vw.close
+
+    CvVideoWriter.new(OUTPUT_FILENAME, 'MJPG', 15, CvSize.new(256, 256)) { |vw|
+      vw.write img
+    }
+    
+    assert_raise(TypeError) {
+      CvVideoWriter.new(OUTPUT_FILENAME, 'MJPG', 15, CvSize.new(256, 256)) { |vw|
+        vw.write DUMMY_OBJ
+      }
+    }
+  end
+
+  def test_close
+    vw = CvVideoWriter.new(OUTPUT_FILENAME, 'MJPG', 15, CvSize.new(320, 240))
+    vw.close
+  end
+end
+

data/test/test_iplconvkernel.rb

@@ -0,0 +1,54 @@
+#!/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::IplConvKernel
+class TestIplConvKernel < OpenCVTestCase
+  def test_initialize
+    [:rect, :cross, :ellipse, CV_SHAPE_RECT, CV_SHAPE_CROSS, CV_SHAPE_ELLIPSE].each { |shape|
+      kernel = IplConvKernel.new(5, 5, 2, 2, shape)
+      assert_not_nil(kernel)
+    }
+
+    values = [1] * 25
+    [:custom, CV_SHAPE_CUSTOM].each { |shape|
+      kernel = IplConvKernel.new(5, 5, 2, 2, shape, values)
+      assert_not_nil(kernel)
+    }
+
+    [:custom, CV_SHAPE_CUSTOM].each { |shape|
+      assert_raise(ArgumentError) {
+        IplConvKernel.new(5, 5, 2, 2, shape)
+      }
+    }
+
+    assert_raise(TypeError) {
+      IplConvKernel.new(5, 5, 2, 2, :foobar)
+    }
+  end
+
+  def test_size
+    kernel = IplConvKernel.new(5, 4, 2, 2, :rect)
+    size = kernel.size
+    assert_equal(5, size.width)
+    assert_equal(4, size.height)
+
+    assert_equal(5, kernel.cols)
+    assert_equal(4, kernel.rows)
+  end
+
+  def test_anchor
+    kernel = IplConvKernel.new(5, 4, 3, 2, :rect)
+    a = kernel.anchor
+    assert_equal(3, a.x)
+    assert_equal(2, a.y)
+
+    assert_equal(3, kernel.anchor_x)
+    assert_equal(2, kernel.anchor_y)
+  end
+end
+

data/test/test_iplimage.rb

@@ -0,0 +1,156 @@
+#!/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::IplImage
+class TestIplImage < OpenCVTestCase
+  def should_classify_images_as(filename, classification)
+    assert_equal(OpenCV::IplImage::load(filename, OpenCV::CV_LOAD_IMAGE_GRAYSCALE).smoothness[0], classification)
+  end
+
+  def test_initialize
+    img = IplImage.new(10, 20)
+    assert_equal(10, img.width)
+    assert_equal(20, img.height)
+    assert_equal(:cv8u, img.depth)
+    assert_equal(3, img.channel)
+
+    img = IplImage.new(30, 40, :cv32f, 1)
+    assert_equal(30, img.width)
+    assert_equal(40, img.height)
+    assert_equal(:cv32f, img.depth)
+    assert_equal(1, img.channel)
+  end
+
+  def test_load
+    img = IplImage.load(FILENAME_CAT)
+    assert_equal(IplImage, img.class)
+    assert_equal(375, img.width)
+    assert_equal(500, img.height)
+    assert_equal(:cv8u, img.depth)
+    assert_equal(3, img.channel)
+    assert_equal('f2e4dc5d6d3fc285203762ff53d150c7', hash_img(img))
+
+    img = IplImage.load(FILENAME_CAT, CV_LOAD_IMAGE_GRAYSCALE)
+    assert_equal(IplImage, img.class)
+    assert_equal(375, img.width)
+    assert_equal(500, img.height)
+    assert_equal(:cv8u, img.depth)
+    assert_equal(1, img.channel)
+    # The following test fails only when executed by test runner. (I don't know why...)
+    #   $ ruby test/runner.rb #=> fail
+    #   $ ruby test/test_iplimage.rb #=> pass
+    assert_equal('b1a0c1c5504961b62e15fa7d57a2e7e0', hash_img(img))
+
+    img = IplImage.load(FILENAME_CAT, CV_LOAD_IMAGE_ANYDEPTH | CV_LOAD_IMAGE_ANYCOLOR)
+    assert_equal(IplImage, img.class)
+    assert_equal(375, img.width)
+    assert_equal(500, img.height)
+    assert_equal(:cv8u, img.depth)
+    assert_equal(3, img.channel)
+    assert_equal('f2e4dc5d6d3fc285203762ff53d150c7', hash_img(img))
+
+    assert_raise(ArgumentError) {
+      IplImage.load
+    }
+    assert_raise(TypeError) {
+      IplImage.load(123)
+    }
+    assert_raise(TypeError) {
+      IplImage.load(FILENAME_CAT, 'foobar')
+    }
+    assert_raise(StandardError) {
+      IplImage.load('file/does/not/exist')
+    }
+  end
+
+  def test_roi
+    img = IplImage.new(20, 30)
+    rect = img.roi
+    assert_equal(0, rect.x)
+    assert_equal(0, rect.y)
+    assert_equal(img.width, rect.width)
+    assert_equal(img.height, rect.height)
+
+    img.set_roi(CvRect.new(2, 3, 10, 20))
+    rect = img.roi
+    assert_equal(2, rect.x)
+    assert_equal(3, rect.y)
+    assert_equal(10, rect.width)
+    assert_equal(20, rect.height)
+
+    img.reset_roi
+    rect = img.roi
+    assert_equal(0, rect.x)
+    assert_equal(0, rect.y)
+    assert_equal(img.width, rect.width)
+    assert_equal(img.height, rect.height)
+
+    img.set_roi(CvRect.new(1, 2, 5, 6)) {|image|
+      rect = image.roi
+      assert_equal(1, rect.x)
+      assert_equal(2, rect.y)
+      assert_equal(5, rect.width)
+      assert_equal(6, rect.height)
+    }
+    rect = img.roi
+    assert_equal(0, rect.x)
+    assert_equal(0, rect.y)
+    assert_equal(img.width, rect.width)
+    assert_equal(img.height, rect.height)
+
+    # Alias
+    img.roi = CvRect.new(4, 5, 11, 12)
+    rect = img.roi
+    assert_equal(4, rect.x)
+    assert_equal(5, rect.y)
+    assert_equal(11, rect.width)
+    assert_equal(12, rect.height)
+  end
+
+  def test_coi
+    img = IplImage.new(20, 30)
+    assert_equal(0, img.coi)
+
+    img.set_coi(1)
+    assert_equal(1, img.coi)
+
+    img.reset_coi
+    assert_equal(0, img.coi)
+
+    img.set_coi(2) {|image|
+      assert_equal(2, image.coi)
+    }
+    assert_equal(0, img.coi)
+
+    # Alias
+    img.coi = 1
+    assert_equal(1, img.coi)
+  end
+
+  def test_smoothness
+    asset_path = File.join(File.dirname(__FILE__), 'samples')
+
+    for image in Array.new(7) { |e| e = File.join(asset_path, "smooth%d.jpg") % e } do
+      should_classify_images_as image, :smooth
+    end
+
+    for image in Array.new(2) { |e| e = File.join(asset_path, "messy%d.jpg") % e } do
+      should_classify_images_as image, :messy
+    end
+
+    for image in Array.new(10) { |e| e = File.join(asset_path, "blank%d.jpg") % e } do
+      should_classify_images_as image, :blank
+    end
+
+    for image in Array.new(2) { |e| e = File.join(asset_path, "partially_blank%d.jpg") % e } do
+      should_classify_images_as image, :blank
+    end
+  end
+end
+
+