afeld-opencv 0.0.8

data/test/test_cvcontour.rb

@@ -0,0 +1,150 @@
+#!/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::CvContour
+class TestCvContour < OpenCVTestCase
+  def test_APPROX_OPTION
+    assert_equal(0, CvContour::APPROX_OPTION[:method])
+    assert_equal(1.0, CvContour::APPROX_OPTION[:accuracy])
+    assert_false(CvContour::APPROX_OPTION[:recursive])
+  end
+  
+  def test_initialize
+    contour = CvContour.new
+    assert_not_nil(contour)
+    assert_equal(CvContour, contour.class)
+    assert(contour.is_a? CvSeq)
+  end
+
+  def test_rect
+    contour = CvContour.new
+    assert_not_nil(contour.rect)
+    assert_equal(CvRect, contour.rect.class)
+  end
+
+  def test_color
+    contour = CvContour.new
+    assert_equal(0, contour.color)
+    contour.color = 1
+    assert_equal(1, contour.color)
+  end
+
+  def test_reserved
+    reserved = CvContour.new.reserved
+    assert_equal(Array, reserved.class)
+    assert_equal(3, reserved.size)
+  end
+
+  def test_approx_poly
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    contours = mat0.find_contours(:mode => CV_RETR_EXTERNAL)
+
+    poly = contours.approx_poly
+    assert_equal(CvContour, poly.class)
+    assert(poly.size > 0)
+    assert(poly.all? { |c| c.class == CvPoint })
+
+    poly = contours.approx_poly(:method => :dp)
+    assert_equal(CvContour, poly.class)
+    assert(poly.size > 0)
+    assert(poly.all? { |c| c.class == CvPoint })
+
+    poly = contours.approx_poly(:accuracy => 2.0)
+    assert_equal(CvContour, poly.class)
+    assert(poly.size > 0)
+    assert(poly.all? { |c| c.class == CvPoint })
+
+    [true, false, 1, 0].each { |recursive|
+      poly = contours.approx_poly(:recursive => recursive)
+      assert_equal(CvContour, poly.class)
+      assert(poly.size > 0)
+      assert(poly.all? { |c| c.class == CvPoint })
+    }
+
+    poly = contours.approx_poly(:method => :dp, :accuracy => 2.0, :recursive => false)
+    assert_equal(CvContour, poly.class)
+    assert(poly.size > 0)
+    assert(poly.all? { |c| c.class == CvPoint })
+
+    # Uncomment the following lines to show the result
+    # poly = contours.approx_poly(:accuracy => 3.0)
+    # dst = mat0.clone.zero
+    # begin
+    #   dst.draw_contours!(poly, CvColor::White, CvColor::Black, 2,
+    #                      :thickness => 1, :line_type => :aa)
+    # end while (poly = poly.h_next)
+    # snap dst
+  end
+  
+  def test_bounding_rect
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    contours = mat0.find_contours
+    rect = contours.bounding_rect
+    assert_equal(CvRect, rect.class)
+    assert_equal(32, rect.x)
+    assert_equal(32, rect.y)
+    assert_equal(65, rect.width)
+    assert_equal(65, rect.height)
+  end
+
+  def test_create_tree
+    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
+    assert_equal(CvContourTree, tree.class)
+    assert_equal(34, tree.p1.x)
+    assert_equal(53, tree.p1.y)
+    assert_equal(0, tree.p2.x)
+    assert_equal(0, tree.p2.y)
+  end
+
+  def test_in
+    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
+    assert(contour.in? CvPoint.new(64, 64))
+    assert_false(contour.in? CvPoint.new(0, 0))
+    assert_nil(contour.in? CvPoint.new(64, 32))
+  end
+
+  def test_measure_distance
+    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
+    assert_in_delta(-0.7071, contour.measure_distance(CvPoint.new(63, 32)), 0.01)
+    assert_in_delta(31.01, contour.measure_distance(CvPoint.new(64, 64)), 0.01)
+  end
+
+  def test_point_polygon_test
+    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
+
+    assert_equal(1, contour.point_polygon_test(CvPoint.new(64, 64), 0))
+    assert_equal(1, contour.point_polygon_test(CvPoint.new(64, 64), false))
+    assert_equal(-1, contour.point_polygon_test(CvPoint.new(0, 0), 0))
+    assert_equal(-1, contour.point_polygon_test(CvPoint.new(0, 0), false))
+    assert_equal(0, contour.point_polygon_test(CvPoint.new(64, 32), 0))
+    assert_equal(0, contour.point_polygon_test(CvPoint.new(64, 32), false))
+
+    assert_in_delta(-0.7071, contour.point_polygon_test(CvPoint.new(63, 32), 1), 0.01)
+    assert_in_delta(-0.7071, contour.point_polygon_test(CvPoint.new(63, 32), true), 0.01)
+    assert_in_delta(31.01, contour.point_polygon_test(CvPoint.new(64, 64), 1), 0.01)
+    assert_in_delta(31.01, contour.point_polygon_test(CvPoint.new(64, 64), true), 0.01)
+  end
+end
+

