2011-01-01 13:04:27 -05:00
|
|
|
#!/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
|
2011-05-21 02:57:44 -04:00
|
|
|
SAMPLE_DIR = File.expand_path(File.dirname(__FILE__)) + '/samples/'
|
|
|
|
FILENAME_CAT = SAMPLE_DIR + 'cat.jpg'
|
|
|
|
FILENAME_LENA256x256 = SAMPLE_DIR + 'lena-256x256.jpg'
|
2011-10-22 17:15:31 -04:00
|
|
|
FILENAME_LENA32x32 = SAMPLE_DIR + 'lena-32x32.jpg'
|
|
|
|
FILENAME_LENA_EYES = File.expand_path(File.dirname(__FILE__)) + '/samples/lena-eyes.jpg'
|
2011-08-21 12:21:51 -04:00
|
|
|
FILENAME_FRUITS = SAMPLE_DIR + 'fruits.jpg'
|
2012-04-05 12:48:32 -04:00
|
|
|
FILENAME_CONTOURS = File.expand_path(File.dirname(__FILE__)) + '/samples/contours.jpg'
|
2012-11-15 10:31:39 -05:00
|
|
|
FILENAME_CHESSBOARD = SAMPLE_DIR + 'chessboard.jpg'
|
2011-05-21 02:57:44 -04:00
|
|
|
HAARCASCADE_FRONTALFACE_ALT = SAMPLE_DIR + 'haarcascade_frontalface_alt.xml.gz'
|
2011-05-28 14:36:09 -04:00
|
|
|
AVI_SAMPLE = SAMPLE_DIR + 'movie_sample.avi'
|
2012-04-05 12:48:32 -04:00
|
|
|
|
2011-06-28 13:25:51 -04:00
|
|
|
DUMMY_OBJ = Digest::MD5.new # dummy object for argument type check test
|
|
|
|
|
2011-01-01 13:04:27 -05:00
|
|
|
def snap(*images)
|
2011-01-15 14:29:15 -05:00
|
|
|
n = -1
|
|
|
|
images.map! { |val|
|
|
|
|
n += 1
|
|
|
|
if val.is_a? Hash
|
|
|
|
val
|
|
|
|
elsif val.is_a? Array
|
|
|
|
{:title => val[0], :image => val[1] }
|
|
|
|
else
|
|
|
|
{:title => "snap-#{n}", :image => val }
|
|
|
|
end
|
|
|
|
}
|
|
|
|
|
|
|
|
pos = CvPoint.new(0, 0)
|
|
|
|
images.each { |img|
|
|
|
|
w = GUI::Window.new(img[:title])
|
|
|
|
w.show(img[:image])
|
|
|
|
w.move(pos)
|
|
|
|
pos.x += img[:image].width
|
|
|
|
if pos.x > 800
|
|
|
|
pos.y += img[:image].height
|
|
|
|
pos.x = 0
|
|
|
|
end
|
|
|
|
}
|
2011-01-01 13:04:27 -05:00
|
|
|
|
|
|
|
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
|
|
|
|
|
2011-02-14 14:05:26 -05:00
|
|
|
unless Test::Unit::TestCase.instance_methods.map {|m| m.to_sym }.include? :assert_false
|
|
|
|
def assert_false(actual, message = nil)
|
|
|
|
assert_equal(false, actual, message)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2011-01-01 13:04:27 -05:00
|
|
|
alias original_assert_in_delta assert_in_delta
|
|
|
|
|
|
|
|
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|
|
2011-01-03 01:46:21 -05:00
|
|
|
m[j, i] = block.call(j, i, count)
|
2011-01-01 13:04:27 -05:00
|
|
|
count += 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
m
|
|
|
|
end
|
2011-01-02 23:47:47 -05:00
|
|
|
|
2012-03-01 12:15:06 -05:00
|
|
|
def create_iplimage(width, height, depth = :cv8u, channel = 4, &block)
|
|
|
|
m = IplImage.new(width, height, depth, channel)
|
|
|
|
block = lambda { |j, i, c| CvScalar.new(*([c + 1] * channel)) } unless block_given?
|
|
|
|
count = 0
|
|
|
|
height.times { |j|
|
|
|
|
width.times { |i|
|
|
|
|
m[j, i] = block.call(j, i, count)
|
|
|
|
count += 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
m
|
|
|
|
end
|
|
|
|
|
2011-01-03 00:21:38 -05:00
|
|
|
def assert_each_cvscalar(actual, delta = 0, &block)
|
2011-01-02 23:47:47 -05:00
|
|
|
raise unless block_given?
|
|
|
|
count = 0
|
|
|
|
actual.height.times { |j|
|
|
|
|
actual.width.times { |i|
|
|
|
|
expected = block.call(j, i, count)
|
|
|
|
if delta == 0
|
|
|
|
expected = expected.to_ary if expected.is_a? CvScalar
|
2011-01-03 01:46:21 -05:00
|
|
|
assert_array_equal(expected, actual[j, i].to_ary)
|
2011-01-02 23:47:47 -05:00
|
|
|
else
|
2011-01-03 01:46:21 -05:00
|
|
|
assert_in_delta(expected, actual[j, i], delta)
|
2011-01-02 23:47:47 -05:00
|
|
|
end
|
|
|
|
count += 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
def print_cvmat(mat)
|
|
|
|
s = []
|
|
|
|
mat.height.times { |j|
|
|
|
|
a = []
|
|
|
|
mat.width.times { |i|
|
2011-01-03 05:13:58 -05:00
|
|
|
tmp = mat[j, i].to_ary.map {|m| m.to_f.round(2) }.join(',')
|
2011-01-02 23:47:47 -05:00
|
|
|
a << "[#{tmp}]"
|
|
|
|
}
|
|
|
|
s << a.join(' ')
|
|
|
|
}
|
|
|
|
puts s.join("\n")
|
|
|
|
end
|
2013-01-19 13:35:00 -05:00
|
|
|
|
|
|
|
def count_threshold(mat, threshold, &block)
|
|
|
|
n = 0
|
|
|
|
block = lambda { |a, b| a > b } unless block_given?
|
|
|
|
(mat.rows * mat.cols).times { |i|
|
|
|
|
n += 1 if block.call(mat[i][0], threshold)
|
|
|
|
}
|
|
|
|
n
|
|
|
|
end
|
2011-01-01 13:04:27 -05:00
|
|
|
end
|
|
|
|
|