ruby-opencv 0.0.8.pre-x86-mingw32

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,236 @@
+#!/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
+    img1 = IplImage.load(FILENAME_CAT)
+    assert_equal(IplImage, img1.class)
+    assert_equal(375, img1.width)
+    assert_equal(500, img1.height)
+    assert_equal(:cv8u, img1.depth)
+    assert_equal(3, img1.channel)
+
+    img2 = IplImage.load(FILENAME_CAT, CV_LOAD_IMAGE_GRAYSCALE)
+    assert_equal(IplImage, img2.class)
+    assert_equal(375, img2.width)
+    assert_equal(500, img2.height)
+    assert_equal(:cv8u, img2.depth)
+    assert_equal(1, img2.channel)
+
+    img3 = IplImage.load(FILENAME_CAT, CV_LOAD_IMAGE_ANYDEPTH | CV_LOAD_IMAGE_ANYCOLOR)
+    assert_equal(IplImage, img3.class)
+    assert_equal(375, img3.width)
+    assert_equal(500, img3.height)
+    assert_equal(:cv8u, img3.depth)
+    assert_equal(3, img3.channel)
+
+    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')
+    }
+
+    # Uncomment the following lines to show the results
+    # snap img1, img2, img3
+  end
+
+  def test_decode
+    data = nil
+    open(FILENAME_CAT, 'rb') { |f|
+      data = f.read
+    }
+    data_ary = data.unpack("c*")
+    data_mat = CvMat.new(1, data_ary.size).set_data(data_ary)
+    expected = IplImage.load(FILENAME_CAT)
+
+    img1 = IplImage.decode(data)
+    img2 = IplImage.decode(data_ary)
+    img3 = IplImage.decode(data_mat)
+    img4 = IplImage.decode(data, CV_LOAD_IMAGE_COLOR)
+    img5 = IplImage.decode(data_ary, CV_LOAD_IMAGE_COLOR)
+    img6 = IplImage.decode(data_mat, CV_LOAD_IMAGE_COLOR)
+    expected_hash = hash_img(expected)
+
+    [img1, img2, img3, img4, img5, img6].each { |img|
+      assert_equal(IplImage, img.class)
+      assert_equal(expected.rows, img.rows)
+      assert_equal(expected.cols, img.cols)
+      assert_equal(expected.channel, img.channel)
+      assert_equal(expected_hash, hash_img(img))
+    }
+
+    expected_c1 = IplImage.load(FILENAME_CAT, CV_LOAD_IMAGE_GRAYSCALE)
+    img1c1 = IplImage.decode(data, CV_LOAD_IMAGE_GRAYSCALE)
+    img2c1 = IplImage.decode(data_ary, CV_LOAD_IMAGE_GRAYSCALE)
+    img3c1 = IplImage.decode(data_mat, CV_LOAD_IMAGE_GRAYSCALE)
+    expected_hash_c1 = hash_img(expected_c1)
+
+    [img1c1, img2c1, img3c1].each { |img|
+      assert_equal(IplImage, img.class)
+      assert_equal(expected_c1.rows, img.rows)
+      assert_equal(expected_c1.cols, img.cols)
+      assert_equal(expected_c1.channel, img.channel)
+      assert_equal(expected_hash_c1, hash_img(img))
+    }
+
+    assert_raise(TypeError) {
+      IplImage.decode(DUMMY_OBJ)
+    }
+    assert_raise(TypeError) {
+      IplImage.decode(data, DUMMY_OBJ)
+    }
+
+    # Uncomment the following line to show the result images
+    # snap img1, img2, img3
+  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
+
+  def test_pyr_segmentation
+    img0 = IplImage.load(FILENAME_CAT, CV_LOAD_IMAGE_ANYCOLOR | CV_LOAD_IMAGE_ANYDEPTH)
+    img0.set_roi(CvRect.new(0, 0, 256, 512))
+    img1, seq1 = img0.pyr_segmentation(2, 255, 50)
+    assert_equal('963b26f51b14f175fbbf128e9b9e979f', hash_img(img1))
+    assert_equal(11, seq1.total)
+
+    assert_raise(CvStsAssert) {
+      img0.pyr_segmentation(-1, 255, 50)
+    }
+    assert_raise(CvStsAssert) {
+      img0.pyr_segmentation(1000, 255, 50)
+    }
+    assert_raise(CvStsAssert) {
+      img0.pyr_segmentation(4, -1, 50)
+    }
+    assert_raise(CvStsAssert) {
+      img0.pyr_segmentation(4, 255, -1)
+    }
+    assert_raise(TypeError) {
+      img0.pyr_segmentation(DUMMY_OBJ, 255, 50)
+    }
+    assert_raise(TypeError) {
+      img0.pyr_segmentation(4, DUMMY_OBJ, 50)
+    }
+    assert_raise(TypeError) {
+      img0.pyr_segmentation(4, 255, DUMMY_OBJ)
+    }
+    assert_raise(CvBadDepth) {
+      IplImage.new(10, 10, :cv32f, 2).pyr_segmentation(4, 255, 50)
+    }
+  end
+end
+
+

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,324 @@
+#!/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.3', CV_VERSION)
+    assert_equal(2, CV_MAJOR_VERSION)
+    assert_equal(4, CV_MINOR_VERSION)
+    assert_equal(3, 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])
+
+    # 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
+
+