tested and modified CvChain

ext/cvchain.cpp

@@ -55,14 +55,49 @@ define_ruby_class()
   rb_hash_aset(approx_chain_option, ID2SYM(rb_intern("minimal_parameter")), INT2FIX(0));
   rb_hash_aset(approx_chain_option, ID2SYM(rb_intern("recursive")), Qfalse);
 
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
   rb_define_method(rb_klass, "origin", RUBY_METHOD_FUNC(rb_origin), 0);
-  rb_define_method(rb_klass, "origin=", RUBY_METHOD_FUNC(rb_set_origin), 0);
+  rb_define_method(rb_klass, "origin=", RUBY_METHOD_FUNC(rb_set_origin), 1);
   rb_define_method(rb_klass, "codes", RUBY_METHOD_FUNC(rb_codes), 0);
   rb_define_method(rb_klass, "points", RUBY_METHOD_FUNC(rb_points), 0);
   rb_define_method(rb_klass, "approx_chain", RUBY_METHOD_FUNC(rb_approx_chain), -1);
   rb_define_alias(rb_klass, "approx", "approx_chain");
 }
 
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvChain *ptr = ALLOC(CvChain);
+  return Data_Wrap_Struct(klass, 0, cvchain_free, ptr);
+}
+
+void
+cvchain_free(void *ptr)
+{
+  if (ptr) {
+    CvChain *chain = (CvChain*)ptr;
+    if (chain->storage)
+      cvReleaseMemStorage(&(chain->storage));
+  }
+}
+
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  CvMemStorage *storage;
+  VALUE storage_value;
+  if (rb_scan_args(argc, argv, "01", &storage_value) > 0) {
+    storage_value = CHECK_CVMEMSTORAGE(storage_value);
+    storage = CVMEMSTORAGE(storage_value);
+  }
+  else
+    storage = cvCreateMemStorage(0);
+  
+  DATA_PTR(self) = (CvChain*)cvCreateSeq(CV_SEQ_ELTYPE_CODE, sizeof(CvChain),
+					 sizeof(char), storage);
+  return self;
+}
+
 /*
  * call-seq:
  *   origin -> cvpoint

ext/cvchain.h

@@ -21,6 +21,10 @@ VALUE rb_class();
 
 void define_ruby_class();
 
+VALUE rb_allocate(VALUE klass);
+void cvchain_free(void *ptr);
+
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
 VALUE rb_origin(VALUE self);
 VALUE rb_set_origin(VALUE self, VALUE origin);
 VALUE rb_codes(VALUE self);

test/test_cvchain.rb

@@ -0,0 +1,61 @@
+#!/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::CvChain
+class TestCvChain < OpenCVTestCase
+  def test_APPROX_OPTION
+    assert_equal(:approx_simple, CvChain::APPROX_CHAIN_OPTION[:method])
+    assert_equal(0, CvChain::APPROX_CHAIN_OPTION[:parameter])
+    assert_equal(0, CvChain::APPROX_CHAIN_OPTION[:minimal_parameter])
+    assert_false(CvChain::APPROX_CHAIN_OPTION[:recursive])
+  end
+  
+  def test_initialize
+    chain = CvChain.new
+    assert_not_nil(chain)
+    assert_equal(CvChain, chain.class)
+    assert(chain.is_a? CvSeq)
+  end
+
+  def test_origin
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    chain = mat0.find_contours(:mode => CV_RETR_EXTERNAL, :method => CV_CHAIN_CODE)
+    assert_equal(CvChain, chain.class)
+    assert_equal(64, chain.origin.x)
+    assert_equal(32, chain.origin.y)
+
+    chain.origin = CvPoint.new(32, 64)
+    assert_equal(32, chain.origin.x)
+    assert_equal(64, chain.origin.y)
+  end
+
+  def test_codes
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    chain = mat0.find_contours(:mode => CV_RETR_EXTERNAL, :method => CV_CHAIN_CODE)
+    assert_equal(Array, chain.codes.class)
+    assert(chain.codes.all? { |a| (a.class == Fixnum) and (a >= 0 and a <= 7) })
+  end
+
+  def test_points
+    mat0 = create_cvmat(128, 128, :cv8u, 1) { |j, i|
+      (j - 64) ** 2 + (i - 64) ** 2 <= (32 ** 2) ? CvColor::White : CvColor::Black
+    }
+    chain = mat0.find_contours(:mode => CV_RETR_EXTERNAL, :method => CV_CHAIN_CODE)
+    assert_equal(Array, chain.points.class)
+    assert(chain.points.all? { |a| a.class == CvPoint })
+  end
+
+  def test_approx_chain
+    flunk('FIXME: CvChain#approx_chain is not implemented yet.')
+  end
+end
+

test/test_cvcontour.rb

@@ -9,8 +9,8 @@ include OpenCV
 # Tests for OpenCV::CvContour
 class TestCvContour < OpenCVTestCase
   def test_APPROX_OPTION
-    assert_equal(CvContour::APPROX_OPTION[:method], 0)
+    assert_equal(0, CvContour::APPROX_OPTION[:method])
-    assert_equal(CvContour::APPROX_OPTION[:accuracy], 1.0)
+    assert_equal(1.0, CvContour::APPROX_OPTION[:accuracy])
     assert_false(CvContour::APPROX_OPTION[:recursive])
   end