afeld-opencv 0.0.8

data/test/test_mouseevent.rb

@@ -0,0 +1,17 @@
+#!/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
+include GUI
+
+# Tests for OpenCV::MouseEvent
+class TestMouseEvent < OpenCVTestCase
+  def test_initialize
+    assert_not_nil(MouseEvent.new)
+    assert_equal(MouseEvent, MouseEvent.new.class)
+  end
+end
+

data/test/test_opencv.rb

@@ -0,0 +1,340 @@
+#!/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
+
+class TestOpenCV < OpenCVTestCase
+  def test_constants
+    # OpenCV version
+    assert_equal('2.4.0', CV_VERSION)
+    assert_equal(2, CV_MAJOR_VERSION)
+    assert_equal(4, CV_MINOR_VERSION)
+    assert_equal(0, CV_SUBMINOR_VERSION)
+
+    # Depths
+    assert_equal(0, CV_8U)
+    assert_equal(1, CV_8S)
+    assert_equal(2, CV_16U)
+    assert_equal(3, CV_16S)
+    assert_equal(4, CV_32S)
+    assert_equal(5, CV_32F)
+    assert_equal(6, CV_64F)
+
+    # Load image flags
+    assert_equal(-1, CV_LOAD_IMAGE_UNCHANGED)
+    assert_equal(0, CV_LOAD_IMAGE_GRAYSCALE)
+    assert_equal(1, CV_LOAD_IMAGE_COLOR)
+    assert_equal(2, CV_LOAD_IMAGE_ANYDEPTH)
+    assert_equal(4, CV_LOAD_IMAGE_ANYCOLOR)
+
+    # Structuring element shapes    
+    assert_equal(0, CV_SHAPE_RECT)
+    assert_equal(1, CV_SHAPE_CROSS)
+    assert_equal(2, CV_SHAPE_ELLIPSE)
+    assert_equal(100, CV_SHAPE_CUSTOM)
+
+    # Types of morphological operations
+    assert_equal(2, CV_MOP_OPEN)
+    assert_equal(3, CV_MOP_CLOSE)
+    assert_equal(4, CV_MOP_GRADIENT)
+    assert_equal(5, CV_MOP_TOPHAT)
+    assert_equal(6, CV_MOP_BLACKHAT)
+
+    # Types of the smoothing
+    assert_equal(0, CV_BLUR_NO_SCALE)
+    assert_equal(1, CV_BLUR)
+    assert_equal(2, CV_GAUSSIAN)
+    assert_equal(3, CV_MEDIAN)
+    assert_equal(4, CV_BILATERAL)
+
+    # Border types
+    assert_equal(0, IPL_BORDER_CONSTANT)
+    assert_equal(1, IPL_BORDER_REPLICATE)
+    
+    # Thresholding types
+    assert_equal(0, CV_THRESH_BINARY)
+    assert_equal(1, CV_THRESH_BINARY_INV)
+    assert_equal(2, CV_THRESH_TRUNC)
+    assert_equal(3, CV_THRESH_TOZERO)
+    assert_equal(4, CV_THRESH_TOZERO_INV)
+    assert_equal(8, CV_THRESH_OTSU)
+
+    # Adaptive methods
+    assert_equal(0, CV_ADAPTIVE_THRESH_MEAN_C)
+    assert_equal(1, CV_ADAPTIVE_THRESH_GAUSSIAN_C)
+
+    # Retrieval mode
+    assert_equal(0, CV_RETR_EXTERNAL)
+    assert_equal(1, CV_RETR_LIST)
+    assert_equal(2, CV_RETR_CCOMP)
+    assert_equal(3, CV_RETR_TREE)
+
+    # Approximation method
+    assert_equal(0, CV_CHAIN_CODE)
+    assert_equal(1, CV_CHAIN_APPROX_NONE)
+    assert_equal(2, CV_CHAIN_APPROX_SIMPLE)
+    assert_equal(3, CV_CHAIN_APPROX_TC89_L1)
+    assert_equal(4, CV_CHAIN_APPROX_TC89_KCOS)
+    assert_equal(5, CV_LINK_RUNS)
+
+    # Termination criteria for iterative algorithms
+    assert_equal(1, CV_TERMCRIT_ITER)
+    assert_equal(1, CV_TERMCRIT_NUMBER)
+    assert_equal(2, CV_TERMCRIT_EPS)
+
+    # Hough transform methods
+    assert_equal(0, CV_HOUGH_STANDARD)
+    assert_equal(1, CV_HOUGH_PROBABILISTIC)
+    assert_equal(2, CV_HOUGH_MULTI_SCALE)
+    assert_equal(3, CV_HOUGH_GRADIENT)
+
+    # Inpaint method
+    assert_equal(0, CV_INPAINT_NS)
+    assert_equal(1, CV_INPAINT_TELEA)
+
+    # Match tempalte method
+    assert_equal(0, CV_TM_SQDIFF)
+    assert_equal(1, CV_TM_SQDIFF_NORMED)
+    assert_equal(2, CV_TM_CCORR)
+    assert_equal(3, CV_TM_CCORR_NORMED)
+    assert_equal(4, CV_TM_CCOEFF)
+    assert_equal(5, CV_TM_CCOEFF_NORMED)
+    
+    # Comparison method
+    assert_equal(1, CV_CONTOURS_MATCH_I1)
+    assert_equal(2, CV_CONTOURS_MATCH_I2)
+    assert_equal(3, CV_CONTOURS_MATCH_I3)
+
+    # Fundamental matrix computing methods
+    assert_equal(1, CV_FM_7POINT)
+    assert_equal(2, CV_FM_8POINT)
+    assert_equal(8, CV_FM_RANSAC)
+    assert_equal(4, CV_FM_LMEDS)
+
+    # Flags of window
+    assert_equal(1, CV_WINDOW_AUTOSIZE)
+
+    # Object detection mode
+    assert_equal(1, CV_HAAR_DO_CANNY_PRUNING)
+    
+    # Interpolation methods
+    assert_equal(0, CV_INTER_NN)
+    assert_equal(1, CV_INTER_LINEAR)
+    assert_equal(2, CV_INTER_CUBIC)
+    assert_equal(3, CV_INTER_AREA)
+    
+    # Warp affine optional flags
+    assert_equal(8, CV_WARP_FILL_OUTLIERS)
+    assert_equal(16, CV_WARP_INVERSE_MAP)
+
+    # SVD operation flags
+    assert_equal(1, CV_SVD_MODIFY_A)
+    assert_equal(2, CV_SVD_U_T)
+    assert_equal(4, CV_SVD_V_T)
+
+    # Histogram representation format
+    assert_equal(0, CV_HIST_ARRAY)
+    assert_equal(1, CV_HIST_SPARSE)
+    assert_equal(1, CV_HIST_TREE)
+    assert_equal(1, CV_HIST_UNIFORM)
+
+    # Histogram comparison method
+    assert_equal(0, CV_COMP_CORREL)
+    assert_equal(1, CV_COMP_CHISQR)
+    assert_equal(2, CV_COMP_INTERSECT)
+    assert_equal(3, CV_COMP_BHATTACHARYYA)
+  end
+
+  def test_symbols
+    # Depths
+    assert_equal(0, DEPTH[:cv8u])
+    assert_equal(1, DEPTH[:cv8s])
+    assert_equal(2, DEPTH[:cv16u])
+    assert_equal(3, DEPTH[:cv16s])
+    assert_equal(4, DEPTH[:cv32s])
+    assert_equal(5, DEPTH[:cv32f])
+    assert_equal(6, DEPTH[:cv64f])
+
+    # Inversion methods
+    assert_equal(0, INVERSION_METHOD[:lu])
+    assert_equal(1, INVERSION_METHOD[:svd])
+    assert_equal(2, INVERSION_METHOD[:svd_sym])
+    assert_equal(2, INVERSION_METHOD[:svd_symmetric])
+
+    # Flags for DFT and DCT
+    assert_equal(0, DXT_FLAG[:forward])
+    assert_equal(1, DXT_FLAG[:inverse])
+    assert_equal(2, DXT_FLAG[:scale])
+    assert_equal(4, DXT_FLAG[:rows])
+
+    # Interpolation methods
+    assert_equal(0, INTERPOLATION_METHOD[:nn])
+    assert_equal(1, INTERPOLATION_METHOD[:linear])
+    assert_equal(2, INTERPOLATION_METHOD[:cubic])
+    assert_equal(3, INTERPOLATION_METHOD[:area])
+
+    # Warp affine optional flags
+    assert_equal(8, WARP_FLAG[:fill_outliers])
+    assert_equal(16, WARP_FLAG[:inverse_map])
+
+    # Homography calculation methods
+    assert_equal(0, HOMOGRAPHY_CALC_METHOD[:all])
+    assert_equal(4, HOMOGRAPHY_CALC_METHOD[:lmeds])
+    assert_equal(8, HOMOGRAPHY_CALC_METHOD[:ransac])
+
+    # Anti aliasing flags
+    assert_equal(16, CONNECTIVITY[:aa])
+    assert_equal(16, CONNECTIVITY[:anti_alias])
+
+    # Retrieval modes
+    assert_equal(0, RETRIEVAL_MODE[:external])
+    assert_equal(1, RETRIEVAL_MODE[:list])
+    assert_equal(2, RETRIEVAL_MODE[:ccomp])
+    assert_equal(3, RETRIEVAL_MODE[:tree])
+
+    # Approximation methods
+    assert_equal(0, APPROX_CHAIN_METHOD[:code])
+    assert_equal(1, APPROX_CHAIN_METHOD[:approx_none])
+    assert_equal(2, APPROX_CHAIN_METHOD[:approx_simple])
+    assert_equal(3, APPROX_CHAIN_METHOD[:approx_tc89_l1])
+    assert_equal(4, APPROX_CHAIN_METHOD[:approx_tc89_kcos])
+
+    # Approximation methods (polygon)
+    assert_equal(0, APPROX_POLY_METHOD[:dp])
+
+    # Match template methods
+    assert_equal(0, MATCH_TEMPLATE_METHOD[:sqdiff])
+    assert_equal(1, MATCH_TEMPLATE_METHOD[:sqdiff_normed])
+    assert_equal(2, MATCH_TEMPLATE_METHOD[:ccorr])
+    assert_equal(3, MATCH_TEMPLATE_METHOD[:ccorr_normed])
+    assert_equal(4, MATCH_TEMPLATE_METHOD[:ccoeff])
+    assert_equal(5, MATCH_TEMPLATE_METHOD[:ccoeff_normed])
+
+    # Structuring element shapes
+    assert_equal(0, STRUCTURING_ELEMENT_SHAPE[:rect])
+    assert_equal(1, STRUCTURING_ELEMENT_SHAPE[:cross])
+    assert_equal(2, STRUCTURING_ELEMENT_SHAPE[:ellipse])
+    assert_equal(100, STRUCTURING_ELEMENT_SHAPE[:custom])
+
+    # Types of morphological operations
+    assert_equal(2, MORPHOLOGICAL_OPERATION[:open])
+    assert_equal(3, MORPHOLOGICAL_OPERATION[:close])
+    assert_equal(4, MORPHOLOGICAL_OPERATION[:gradient])
+    assert_equal(5, MORPHOLOGICAL_OPERATION[:tophat])
+    assert_equal(6, MORPHOLOGICAL_OPERATION[:blackhat])
+
+    # Types of the smoothing
+    assert_equal(0, SMOOTHING_TYPE[:blur_no_scale])
+    assert_equal(1, SMOOTHING_TYPE[:blur])
+    assert_equal(2, SMOOTHING_TYPE[:gaussian])
+    assert_equal(3, SMOOTHING_TYPE[:median])
+    assert_equal(4, SMOOTHING_TYPE[:bilateral])
+
+    # Thresholding types
+    assert_equal(0, THRESHOLD_TYPE[:binary])
+    assert_equal(1, THRESHOLD_TYPE[:binary_inv])
+    assert_equal(2, THRESHOLD_TYPE[:trunc])
+    assert_equal(3, THRESHOLD_TYPE[:tozero])
+    assert_equal(4, THRESHOLD_TYPE[:tozero_inv])
+    assert_equal(8, THRESHOLD_TYPE[:otsu])
+
+    # Hough transform methods
+    assert_equal(0, HOUGH_TRANSFORM_METHOD[:standard])
+    assert_equal(1, HOUGH_TRANSFORM_METHOD[:probabilistic])
+    assert_equal(2, HOUGH_TRANSFORM_METHOD[:multi_scale])
+    assert_equal(3, HOUGH_TRANSFORM_METHOD[:gradient])
+
+    # Inpaint method
+    assert_equal(0, INPAINT_METHOD[:ns])
+    assert_equal(1, INPAINT_METHOD[:telea])
+
+    # Comparison method
+    assert_equal(1, COMPARISON_METHOD[:i1])
+    assert_equal(2, COMPARISON_METHOD[:i2])
+    assert_equal(3, COMPARISON_METHOD[:i3])
+  end
+
+  def test_cvt_color_funcs
+    mat_1ch = CvMat.new(1, 1, :cv8u, 1)
+    mat_1ch[0] = CvScalar.new(10)
+
+    mat_3ch = CvMat.new(1, 1, :cv8u, 3)
+    mat_3ch[0] = CvScalar.new(10, 20, 30)
+
+    mat_4ch = CvMat.new(1, 1, :cv8u, 4)
+    mat_4ch[0] = CvScalar.new(10, 20, 30, 40)
+
+    gray_rgb = (0.299 * mat_3ch[0][0] + 0.587 * mat_3ch[0][1] + 0.114 * mat_3ch[0][2]).round
+    gray_bgr = (0.299 * mat_3ch[0][2] + 0.587 * mat_3ch[0][1] + 0.114 * mat_3ch[0][0]).round
+
+    # RGB(A) <=> RGB(A)
+    [mat_3ch.BGR2BGRA, mat_3ch.RGB2RGBA].each { |m|
+      assert_equal(CvMat, m.class)
+      assert_equal(4, m.channel)
+      assert_cvscalar_equal(CvScalar.new(10, 20, 30, 255), m[0])
+    }
+    [mat_3ch.BGR2RGBA, mat_3ch.RGB2BGRA].each { |m|
+      assert_equal(CvMat, m.class)
+      assert_equal(4, m.channel)
+      assert_cvscalar_equal(CvScalar.new(30, 20, 10, 255), m[0])
+    }
+    [mat_4ch.BGRA2BGR, mat_4ch.RGBA2RGB].each { |m|
+      assert_equal(CvMat, m.class)
+      assert_equal(3, m.channel)
+      assert_cvscalar_equal(CvScalar.new(10, 20, 30, 0), m[0])
+    }
+    [mat_4ch.RGBA2BGR, mat_4ch.BGRA2RGB].each { |m|
+      assert_equal(CvMat, m.class)
+      assert_equal(3, m.channel)
+      assert_cvscalar_equal(CvScalar.new(30, 20, 10, 0), m[0])
+    }
+    [mat_3ch.BGR2RGB, mat_3ch.RGB2BGR].each { |m|
+      assert_equal(CvMat, m.class)
+      assert_equal(3, m.channel)
+      assert_cvscalar_equal(CvScalar.new(30, 20, 10, 0), m[0])
+    }
+    [mat_4ch.BGRA2RGBA, mat_4ch.RGBA2BGRA].each { |m|
+      assert_equal(CvMat, m.class)
+      assert_equal(4, m.channel)
+      assert_cvscalar_equal(CvScalar.new(30, 20, 10, 40), m[0])
+    }
+
+    # RGB <=> GRAY
+    [mat_3ch.BGR2GRAY, mat_4ch.BGRA2GRAY].each { |m|
+      assert_equal(CvMat, m.class)
+      assert_equal(1, m.channel)
+      assert_cvscalar_equal(CvScalar.new(gray_bgr, 0, 0, 0), m[0])
+    }
+    [mat_3ch.RGB2GRAY, mat_4ch.RGBA2GRAY].each { |m|
+      assert_equal(CvMat, m.class)
+      assert_equal(1, m.channel)
+      assert_cvscalar_equal(CvScalar.new(gray_rgb, 0, 0, 0), m[0])
+    }
+    [mat_1ch.GRAY2BGR, mat_1ch.GRAY2RGB].each { |m|
+      assert_equal(CvMat, m.class)
+      assert_equal(3, m.channel)
+      assert_cvscalar_equal(CvScalar.new(10, 10, 10, 0), m[0])
+    }
+    [mat_1ch.GRAY2BGRA, mat_1ch.GRAY2RGBA].each { |m|
+      assert_equal(CvMat, m.class)
+      assert_equal(4, m.channel)
+      assert_cvscalar_equal(CvScalar.new(10, 10, 10, 255), m[0])
+    }
+
+    img_3ch = IplImage.new(1, 1, :cv8u, 3)
+    assert_equal(IplImage, img_3ch.BGR2GRAY.class)
+
+    flunk('FIXME: Most cvtColor functions are not tested yet.')
+  end
+
+  def test_build_information
+    s = build_information
+    assert_equal(String, s.class)
+    assert(s =~ /^\s+General configuration for OpenCV #{CV_VERSION}/)
+  end
+end
+
+

data/test/test_pointset.rb

@@ -0,0 +1,130 @@
+#!/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::PointSet
+class TestPointSet < OpenCVTestCase
+  def setup
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    @contour1 = mat0.find_contours
+    @contour2 = CvContour.new
+  end
+
+  def test_contour_area
+    assert_equal(3118, @contour1.contour_area.to_i)
+    
+    s = CvSlice.new(0, @contour1.size / 2)
+    assert_equal(1527, @contour1.contour_area(s).to_i)
+
+    assert_raise(TypeError) {
+      @contour1.contour_area(DUMMY_OBJ)
+    }
+    assert_raise(CvStsBadArg) {
+      @contour2.contour_area
+    }
+  end
+
+  def test_fit_ellipse2
+    box = @contour1.fit_ellipse2
+
+    center = box.center
+    assert_equal(64, center.x.to_i)
+    assert_equal(64, center.y.to_i)
+
+    size = box.size
+    assert_in_delta(63.116, size.width, 0.001)
+    assert_in_delta(63.116, size.height, 0.001)
+    assert_in_delta(180, box.angle, 0.001)
+
+    assert_raise(CvStsBadArg) {
+      @contour2.fit_ellipse2
+    }
+  end
+
+  def test_convex_hull2
+    [@contour1.convex_hull2, @contour1.convex_hull2(true)].each { |hull|
+      assert_equal(36, hull.size)
+      assert_equal(CvContour, hull.class)
+      assert_equal(CvPoint, hull[0].class)
+      assert_equal(32, hull[0].x)
+      assert_equal(64, hull[0].y)
+    }
+
+    hull = @contour1.convex_hull2(false)
+    assert_equal(36, hull.size)
+    assert_equal(CvContour, hull.class)
+    assert_equal(CvPoint, hull[0].class)
+    assert_equal(96, hull[0].x)
+    assert_equal(64, hull[0].y)
+
+    @contour1.convex_hull2(DUMMY_OBJ)
+  end
+
+  def test_check_contour_convexity
+    assert_false(@contour1.check_contour_convexity)
+  end
+
+  def test_convexity_defects
+    hull = @contour1.convex_hull2(true, false)
+    defects = @contour1.convexity_defects(hull)
+    assert_equal(CvSeq, defects.class)
+    assert_equal(CvConvexityDefect, defects[0].class)
+    assert_equal(32, defects.size)
+
+    d = defects[0]
+    assert_equal(33, d.start.x)
+    assert_equal(57, d.start.y)
+    assert_equal(33, d.depth_point.x)
+    assert_equal(63, d.depth_point.y)
+    assert_equal(32, d.end.x)
+    assert_equal(64, d.end.y)
+    assert_in_delta(0.8485, d.depth, 0.001)
+
+    assert_raise(TypeError) {
+      @contour1.convexity_defects(DUMMY_OBJ)
+    }
+  end
+
+  def test_min_area_rect2
+    box = @contour1.min_area_rect2
+
+    assert_equal(CvBox2D, box.class)
+    center = box.center
+    assert_equal(64, center.x.to_i)
+    assert_equal(64, center.y.to_i)
+
+    size = box.size
+    assert_in_delta(63.356, size.width, 0.001)
+    assert_in_delta(63.356, size.height, 0.001)
+    assert_in_delta(-8.130, box.angle, 0.001)
+
+    flunk('FIXME: Currently PointSet#min_area_rect2 causes segmentation fault when "self" is invalid.')    
+    assert_raise(CvStsBadSize) {
+      @contour2.min_area_rect2
+    }
+  end
+
+  def test_min_enclosing_circle
+    circle = @contour1.min_enclosing_circle
+    assert_equal(CvCircle32f, circle.class)
+    center = circle.center
+    assert_equal(64, center.x.to_i)
+    assert_equal(64, center.y.to_i)
+    assert_in_delta(32.959, circle.radius, 0.001)
+
+    assert_raise(CvStsBadArg) {
+      @contour2.min_enclosing_circle
+    }
+  end
+
+  def test_calc_pgh
+    flunk('FIXME: PointSet#calc_pgh is not implemented yet.')
+  end
+end
+