data/test/test_cvcontourtree.rb

@@ -0,0 +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
+

data/test/test_cverror.rb

@@ -0,0 +1,50 @@
+#!/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::CvError
+class TestCvError < OpenCVTestCase
+  def test_cverror
+    assert_equal(StandardError, CvError.superclass)
+    begin
+      raise CvError
+    rescue
+      assert_equal(CvError, $!.class)
+    end
+  end
+  
+  def test_subclass
+    errors = [CvStsBackTrace, CvStsError, CvStsInternal, CvStsNoMem, CvStsBadArg, CvStsBadFunc, CvStsNoConv, CvStsAutoTrace, CvHeaderIsNull, CvBadImageSize, CvBadOffset, CvBadDataPtr, CvBadStep, CvBadModelOrChSeq, CvBadNumChannels, CvBadNumChannel1U, CvBadDepth, CvBadAlphaChannel, CvBadOrder, CvBadOrigin, CvBadAlign, CvBadCallBack, CvBadTileSize, CvBadCOI, CvBadROISize, CvMaskIsTiled, CvStsNullPtr, CvStsVecLengthErr, CvStsFilterStructContentErr, CvStsKernelStructContentErr, CvStsFilterOffsetErr, CvStsBadSize, CvStsDivByZero, CvStsInplaceNotSupported, CvStsObjectNotFound, CvStsUnmatchedFormats, CvStsBadFlag, CvStsBadPoint, CvStsBadMask, CvStsUnmatchedSizes, CvStsUnsupportedFormat, CvStsOutOfRange, CvStsParseError, CvStsNotImplemented, CvStsBadMemBlock, CvStsAssert, CvGpuNotSupported, CvGpuApiCallError]
+
+    errors.each { |err|
+      assert_equal(CvError, err.superclass)
+
+      begin
+        raise err
+      rescue err
+        assert_equal(err, $!.class)
+      rescue
+        flunk("Failed to catch #{err}")
+      end
+
+      begin
+        raise err
+      rescue CvError
+        assert_equal(err, $!.class)
+      rescue
+        flunk("Failed to catch #{err}")
+      end
+
+      begin
+        raise err
+      rescue
+        assert_equal(err, $!.class)
+      end
+    }
+  end
+end
+

data/test/test_cvfeaturetree.rb

@@ -0,0 +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
+

data/test/test_cvfont.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::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

@@ -0,0 +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
+

data/test/test_cvhistogram.rb

