bonanza-ruby-opencv 0.0.13.20140330211753

data/test/test_cvsize2d32f.rb

@@ -0,0 +1,75 @@
+#!/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::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 -*-
+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 -*-
+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 -*-
+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 -*-
+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 -*-
+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 -*-
+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_eigenfaces.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8-unix -*- 
+require 'test/unit'
+require 'opencv'
+require 'date'
+require File.expand_path(File.dirname(__FILE__)) + '/helper'
+
+include OpenCV
+
+# Tests for OpenCV::EigenFaces
+class TestEigenFaces < OpenCVTestCase
+  def setup
+    @eigenfaces = EigenFaces.new
+
+    @eigenfaces_trained = EigenFaces.new
+    @images = [CvMat.load(FILENAME_LENA256x256, CV_LOAD_IMAGE_GRAYSCALE)] * 2
+    @labels = [1, 2]
+    @eigenfaces_trained.train(@images, @labels)
+  end
+
+  def test_initialize
+    [EigenFaces.new, EigenFaces.new(1), EigenFaces.new(1, 99999)].each { |ef|
+      assert_equal(EigenFaces, ef.class)
+    }
+
+    assert_raise(TypeError) {
+      EigenFaces.new(DUMMY_OBJ)
+    }
+
+    assert_raise(TypeError) {
+      EigenFaces.new(1, DUMMY_OBJ)
+    }
+  end
+
+  def test_train
+    assert_nil(@eigenfaces.train(@images, @labels))
+
+    assert_raise(TypeError) {
+      @eigenfaces.train(DUMMY_OBJ, @labels)
+    }
+
+    assert_raise(TypeError) {
+      @eigenfaces.train(@images, DUMMY_OBJ)
+    }
+  end
+
+  def test_predict
+    predicted_label, predicted_confidence = @eigenfaces_trained.predict(@images[0])
+    assert_equal(@labels[0], predicted_label)
+    assert_in_delta(0.0, predicted_confidence, 0.01)
+
+    assert_raise(TypeError) {
+      @eigenfaces_trained.predict(DUMMY_OBJ)
+    }
+  end
+
+  def test_save
+    filename = "eigenfaces_save-#{DateTime.now.strftime('%Y%m%d%H%M%S')}.xml"
+    begin
+      @eigenfaces_trained.save(filename)
+      assert(File.exist? filename)
+    ensure
+      File.delete filename
+    end
+    assert_raise(TypeError) {
+      @eigenfaces_trained.save(DUMMY_OBJ)
+    }
+  end
+
+  def test_load
+    assert_nothing_raised {
+      @eigenfaces_trained.load('eigenfaces_save.xml')
+    }
+    assert_raise(TypeError) {
+      @eigenfaces_trained.load(DUMMY_OBJ)
+    }
+  end
+
+  def test_name
+    assert_equal('FaceRecognizer.Eigenfaces', @eigenfaces.name)
+  end
+
+  def test_get_mat
+    mat = @eigenfaces_trained.get_mat('eigenvalues')
+    assert_not_nil(mat)
+    assert_equal(CvMat, mat.class)
+
+    assert_raise(TypeError) {
+      @eigenfaces_trained.get_mat(DUMMY_OBJ)
+    }
+  end
+end
+