@@ -0,0 +1,271 @@
+#!/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::CvHistogram
+class TestCvHistogram < OpenCVTestCase
+  def setup
+    @img = IplImage.load(FILENAME_LENA32x32, 0)
+
+    dim = 1
+    sizes = [8]
+    ranges = [[0, 255]]
+    @hist1 = CvHistogram.new(dim, sizes, CV_HIST_ARRAY, ranges, true).calc_hist!([@img])
+
+    dim = 2
+    sizes = [8, 16]
+    ranges = [[0, 255], [0, 255]]
+    @hist2 = CvHistogram.new(dim, sizes, CV_HIST_SPARSE, ranges, true).calc_hist!([@img, @img])
+  end
+
+  def teardown
+    @hist1 = nil
+    @hist2 = nil
+    GC.start
+  end
+
+  def test_initialize
+    dim = 1
+    sizes = [256]
+    ranges = [[0, 256]]
+    hist1 = CvHistogram.new(dim, sizes, CV_HIST_ARRAY, ranges, true)
+    hist2 = CvHistogram.new(dim, sizes, CV_HIST_ARRAY)
+    hist3 = CvHistogram.new(dim, sizes, CV_HIST_ARRAY, nil)
+    hist4 = CvHistogram.new(dim, sizes, CV_HIST_ARRAY, nil, false)
+  end
+
+  def test_is_uniform
+    assert(@hist1.is_uniform?)
+    assert(@hist2.is_uniform?)
+  end
+
+  def test_is_sparse
+    assert_false(@hist1.is_sparse?)
+    assert(@hist2.is_sparse?)
+  end
+
+  def test_has_range
+    assert(@hist1.has_range?)
+    assert(@hist2.has_range?)
+  end
+
+  def test_calc_hist
+    img = IplImage.new(1, 1, :cv8u, 1)
+    assert_equal(CvHistogram, @hist1.calc_hist([img]).class)
+    assert_equal(CvHistogram, @hist1.calc_hist([img, img]).class)
+    assert_equal(CvHistogram, @hist1.calc_hist([img], true).class)
+    assert_equal(CvHistogram, @hist1.calc_hist([img, img], false).class)
+    mask = CvMat.new(1, 1, :cv8u, 1)
+    assert_equal(CvHistogram, @hist1.calc_hist([img], true, mask).class)
+
+    assert_raise(TypeError) {
+      @hist1.calc_hist(img)
+    }
+    assert_raise(TypeError) {
+      @hist1.calc_hist([DUMMY_OBJ])
+    }
+    assert_raise(TypeError) {
+      @hist1.calc_hist(nil)
+    }
+    assert_raise(TypeError) {
+      @hist1.calc_hist([img], true, DUMMY_OBJ)
+    }
+    assert_raise(CvStsBadArg) {
+      @hist1.calc_hist([])
+    }
+  end
+
+  def test_aref
+    expected = [0.0, 102.0, 189.0, 244.0, 285.0, 140.0, 64.0, 0.0]
+    expected.each_with_index { |x, i|
+      assert_in_delta(x, @hist1[i], 0.001)
+      assert_in_delta(x, @hist1.query_hist_value(i), 0.001)
+    }
+  end
+
+  def test_min_max_value
+    min, max, min_loc, max_loc = @hist1.min_max_value
+    assert_in_delta(0.0, min, 0.001)
+    assert_in_delta(285.0, max, 0.001)
+    assert_equal(Array, min_loc.class)
+    assert_equal(Array, max_loc.class)
+    assert_equal(1, min_loc.size)
+    assert_equal(1, max_loc.size)
+    assert_equal(0, min_loc[0])
+    assert_equal(4, max_loc[0])
+
+    min, max, min_loc, max_loc = @hist2.min_max_value
+    assert_in_delta(14.0, min, 0.001)
+    assert_in_delta(158.0, max, 0.001)
+    assert_equal(Array, min_loc.class)
+    assert_equal(Array, max_loc.class)
+    assert_equal(2, min_loc.size)
+    assert_equal(2, max_loc.size)
+    assert_equal(1, min_loc[0])
+    assert_equal(2, min_loc[1])
+    assert_equal(4, max_loc[0])
+    assert_equal(9, max_loc[1])
+  end
+
+  def test_dims
+    dims, sizes = @hist1.dims
+    assert_equal(1, dims)
+    assert_equal(Array, sizes.class)
+    assert_equal(1, sizes.size)
+    assert_equal(8, sizes[0])
+
+    dims, sizes = @hist2.dims
+    assert_equal(2, dims)
+    assert_equal(Array, sizes.class)
+    assert_equal(2, sizes.size)
+    assert_equal(8, sizes[0])
+    assert_equal(16, sizes[1])
+  end
+
+  def test_copy_hist
+    expected = [0.0, 102.0, 189.0, 244.0, 285.0, 140.0, 64.0, 0.0]
+    hist = @hist1.copy_hist
+    expected.each_with_index { |x, i|
+      assert_in_delta(x, hist[i], 0.001)
+      assert_in_delta(x, hist.query_hist_value(i), 0.001)
+    }
+  end
+
+  def test_clear_hist
+    @hist1.clear_hist!
+    dims, sizes = @hist1.dims
+    dims.times { |i|
+      assert_in_delta(0.0, @hist1[i], 0.001)
+    }
+  end
+
+  def test_normalize_hist
+    @hist1.normalize_hist!(100)
+    expected = [0.0, 9.96, 18.46, 23.83, 27.83, 13.67, 6.25, 0.0]
+    expected.each_with_index { |x, i|
+      assert_in_delta(x, @hist1[i], 0.01)
+    }
+  end
+
+  def test_thresh_hist
+    @hist1.thresh_hist!(150)
+    expected = [0.0, 0.0, 189.0, 244.0, 285.0, 0.0, 0.0, 0.0]
+    expected.each_with_index { |x, i|
+      assert_in_delta(x, @hist1[i], 0.001)
+    }
+  end
+
+  def test_set_hist_bin_ranges
+    dim = 1
+    sizes = [8]
+
+    hist = CvHistogram.new(dim, sizes, CV_HIST_ARRAY)
+    assert_false(hist.has_range?)
+    assert(hist.is_uniform?)
+
+    ranges = [[0, 255]]    
+    hist.set_hist_bin_ranges!(ranges, true)
+    assert(hist.has_range?)
+    assert(hist.is_uniform?)
+
+    assert_raise(TypeError) {
+      hist.set_hist_bin_ranges!(DUMMY_OBJ)
+    }
+    assert_raise(TypeError) {
+      hist.set_hist_bin_ranges!([DUMMY_OBJ])
+    }
+  end
+
+  def test_calc_back_project
+    back_project = @hist1.calc_back_project([@img])
+    assert_equal(@img.class, back_project.class)
+    assert_equal('2a0097af1ab4f9343e4feaae3a780c93', hash_img(back_project))
+
+    assert_raise(TypeError) {
+      @hist1.calc_back_project(DUMMY_OBJ)
+    }
+    assert_raise(TypeError) {
+      @hist1.calc_back_project([DUMMY_OBJ])
+    }
+  end
+
+  def test_calc_back_project_patch
+    img = IplImage.load(FILENAME_LENA256x256, 0)
+    template = IplImage.load(FILENAME_LENA_EYES, 0)
+
+    dim = 1
+    sizes = [8]
+    ranges = [[0, 255]]
+    hist = CvHistogram.new(dim, sizes, CV_HIST_ARRAY, ranges).calc_hist!([template])
+    back_project = hist.calc_back_project_patch([img], template.size, CV_COMP_CORREL, 1.0)
+    assert_equal('e6497e45c6f2f715328bbc2fefe31581', hash_img(back_project))
+
+    assert_raise(TypeError) {
+      hist.calc_back_project_patch(DUMMY_OBJ, template.size, CV_COMP_CORREL, 1.0)
+    }
+    assert_raise(TypeError) {
+      hist.calc_back_project_patch([DUMMY_OBJ], template.size, CV_COMP_CORREL, 1.0)
+    }
+
+    # Uncomment the following line to show the result
+    # min_val, max_val, min_loc, max_loc = back_project.min_max_loc
+    # result = img.rectangle(max_loc, CvPoint.new(max_loc.x + template.width, max_loc.y + template.height),
+    #                        :thickness => 2)
+    # snap img, template, back_project, result
+  end
+
+  def test_compare_hist
+    img = IplImage.load(FILENAME_CAT, 0)
+    dim, sizes = @hist1.dims
+    ranges = [[0, 255]]
+    hist = CvHistogram.new(dim, sizes, CV_HIST_ARRAY, ranges).calc_hist!([img])
+
+    assert_in_delta(0.7446, CvHistogram.compare_hist(@hist1, hist, CV_COMP_CORREL), 0.001)
+    assert_in_delta(184459.0, CvHistogram.compare_hist(@hist1, hist, CV_COMP_CHISQR), 1.0)
+    assert_in_delta(1024.0, CvHistogram.compare_hist(@hist1, hist, CV_COMP_INTERSECT), 1.0)
+    assert_in_delta(0.2955, CvHistogram.compare_hist(@hist1, hist, CV_COMP_BHATTACHARYYA), 0.001)
+
+    assert_raise(TypeError) {
+      CvHistogram.compare_hist(DUMMY_OBJ, hist, CV_COMP_CORREL)
+    }
+    assert_raise(TypeError) {
+      CvHistogram.compare_hist(@hist1, DUMMY_OBJ, CV_COMP_CORREL)
+    }
+    assert_raise(TypeError) {
+      CvHistogram.compare_hist(@hist1, hist, DUMMY_OBJ)
+    }
+  end
+
+  def test_calc_prob_density
+    img = IplImage.load(FILENAME_CAT, 0)
+    dim, sizes = @hist1.dims
+    ranges = [[0, 255]]
+    hist = CvHistogram.new(dim, sizes, CV_HIST_ARRAY, ranges).calc_hist!([img])
+    dst = CvHistogram.calc_prob_density(hist, @hist1)
+
+    assert_equal(CvHistogram, dst.class)
+    dim, sizes = dst.dims
+    expected_dim, expected_sizes = @hist1.dims
+    assert_equal(expected_dim, dim)
+    expected_sizes.each_with_index { |x, i|
+      assert_equal(x, sizes[i])
+    }
+
+    expected = [0.0, 1.437, 1.135, 1.092, 2.323, 3.712, 3.103, 0.0]
+    expected.each_with_index { |x, i|
+      assert_in_delta(x, dst[i], 0.001)
+    }
+
+    assert_raise(TypeError) {
+      CvHistogram.calc_prob_density(DUMMY_OBJ, @hist1)
+    }
+    assert_raise(TypeError) {
+      CvHistogram.calc_prob_density(hist, DUMMY_OBJ)
+    }
+  end
+end
+