Initial commit, with some minor changes from orig (date, exec bit, line endings, /usr/bin/env)

History.txt

@@ -0,0 +1,5 @@
+=== 0.0.6 / 2008-06-27
+
+* First gem release.
+
+  * Some OpenCV function wrapped.

License.txt

@@ -0,0 +1,30 @@
+The BSD Liscense
+
+Copyright (c) 2008, Masakazu Yonekura
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of Masakazu Yonekura. nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of Masakazu Yonekura.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Manifest.txt

@@ -0,0 +1,115 @@
+History.txt
+Manifest.txt
+README.txt
+License.txt
+Rakefile
+examples/convexhull.rb
+examples/face_detect.rb
+examples/houghcircle.rb
+examples/inpaint.png
+examples/inpaint.rb
+examples/paint.rb
+examples/snake.rb
+examples/stuff.jpg
+ext/curve.cpp
+ext/curve.h
+ext/cvavgcomp.cpp
+ext/cvavgcomp.h
+ext/cvbox2d.cpp
+ext/cvbox2d.h
+ext/cvcapture.cpp
+ext/cvcapture.h
+ext/cvchain.cpp
+ext/cvchain.h
+ext/cvchaincode.cpp
+ext/cvchaincode.h
+ext/cvcircle32f.cpp
+ext/cvcircle32f.h
+ext/cvcondensation.cpp
+ext/cvcondensation.h
+ext/cvconnectedcomp.cpp
+ext/cvconnectedcomp.h
+ext/cvcontour.cpp
+ext/cvcontour.h
+ext/cvcontourtree.cpp
+ext/cvcontourtree.h
+ext/cvconvexitydefect.cpp
+ext/cvconvexitydefect.h
+ext/cverror.cpp
+ext/cverror.h
+ext/cvfont.cpp
+ext/cvfont.h
+ext/cvhaarclassifiercascade.cpp
+ext/cvhaarclassifiercascade.h
+ext/cvhistogram.cpp
+ext/cvhistogram.h
+ext/cvindex.cpp
+ext/cvindex.h
+ext/cvline.cpp
+ext/cvline.h
+ext/cvmat.cpp
+ext/cvmat.h
+ext/cvmatnd.cpp
+ext/cvmatnd.h
+ext/cvmemstorage.cpp
+ext/cvmemstorage.h
+ext/cvmoments.cpp
+ext/cvmoments.h
+ext/cvpoint.cpp
+ext/cvpoint.h
+ext/cvpoint2d32f.cpp
+ext/cvpoint2d32f.h
+ext/cvpoint3d32f.cpp
+ext/cvpoint3d32f.h
+ext/cvrect.cpp
+ext/cvrect.h
+ext/cvscalar.cpp
+ext/cvscalar.h
+ext/cvseq.cpp
+ext/cvseq.h
+ext/cvset.cpp
+ext/cvset.h
+ext/cvsize.cpp
+ext/cvsize.h
+ext/cvsize2d32f.cpp
+ext/cvsize2d32f.h
+ext/cvslice.cpp
+ext/cvslice.h
+ext/cvsparsemat.cpp
+ext/cvsparsemat.h
+ext/cvtermcriteria.cpp
+ext/cvtermcriteria.h
+ext/cvtwopoints.cpp
+ext/cvtwopoints.h
+ext/cvvector.cpp
+ext/cvvector.h
+ext/cvvideowriter.cpp
+ext/cvvideowriter.h
+ext/extconf.rb
+ext/gui.cpp
+ext/gui.h
+ext/iplconvkernel.cpp
+ext/iplconvkernel.h
+ext/iplimage.cpp
+ext/iplimage.h
+ext/mouseevent.cpp
+ext/mouseevent.h
+ext/opencv.cpp
+ext/opencv.h
+ext/point3dset.cpp
+ext/point3dset.h
+ext/pointset.cpp
+ext/pointset.h
+ext/trackbar.cpp
+ext/trackbar.h
+ext/window.cpp
+ext/window.h
+images/CvMat_sobel.png
+images/CvMat_sub_rect.png
+images/CvSeq_relationmap.png
+images/face_detect_from_lena.jpg
+lib/opencv.rb
+lib/version.rb
+setup/setup.cygwin.rb
+setup/setup.mingw.rb
+setup/setup.mswin32.rb

README.txt

@@ -0,0 +1,47 @@
+= opencv
+
+OpenCV Sourceforge Project
+http://sourceforge.net/projects/opencvlibrary/
+
+Ruby/OpenCV Author's Web Page
+http://blueruby.mydns.jp/opencv
+
+== DESCRIPTION:
+
+OpenCV Ruby Wrapper
+
+== FEATURES/PROBLEMS:
+
+* First release rubygems, Some OpenCV function wrapped.
+
+== SYNOPSIS:
+
+# Show image via GUI Window.
+
+require "rubygems"
+gem "opencv"
+require "opencv"
+
+image = OpenCV::IplImage.load("sample.jpg")
+window = OpenCV::GUI::Window.new("preview")
+window.show(image)
+OpenCV::GUI::wait_key
+
+# other sample code, see examples/*.rb
+
+== REQUIREMENTS:
+
+* OpenCV 1.0 or later.
+  http://sourceforge.net/projects/opencvlibrary/
+* ffcall (optional)
+  http://www.haible.de/bruno/packages-ffcall.html
+
+== INSTALL:
+
+gem install opencv
+
+== LICENSE:
+
+The BSD Liscense
+
+see LICENSE.txt

Rakefile

@@ -0,0 +1,34 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/version'
+
+Hoe.new('opencv', OpenCV::VERSION) do |p|
+  p.author = ['Masakazu Yonekura']
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.description = <<EOF
+OpenCV wrapper for Ruby
+EOF
+  p.rubyforge_name = 'opencv'
+  p.developer('lsxi', 'masakazu.yonekura@gmail.com')
+  p.email = ['masakazu.yonekura@gmail.com']
+  
+  p.need_tar = false
+  p.need_zip = false
+  # p.rdoc_pattern = 
+  # p.remote_rdoc_dir =
+  # p.rsync =
+  p.spec_extras = {
+    :extensions => %w{ext/extconf.rb}
+  }
+  p.summary = 'OpenCV wrapper for Ruby.'
+  # p.test_globs = 'spec/**/*_spec.rb'
+  p.clean_globs |= ['*.o']
+  
+  p.url = 'http://blueruby.mydns.jp/opencv'
+  
+  p.extra_deps << ['hoe']
+end
+
+# vim: syntax=Ruby

examples/convexhull.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# convexhull.rb
+gem "opencv"
+require "opencv"
+require "pp"
+include OpenCV
+
+window = GUI::Window.new("convexhull")
+pp CvCapture::INTERFACE
+capture = CvCapture::open
+
+accuracy = 0.1
+t = window.set_trackbar("accuracy", 100, 1){|v|
+  accuracy = 0.1 * v
+}
+
+while true
+  key = GUI::wait_key(1)
+  image = capture.query
+  gray = image.BGR2GRAY
+  bin = gray.threshold_binary(0x44, 0xFF)
+  contours = bin.find_contours  
+  while contours    
+    image.poly_line! contours.approx(:accuracy => accuracy), :color => CvScalar::Red
+    contours.convexity_defects.each{|cd|
+      image.circle! cd.start, 1, :color => CvScalar::Blue
+      image.circle! cd.end, 1, :color => CvScalar::Blue
+      image.circle! cd.depth_point, 1, :color => CvScalar::Blue
+    }
+
+    contours = contours.h_next
+  end
+  #pts = gray.good_features_to_track(0.01, 10)
+  #puts pts.length
+  window.show image  
+  next unless key
+  case key.chr
+  when "\e"
+    exit
+  end
+end

examples/face_detect.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# face_detect.rb
+require "rubygems"
+gem "opencv"
+require "opencv"
+
+include OpenCV
+
+window = GUI::Window.new("face detect")
+capture = CvCapture.open
+detector = CvHaarClassifierCascade::load("C:/Program Files/OpenCV/data/haarcascades/haarcascade_frontalface_alt.xml")
+
+while true
+  key = GUI::wait_key(1)
+  image = capture.query
+  detector.detect_objects(image){|i|
+    image.rectangle! i.top_left, i.bottom_right, :color => CvColor::Red
+  }
+  window.show image
+  next unless key
+  case key.chr
+  when "\e"
+    exit
+  end
+end

examples/houghcircle.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# houghcircle.rb
+require "rubygems"
+gem "opencv"
+require "opencv"
+include OpenCV
+
+original_window = GUI::Window.new "original"
+hough_window = GUI::Window.new "hough circles"
+
+image = IplImage::load "stuff.jpg"
+gray = image.BGR2GRAY
+
+result = image.clone
+original_window.show image
+detect = gray.hough_circles_gradient(2.0, 10, 200, 50)
+puts detect.size
+detect.each{|circle|
+  puts "#{circle.center.x},#{circle.center.y} - #{circle.radius}"
+  result.circle! circle.center, circle.radius, :color => CvColor::Red, :thickness => 3
+}
+hough_window.show result
+GUI::wait_key

examples/inpaint.png

@@ -0,0 +1,2 @@
+‰PNG
+

examples/inpaint.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# inpaint.rb
+require "rubygems"
+gem "opencv"
+require "opencv"
+
+include OpenCV
+
+owindow = GUI::Window.new "original"
+mwindow = GUI::Window.new "mask"
+iwindow = GUI::Window.new "inpaint"
+
+image = IplImage::load "inpaint.png"
+b, g, r = image.split
+original_mask = r.threshold_binary_inverse(0x00, 0xFF) & b.threshold_binary_inverse(0x00, 0xFF)
+mask = original_mask.copy
+
+num_dilate = 3
+radius = 5
+dilate_bar = mwindow.set_trackbar("dilate", 10, num_dilate){|v|
+  num_dilate = v
+  mask = original_mask.dilate(nil, num_dilate)
+  mwindow.show mask  
+}
+
+radius_bar = mwindow.set_trackbar("radius", 30, radius){|v|
+  radius = v
+}
+
+owindow.show image
+mwindow.show mask
+
+while key = GUI::wait_key
+  case key.chr
+  when "\e" # esc
+    exit
+  when "n"
+    iwindow.show image.inpaint_ns(mask, radius)
+  when "t"
+    iwindow.show image.inpaint_telea(mask, radius)
+  end
+end
+

examples/paint.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+# paint.rb
+require "rubygems"
+gem "opencv"
+require "opencv"
+
+include OpenCV
+
+window = GUI::Window.new("free canvas")
+canvas = CvMat.new(500, 500, 0, 3).fill!(0xFF) # create white canvas
+window.show canvas
+
+colors = CvColor::constants.collect{|i| i.to_s }
+
+usage =<<USAGE
+[mouse]
+drag            - draw
+right button    - fill by color
+[keyborad]
+1 to 9          - change thickness of line
+type color name - change color
+esc             - exit
+USAGE
+puts usage
+
+point = nil
+
+# drawing option
+opt = {
+  :color => CvColor::Black,
+  :tickness => 1
+}
+
+window.on_mouse{|m|
+  case m.event
+  when :move
+    if m.left_button?
+      canvas.line!(point, m, opt) if point
+      point = m
+    end
+  when :left_button_down
+    canvas.line!(m, m, opt)
+    point = m
+  when :left_button_up
+    point = nil
+  when :right_button_down
+    mask = canvas.flood_fill!(m, opt[:color])    
+  end
+  window.show canvas
+}
+
+color_name = ''
+while key = GUI.wait_key
+  next if key < 0
+  case key.chr
+  when "\e" # [esc] - exit
+    exit
+  when '1'..'9'
+    puts "change thickness to #{key.chr.to_i}."
+    opt[:thickness] = key.chr.to_i
+  else
+    color_name << key.chr
+    choice = colors.find_all{|i| i =~ /\A#{color_name}/i}
+    if choice.size == 1
+      color,= choice
+      puts "change color to #{color}."
+      opt[:color] = CvColor::const_get(color)
+    end
+    color_name = '' if choice.length < 2
+  end
+end
+

examples/snake.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# snake.rb
+require "rubygems"
+gem "opencv"
+require "opencv"
+include OpenCV
+
+puts <<USAGE
+usage:
+  left-click: set point
+  right-click: do snake
+USAGE
+
+window = GUI::Window.new "snake demo"
+image = CvMat.new(256, 256, :cv8u, 1).clear!
+image.circle!(CvPoint.new(128,128), 40, :color => CvColor::White, :thickness =>  -1)
+display = image.GRAY2BGR
+
+window.show display
+
+points = []
+
+window.on_mouse{|mouse|
+  case mouse.event
+  when :left_button_down
+    display[mouse.x, mouse.y] = CvColor::Red
+    puts "set point (#{mouse.x},#{mouse.y})"
+    points << CvPoint.new(mouse.x, mouse.y)
+    window.show display
+  when :right_button_down
+    if points.length < 3
+      puts "please set more point!"
+      next
+    end
+    points = image.snake_image(points, 1.0, 0.5, 1.5, CvSize.new(3, 3), 100)
+    display = image.GRAY2BGR
+    display.poly_line! points, :color => CvColor::Red, :is_closed => true
+    window.show display
+  end
+}
+
+GUI::wait_key
+

examples/stuff.jpg

@@ -0,0 +1 @@
+<EFBFBD>ﾘ<EFBFBD><EFBFBD>

ext/curve.cpp

@@ -0,0 +1,103 @@
+/************************************************************
+
+   curve.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#include"curve.h"
+/*
+ * Document-class: OpenCV::Curve
+ *
+ * Curve sequence.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CURVE
+
+VALUE module;
+    
+VALUE
+rb_module()
+{
+  return module;
+}
+
+void
+define_ruby_module()
+{
+  if(module)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  module = rb_define_module_under(opencv, "Curve");
+  rb_define_method(module, "close?", RUBY_METHOD_FUNC(rb_closed_q), 0);
+  rb_define_method(module, "convex?", RUBY_METHOD_FUNC(rb_convex_q), 0);
+  rb_define_method(module, "hole?", RUBY_METHOD_FUNC(rb_hole_q), 0);
+  rb_define_method(module, "simple?", RUBY_METHOD_FUNC(rb_simple_q), 0);
+  rb_define_method(module, "arc_length", RUBY_METHOD_FUNC(rb_arc_length), -1);
+}
+
+/*
+ * If curve is closed, return true. Otherwise return false.
+ */
+VALUE
+rb_closed_q(VALUE self)
+{
+  return CV_IS_SEQ_CLOSED(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * If curve is convex, return true. Otherwise return false.
+ */
+VALUE
+rb_convex_q(VALUE self)
+{
+  return CV_IS_SEQ_CONVEX(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * If curve is hole(inner contour), return true. Otherwise return false.
+ */
+VALUE
+rb_hole_q(VALUE self)
+{  
+  return CV_IS_SEQ_HOLE(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * no idia.
+ */
+VALUE
+rb_simple_q(VALUE self)
+{
+  return CV_IS_SEQ_SIMPLE(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   arc_length(<i>[slice = nil][,is_closed = nil]</i>) -> float
+ *
+ * Calculates contour perimeter or curve length.
+ * <i>slice</i> is starting and ending points of the curve.
+ * <i>is_closed</i> is indicates whether the curve is closed or not. There are 3 cases:
+ * * is_closed = true  - the curve is assumed to be unclosed.
+ * * is_closed = false - the curve is assumed to be closed.
+ * * is_closed = nil (default) use self#close?
+ */
+VALUE
+rb_arc_length(int argc, VALUE *argv, VALUE self)
+{
+  VALUE slice, is_closed;
+  rb_scan_args(argc, argv, "02", &slice, &is_closed);
+  return rb_float_new(cvArcLength(CVARR(self), NIL_P(slice) ? CV_WHOLE_SEQ : VALUE_TO_CVSLICE(slice), TRUE_OR_FALSE(is_closed, -1)));
+}
+
+__NAMESPACE_END_CURVE
+__NAMESPACE_END_OPENCV
+

ext/curve.h

@@ -0,0 +1,34 @@
+/************************************************************
+
+   curve.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSEQ_CURVE_H
+#define RUBY_OPENCV_CVSEQ_CURVE_H
+
+#include"opencv.h"
+
+#define __NAMESPACE_BEGIN_CURVE namespace mCurve{
+#define __NAMESPACE_END_CURVE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CURVE
+
+VALUE rb_module();
+
+void define_ruby_module();
+
+VALUE rb_closed_q(VALUE self);
+VALUE rb_convex_q(VALUE self);
+VALUE rb_hole_q(VALUE self);
+VALUE rb_simple_q(VALUE self);
+VALUE rb_arc_length(int argc, VALUE *argv, VALUE self);
+
+__NAMESPACE_END_CURVE
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSEQ_CURVE_H

ext/cvavgcomp.cpp

@@ -0,0 +1,67 @@
+/************************************************************
+
+   cvavgcomp.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvavgcomp.h"
+/*
+ * Document-class: OpenCV::CvAvgComp
+ *
+ * CvRect with parameter "neighbors".
+ * CvHaarClassifierCascade#detect_object. 
+ *
+ *   typedef struct CvAvgComp{
+ *     CvRect rect;
+ *     int neighbors;
+ *   }
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_AVGCOMP
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * cvrect = rb_define_class_under(opencv, "CvRect", rb_cObject);
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv(), cvrect = cCvRect::rb_class();
+  rb_klass = rb_define_class_under(opencv, "CvAvgComp", cvrect);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "neighbors", RUBY_METHOD_FUNC(rb_neighbors), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvAvgComp *ptr;
+  return Data_Make_Struct(klass, CvAvgComp, 0, -1, ptr);
+}
+
+/*
+ * Return neighbors.
+ */
+VALUE
+rb_neighbors(VALUE self)
+{
+  return INT2FIX(CVAVGCOMP(self)->neighbors);
+}
+
+__NAMESPACE_END_AVGCOMP
+__NAMESPACE_END_OPENCV

ext/cvavgcomp.h

@@ -0,0 +1,39 @@
+/**********************************************************************
+
+   cvavgcomp.h
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+**********************************************************************/
+#ifndef RUBY_OPENCV_AVGCOMP_H
+#define RUBY_OPENCV_AVGCOMP_H
+
+#define __NAMESPACE_BEGIN_AVGCOMP namespace cCvAvgComp{
+#define __NAMESPACE_END_AVGCOMP }
+
+#include <opencv.h>
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_AVGCOMP
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_neighbors(VALUE self);
+
+__NAMESPACE_END_AVGCOMP
+
+inline CvAvgComp *CVAVGCOMP(VALUE object){
+  CvAvgComp *ptr;
+  Data_Get_Struct(object, CvAvgComp, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+
+#endif // RUBY_OPENCV_AVGCOMP_H

ext/cvbox2d.cpp

@@ -0,0 +1,114 @@
+/************************************************************
+
+   cvbox2d.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvbox2d.h"
+/*
+ * Document-class: OpenCV::CvBox2D
+ *
+ * C structure is here.
+ *   typdef struct CvBox2D{
+ *     CvPoint2D32f center; // center of the box.
+ *     CvSize2D32f size;    // box width and length
+ *     float angle;         // angle between the horizonal axis and the first side (i.e length) in radians
+ *   }CvBox2D;
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVBOX2D
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  rb_klass = rb_define_class_under(opencv, "CvBox2D", rb_cObject);
+  rb_define_method(rb_klass, "center", RUBY_METHOD_FUNC(rb_center), 0);
+  rb_define_method(rb_klass, "size", RUBY_METHOD_FUNC(rb_size), 0);
+  rb_define_method(rb_klass, "angle", RUBY_METHOD_FUNC(rb_angle), 0);
+  rb_define_method(rb_klass, "points", RUBY_METHOD_FUNC(rb_points), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvBox2D *ptr;
+  return Data_Make_Struct(klass, CvBox2D, 0, -1, ptr);
+}
+
+/*
+ * Return center point of box as CvPoint2D32f.
+ */
+VALUE
+rb_center(VALUE self)
+{
+  return REFER_OBJECT(cCvPoint2D32f::rb_class(), &CVBOX2D(self)->center, self);
+}
+
+/*
+ * Return size of box as CvSize2D32f.
+ */
+VALUE
+rb_size(VALUE self)
+{
+  return REFER_OBJECT(cCvSize2D32f::rb_class(), &CVBOX2D(self)->size, self);
+}
+
+/*
+ * Return angle of box as Float.
+ */
+VALUE
+rb_angle(VALUE self)
+{
+  return rb_float_new(CVBOX2D(self)->angle);
+}
+
+/*
+ * Find box vertices. Return Array contain 4 CvPoint2D32f.
+ */
+VALUE
+rb_points(VALUE self)
+{
+  const int n = 4;
+  CvPoint2D32f p[n];
+  cvBoxPoints(*CVBOX2D(self), p);
+  VALUE points = rb_ary_new2(n);
+  for(int i = 0; i < n; i++)
+    rb_ary_store(points, i, cCvPoint2D32f::new_object(p[i]));        
+  return points;
+}
+
+VALUE
+new_object()
+{
+  return rb_allocate(cCvBox2D::rb_class());
+}
+
+VALUE
+new_object(CvBox2D box)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVBOX2D(object) = box;
+  return object;
+}
+
+__NAMESPACE_END_CVBOX2D
+__NAMESPACE_END_OPENCV

ext/cvbox2d.h

@@ -0,0 +1,53 @@
+/************************************************************
+
+   cvbox2d.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVBOX2D_H
+#define RUBY_OPENCV_CVBOX2D_H
+
+#include"opencv.h"
+
+#define __NAMESPACE_BEGIN_CVBOX2D namespace cCvBox2D{
+#define __NAMESPACE_END_CVBOX2D }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVBOX2D
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+
+VALUE rb_center(VALUE self);
+VALUE rb_size(VALUE self);
+VALUE rb_angle(VALUE self);
+VALUE rb_points(VALUE self);
+
+VALUE new_object();
+VALUE new_object(CvBox2D box);
+
+__NAMESPACE_END_CVBOX2D
+
+inline CvBox2D *CVBOX2D(VALUE object){
+  CvBox2D *ptr;
+  Data_Get_Struct(object, CvBox2D, ptr);
+  return ptr;
+}
+
+inline CvBox2D VALUE_TO_CVBOX2D(VALUE object){
+  if(rb_obj_is_kind_of(object, cCvBox2D::rb_class())) {
+    return *CVBOX2D(object);
+  }else{
+    rb_raise(rb_eTypeError, "require %s or compatible object.", rb_class2name(cCvBox2D::rb_class()));
+  }
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVBOX2D_H

ext/cvcapture.cpp

@@ -0,0 +1,276 @@
+/************************************************************
+
+   cvcapture.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include"cvcapture.h"
+/*
+ * Document-class: OpenCV::CvCapture
+ *
+ * Capture image from video stream.
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCAPTURE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvCapture", rb_cData);
+  
+  VALUE video_interface = rb_hash_new();
+  /* {:any, :mil, :vfw, :v4l, :v4l2, :fireware, :ieee1394, :dc1394, :cmu1394, :stereo, :tyzx, :tyzx_left, :tyzx_right, :tyzx_color, :tyzx_z, :qt, :qtuicktime}: video source */
+  rb_define_const(rb_klass, "INTERFACE", video_interface);
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("any")), INT2FIX(CV_CAP_ANY));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("mil")), INT2FIX(CV_CAP_MIL));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("vfw")), INT2FIX(CV_CAP_VFW));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("v4l")), INT2FIX(CV_CAP_V4L));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("v4l2")), INT2FIX(CV_CAP_V4L2));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("fireware")), INT2FIX(CV_CAP_FIREWARE));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("ieee1394")), INT2FIX(CV_CAP_IEEE1394));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("dc1394")), INT2FIX(CV_CAP_DC1394));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("cmu1394")), INT2FIX(CV_CAP_CMU1394));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("stereo")), INT2FIX(CV_CAP_STEREO));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx")), INT2FIX(CV_CAP_TYZX));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_left")), INT2FIX(CV_TYZX_LEFT));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_right")), INT2FIX(CV_TYZX_RIGHT));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_color")), INT2FIX(CV_TYZX_COLOR));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_z")), INT2FIX(CV_TYZX_Z));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("qt")), INT2FIX(CV_CAP_QT));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("quicktime")), INT2FIX(CV_CAP_QT));
+  
+  rb_define_singleton_method(rb_klass, "open", RUBY_METHOD_FUNC(rb_open), -1);
+  
+  rb_define_method(rb_klass, "grab", RUBY_METHOD_FUNC(rb_grab), 0);
+  rb_define_method(rb_klass, "retrieve", RUBY_METHOD_FUNC(rb_retrieve), 0);
+  rb_define_method(rb_klass, "query", RUBY_METHOD_FUNC(rb_query), 0);
+  rb_define_method(rb_klass, "millisecond", RUBY_METHOD_FUNC(rb_millisecond), 0);
+  rb_define_method(rb_klass, "frames", RUBY_METHOD_FUNC(rb_frames), 0);
+  rb_define_method(rb_klass, "size", RUBY_METHOD_FUNC(rb_size), 0);
+  rb_define_method(rb_klass, "width", RUBY_METHOD_FUNC(rb_width), 0);
+  rb_define_method(rb_klass, "height", RUBY_METHOD_FUNC(rb_height), 0);
+  rb_define_method(rb_klass, "fps", RUBY_METHOD_FUNC(rb_fps), 0);
+  rb_define_method(rb_klass, "fourcc", RUBY_METHOD_FUNC(rb_fourcc), 0);
+  rb_define_method(rb_klass, "frame_count", RUBY_METHOD_FUNC(rb_frame_count), 0);
+}
+
+void
+free(void *ptr)
+{ 
+  if(ptr)
+    cvReleaseCapture((CvCapture**)&ptr);
+}
+
+/*
+ * call-seq:
+ *   CvCapture.open(<i>[dev = -1]</i>)
+ *
+ * Reading video stream from the specified file or camera device.
+ * If <i>dev</i> is string (i.e "stream.avi"), reading video stream from file.
+ * If <i>dev</i> is number or symbol(include CvCapture::INTERFACE),
+ * reading video stream from camera. 
+ * Currently two camera interfaces can be used on Windows:
+ * * Video for Windows(VFW)
+ * * Matrox Imaging Library(MIL)
+ * and two on Linux
+ * * V4L
+ * * FireWire(IEEE1394).
+ * If there is only one camera or it does not matter what camera to use <i>nil</i> may be passed.
+ */
+VALUE
+rb_open(int argc, VALUE *argv, VALUE self)
+{
+  VALUE device, i;
+  rb_scan_args(argc, argv, "01", &device);
+  CvCapture *capture = 0;
+  switch (TYPE(device)) {
+  case T_STRING:
+    capture = cvCaptureFromFile(StringValueCStr(device));
+    break;
+  case T_FIXNUM:
+    capture = cvCaptureFromCAM(FIX2INT(device));
+    break;
+  case T_SYMBOL:    
+    i = rb_hash_aref(rb_const_get(rb_class(), rb_intern("INTERFACE")), device);
+    if (NIL_P(i))
+      rb_raise(rb_eArgError, "undefined interface.");
+    capture = cvCaptureFromCAM(NUM2INT(i));
+    break;
+  case T_NIL:
+    capture = cvCaptureFromCAM(CV_CAP_ANY);
+    break;
+  }
+  if (!capture)
+    rb_raise(rb_eStandardError, "Invalid capture format.");
+  return Data_Wrap_Struct(rb_klass, 0, free, capture);
+}
+
+
+/*
+ * call-seq:
+ *   grab -> true or false
+ *
+ * Grabbed frame is stored internally. To grab frame
+ * <i>fast</i> that is important for syncronization in case of reading from
+ * several cameras simultaneously. The grabbed frames are not exposed because
+ * they may be stored in compressed format (as defined by camera/driver).
+ * To retrieve the grabbed frame, retrieve should be used.
+ *
+ * If grabbed frame was success, return true. Otherwise return false.
+ */
+VALUE
+rb_grab(VALUE self)
+{
+  return cvGrabFrame(CVCAPTURE(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   retrieve -> CvMat or nil
+ *
+ * Gets the image grabbed with grab.
+ */
+VALUE
+rb_retrieve(VALUE self)
+{
+  IplImage *frame = cvRetrieveFrame(CVCAPTURE(self));
+  if(!frame)
+    return Qnil;
+  VALUE image = cIplImage::new_object(cvSize(frame->width, frame->height), CV_MAKETYPE(CV_8U, frame->nChannels));
+  if (frame->origin == IPL_ORIGIN_TL) {
+    cvCopy(frame, CVARR(image));
+  } else {
+    cvFlip(frame, CVARR(image));
+  }
+  return image;
+}
+
+/*
+ * call-seq:
+ *   query -> CvMat or nil
+ *
+ * Grabs and returns a frame camera or file. Just a combination of grab and retrieve in one call.
+ */
+VALUE
+rb_query(VALUE self)
+{
+  IplImage *frame = cvQueryFrame(CVCAPTURE(self));
+  if(!frame)
+    return Qnil;
+  VALUE image = cIplImage::new_object(cvSize(frame->width, frame->height), CV_MAKETYPE(CV_8U, frame->nChannels));
+  if (frame->origin == IPL_ORIGIN_TL) {
+    cvCopy(frame, CVARR(image));
+  } else {
+    cvFlip(frame, CVARR(image));
+  }
+  return image;
+}
+
+/*
+ * Film current position in milliseconds or video capture timestamp.
+ */
+VALUE
+rb_millisecond(VALUE self)
+{
+  return rb_dbl2big(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_POS_MSEC));
+}
+
+/*
+ * 0-based index of the frame to be decoded/captured next
+ */
+VALUE
+rb_frames(VALUE self)
+{
+  return rb_float_new(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_POS_FRAMES));
+}
+
+/*
+ * Relative position of video file (0 - start of the film, 1 - end of the film)
+ */
+VALUE
+rb_avi_ratio(VALUE self)
+{
+  return rb_float_new(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_POS_AVI_RATIO));  
+}
+
+/*
+ * Size of frames in the video stream.
+ */
+VALUE
+rb_size(VALUE self)
+{
+  return cCvSize::new_object(cvSize((int)cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FRAME_WIDTH), (int)cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FRAME_HEIGHT))); 
+}
+
+/*
+ * Width of frames in the video stream.
+ */
+VALUE
+rb_width(VALUE self)
+{
+  return rb_dbl2big(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FRAME_WIDTH));
+}
+
+/*
+ * Height of frames in the video stream.
+ */
+VALUE
+rb_height(VALUE self)
+{
+  return rb_dbl2big(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FRAME_HEIGHT));
+}
+
+/*
+ * Frame rate
+ */
+VALUE
+rb_fps(VALUE self)
+{
+  return rb_dbl2big(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FPS));
+}
+
+/*
+ * 4character code of codec. see http://www.fourcc.org/
+ */
+VALUE
+rb_fourcc(VALUE self)
+{
+  char str[4];
+  double fourcc = cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FOURCC);
+  sprintf(str, "%s", (char*)&fourcc);
+  return rb_str_new2(str);
+}
+
+/*
+ * Number of frames in video file.
+ */
+VALUE
+rb_frame_count(VALUE self)
+{
+  return rb_dbl2big(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FRAME_COUNT));
+}
+
+
+__NAMESPACE_END_CVCAPTURE
+__NAMESPACE_END_OPENCV

ext/cvcapture.h

@@ -0,0 +1,54 @@
+/************************************************************
+
+   cvcapture.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCAPTURE_H
+#define RUBY_OPENCV_CVCAPTURE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCAPTURE namespace cCvCapture{
+#define __NAMESPACE_END_CVCAPTURE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCAPTURE
+
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+void free(void *ptr);
+VALUE rb_open(int argc, VALUE *argv, VALUE klass);
+
+VALUE rb_grab(VALUE self);
+VALUE rb_retrieve(VALUE self);
+VALUE rb_query(VALUE self);
+
+VALUE rb_millisecond(VALUE self);
+VALUE rb_frames(VALUE self);
+VALUE rb_avi_ratio(VALUE self);
+VALUE rb_size(VALUE self);
+VALUE rb_width(VALUE self);
+VALUE rb_height(VALUE self);
+VALUE rb_fps(VALUE self);
+VALUE rb_fourcc(VALUE self);
+VALUE rb_frame_count(VALUE self);
+
+__NAMESPACE_END_CVCAPTURE
+
+
+inline CvCapture *CVCAPTURE(VALUE object){
+  CvCapture *ptr;
+  Data_Get_Struct(object, CvCapture, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCAPTURE_H

ext/cvchain.cpp

@@ -0,0 +1,184 @@
+/************************************************************
+
+   cvchain.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvchain.h"
+/*
+ * Document-class: OpenCV::CvChain
+ *
+ * Freeman chain code.
+ * CvMat#find_contours(:method => :code)
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCHAIN
+
+#define APPROX_CHAIN_OPTION(op) NIL_P(op) ? rb_const_get(rb_class(), rb_intern("APPROX_CHAIN_OPTION")) : rb_funcall(rb_const_get(rb_class(), rb_intern("APPROX_CHAIN_OPTION")), rb_intern("merge"), 1, op)
+#define APPROX_CHAIN_METHOD(op) CVMETHOD("APPROX_CHAIN_METHOD", rb_hash_aref(op, ID2SYM(rb_intern("method"))), CV_CHAIN_APPROX_SIMPLE)
+#define APPROX_CHAIN_PARAMETER(op) NUM2INT(rb_hash_aref(op, ID2SYM(rb_intern("parameter"))))
+#define APPROX_CHAIN_MINIMAL_PARAMETER(op) NUM2INT(rb_hash_aref(op, ID2SYM(rb_intern("minimal_parameter"))))
+#define APPROX_CHAIN_RECURSIVE(op) ({VALUE _recursive = rb_hash_aref(op, ID2SYM(rb_intern("recursive"))); NIL_P(_recursive) ? 0 : _recursive == Qfalse ? 0 : 1;})
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * cvseq = rb_define_class_under(opencv, "CvSeq");
+   * curve = rb_define_module_under(opencv, "Curve");
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  VALUE cvseq = cCvSeq::rb_class();
+  VALUE curve = mCurve::rb_module();
+
+  rb_klass = rb_define_class_under(opencv, "CvChain", cvseq);
+  rb_include_module(rb_klass, curve);
+  VALUE approx_chain_option = rb_hash_new();
+  rb_define_const(rb_klass, "APPROX_CHAIN_OPTION", approx_chain_option); 
+  rb_hash_aset(approx_chain_option, ID2SYM(rb_intern("method")), ID2SYM(rb_intern("approx_simple")));
+  rb_hash_aset(approx_chain_option, ID2SYM(rb_intern("parameter")), rb_float_new(0));
+  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_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, "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");
+}
+
+/*
+ * call-seq:
+ *   origin -> cvpoint
+ *
+ * Return Freeman chain code origin.
+ */
+VALUE
+rb_origin(VALUE self)
+{
+  return cCvPoint::new_object(CVCHAIN(self)->origin);
+}
+
+/*
+ * call-seq:
+ *   origin = point -> self
+ *
+ * Set Freeman chain code origin.
+ */
+VALUE
+rb_set_origin(VALUE self, VALUE origin)
+{
+  CVCHAIN(self)->origin = VALUE_TO_CVPOINT(origin);  
+  return self;
+}
+
+/*
+ * call-seq:
+ *   codes -> array(contain fixnum)
+ *
+ * Return Freeman chain codes.
+ */
+VALUE
+rb_codes(VALUE self)
+{
+  CvChain *chain = CVCHAIN(self);
+  CvChainPtReader reader;
+  CvPoint p = chain->origin;
+  VALUE ary = rb_ary_new2(chain->total);
+  cvStartReadChainPoints(chain, &reader);
+  for (int i = 0; i < chain->total; i++) {
+    CV_READ_SEQ_ELEM(reader.code, (*((CvSeqReader*)&(reader))));
+    rb_ary_store(ary, i, CHR2FIX(reader.code));
+  }
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   points -> array(contain cvpoint)
+ *
+ * Return points that represent by Freeman chain code.
+ */
+VALUE
+rb_points(VALUE self)
+{
+  CvChain *chain = CVCHAIN(self);
+  CvChainPtReader reader;
+  CvPoint p = chain->origin;
+  VALUE ary = rb_ary_new2(chain->total);
+  cvStartReadChainPoints(chain, &reader);
+  for (int i = 0; i < chain->total; i++) {
+    CV_READ_CHAIN_POINT(p, reader);
+    rb_ary_store(ary, i, cCvPoint::new_object(p));
+  }
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   approx_chain(<i>[approx_chain_option]</i>) -> cvcontour
+ *
+ * Approximates Freeman chain(s) with polygonal curve.
+ * <i>approx_chain_option</i> should be Hash include these keys.
+ *   :method - Approximation method.
+ *      :approx_none - translate all the points from the chain code into points;
+ *      :approx_simple(default) - compress horizontal, vertical, and diagonal segments, that is,
+ *                                the function leaves only their ending points.
+ *      :approx_tc89_l1
+ *      :approx_tc89_kcos - apply one of the flavors of Teh-Chin chain approximation algorithm.
+ *      If set the difference between the current pixel and seed pixel is considered,
+ *      otherwise difference between neighbor pixels is considered (the range is floating).
+ *   :parameter - Method parameter (not used now).
+ *   :minimal_perimeter (default 0)
+ *      Approximates only those contours whose perimeters are not less than minimal_perimeter. Other chains are removed from the resulting structure.
+ *   :recursive (default false)
+ *      If not nil or false, the function approximates all chains that access can be obtained to
+ *      from self by h_next or v_next links. If 0, the single chain is approximated.
+ *
+ */
+VALUE
+rb_approx_chain(int argc, VALUE *argv, VALUE self)
+{
+  VALUE approx_chain_option, storage;
+  rb_scan_args(argc, argv, "01", &approx_chain_option);
+  approx_chain_option = APPROX_CHAIN_OPTION(approx_chain_option);
+  /* can't compile VC
+  storage = cCvMemStorage::new_object();
+  CvSeq *seq = cvApproxChains(CVSEQ(self), CVMEMSTORAGE(storage),			      
+			      APPROX_CHAIN_METHOD(approx_chain_option),
+			      APPROX_CHAIN_PARAMETER(approx_chain_option),			    
+			      APPROX_CHAIN_MINIMAL_PARAMETER(approx_chain_option),			      
+			      APPROX_CHAIN_RECURSIVE(approx_chain_option));
+  
+  return cCvSeq::new_sequence(cCvContour::rb_class(), seq, cCvPoint::rb_class(), storage);
+  */
+  return Qnil;
+}
+
+VALUE
+new_object()
+{
+  VALUE storage = cCvMemStorage::new_object();
+  CvSeq *seq = cvCreateSeq(CV_SEQ_CHAIN_CONTOUR, sizeof(CvChain), sizeof(CvChainCode), CVMEMSTORAGE(storage));
+  VALUE object = cCvSeq::new_sequence(cCvChain::rb_class(), seq, cCvChainCode::rb_class(), storage);
+  return object;
+}
+
+__NAMESPACE_END_CVCHAIN
+__NAMESPACE_END_OPENCV

ext/cvchain.h

@@ -0,0 +1,43 @@
+/************************************************************
+
+  cvchain.h -
+
+  $Author: lsxi $
+
+  Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCHAIN_H
+#define RUBY_OPENCV_CVCHAIN_H
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCHAIN namespace cCvChain{
+#define __NAMESPACE_END_CVCHAIN }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCHAIN
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_origin(VALUE self);
+VALUE rb_set_origin(VALUE self, VALUE origin);
+VALUE rb_codes(VALUE self);
+VALUE rb_points(VALUE self);
+VALUE rb_approx_chain(int argc, VALUE *argv, VALUE self);
+
+VALUE new_object();
+
+__NAMESPACE_END_CVCHAIN
+
+inline CvChain*
+CVCHAIN(VALUE object){
+  CvChain *ptr;
+  Data_Get_Struct(object, CvChain, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCHAIN_H

ext/cvchaincode.cpp

@@ -0,0 +1,49 @@
+/************************************************************
+
+   cvchaincode.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvchaincode.h"
+/*
+ * Document-class: OpenCV::CvChainCode
+ *
+ * Freeman chain code.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCHAINCODE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvChainCode", rb_cObject);
+}
+
+VALUE
+rb_to_i(VALUE self)
+{
+  return CHR2FIX(CVCHAINCODE(self)->code);
+}
+
+__NAMESPACE_END_CVCHAINCODE
+__NAMESPACE_END_OPENCV

ext/cvchaincode.h

@@ -0,0 +1,43 @@
+/************************************************************
+
+    opchaincode.h -
+
+    $Author: lsxi $
+
+    Copyright (C) 2008 Masakazu Yonekura
+
+ ************************************************************/
+#ifndef RUBY_OPENCV_CVCHAINCODE_H
+#define RUBY_OPENCV_CVCHAINCODE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCHAINCODE namespace cCvChainCode{
+#define __NAMESPACE_END_CVCHAINCODE }
+
+typedef struct CvChainCode{
+  char code;
+}CvChainCode;
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCHAINCODE
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_to_i(VALUE self);
+
+__NAMESPACE_END_CVCHAINCODE
+
+inline CvChainCode*
+CVCHAINCODE(VALUE object){
+  CvChainCode *ptr;
+  Data_Get_Struct(object, CvChainCode, ptr);
+  return ptr;
+}
+
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCHAINCODE_H

ext/cvcircle32f.cpp

@@ -0,0 +1,90 @@
+/************************************************************
+
+   cvcircle32f.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvcircle32f.h"
+/*
+ * Document-class: OpenCV::CvCircle32f
+ *
+ * Combination of center and radius.
+ *
+ * see CvMat#hough_circles
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCIRCLE32F
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvCircle32f", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "center", RUBY_METHOD_FUNC(rb_center), 0);
+  rb_define_method(rb_klass, "radius", RUBY_METHOD_FUNC(rb_radius), 0);
+
+  //rb_define_method(rb_klass, "to_s", RUBY_METHOD_FUNC(rb_to_s), 0);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvCircle32f *ptr;
+  return Data_Make_Struct(klass, CvCircle32f, 0, -1, ptr);
+}
+
+/*
+ * Return parameter on center.
+ */
+VALUE
+rb_center(VALUE self)
+{
+  return cCvPoint2D32f::new_object(CVCIRCLE32F(self)->center);
+}
+
+/*
+ * Return parameter on radius.
+ */
+VALUE
+rb_radius(VALUE self)
+{
+  return rb_float_new(CVCIRCLE32F(self)->radius);
+}
+
+VALUE
+rb_to_ary(VALUE self)
+{
+  return rb_ary_new3(2, rb_center(self), rb_radius(self));
+}
+
+VALUE
+new_object(CvCircle32f circle32f)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVCIRCLE32F(object) = circle32f;
+  return object;
+}
+
+__NAMESPACE_END_CVCIRCLE32F
+__NAMESPACE_END_OPENCV

ext/cvcircle32f.h

@@ -0,0 +1,53 @@
+/************************************************************
+
+   cvcircle32f.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCIRCLE32F_H
+#define RUBY_OPENCV_CVCIRCLE32F_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCIRCLE32F namespace cCvCircle32f{
+#define __NAMESPACE_END_CVCIRCLE32F }
+
+__NAMESPACE_BEGIN_OPENCV
+
+typedef struct CvCircle32f{
+  CvPoint2D32f center;
+  float radius;
+} CvCircle32f;
+
+__NAMESPACE_BEGIN_CVCIRCLE32F
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_center(VALUE self);
+VALUE rb_radius(VALUE self);
+
+VALUE rb_to_s(VALUE self);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object(CvCircle32f circle32f);
+
+__NAMESPACE_END_CVCIRCLE32F
+
+inline CvCircle32f*
+CVCIRCLE32F(VALUE object)
+{
+  CvCircle32f *ptr;
+  Data_Get_Struct(object, CvCircle32f, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCIRCLE32F_H

ext/cvcondensation.cpp

@@ -0,0 +1,230 @@
+/************************************************************
+
+   cvcondensation.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvcondensation.h"
+/*
+ * Document-class: OpenCV::CvConDensation
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONDENSATION
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  rb_klass = rb_define_class_under(opencv, "CvConDensation", rb_cObject);
+  rb_define_method(rb_klass, "dp", RUBY_METHOD_FUNC(rb_dp), 0);
+  rb_define_method(rb_klass, "mp", RUBY_METHOD_FUNC(rb_mp), 0);
+  rb_define_method(rb_klass, "dynamic_matrix", RUBY_METHOD_FUNC(rb_dynamic_matrix), 0);
+  rb_define_method(rb_klass, "confidence", RUBY_METHOD_FUNC(rb_confidence), 0);
+  rb_define_method(rb_klass, "cumulative", RUBY_METHOD_FUNC(rb_cumulative), 0);
+  rb_define_method(rb_klass, "state", RUBY_METHOD_FUNC(rb_state), 0);
+  rb_define_method(rb_klass, "samples_num", RUBY_METHOD_FUNC(rb_samples_num), 0);
+  rb_define_method(rb_klass, "init_sample_set", RUBY_METHOD_FUNC(rb_init_sample_set), 2);
+  rb_define_method(rb_klass, "update_by_time", RUBY_METHOD_FUNC(rb_update_by_time), 0);
+  rb_define_alias(rb_klass, "update", "update_by_time");
+  rb_define_method(rb_klass, "each_sample", RUBY_METHOD_FUNC(rb_each_sample), 0);
+  rb_define_method(rb_klass, "calculate_confidence", RUBY_METHOD_FUNC(rb_calculate_confidence), 0);
+}
+
+/*
+ * call-seq:
+ *   dp -> int
+ *
+ * Return dimension of state vector
+ */
+VALUE
+rb_dp(VALUE self)
+{
+  return INT2FIX(CVCONDENSATION(self)->DP);
+}
+
+/*
+ * call-seq:
+ *   mp -> int
+ *
+ * Return demension of measurement vector.
+ */
+VALUE
+rb_mp(VALUE self)
+{
+  return INT2FIX(CVCONDENSATION(self)->MP);
+}
+
+/*
+ * call-seq:
+ *   dynamic_matrix -> mat
+ *
+ * Return matrix of the linear Dynamics system.
+ */
+VALUE
+rb_dynamic_matrix(VALUE self)
+{
+  CvConDensation *cd = CVCONDENSATION(self);
+  return DEPEND_OBJECT(cCvMat::rb_class(), cvInitMatHeader(ALLOC(CvMat), cd->DP, cd->DP, CV_MAKETYPE(CV_32F, 1), cd->DynamMatr), self);
+}
+
+/*
+ * call-seq:
+ *   confidence -> mat
+ *
+ * Return confidence for each sample.
+ */
+VALUE
+rb_confidence(VALUE self)
+{
+  CvConDensation *cd = CVCONDENSATION(self);
+  return DEPEND_OBJECT(cCvMat::rb_class(), cvInitMatHeader(ALLOC(CvMat), cd->SamplesNum, 1, CV_MAKETYPE(CV_32F, 1), cd->flConfidence), self);
+}
+
+/*
+ * call-seq:
+ *   cumulative -> mat
+ *
+ * Return cumulative confidence.
+ */
+VALUE
+rb_cumulative(VALUE self)
+{
+  CvConDensation *cd = CVCONDENSATION(self);
+  return DEPEND_OBJECT(cCvMat::rb_class(), cvInitMatHeader(ALLOC(CvMat), cd->SamplesNum, 1, CV_MAKETYPE(CV_32F, 1), cd->flCumulative), self);
+}
+
+/*
+ * call-seq:
+ *   state -> mat
+ *
+ * Return vector of state
+ */
+VALUE
+rb_state(VALUE self)
+{
+  CvConDensation *cd = CVCONDENSATION(self);
+  return DEPEND_OBJECT(cCvMat::rb_class(), cvInitMatHeader(ALLOC(CvMat), cd->DP, 1, CV_MAKETYPE(CV_32F, 1), cd->State), self);  
+}
+
+/*
+ * call-seq:
+ *   samples_num -> int
+ *
+ * Return number of the samples
+ */
+VALUE
+rb_samples_num(VALUE self)
+{
+  return INT2FIX(CVCONDENSATION(self)->SamplesNum);
+}
+
+/*
+ * call-seq:
+ *   init_sample_set(upper, lower)
+ *
+ * Initializes sample set for ConDensation algorithm.
+ * Fills the samples with values within specified(lower to upper) ranges.
+ */
+VALUE
+rb_init_sample_set(VALUE self, VALUE lower, VALUE upper)
+{
+  CvConDensation *cd = CVCONDENSATION(self);
+  CvMat *lower_bound = CVMAT(lower), *upper_bound = CVMAT(upper), lb_stub, ub_stub;
+  int lower_type = lower_bound->type, upper_type = lower_bound->type;
+  if (lower_type != CV_32FC1 || lower_bound->cols != 1) {
+    if (CV_MAT_DEPTH(lower_type) == CV_32F) {
+      lower_bound = cvReshape(lower_bound, &lb_stub, 1, lower_bound->rows * lower_bound->cols);
+    } else {
+      lower = cCvMat::new_object(cvSize(lower_bound->rows * lower_bound->cols, 1), CV_MAKETYPE(CV_32S, 1));
+      cvConvertScale(lower_bound, CVARR(lower));
+      lower_bound = CVMAT(lower);      
+    }
+  }
+  if (upper_type != CV_32FC1 || upper_bound->cols != 1) {
+    if (CV_MAT_DEPTH(upper_type) == CV_32F) {
+      upper_bound = cvReshape(upper_bound, &ub_stub, 1, upper_bound->rows * upper_bound->cols);
+    } else {
+      upper = cCvMat::new_object(cvSize(upper_bound->rows * upper_bound->cols, 1), CV_MAKETYPE(CV_32F, 1));
+      cvConvertScale(upper_bound, CVARR(upper));
+      upper_bound = CVMAT(upper);      
+    }
+  }
+  if (lower_bound->rows != cd->DP || upper_bound->rows != cd->DP) {
+    rb_raise(rb_eTypeError, "sample matrix step unmatch.");
+  }
+  cvConDensInitSampleSet(cd, lower_bound, upper_bound);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   update_by_time
+ *
+ * Estimates subsequent model state.
+ */
+VALUE
+rb_update_by_time(VALUE self)
+{
+  cvConDensUpdateByTime(CVCONDENSATION(self));
+  return self;
+}
+
+/*
+ * call-seq:
+ *   each_sample{|mat| ... }
+ *
+ * Evaluate each sample by given block.
+ */
+VALUE
+rb_each_sample(VALUE self)
+{
+  CvConDensation *cd = CVCONDENSATION(self);
+  if (rb_block_given_p()) {
+    for (int i = 0; i < cd->SamplesNum; i++) {
+      rb_yield(DEPEND_OBJECT(cCvMat::rb_class(), cvInitMatHeader(ALLOC(CvMat), cd->DP, 1, CV_MAKETYPE(CV_32F, 1), cd->flSamples[i]), self));
+      }
+  }
+  return self;
+}
+
+/*
+ * call-seq:
+ *   calculate_confidence{|value| ... }
+ *
+ * Evalute each sample by given block, then return value set to confidence.
+ */
+VALUE
+rb_calculate_confidence(VALUE self)
+{
+  VALUE value;
+  CvConDensation *cd = CVCONDENSATION(self);
+  if (rb_block_given_p()) {
+    for (int i = 0; i < cd->SamplesNum; i++) {
+      value = rb_yield(DEPEND_OBJECT(cCvMat::rb_class(), cvInitMatHeader(ALLOC(CvMat), cd->DP, 1, CV_MAKETYPE(CV_32F, 1), cd->flSamples[i]), self));
+      cd->flConfidence[i] = NUM2DBL(value);
+    }
+  }
+  return self;
+}
+
+__NAMESPACE_END_CVCONDENSATION
+__NAMESPACE_END_OPENCV

ext/cvcondensation.h

@@ -0,0 +1,49 @@
+/************************************************************
+
+   cvcondensation.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCONDENSATION_H
+#define RUBY_OPENCV_CVCONDENSATION_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCONDENSATION namespace cCvConDensation{
+#define __NAMESPACE_END_CVCONDENSATION }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONDENSATION
+
+VALUE rb_class();
+void define_ruby_class();
+
+VALUE rb_dp(VALUE self);
+VALUE rb_mp(VALUE self);
+VALUE rb_dynamic_matrix(VALUE self);
+VALUE rb_state(VALUE self);
+VALUE rb_confidence(VALUE self);
+VALUE rb_cumulative(VALUE self);
+VALUE rb_samples_num(VALUE self);
+
+VALUE rb_init_sample_set(VALUE self, VALUE lower, VALUE upper);
+VALUE rb_update_by_time(VALUE self);
+VALUE rb_each_sample(VALUE self);
+VALUE rb_calculate_confidence(VALUE self);
+
+__NAMESPACE_END_CVCONDENSATION
+
+inline CvConDensation*
+CVCONDENSATION(VALUE object)
+{
+  CvConDensation *ptr;
+  Data_Get_Struct(object, CvConDensation, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCONDENSATION_H

ext/cvconnectedcomp.cpp

@@ -0,0 +1,115 @@
+/************************************************************
+
+   cvconnectedcomp.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvconnectedcomp.h"
+/*
+ * Document-class: OpenCV::CvConnectedComp
+ *
+ * see CvMat#flood_fill
+ *
+ * C structure is here.
+ *   typedef struct CvConnectedComp
+ *   {
+ *     double area;    
+ *     CvScalar value; 
+ *     CvRect rect;    
+ *     CvSeq* contour;
+ *   } CvConnectedComp;
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONNECTEDCOMP
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvConnectedComp", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "area", RUBY_METHOD_FUNC(rb_area), 0);
+  rb_define_method(rb_klass, "value", RUBY_METHOD_FUNC(rb_value), 0);
+  rb_define_method(rb_klass, "rect", RUBY_METHOD_FUNC(rb_rect), 0);
+  rb_define_method(rb_klass, "rect=", RUBY_METHOD_FUNC(rb_set_rect), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvConnectedComp *ptr;
+  return Data_Make_Struct(klass, CvConnectedComp, 0, -1, ptr);
+}
+
+/*
+ * Return area of connected component.
+ */
+VALUE
+rb_area(VALUE self)
+{
+  return rb_float_new(CVCONNECTEDCOMP(self)->area);
+}
+
+/*
+ * Return average color of the connected component.
+ */
+VALUE
+rb_value(VALUE self)
+{
+  return REFER_OBJECT(cCvScalar::rb_class(), &CVCONNECTEDCOMP(self)->value, self);
+}
+
+/*
+ * Return ROI of the component.
+ */
+VALUE
+rb_rect(VALUE self)
+{
+  return REFER_OBJECT(cCvRect::rb_class(), &CVCONNECTEDCOMP(self)->rect, self);
+}
+
+/*
+ * Set ROI of the component.
+ */
+VALUE
+rb_set_rect(VALUE self, VALUE rect)
+{
+  CVCONNECTEDCOMP(self)->rect = VALUE_TO_CVRECT(rect);
+  return self;
+}
+
+VALUE
+new_object()
+{
+  return rb_allocate(rb_klass);
+}
+
+VALUE
+new_object(CvConnectedComp comp)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVCONNECTEDCOMP(object) = comp;
+  return object;
+}
+
+__NAMESPACE_END_CVCONNECTEDCOMP
+__NAMESPACE_END_OPENCV

ext/cvconnectedcomp.h

@@ -0,0 +1,46 @@
+/************************************************************
+
+   cvconnectedcomp.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCONNECTEDCOMP_H
+#define RUBY_OPENCV_CVCONNECTEDCOMP_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCONNECTEDCOMP namespace cCvConnectedComp{
+#define __NAMESPACE_END_CVCONNECTEDCOMP }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONNECTEDCOMP
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+
+VALUE rb_area(VALUE self);
+VALUE rb_value(VALUE self);
+VALUE rb_rect(VALUE self);
+VALUE rb_set_rect(VALUE self, VALUE rect);
+VALUE rb_contour(VALUE self);
+
+VALUE new_object();
+VALUE new_object(CvConnectedComp comp);
+
+__NAMESPACE_END_CVCONNECTEDCOMP
+
+inline CvConnectedComp *CVCONNECTEDCOMP(VALUE object){
+  CvConnectedComp *ptr;
+  Data_Get_Struct(object, CvConnectedComp, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCONNECTEDCOMP_H

ext/cvcontour.cpp

@@ -0,0 +1,219 @@
+/************************************************************
+
+   cvcontour.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvcontour.h"
+/*
+ * Document-class: OpenCV::CvContour
+ *
+ * Contour.
+ * CvMat#find_contours
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONTOUR
+
+#define APPROX_POLY_OPTION(op) NIL_P(op) ? rb_const_get(rb_class(), rb_intern("APPROX_OPTION")) : rb_funcall(rb_const_get(rb_class(), rb_intern("APPROX_OPTION")), rb_intern("merge"), 1, op)
+#define APPROX_POLY_METHOD(op) CVMETHOD("APPROX_POLY_METHOD", rb_hash_aref(op, ID2SYM(rb_intern("method"))), CV_POLY_APPROX_DP)
+#define APPROX_POLY_ACCURACY(op) NUM2DBL(rb_hash_aref(op, ID2SYM(rb_intern("accuracy"))))
+#define APPROX_POLY_RECURSIVE(op) ({VALUE _recursive = rb_hash_aref(op, ID2SYM(rb_intern("recursive"))); NIL_P(_recursive) ? 0 : _recursive == Qfalse ? 0 : 1;})
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * cvseq = rb_define_class_under(opencv, "CvSeq");
+   * curve = rb_define_module_under(opencv, "Curve");
+   * pointset = rb_define_module_under(opencv, "PointSet");
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  VALUE cvseq = cCvSeq::rb_class();
+  VALUE curve = mCurve::rb_module();
+  VALUE pointset = mPointSet::rb_module();
+
+  rb_klass = rb_define_class_under(opencv, "CvContour", cvseq);
+  rb_include_module(rb_klass, curve);
+  rb_include_module(rb_klass, pointset);
+  
+  VALUE approx_option = rb_hash_new();
+  rb_define_const(rb_klass, "APPROX_OPTION", approx_option);
+  rb_hash_aset(approx_option, ID2SYM(rb_intern("method")), INT2FIX(CV_POLY_APPROX_DP));
+  rb_hash_aset(approx_option, ID2SYM(rb_intern("accuracy")), rb_float_new(1.0));
+  rb_hash_aset(approx_option, ID2SYM(rb_intern("recursive")), Qfalse);
+  
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "rect", RUBY_METHOD_FUNC(rb_rect), 0);
+  rb_define_method(rb_klass, "color", RUBY_METHOD_FUNC(rb_color), 0);
+  rb_define_method(rb_klass, "color=", RUBY_METHOD_FUNC(rb_set_color), 1);
+  rb_define_method(rb_klass, "reserved", RUBY_METHOD_FUNC(rb_reserved), 0);
+  rb_define_method(rb_klass, "approx_poly", RUBY_METHOD_FUNC(rb_approx_poly), -1);
+  rb_define_alias(rb_klass, "approx", "approx_poly");
+  rb_define_method(rb_klass, "bounding_rect", RUBY_METHOD_FUNC(rb_bounding_rect), 0);
+  rb_define_method(rb_klass, "create_tree", RUBY_METHOD_FUNC(rb_create_tree), -1);
+  rb_define_method(rb_klass, "in?", RUBY_METHOD_FUNC(rb_in_q), 1);
+  rb_define_method(rb_klass, "measure_distance", RUBY_METHOD_FUNC(rb_measure_distance), 1);
+}
+
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  /*
+  VALUE storage;
+  CvSeq *seq = 0;
+  rb_scan_args(argc, argv, "01", &storage);
+  
+  storage = CHECK_CVMEMSTORAGE(storage);
+  seq = cvCreateSeq(CV_SEQ_ELTYPE_POINT, sizeof(CvSeq), sizeof(CvPoint), CVMEMSTORAGE(storage));
+  DATA_PTR(self) = seq;
+  resist_root_object(seq, storage);
+  st_insert(cCvSeq::seqblock_klass, (st_data_t)seq, (st_data_t)klass);
+  */
+  return self;
+}
+
+VALUE
+rb_rect(VALUE self)
+{
+  return cCvRect::new_object(CVCONTOUR(self)->rect);
+}
+
+VALUE
+rb_color(VALUE self)
+{
+  return INT2NUM(CVCONTOUR(self)->color);
+}
+
+VALUE
+rb_set_color(VALUE self, VALUE color)
+{
+  CVCONTOUR(self)->color = NUM2INT(color);
+  return self;
+}
+
+VALUE
+rb_reserved(VALUE self)
+{
+  return rb_ary_new3(3,
+		     INT2NUM(CVCONTOUR(self)->reserved[0]),
+		     INT2NUM(CVCONTOUR(self)->reserved[1]),
+		     INT2NUM(CVCONTOUR(self)->reserved[2]));
+}
+
+/*
+ * call-seq:
+ *   approx_poly(<i>approx_poly_option</i>) -> cvcontour
+ *
+ * Approximates polygonal curve(s) with desired precision.
+ * <i>approx_poly_option</i> should be Hash include these keys.
+ *   :method - Approximation method.
+ *     :dp - corresponds to Douglas-Peucker algorithm.
+ *   :accuracy - approximation accuracy. (high-accuracy will create more simple contours)
+ *   :recursive - (default false)
+ *      If not nil or false, the function approximates all chains that access can be obtained to
+ *      from self by h_next or v_next links. If 0, approximated this one.
+ */
+
+VALUE
+rb_approx_poly(int argc, VALUE *argv, VALUE self)
+{
+  VALUE approx_poly_option, storage;
+  rb_scan_args(argc, argv, "01", &approx_poly_option);  
+  approx_poly_option = APPROX_POLY_OPTION(approx_poly_option);
+  storage = cCvMemStorage::new_object();
+  /*
+  CvSeq *contour = cvApproxPoly(CVCONTOUR(self), sizeof(CvContour), CVMEMSTORAGE(storage),
+				APPROX_POLY_METHOD(approx_poly_option),
+				APPROX_POLY_ACCURACY(approx_poly_option),
+				APPROX_POLY_RECURSIVE(approx_poly_option));
+  return cCvSeq::new_sequence(cCvContour::rb_class(), contour, cCvPoint::rb_class(), storage);
+  */
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   bounding_rect -> rect
+ *
+ * Calculates up-right bounding rectangle of point set.
+ * 
+ */
+VALUE
+rb_bounding_rect(VALUE self)
+{
+  return cCvRect::new_object(cvBoundingRect(CVCONTOUR(self), 1));
+}
+
+/*
+ * call-seq:
+ *   create_tree([threshold = 0.0]) -> cvcontourtree
+ *
+ * Creates hierarchical representation of contour.
+ * If the parameter <i>threshold</i> is less than or equal to 0,
+ * the method creates full binary tree representation.
+ * If the threshold is greater than 0, the function creates
+ * representation with the precision threshold: 
+ */
+VALUE
+rb_create_tree(int argc, VALUE *argv, VALUE self)
+{
+  VALUE threshold, storage;
+  rb_scan_args(argc, argv, "01", &threshold);
+  storage = cCvMemStorage::new_object();
+  CvContourTree *tree = cvCreateContourTree(CVSEQ(self), CVMEMSTORAGE(storage), IF_DBL(threshold, 0.0));
+  return cCvSeq::new_sequence(cCvContourTree::rb_class(), (CvSeq*)tree, cCvPoint::rb_class(), storage);
+}
+
+/*
+ * call-seq:
+ *    in?(<i>point</i>) -> true or nil or false
+ *
+ * Determines whether the <i>point</i> is inside contour(true), outside(false), or lies on an edge(nil).
+ */
+VALUE
+rb_in_q(VALUE self, VALUE point)
+{
+  double n = cvPointPolygonTest(CVARR(self), VALUE_TO_CVPOINT2D32F(point), 0);
+  return n == 0 ? Qnil : n > 0 ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *    measure_distance(<i>point</i>) -> float
+ *
+ * Return distance between the point and the nearest contour edge.
+ */
+VALUE
+rb_measure_distance(VALUE self, VALUE point)
+{
+  return rb_float_new(cvPointPolygonTest(CVARR(self), VALUE_TO_CVPOINT2D32F(point), 1));
+}
+
+
+VALUE new_object()
+{  
+  VALUE storage = cCvMemStorage::new_object();
+  CvSeq *seq = cvCreateSeq(CV_SEQ_CONTOUR, sizeof(CvContour), sizeof(CvPoint), CVMEMSTORAGE(storage));
+  VALUE object = cCvSeq::new_sequence(cCvContour::rb_class(), seq, cCvPoint::rb_class(), storage);
+  return object;
+}
+
+__NAMESPACE_END_CVCONTOUR
+__NAMESPACE_END_OPENCV
+

ext/cvcontour.h

@@ -0,0 +1,47 @@
+/************************************************************
+
+  cvcontour.h -
+
+  $Author: lsxi $
+
+  Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCONTOUR_H
+#define RUBY_OPENCV_CVCONTOUR_H
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCONTOUR namespace cCvContour{
+#define __NAMESPACE_END_CVCONTOUR }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONTOUR
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_rect(VALUE self);
+VALUE rb_color(VALUE self);
+VALUE rb_set_color(VALUE self, VALUE color);
+VALUE rb_reserved(VALUE self);
+VALUE rb_approx_poly(int argc, VALUE *argv, VALUE self);
+VALUE rb_bounding_rect(VALUE self);
+VALUE rb_create_tree(int argc, VALUE *argv, VALUE self);
+VALUE rb_in_q(VALUE self, VALUE point);
+VALUE rb_measure_distance(VALUE self, VALUE point);
+
+VALUE new_object();
+__NAMESPACE_END_CVCONTOUR
+
+inline CvContour*
+CVCONTOUR(VALUE object){
+  CvContour *ptr;
+  Data_Get_Struct(object, CvContour, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCONTOUR_H

ext/cvcontourtree.cpp

@@ -0,0 +1,86 @@
+/************************************************************
+
+   cvcontourtree.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvcontour.h"
+/*
+ * Document-class: OpenCV::CvContourTree
+ *
+ * Contour tree. CvContour#create_tree
+ *
+ * C structure is here.
+ *  typedef struct CvContourTree{
+ *    CV_SEQUENCE_FIELDS()
+ *    CvPoint p1;
+ *    CvPoint p2;
+ *  }CvContourTree;
+ * 
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONTOURTREE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * cvseq = rb_define_class_under(opencv, "CvSeq");
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  VALUE cvseq = cCvSeq::rb_class();
+  
+  rb_klass = rb_define_class_under(opencv, "CvContourTree", cvseq);
+  rb_define_method(rb_klass, "p1", RUBY_METHOD_FUNC(rb_p1), 0);
+  rb_define_method(rb_klass, "p2", RUBY_METHOD_FUNC(rb_p2), 0);
+  rb_define_method(rb_klass, "contour", RUBY_METHOD_FUNC(rb_contour), 0);
+
+}
+
+VALUE
+rb_p1(VALUE self)
+{
+  return REFER_OBJECT(cCvPoint::rb_class(), &CVCONTOURTREE(self)->p1, self);
+}
+
+VALUE
+rb_p2(VALUE self)
+{
+  return REFER_OBJECT(cCvPoint::rb_class(), &CVCONTOURTREE(self)->p2, self);
+}
+
+/*
+ * call-seq:
+ *   contour(<i>[criteria = 0]</i>) -> cvcontour
+ *
+ * Restores the contour from its binary tree representation.
+ * The parameter criteria determines the accuracy and/or the number of tree levels
+ * used for reconstruction, so it is possible to build approximated contour.
+ */
+VALUE
+rb_contour(int argc, VALUE *argv, VALUE self)
+{
+  VALUE criteria, storage;
+  rb_scan_args(argc, argv, "01", &criteria);
+  CvSeq *contour = cvContourFromContourTree(CVCONTOURTREE(self), CVMEMSTORAGE(storage), VALUE_TO_CVTERMCRITERIA(criteria));
+  return cCvSeq::new_sequence(cCvContour::rb_class(), contour, cCvPoint::rb_class(), storage);
+}
+
+__NAMESPACE_END_CVCONTOURTREE
+__NAMESPACE_END_OPENCV

ext/cvcontourtree.h

@@ -0,0 +1,41 @@
+/************************************************************
+
+  cvcontourtree.h -
+
+  $Author: lsxi $
+
+  Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCONTOURTREE_H
+#define RUBY_OPENCV_CVCONTOURTREE_H
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCONTOURTREE namespace cCvContourTree{
+#define __NAMESPACE_END_CVCONTOURTREE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONTOURTREE
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_p1(VALUE self);
+VALUE rb_p2(VALUE self);
+VALUE rb_contour(int argc, VALUE *argv, VALUE self);
+
+VALUE new_object();
+
+__NAMESPACE_END_CVCONTOURTREE
+
+inline CvContourTree*
+CVCONTOURTREE(VALUE object){
+  CvContourTree *ptr;
+  Data_Get_Struct(object, CvContourTree, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCONTOUR_H

ext/cvconvexitydefect.cpp

@@ -0,0 +1,103 @@
+/************************************************************
+
+   cvconvexitydefect.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvconvexitydefect.h"
+/*
+ * Document-class: OpenCV::CvConvexityDefect
+ *
+ * Convexity.
+ * C structure is here.
+ *   typedef struct CvConvexityDefect {
+ *     CvPoint* start;
+ *     CvPoint* end;
+ *     CvPoint* depth_point;
+ *     float depth;
+ *   }CvConvexityDefect;
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONVEXITYDEFECT
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvConvexityDefect", rb_cObject);
+  rb_define_method(rb_klass, "start", RUBY_METHOD_FUNC(rb_start), 0);
+  rb_define_method(rb_klass, "end", RUBY_METHOD_FUNC(rb_end), 0);
+  rb_define_method(rb_klass, "depth_point", RUBY_METHOD_FUNC(rb_depth_point), 0);
+  rb_define_method(rb_klass, "depth", RUBY_METHOD_FUNC(rb_depth), 0);
+}
+
+/*
+ * call-seq:
+ *   start -> cvpoint
+ *
+ * Return start point as CvPoint.
+ */
+VALUE
+rb_start(VALUE self)
+{
+  return cCvPoint::new_object(*CVCONVEXITYDEFECT(self)->start);
+}
+
+/*
+ * call-seq:
+ *   end -> cvpoint
+ *
+ * Return end point as CvPoint.
+ */
+VALUE
+rb_end(VALUE self)
+{
+  return cCvPoint::new_object(*CVCONVEXITYDEFECT(self)->end);
+}
+
+/*
+ * call-seq:
+ *   depth_point -> cvpoint
+ *
+ * Return depth point as CvPoint.
+ */
+VALUE
+rb_depth_point(VALUE self)
+{
+  return cCvPoint::new_object(*CVCONVEXITYDEFECT(self)->depth_point);
+}
+
+/*
+ * call-seq:
+ *   depth -> float
+ *
+ * Return depth.
+ */
+VALUE
+rb_depth(VALUE self)
+{
+  return rb_float_new(CVCONVEXITYDEFECT(self)->depth);
+}
+
+__NAMESPACE_END_CVCONVEXITYDEFECT
+__NAMESPACE_END_OPENCV

ext/cvconvexitydefect.h

@@ -0,0 +1,42 @@
+/************************************************************
+
+   cvconvexitydefect.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCONVEXITYDEFECT_H
+#define RUBY_OPENCV_CVCONVEXITYDEFECT_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCONVEXITYDEFECT namespace cCvConvexityDefect{
+#define __NAMESPACE_END_CVCONVEXITYDEFECT }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONVEXITYDEFECT
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_start(VALUE self);
+VALUE rb_end(VALUE self);
+VALUE rb_depth_point(VALUE self);
+VALUE rb_depth(VALUE self);
+
+__NAMESPACE_END_CVCONVEXITYDEFECT
+
+inline CvConvexityDefect*
+CVCONVEXITYDEFECT(VALUE object)
+{
+  CvConvexityDefect *ptr;
+  Data_Get_Struct(object, CvConvexityDefect, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCONVEXITYDEFECT_H

ext/cverror.cpp

@@ -0,0 +1,140 @@
+/************************************************************
+
+    cverror.cpp -
+
+    $Author: lsxi $
+
+    Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cverror.h"
+/*
+ * Document-module: OpenCV::CvError
+ * 
+ * =Internal OpenCV errors
+ *
+ * This module collect OpenCV internal error wrapper classes.
+ * * CvStatusBackTrace
+ * * CvStatusError
+ * * CvStatusInternal
+ * * CvStatusNoMemory
+ * * CvStatusBadArgument
+ * * CvStatusNoConverge
+ * * CvStatusAutoTrace
+ *
+ * * CvHeaderIsNull
+ * * CvBadImageSize
+ * * CvBadOffset
+ * * CvBadDataPointer
+ * * CvBadStep
+ * * CvBadModelOrChannelSequence
+ * * CvBadNumChannels
+ * * CvBadAlphaChannel
+ * * CvBadOrder
+ * * CvBadOrigin
+ * * CvBadAlign
+ * * CvBadCallback
+ * * CvBadTileSize
+ * * CvBadCOI
+ * * CvBadROISize
+ * 
+ * * CvMaskIsTiled
+ *
+ * * CvStatusNullPointer
+ * * CvStatusVectorLengthError
+ * * CvStatusFilterStructContentError
+ * * CvStatusKernelStructContentError
+ * * CvStatusFilterOffsetError
+ * 
+ * * CvStatusBadSize
+ * * CvStatusDivByZero
+ * * CvStatusInplaceNotSupported
+ * * CvStatusObjectNotFound
+ * * CvStatusUnmatchedFormant
+ * * CvStatusUnsupportedFormats
+ * * CvStatusOutOfRange
+ * * CvStatusParseError
+ * * CvStatusNotImplemented
+ * * CvStsBadMemoryBlock
+ */
+#define RESIST_CVERROR(object_name, error_code, parent) st_insert(cv_error, (st_data_t)error_code, (st_data_t)rb_define_class_under(rb_module_opencv(), object_name, parent))
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVERROR
+
+st_table *cv_error = st_init_numtable();
+    
+VALUE module;
+
+void
+define_ruby_module()
+{
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  module = rb_define_module_under(opencv, "CvError");
+  RESIST_CVERROR("CvStatusBackTrace",   CV_StsBackTrace, rb_eStandardError);
+  RESIST_CVERROR("CvStatusError",       CV_StsError,     rb_eStandardError);
+  RESIST_CVERROR("CvStatusInternal",    CV_StsInternal,  rb_eStandardError);
+  RESIST_CVERROR("CvStatusNoMemory",    CV_StsNoMem,     rb_eNoMemError);
+  RESIST_CVERROR("CvStatusBadArgument", CV_StsBadArg,    rb_eArgError);
+  RESIST_CVERROR("CvStatusBadFunction", CV_StsBadFunc,   rb_eStandardError);
+  RESIST_CVERROR("CvStatusNoConverge",  CV_StsNoConv,    rb_eStandardError);
+  RESIST_CVERROR("CvStatusAutoTrace",   CV_StsAutoTrace, rb_eStandardError);
+  
+  RESIST_CVERROR("CvHeaderIsNull",      CV_HeaderIsNull, rb_eStandardError);
+  RESIST_CVERROR("CvBadImageSize",      CV_BadImageSize, rb_eRangeError);
+  RESIST_CVERROR("CvBadOffset",         CV_BadOffset,    rb_eStandardError);
+  RESIST_CVERROR("CvBadDataPointer",    CV_BadDataPtr,   rb_eStandardError);
+  RESIST_CVERROR("CvBadStep",           CV_BadStep,      rb_eStandardError);
+  RESIST_CVERROR("CvBadModelOrChannelSequence", CV_BadModelOrChSeq, rb_eStandardError);
+  RESIST_CVERROR("CvBadNumChannels",    CV_BadNumChannels, rb_eStandardError);
+  RESIST_CVERROR("CvBadNumChannel1U",   CV_BadNumChannel1U, rb_eStandardError);
+  RESIST_CVERROR("CvNBadDepth",         CV_BadDepth,     rb_eStandardError);
+  RESIST_CVERROR("CvBadAlphaChannel",   CV_BadAlphaChannel, rb_eStandardError);
+  RESIST_CVERROR("CvBadOrder",          CV_BadOrder,     rb_eStandardError);
+  RESIST_CVERROR("CvBadOrigin",         CV_BadOrigin,    rb_eStandardError);
+  RESIST_CVERROR("CvBadAlign",          CV_BadAlign,     rb_eStandardError);
+  RESIST_CVERROR("CvBadCallBack",       CV_BadCallBack,  rb_eStandardError);
+  RESIST_CVERROR("CvBadTileSize",       CV_BadTileSize,  rb_eStandardError);
+  RESIST_CVERROR("CvBadCOI",            CV_BadCOI,       rb_eStandardError);
+  RESIST_CVERROR("CvBadROISize",        CV_BadROISize,   rb_eStandardError);
+  
+  RESIST_CVERROR("CvMaskIsTiled",       CV_MaskIsTiled,   rb_eStandardError);
+  
+  RESIST_CVERROR("CvStatusNullPointer", CV_StsNullPtr,    rb_eStandardError);
+  RESIST_CVERROR("CvStatusVectorLengthError", CV_StsVecLengthErr, rb_eStandardError);
+  RESIST_CVERROR("CvStatusFilterStructContentError", CV_StsFilterStructContentErr, rb_eStandardError);
+  RESIST_CVERROR("CvStatusKernelStructContentError", CV_StsKernelStructContentErr, rb_eStandardError);
+  RESIST_CVERROR("CvStatusFilterOffsetError",        CV_StsFilterOffsetErr,        rb_eStandardError);
+      
+  RESIST_CVERROR("CvStatusBadSize",     CV_StsBadSize,    rb_eStandardError);
+  RESIST_CVERROR("CvStatusDivByZero",   CV_StsDivByZero,  rb_eStandardError);
+  RESIST_CVERROR("CvStatusInplaceNotSupported", CV_StsInplaceNotSupported, rb_eStandardError);
+  RESIST_CVERROR("CvStatusObjectNotFound", CV_StsObjectNotFound, rb_eStandardError);
+  RESIST_CVERROR("CvStatusUnmatchedFormats", CV_StsUnmatchedFormats, rb_eStandardError);
+  RESIST_CVERROR("CvStatusBadFlag",     CV_StsBadFlag,    rb_eStandardError);
+  RESIST_CVERROR("CvStatusBadPoint",    CV_StsBadPoint,   rb_eStandardError);
+  RESIST_CVERROR("CvStatusBadMask",     CV_StsBadMask,    rb_eStandardError);
+  RESIST_CVERROR("CvStatusUnmatchedSizes", CV_StsUnmatchedSizes, rb_eStandardError);
+  RESIST_CVERROR("CvStatusUnsupportedFormat", CV_StsUnsupportedFormat, rb_eStandardError);
+  RESIST_CVERROR("CvStatusOutOfRange",  CV_StsOutOfRange, rb_eStandardError);
+  RESIST_CVERROR("CvStatusParseError",  CV_StsParseError, rb_eStandardError);
+  RESIST_CVERROR("CvStatusNotImplemented", CV_StsNotImplemented, rb_eNotImpError);
+  RESIST_CVERROR("CvStsBadMemoryBlock", CV_StsBadMemBlock,rb_eStandardError);
+}
+    
+VALUE
+by_code(int error_code)
+{
+  VALUE klass = 0;
+  st_lookup(cv_error, (st_data_t)error_code, (st_data_t*)&klass);
+  return klass ? klass : rb_eStandardError;
+}
+
+__NAMESPACE_END_CVERROR
+__NAMESPACE_END_OPENCV

ext/cverror.h

@@ -0,0 +1,79 @@
+/************************************************************
+
+   cverror.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVERROR_H
+#define RUBY_OPENCV_CVERROR_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVERROR namespace mCvError{
+#define __NAMESPACE_END_CVERROR }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVERROR
+
+/*
+  VALUE
+  status_back_trace,
+  status_error,
+  status_internal,
+  status_no_memory,      
+  status_bad_argument,
+  status_bad_function,
+  status_no_converge,
+  status_auto_trace,
+  
+  header_is_null,
+  bad_image_size,
+  bad_offset,
+  bad_data_pointer,
+  bad_step,
+  bad_model_or_channel_seqence,
+  bad_num_channels,
+  bad_num_channel1U,
+  bad_depth,
+  bad_alpha_channel,
+  bad_order,
+  bad_origin,
+  bad_align,
+  bad_callback,
+  bad_tile_size,
+  bad_COI,
+  bad_ROI_size,
+  
+  mask_is_tiled,
+  
+  status_null_pointer,
+  status_vector_length_error,
+  status_filter_struct_content_error,
+  status_kernel_struct_content_error,
+  status_filter_offset_error,
+  
+  status_bad_size,
+  status_div_by_zero,
+  status_inplace_not_supported,
+  status_object_not_found,
+  status_unmatched_formats,
+  status_bad_flags,
+  status_bad_point,
+  status_bad_mask,
+  status_unmatched_sizes,
+  status_unsupported_format,
+  status_out_of_range,
+  status_parse_error,
+  status_not_implemented,
+  status_bad_memory_block;
+*/
+void define_ruby_module();  
+VALUE by_code(int error_code);
+
+__NAMESPACE_END_CVERROR
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVERROR_H

ext/cvfont.cpp

@@ -0,0 +1,173 @@
+/************************************************************
+
+   cvfont.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvfont.h"
+/*
+ * Document-class: OpenCV::CvFont
+ *
+ * Font structure that can be passed to text rendering functions. 
+ * see CvMat#put_text, CvMat#put_text!
+ */
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVFONT
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvFont", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  VALUE face = rb_hash_new();
+  rb_define_const(rb_klass, "FACE", face);
+  rb_hash_aset(face, ID2SYM(rb_intern("simplex")), INT2FIX(CV_FONT_HERSHEY_SIMPLEX));
+  rb_hash_aset(face, ID2SYM(rb_intern("plain")), INT2FIX(CV_FONT_HERSHEY_PLAIN));
+  rb_hash_aset(face, ID2SYM(rb_intern("duplex")), INT2FIX(CV_FONT_HERSHEY_DUPLEX));
+  rb_hash_aset(face, ID2SYM(rb_intern("triplex")), INT2FIX(CV_FONT_HERSHEY_TRIPLEX));
+  rb_hash_aset(face, ID2SYM(rb_intern("complex_small")), INT2FIX(CV_FONT_HERSHEY_COMPLEX_SMALL));
+  rb_hash_aset(face, ID2SYM(rb_intern("script_simplex")), INT2FIX(CV_FONT_HERSHEY_SCRIPT_SIMPLEX));
+  rb_hash_aset(face, ID2SYM(rb_intern("script_complex")), INT2FIX(CV_FONT_HERSHEY_SCRIPT_COMPLEX));
+
+  VALUE default_option = rb_hash_new();
+  rb_define_const(rb_klass, "FONT_OPTION", default_option);
+  rb_hash_aset(default_option, ID2SYM(rb_intern("hscale")), rb_float_new(1.0));
+  rb_hash_aset(default_option, ID2SYM(rb_intern("vscale")), rb_float_new(1.0));
+  rb_hash_aset(default_option, ID2SYM(rb_intern("shear")), INT2FIX(0));
+  rb_hash_aset(default_option, ID2SYM(rb_intern("thickness")), INT2FIX(1));
+  rb_hash_aset(default_option, ID2SYM(rb_intern("line_type")), INT2FIX(8));
+  
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvFont *ptr;
+  return Data_Make_Struct(klass, CvFont, 0, -1, ptr);
+}
+
+
+/*
+ * call-seq:
+ *   CvFont.new(<i>face[,font_option]</i>) -> font
+ *
+ * Create font object.
+ * <i>face</i> is font name identifier. 
+ * 
+ * Only a subset of Hershey fonts (http://sources.isc.org/utils/misc/hershey-font.txt) are supported now:
+ * * :simplex - normal size sans-serif font
+ * * :plain - small size sans-serif font
+ * * :duplex - normal size sans-serif font (more complex than :simplex)
+ * * :complex - normal size serif font
+ * * :triplex - normal size serif font (more complex than :complex)
+ * * :complex_small - smaller version of :complex
+ * * :script_simplex - hand-writing style font
+ * * :script_complex - more complex variant of :script_simplex
+ *
+ * <i>font_option</i> should be Hash include these keys.
+ *   :hscale
+ *     Horizontal scale. If equal to 1.0, the characters have the original width depending on the font type.
+ *     If equal to 0.5, the characters are of half the original width.
+ *   :vscale
+ *     Vertical scale. If equal to 1.0, the characters have the original height depending on the font type.
+ *     If equal to 0.5, the characters are of half the original height.
+ *   :shear
+ *     Approximate tangent of the character slope relative to the vertical line.
+ *     Zero value means a non-italic font, 1.0f means ~45degree slope, etc.
+ *   :thickness
+ *     Thickness of the text strokes.
+ *   :line_type
+ *     Type of the strokes, see CvMat#Line description.
+ *   :italic
+ *     If value is not nil or false that means italic or oblique font.
+ *
+ * note: <i>font_option</i>'s default value is CvFont::FONT_OPTION.
+ *
+ * e.g. Create Font
+ *   OpenCV::CvFont.new(:simplex, :hscale => 2, :vslace => 2, :italic => true)
+ *   # create 2x bigger than normal, italic type font.
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE face, font_option;
+  rb_scan_args(argc, argv, "11", &face, &font_option);
+  Check_Type(face, T_SYMBOL);
+  face = rb_hash_aref(rb_const_get(cCvFont::rb_class(), rb_intern("FACE")), face);
+  if (NIL_P(face)) {
+    rb_raise(rb_eArgError, "undefined face.");
+  }
+  font_option = FONT_OPTION(font_option);
+  /*
+  cvInitFont(CVFONT(self),
+	     (FIX2INT(face) | FO_ITALIC(font_option)),
+	     FO_HSCALE(font_option),
+	     FO_VSCALE(font_option),
+	     FO_SHEAR(font_option),
+	     FO_THICKNESS(font_option),
+	     FO_LINE_TYPE(font_option));
+  */
+  return self;
+}
+
+
+VALUE
+rb_face(VALUE self)
+{
+  return FIX2INT(CVFONT(self)->font_face);
+}
+
+VALUE
+rb_hscale(VALUE self)
+{
+  return rb_float_new(CVFONT(self)->hscale);
+}
+
+VALUE
+rb_vscale(VALUE self)
+{
+  return rb_float_new(CVFONT(self)->vscale);
+}
+
+VALUE
+rb_shear(VALUE self)
+{
+  return rb_float_new(CVFONT(self)->shear);
+}
+
+VALUE
+rb_thickness(VALUE self)
+{
+  return FIX2INT(CVFONT(self)->thickness);
+}
+
+VALUE
+rb_line_type(VALUE self)
+{
+  return FIX2INT(CVFONT(self)->line_type);
+}
+
+__NAMESPACE_END_CVFONT
+__NAMESPACE_END_OPENCV

ext/cvfont.h

@@ -0,0 +1,56 @@
+/************************************************************
+
+   cvfont.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVFONT_H
+#define RUBY_OPENCV_CVFONT_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVFONT namespace cCvFont{
+#define __NAMESPACE_END_CVFONT }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVFONT
+
+#define FONT_OPTION(op) NIL_P(op) ? rb_const_get(rb_class(), rb_intern("FONT_OPTION")) : rb_funcall(rb_const_get(rb_class(), rb_intern("FONT_OPTION")), rb_intern("merge"), 1, font_option)
+#define FO_ITALIC(op) ({VALUE _italic = rb_hash_aref(op, ID2SYM(rb_intern("italic"))); NIL_P(_italic) ? 0 : _italic == Qfalse ? 0 : 1;})
+#define FO_HSCALE(op) NUM2DBL(rb_hash_aref(op, ID2SYM(rb_intern("hscale"))))
+#define FO_VSCALE(op) NUM2DBL(rb_hash_aref(op, ID2SYM(rb_intern("vscale"))))
+#define FO_SHEAR(op) NUM2DBL(rb_hash_aref(op, ID2SYM(rb_intern("shear"))))
+#define FO_THICKNESS(op) FIX2INT(rb_hash_aref(op, ID2SYM(rb_intern("thickness"))))
+#define FO_LINE_TYPE(op) FIX2INT(rb_hash_aref(op, ID2SYM(rb_intern("line_type"))) == ID2SYM("aa") ? INT2FIX(CV_AA) : rb_hash_aref(op, ID2SYM(rb_intern("line_type"))))
+
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_face(VALUE self);
+VALUE rb_hscale(VALUE self);
+VALUE rb_vscale(VALUE self);
+VALUE rb_shear(VALUE self);
+VALUE rb_thickness(VALUE self);
+VALUE rb_line_type(VALUE self);
+
+__NAMESPACE_END_CVFONT
+
+inline CvFont*
+CVFONT(VALUE object)
+{
+  CvFont *ptr;
+  Data_Get_Struct(object, CvFont, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVFONT_H

ext/cvhaarclassifiercascade.cpp

@@ -0,0 +1,159 @@
+/************************************************************
+
+  cvhaarclassifercascade.cpp -
+
+  $Author: lsxi $
+
+  Copyright (C) 2005-2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvhaarclassifiercascade.h"
+/*
+ * Document-class: OpenCV::CvHaarClassifierCascade
+ *
+ * CvHaarClassifierCascade object is "fast-object-detector".
+ * This detector can discover object (e.g. human's face) from image.
+ *
+ * Find face-area from picture "lena"...
+ * link:../images/face_detect_from_lena.jpg
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVHAARCLASSIFERCASCADE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvHaarClassifierCascade", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "load", RUBY_METHOD_FUNC(rb_load), 1);
+  rb_define_method(rb_klass, "detect_objects", RUBY_METHOD_FUNC(rb_detect_objects), -1);
+  rb_define_method(rb_klass, "detect_objects_with_pruning", RUBY_METHOD_FUNC(rb_detect_objects_with_pruning), -1);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  return OPENCV_OBJECT(klass, 0);
+}
+
+/*
+ * call-seq:
+ *   CvHaarClassiferCascade.load(<i>path</i>) -> object-detector
+ * 
+ * Load trained cascade of haar classifers from file.
+ * Object detection classifiers are stored in XML or YAML files.
+ * sample of object detection classifier files is included by OpenCV.
+ *
+ * You can found these at
+ *    C:\Program Files\OpenCV\data\haarcascades\*.xml (Windows, default install path)
+ *
+ * e.g. you want to try to detect human's face.
+ *    detector = CvHaarClassiferCascade.load("haarcascade_frontalface_alt.xml")
+ */
+VALUE
+rb_load(VALUE klass, VALUE path)
+{
+  CvHaarClassifierCascade *cascade = (CvHaarClassifierCascade*)cvLoad(StringValueCStr(path), 0, 0, 0);
+  if(!CV_IS_HAAR_CLASSIFIER(cascade))
+    rb_raise(rb_eTypeError, "invalid format haar classifier cascade file.");
+  return OPENCV_OBJECT(rb_klass, cascade);
+}
+
+VALUE
+rb_save(VALUE self, VALUE path)
+{
+  rb_raise(rb_eNotImpError, "");
+}
+
+/*
+ * call-seq:
+ *   detect_objects(image[,scale_factor = 1.1, min_neighbor = 3, min_size = CvSize.new(0,0)]) -> cvseq(include CvAvgComp object)
+ *   detect_objects(image[,scale_factor = 1.1, min_neighbor = 3, min_size = CvSize.new(0,0)]){|cmp| ... } -> cvseq(include CvAvgComp object)
+ *
+ * Detects objects in the image. This method finds rectangular regions in the
+ * given image that are likely to contain objects the cascade has been trained
+ * for and return those regions as a sequence of rectangles.
+ *
+ * * scale_factor (should be > 1.0)
+ *     The factor by which the search window is scaled between the subsequent scans, for example, 1.1 mean increasing window by 10%.
+ * * min_neighbors
+ *     Minimum number (minus 1) of neighbor rectangles that makes up an object.
+ *     All the groups of a smaller number of rectangles than min_neighbors - 1 are rejected.
+ *     If min_neighbors is 0, the function does not any grouping at all and returns all the detected
+ *     candidate rectangles, whitch many be useful if the user wants to apply a customized grouping procedure.
+ * * min_size
+ *     Minimum window size. By default, it is set to size of samples the classifier has been trained on.
+ */
+VALUE 
+rb_detect_objects(int argc, VALUE *argv, VALUE self)
+{ 
+  VALUE image, storage, scale_factor, min_neighbors, min_size, result;
+  rb_scan_args(argc, argv, "14", &image, &storage, &scale_factor, &min_neighbors, &min_size);
+  if (!rb_obj_is_kind_of(image, cCvMat::rb_class()))
+    rb_raise(rb_eTypeError, "argument 1(target-image) should be %s.", rb_class2name(cCvMat::rb_class()));
+  double scale = IF_DBL(scale_factor, 1.1);
+  if (!(scale > 1.0))
+    rb_raise(rb_eArgError, "argument 2 (scale factor) must > 1.0.");
+  storage = CHECK_CVMEMSTORAGE(storage);
+  CvSeq *seq = cvHaarDetectObjects(CVMAT(image), CVHAARCLASSIFIERCASCADE(self), CVMEMSTORAGE(storage),
+                                   scale, IF_INT(min_neighbors, 3), 0, NIL_P(min_size) ? cvSize(0,0) : VALUE_TO_CVSIZE(min_size));
+  result = cCvSeq::new_sequence(cCvSeq::rb_class(), seq, cCvAvgComp::rb_class(), storage);
+  if (rb_block_given_p()) {
+    for(int i = 0; i < seq->total; i++)
+      rb_yield(REFER_OBJECT(cCvAvgComp::rb_class(), cvGetSeqElem(seq, i), storage));      
+  }
+  return result;
+}
+
+/*
+ * call-seq:
+ *   detect_objects_with_pruning(image[,scale_factor = 1.1, min_neighbor = 3, min_size = CvSize.new(0,0)]) -> cvseq(include CvAvgComp object)
+ *   detect_objects_with_pruning(image[,scale_factor = 1.1, min_neighbor = 3, min_size = CvSize.new(0,0)]){|cmp| ... } -> cvseq(include CvAvgComp object)
+ *
+ * Almost same to #detect_objects (Return detected objects).
+ * 
+ * Before scanning to image, Canny edge detector to reject some image regions
+ * that contain too few or too much edges, and thus can not contain the searched object.
+ *
+ *   note: The particular threshold values are tuned for face detection.
+ *         And in this case the pruning speeds up the processing.
+ */ 
+VALUE
+rb_detect_objects_with_pruning(int argc, VALUE *argv, VALUE self)
+{
+  VALUE image, storage, scale_factor, min_neighbors, min_size, result;
+  rb_scan_args(argc, argv, "14", &image, &storage, &scale_factor, &min_neighbors, &min_size);
+  if (!rb_obj_is_kind_of(image, cCvMat::rb_class()))
+    rb_raise(rb_eTypeError, "argument 1(target-image) should be %s.", rb_class2name(cCvMat::rb_class()));
+  double scale = IF_DBL(scale_factor, 1.1);
+  if (!(scale > 1.0))
+    rb_raise(rb_eArgError, "argument 2 (scale factor) must > 1.0.");
+  storage = CHECK_CVMEMSTORAGE(storage);
+  CvSeq *seq = cvHaarDetectObjects(CVMAT(image), CVHAARCLASSIFIERCASCADE(self), CVMEMSTORAGE(storage),
+                                   scale, IF_INT(min_neighbors, 3), CV_HAAR_DO_CANNY_PRUNING, NIL_P(min_size) ? cvSize(0,0) : VALUE_TO_CVSIZE(min_size));
+  result = cCvSeq::new_sequence(cCvSeq::rb_class(), seq, cCvAvgComp::rb_class(), storage);
+  if (rb_block_given_p()) {
+    for(int i = 0; i < seq->total; i++)
+      rb_yield(REFER_OBJECT(cCvAvgComp::rb_class(), cvGetSeqElem(seq, i), storage));      
+  }
+  return result;
+}
+
+__NAMESPACE_END_CVHAARCLASSIFERCASCADE
+__NAMESPACE_END_OPENCV

ext/cvhaarclassifiercascade.h

@@ -0,0 +1,41 @@
+/************************************************************
+
+   cvhaarclassifiercascade.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVHAARCLASSIFIERCASCADE_H
+#define RUBY_OPENCV_CVHAARCLASSIFIERCASCADE_H
+
+#define __NAMESPACE_BEGIN_CVHAARCLASSIFERCASCADE namespace cCvHaarClassifierCascade{
+#define __NAMESPACE_END_CVHAARCLASSIFERCASCADE }
+
+#include"opencv.h"
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVHAARCLASSIFERCASCADE
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_load(VALUE klass, VALUE path);
+VALUE rb_save(VALUE self, VALUE name);
+VALUE rb_detect_objects(int argc, VALUE *argv, VALUE self);
+VALUE rb_detect_objects_with_pruning(int argc, VALUE *argv, VALUE self);
+
+__NAMESPACE_END_CVHAARCLASSIFERCASCADE
+inline CvHaarClassifierCascade *CVHAARCLASSIFIERCASCADE(VALUE object){
+  CvHaarClassifierCascade *ptr;
+  Data_Get_Struct(object, CvHaarClassifierCascade, ptr);
+  return ptr;
+}
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVHAARCLASSIFIERCASCADE_H

ext/cvhistogram.cpp

@@ -0,0 +1,200 @@
+/************************************************************
+
+   cvhistogram.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2008 Masakazu Yonekura
+
+************************************************************/
+#include "cvhistogram.h"
+/*
+ * Document-class: OpenCV::CvHistogram
+ *
+ * Muti-dimensional histogram.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVHISTOGRAM
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvHistogram", rb_cObject);
+  
+  rb_define_method(rb_klass, "is_uniform?", RUBY_METHOD_FUNC(rb_is_uniform), 0);
+  rb_define_method(rb_klass, "is_sparse?", RUBY_METHOD_FUNC(rb_is_sparse), 0);
+  rb_define_method(rb_klass, "has_range?", RUBY_METHOD_FUNC(rb_has_range), 0);
+  rb_define_method(rb_klass, "dims", RUBY_METHOD_FUNC(rb_dims), 0);
+
+  rb_define_method(rb_klass, "normalize", RUBY_METHOD_FUNC(rb_normalize), 1);
+  rb_define_method(rb_klass, "normalize!", RUBY_METHOD_FUNC(rb_normalize_bang), 1);
+  rb_define_method(rb_klass, "thresh", RUBY_METHOD_FUNC(rb_thresh), 1);
+  rb_define_alias(rb_klass, "threshold", "thresh");
+  rb_define_method(rb_klass, "thresh!", RUBY_METHOD_FUNC(rb_thresh_bang), 1);
+  rb_define_alias(rb_klass, "threshold!", "thresh!");
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  // not yet
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   is_uniform? -> true or false
+ *
+ */
+VALUE
+rb_is_uniform(VALUE self)
+{
+  return CV_IS_UNIFORM_HIST(CVHISTOGRAM(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   is_sparse? -> true or false
+ *
+ */
+VALUE
+rb_is_sparse(VALUE self)
+{
+  return CV_IS_SPARSE_HIST(CVHISTOGRAM(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   has_range? -> true or false
+ */
+VALUE
+rb_has_range(VALUE self)
+{
+  return CV_HIST_HAS_RANGES(CVHISTOGRAM(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   dims -> [int[,int...]]
+ */
+VALUE
+rb_dims(VALUE self)
+{
+  int size[CV_MAX_DIM];
+  int dims = cvGetDims(CVHISTOGRAM(self)->bins, size);
+  VALUE result = rb_ary_new2(dims);
+  for(int i = 0; i < dims; i++){
+    rb_ary_store(result, i, INT2FIX(size[i]));
+  }
+  return result;
+}
+
+/*
+ * call-seq:
+ *   bins -> cvmatnd or cvsparsemat
+ */
+VALUE
+rb_bins(VALUE self)
+{
+  CvHistogram *hist = CVHISTOGRAM(self);
+  return REFER_OBJECT(CV_IS_SPARSE_HIST(hist) ? cCvSparseMat::rb_class() : cCvMatND::rb_class(), hist->bins, self);
+}
+
+/*
+ * call-seq:
+ *   copy -> cvhist
+ *
+ * Clone histogram.
+ */
+VALUE
+rb_copy(VALUE self)
+{
+  VALUE dest = 0;
+  CvHistogram *hist = CVHISTOGRAM(dest);
+  cvCopyHist(CVHISTOGRAM(self), &hist);
+  return dest;
+}
+
+/*
+ * call-seq:
+ *   clear!
+ *
+ * Sets all histogram bins to 0 in case of dense histogram and removes all histogram bins in case of sparse array.
+ */
+VALUE
+rb_clear_bang(VALUE self)
+{
+  cvClearHist(CVHISTOGRAM(self));
+  return self;
+}
+
+/*
+ * call-seq:
+ *   normalize(<i>factor</i>) -> cvhist
+ *
+ * Return normalized the histogram bins by scaling them, such that the sum of the bins becomes equal to <i>factor</i>.
+ */
+VALUE
+rb_normalize(VALUE self, VALUE factor)
+{
+  return rb_normalize_bang(rb_copy(self), factor);
+}
+
+/*
+ * call-seq:
+ *   normalize!(<i>factor</i>) -> self
+ *
+ * normalizes the histogram bins by scaling them, such that the sum of the bins becomes equal to <i>factor</i>.
+ */
+VALUE
+rb_normalize_bang(VALUE self, VALUE factor)
+{
+  cvNormalizeHist(CVHISTOGRAM(self), NUM2DBL(factor));
+  return self;
+}
+
+/*
+ * call-seq:
+ *   thresh(<i>factor</i>) -> cvhist
+ *
+ * Return cleared histogram bins that are below the specified threshold.
+ */
+VALUE
+rb_thresh(VALUE self, VALUE factor)
+{
+  return rb_thresh_bang(rb_copy(self), factor);
+}
+
+/*
+ * call-seq:
+ *   thresh!(<i>factor</i>) -> self
+ *
+ * Cleares histogram bins that are below the specified threshold.
+ */
+VALUE
+rb_thresh_bang(VALUE self, VALUE factor)
+{
+  cvThreshHist(CVHISTOGRAM(self), NUM2DBL(factor));
+  return self;
+}
+
+
+__NAMESPACE_END_CVHISTOGRAM
+__NAMESPACE_END_OPENCV

ext/cvhistogram.h

@@ -0,0 +1,51 @@
+/************************************************************
+
+   cvhistogram.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2008 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVHISTOGRAM_H
+#define RUBY_OPENCV_CVHISTOGRAM_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVHISTOGRAM namespace cCvHistogram{
+#define __NAMESPACE_END_CVHISTOGRAM }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVHISTOGRAM
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_is_uniform(VALUE self);
+VALUE rb_is_sparse(VALUE self);
+VALUE rb_has_range(VALUE self);
+VALUE rb_dims(VALUE self);
+VALUE rb_bins(VALUE self);
+
+VALUE rb_clear(VALUE self);
+VALUE rb_clear_bang(VALUE self);
+
+VALUE rb_normalize(VALUE self, VALUE factor);
+VALUE rb_normalize_bang(VALUE self, VALUE factor);
+VALUE rb_thresh(VALUE self, VALUE factor);
+VALUE rb_thresh_bang(VALUE self, VALUE factor);
+
+__NAMESPACE_END_CVHISTOGRAM
+
+inline CvHistogram
+*CVHISTOGRAM(VALUE object)
+{
+  CvHistogram *ptr;
+  Data_Get_Struct(object, CvHistogram, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVHISTOGRAM_H

ext/cvindex.cpp

@@ -0,0 +1,73 @@
+/************************************************************
+
+   cvindex.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#include"cvindex.h"
+/*
+ * Document-class: OpenCV::CvIndex
+ *
+ * 
+ */
+
+namespace mOpenCV{
+  
+  namespace cCvIndex{
+    VALUE rb_klass;
+
+    VALUE rb_class(){
+      return rb_klass;
+    }
+    
+    void define_ruby_class(){
+      if(rb_klass)
+        return;
+      /* 
+       * opencv = rb_define_module("OpenCV");
+       * 
+       * note: this comment is used by rdoc.
+       */
+      VALUE opencv = rb_module_opencv();
+      rb_klass = rb_define_class_under(opencv, "CvIndex", rb_cObject);
+      rb_define_alloc_func(rb_klass, rb_allocate);
+      rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+      rb_define_singleton_method(rb_klass, "cv_new", RUBY_METHOD_FUNC(rb_cv_new), -1);
+      rb_define_method(rb_klass, "value", RUBY_METHOD_FUNC(rb_value), 0);
+      rb_define_method(rb_klass, "to_s", RUBY_METHOD_FUNC(rb_to_s), 0);
+    }
+
+    VALUE rb_allocate(VALUE klass){
+      CvIndex *ptr;
+      return Data_Make_Struct(rb_klass, CvIndex, 0, free, ptr);
+    }
+
+    VALUE rb_initialize(int argc, VALUE *argv, VALUE self){
+      VALUE value;
+      if(rb_scan_args(argc, argv, "01", &value) > 0){
+        Check_Type(value, T_FIXNUM);
+        CVINDEX(self)->value = FIX2INT(value);
+      }
+      return self;
+    }
+
+    VALUE rb_cv_new(int argc, VALUE *argv, VALUE klass){
+      VALUE object = rb_allocate(klass);
+      return rb_initialize(argc, argv, object);
+    }
+
+    VALUE rb_value(VALUE self){
+      return INT2FIX(CVINDEX(self)->value);
+    }
+    
+    VALUE rb_to_s(VALUE self){
+      return rb_funcall(INT2FIX(CVINDEX(self)->value), rb_intern("to_s"), 0);
+    }
+    
+  }
+  
+  
+}

ext/cvindex.h

@@ -0,0 +1,40 @@
+/************************************************************
+
+   cvindex.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVINDEX_H
+#define RUBY_OPENCV_CVINDEX_H
+
+#include"opencv.h"
+
+namespace mOpenCV{
+
+  typedef struct CvIndex{
+    int value;
+  }CvIndex;
+
+  namespace cCvIndex{    
+    VALUE rb_class();
+
+    void define_ruby_class();
+
+    VALUE rb_allocate(VALUE klass);
+    VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+    VALUE rb_cv_new(int argc, VALUE *argv, VALUE klass);
+    VALUE rb_value(VALUE self);
+    VALUE rb_to_s(VALUE self);
+  }
+
+  inline CvIndex *CVINDEX(VALUE object){    
+    CvIndex *ptr;
+    Data_Get_Struct(object, CvIndex, ptr);
+    return ptr;
+  }
+}
+
+#endif // RUBY_OPENCV_CVINDEX_H

ext/cvline.cpp

@@ -0,0 +1,106 @@
+/************************************************************
+
+   cvline.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvline.h"
+/*
+ * Document-class: OpenCV::CvLine
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVLINE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvLine", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "rho", RUBY_METHOD_FUNC(rb_rho), 0);
+  rb_define_method(rb_klass, "rho=", RUBY_METHOD_FUNC(rb_set_rho), 1);
+  rb_define_method(rb_klass, "theta", RUBY_METHOD_FUNC(rb_theta), 0);
+  rb_define_method(rb_klass, "theta=", RUBY_METHOD_FUNC(rb_set_theta), 1);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvLine *ptr;
+  return Data_Make_Struct(klass, CvLine, 0, -1, ptr);
+}
+
+/*
+ * Return parameter on rho.
+ */
+VALUE
+rb_rho(VALUE self)
+{
+  return rb_float_new(CVLINE(self)->rho);
+}
+
+/*
+ * call-seq:
+ *   rho = val
+ *
+ * Set rho parameter, return self.
+ */
+VALUE
+rb_set_rho(VALUE self, VALUE rho)
+{
+  CVLINE(self)->rho = NUM2DBL(rho);
+  return self;
+}
+
+/*
+ * Return parameter on theta.
+ */
+VALUE
+rb_theta(VALUE self)
+{
+  return rb_float_new(CVLINE(self)->theta);
+}
+
+/*
+ * call-seq:
+ *   y = val
+ *
+ * Set theta parameter, return self.
+ */
+VALUE
+rb_set_theta(VALUE self, VALUE theta)
+{
+  CVLINE(self)->theta = NUM2DBL(theta);
+  return self;
+}
+
+VALUE
+new_object(CvLine line)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVLINE(object) = line;
+  return object;
+}
+
+__NAMESPACE_END_CVLINE
+__NAMESPACE_END_OPENCV

ext/cvline.h

@@ -0,0 +1,52 @@
+/************************************************************
+
+   cvline.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVLINE_H
+#define RUBY_OPENCV_CVLINE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVLINE namespace cCvLine{
+#define __NAMESPACE_END_CVLINE }
+
+__NAMESPACE_BEGIN_OPENCV
+
+typedef struct CvLine{
+  float rho;
+  float theta;
+} CvLine;
+
+__NAMESPACE_BEGIN_CVLINE
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_rho(VALUE self);
+VALUE rb_set_rho(VALUE self, VALUE rho);
+VALUE rb_theta(VALUE self);
+VALUE rb_set_theta(VALUE self, VALUE theta);
+
+VALUE new_object(CvLine line);
+
+__NAMESPACE_END_CVLINE
+
+inline CvLine*
+CVLINE(VALUE object)
+{
+  CvLine *ptr;
+  Data_Get_Struct(object, CvLine, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVLINE_H

ext/cvmat.h

@@ -0,0 +1,286 @@
+/************************************************************
+
+   cvmat.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVMAT_H
+#define RUBY_OPENCV_CVMAT_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVMAT namespace cCvMat{
+#define __NAMESPACE_END_CVMAT }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMAT
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_method_missing(int argc, VALUE *argv, VALUE self);
+VALUE rb_to_s(VALUE self);
+VALUE rb_has_parent_q(VALUE self);
+VALUE rb_parent(VALUE self);
+VALUE rb_inside_q(VALUE self, VALUE object);
+VALUE rb_to_IplConvKernel(VALUE self, VALUE anchor);
+VALUE rb_create_mask(VALUE self);
+
+VALUE rb_width(VALUE self);
+VALUE rb_height(VALUE self);
+VALUE rb_depth(VALUE self);
+VALUE rb_channel(VALUE self);
+VALUE rb_data(VALUE self);
+
+VALUE rb_clone(VALUE self);
+VALUE rb_copy(int argc, VALUE *argv, VALUE self);
+VALUE copy(VALUE mat);
+
+VALUE rb_to_8u(VALUE self);
+VALUE rb_to_8s(VALUE self);
+VALUE rb_to_16u(VALUE self);
+VALUE rb_to_16s(VALUE self);
+VALUE rb_to_32s(VALUE self);
+VALUE rb_to_32f(VALUE self);
+VALUE rb_to_64f(VALUE self);
+VALUE rb_vector_q(VALUE self);
+VALUE rb_square_q(VALUE self);
+// cxcore function
+VALUE rb_to_CvMat(VALUE self);
+VALUE rb_to_IplImage(VALUE self);
+VALUE rb_sub_rect(VALUE self, VALUE args);
+VALUE rb_slice_width(VALUE self, VALUE num);
+VALUE rb_slice_height(VALUE self, VALUE num);
+VALUE rb_row(VALUE self, VALUE args);
+VALUE rb_col(VALUE self, VALUE args);
+VALUE rb_each_row(VALUE self);
+VALUE rb_each_col(VALUE self);
+VALUE rb_diag(int argc, VALUE *argv, VALUE self);
+VALUE rb_size(VALUE self);
+VALUE rb_dims(VALUE self);
+VALUE rb_dim_size(VALUE self, VALUE index);
+VALUE rb_aref(VALUE self, VALUE args);
+VALUE rb_aset(VALUE self, VALUE args);
+VALUE rb_fill(int argc, VALUE *argv, VALUE self);
+VALUE rb_fill_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_clear(VALUE self);
+VALUE rb_clear_bang(VALUE self);
+VALUE rb_set_identity(int argc, VALUE *argv, VALUE self);
+VALUE rb_set_identity_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_range(int argc, VALUE *argv, VALUE self);
+VALUE rb_range_bang(int argc, VALUE *argv, VALUE self);
+/* Transforms and Permutations */
+VALUE rb_reshape(VALUE self, VALUE hash);
+VALUE rb_repeat(VALUE self, VALUE object);
+VALUE rb_flip(int argc, VALUE *argv, VALUE self);
+VALUE rb_flip_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_split(VALUE self);
+VALUE rb_merge(VALUE klass, VALUE args);
+VALUE rb_mix_channels(int argc, VALUE *argv, VALUE klass);
+VALUE rb_rand_shuffle(int argc, VALUE *argv, VALUE klass);
+VALUE rb_rand_shuffle_bang(int argc, VALUE *argv, VALUE klass);
+
+VALUE rb_lut(VALUE self, VALUE lut);
+VALUE rb_convert_scale(VALUE self, VALUE hash);
+VALUE rb_convert_scale_abs(VALUE self, VALUE hash);
+VALUE rb_add(int argc, VALUE *argv, VALUE self);
+VALUE rb_sub(int argc, VALUE *argv, VALUE self);    
+VALUE rb_mul(int argc, VALUE *argv, VALUE self);
+VALUE rb_div(int argc, VALUE *argv, VALUE self);    
+VALUE rb_and(int argc, VALUE *argv, VALUE self);
+VALUE rb_or(int argc, VALUE *argv, VALUE self);
+VALUE rb_xor(int argc, VALUE *argv, VALUE self);
+VALUE rb_not(VALUE self);
+VALUE rb_not_bang(VALUE self);
+VALUE rb_cmp_internal(VALUE self, VALUE val, int operand);
+VALUE rb_eq(VALUE self, VALUE val);
+VALUE rb_gt(VALUE self, VALUE val);
+VALUE rb_ge(VALUE self, VALUE val);
+VALUE rb_lt(VALUE self, VALUE val);
+VALUE rb_le(VALUE self, VALUE val);
+VALUE rb_ne(VALUE self, VALUE val);
+VALUE rb_in_range(VALUE self, VALUE min, VALUE max);
+VALUE rb_abs_diff(VALUE self, VALUE val);
+/* Statistics */
+VALUE rb_count_non_zero(VALUE self);
+VALUE rb_sum(VALUE self);
+VALUE rb_avg(int argc, VALUE *argv, VALUE self);
+VALUE rb_avg_sdv(int argc, VALUE *argv, VALUE self);
+VALUE rb_sdv(int argc, VALUE *argv, VALUE self);
+VALUE rb_min_max_loc(int argc, VALUE *argv, VALUE self);
+
+//VALUE rb_norm();
+VALUE rb_dot_product(VALUE self, VALUE mat);
+VALUE rb_cross_product(VALUE self, VALUE mat);
+// VALUE rb_gemm();
+VALUE rb_transform(int argc, VALUE *argv, VALUE self);
+VALUE rb_perspective_transform(VALUE self, VALUE mat);
+VALUE rb_mul_transposed(VALUE self, VALUE args);
+VALUE rb_trace(VALUE self);
+VALUE rb_transpose(VALUE self);
+VALUE rb_transpose_bang(VALUE self);
+VALUE rb_det(VALUE self);
+VALUE rb_invert(int argc, VALUE *argv, VALUE self);
+VALUE rb_solve(int argc, VALUE *argv, VALUE self);
+VALUE rb_svd(int argc, VALUE *argv, VALUE self);
+VALUE rb_svbksb(int argc, VALUE *argv, VALUE self);
+VALUE rb_eigenvv(int argc, VALUE *argv, VALUE self);
+VALUE rb_eigenvv_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_calc_covar_matrix(int argc, VALUE *argv, VALUE self);
+VALUE rb_mahalonobis(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_dft(int argc, VALUE *argv, VALUE self);
+//VALUE rb_optimal_dft_size(VALUE self);
+//VALUE rb_mul_spectrums(int argc, VALUE *argv, VALUE self);
+VALUE rb_dct(int argc, VALUE *argv, VALUE self);
+
+/* drawing function*/
+VALUE rb_line(int argc, VALUE *argv, VALUE self);
+VALUE rb_line_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_rectangle(int argc, VALUE *argv, VALUE self);
+VALUE rb_rectangle_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_circle(int argc, VALUE *argv, VALUE self);
+VALUE rb_circle_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_ellipse(int argc, VALUE *argv, VALUE self);
+VALUE rb_ellipse_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_ellipse_box(int argc, VALUE *argv, VALUE self);
+VALUE rb_ellipse_box_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_fill_poly(int argc, VALUE *argv, VALUE self);
+VALUE rb_fill_poly_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_fill_convex_poly(int argc, VALUE *argv, VALUE self);
+VALUE rb_fill_convex_poly_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_poly_line(int argc, VALUE *argv, VALUE self);
+VALUE rb_poly_line_bang(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_put_text(int argc, VALUE *argv, VALUE self);
+VALUE rb_put_text_bang(int argc, VALUE *argv, VALUE self);
+/* cv function */
+VALUE rb_sobel(int argc, VALUE *argv, VALUE self);
+VALUE rb_laplace(int argc, VALUE *argv, VALUE self);
+VALUE rb_canny(int argc, VALUE *argv, VALUE self);
+VALUE rb_pre_corner_detect(int argc, VALUE *argv, VALUE self);
+VALUE rb_corner_eigenvv(int argc, VALUE *argv, VALUE self);
+VALUE rb_corner_min_eigen_val(int argc, VALUE *argv, VALUE self);
+VALUE rb_corner_harris(int argc, VALUE *argv, VALUE self);
+VALUE rbi_find_corner_sub_pix(int argc, VALUE *argv, VALUE self);
+VALUE rb_good_features_to_track(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_sample_line(int argc, VALUE *argv, VALUE self);
+VALUE rb_rect_sub_pix(VALUE self, VALUE center, VALUE size);
+VALUE rb_quadrangle_sub_pix(VALUE self, VALUE map_matrix, VALUE size);
+VALUE rb_resize(int argc, VALUE *argv, VALUE self);
+VALUE rb_warp_affine(int argc, VALUE *argv, VALUE self);
+VALUE rb_rotation(VALUE self, VALUE center, VALUE angle, VALUE scale);
+VALUE rb_warp_perspective(int argc, VALUE *argv, VALUE self);
+//VALUE rb_perspective_transform();
+VALUE rb_remap(int argc, VALUE *argv, VALUE self);
+VALUE rb_log_polar(int argc, VALUE *argv);
+
+VALUE rb_erode(int argc, VALUE *argv, VALUE self);
+VALUE rb_erode_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_dilate(int argc, VALUE *argv, VALUE self);
+VALUE rb_dilate_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_morphology_open(int argc, VALUE *argv, VALUE self);
+VALUE rb_morphology_close(int argc, VALUE *argv, VALUE self);
+VALUE rb_morphology_gradient(int argc, VALUE *argv, VALUE self);
+VALUE rb_morphology_tophat(int argc, VALUE *argv, VALUE self);
+VALUE rb_morphology_blackhat(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_smooth_blur_no_scale(int argc, VALUE *argv, VALUE self);
+VALUE rb_smooth_blur(int argc, VALUE *argv, VALUE self);
+VALUE rb_smooth_gaussian(int argc, VALUE *argv, VALUE self);
+VALUE rb_smooth_median(int argc, VALUE *argv, VALUE self);
+VALUE rb_smooth_bilateral(int argc, VALUE *argv, VALUE self);
+VALUE rb_filter2d(int argc, VALUE *argv, VALUE self);
+VALUE rb_copy_make_border_constant(int argc, VALUE *argv, VALUE self);
+VALUE rb_copy_make_border_replicate(int argc, VALUE *argv, VALUE self);
+VALUE rb_integral(int argc, VALUE *argv, VALUE self);
+VALUE rb_threshold_binary(int argc, VALUE *argv, VALUE self);
+VALUE rb_threshold_binary_inverse(int argc, VALUE *argv, VALUE self);
+VALUE rb_threshold_trunc(int argc, VALUE *argv, VALUE self);
+VALUE rb_threshold_to_zero(int argc, VALUE *argv, VALUE self);
+VALUE rb_threshold_to_zero_inverse(int argc, VALUE *argv, VALUE self);
+VALUE rb_adaptive_threshold(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_pyr_down(int argc, VALUE *argv, VALUE self);
+VALUE rb_pyr_up(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_flood_fill(int argc, VALUE *argv, VALUE self);
+VALUE rb_flood_fill_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_find_contours(int argc, VALUE *argv, VALUE self);
+VALUE rb_find_contours_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_pyr_segmentation(int argc, VALUE *argv, VALUE self);
+VALUE rb_pyr_mean_shift_filtering(int argc, VALUE *argv, VALUE self);
+VALUE rb_watershed(VALUE self);
+
+VALUE rb_moments(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_hough_lines_standard(int argc, VALUE *argv, VALUE self);
+VALUE rb_hough_lines_probabilistic(int argc, VALUE *argv, VALUE self);
+VALUE rb_hough_lines_multi_scale(int argc, VALUE *argv, VALUE self);
+VALUE rb_hough_circles_gradient(int argc, VALUE *argv, VALUE self);
+VALUE rb_dist_transform(int argc, VALUE *argv, VALUE self);
+VALUE rb_inpaint_ns(VALUE self, VALUE mask, VALUE radius);
+VALUE rb_inpaint_telea(VALUE self, VALUE mask, VALUE radius);
+
+VALUE rb_equalize_hist(VALUE self);
+/* Matching*/
+VALUE rb_match_template(int argc, VALUE *argv, VALUE self);
+VALUE rb_match_shapes_i1(int argc, VALUE *argv, VALUE self);
+VALUE rb_match_shapes_i2(int argc, VALUE *argv, VALUE self);
+VALUE rb_match_shapes_i3(int argc, VALUE *argv, VALUE self);
+// VALUE rb_calc_emd(int argc, VALUE *argv, VALUE self);
+/* Object Tracking */
+VALUE rb_mean_shift(VALUE self, VALUE window, VALUE criteria);
+VALUE rb_cam_shift(VALUE self, VALUE window, VALUE criteria);
+VALUE rb_snake_image(int argc, VALUE *argv, VALUE self);
+/* Optical Flow */
+VALUE rb_optical_flow_hs(int argc, VALUE *argv, VALUE self);
+VALUE rb_optical_flow_lk(int argc, VALUE *argv, VALUE self);
+VALUE rb_optical_flow_bm(int argc, VALUE *argv, VALUE self);
+VALUE rb_optical_flow_pyr_lk(int argc, VALUE *argv, VALUE self);
+
+/* Epipolar Geometory */
+VALUE rb_find_fundamental_mat_7point(int argc, VALUE *argv, VALUE klass);
+VALUE rb_find_fundamental_mat_8point(int argc, VALUE *argv, VALUE klass);
+VALUE rb_find_fundamental_mat_ransac(int argc, VALUE *argv, VALUE klass);
+VALUE rb_find_fundamental_mat_lmeds(int argc, VALUE *argv, VALUE klass);
+VALUE rb_compute_correspond_epilines(VALUE klass, VALUE points, VALUE which_image, VALUE fundamental_matrix);
+  
+// HighGUI function
+VALUE rb_save_image(VALUE self, VALUE filename);
+
+VALUE new_object(int rows, int cols, int type);
+VALUE new_object(CvSize size, int type);
+
+__NAMESPACE_END_CVMAT
+
+inline CvMat*
+CVMAT(VALUE object)
+{
+  CvMat *ptr, stub;
+  Data_Get_Struct(object, CvMat, ptr);
+  return cvGetMat(ptr, &stub);
+}
+
+inline CvMat*
+MASK(VALUE object)
+{
+  if(NIL_P(object))
+    return NULL;
+  else if(rb_obj_is_kind_of(object, cCvMat::rb_class()) && CV_MAT_CN(CVMAT(object)->type) == CV_8UC1)
+    return CVMAT(object);
+  else
+    rb_raise(rb_eTypeError, "object is not mask.");
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVMAT_H

ext/cvmatnd.cpp

@@ -0,0 +1,44 @@
+/***********************************************************
+
+   cvmatnd.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvmatnd.h"
+/*
+ * Document-class: OpenCV::CvMatND
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMATND
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * cvmat = rb_define_class_under(opencv, "CvMat", rb_cObject);
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv(), cvmat = cCvMat::rb_class();
+  
+  rb_klass = rb_define_class_under(opencv, "CvMatND", cvmat);
+}
+
+__NAMESPACE_END_CVMATND
+__NAMESPACE_END_OPENCV
+

ext/cvmatnd.h

@@ -0,0 +1,28 @@
+/************************************************************
+
+   cvmatnd.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVMATND_H
+#define RUBY_OPENCV_CVMATND_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVMATND namespace cCvMatND{
+#define __NAMESPACE_END_CVMATND }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMATND
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+__NAMESPACE_END_CVMATND
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVMATND_H

ext/cvmemstorage.cpp

@@ -0,0 +1,64 @@
+/************************************************************
+
+   cvmemstorage.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#include "cvmemstorage.h"
+/*
+ * Document-class: OpenCV::CvMemStorage
+ *
+ * Internal memory management class used by CvSeq.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMEMSTORAGE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  rb_klass = rb_define_class_under(opencv, "CvMemStorage", rb_cObject);
+  //rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);     
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvMemStorage *storage = cvCreateMemStorage();
+  return Data_Wrap_Struct(klass, 0, free, storage);
+}
+
+void
+free(void *ptr)
+{
+  cvReleaseMemStorage((CvMemStorage**)&ptr);
+}
+
+VALUE
+new_object(int blocksize)
+{
+  CvMemStorage *storage = cvCreateMemStorage(blocksize);
+  return Data_Wrap_Struct(rb_klass, 0, free, storage);
+}
+
+
+__NAMESPACE_END_CVMEMSTORAGE
+__NAMESPACE_END_OPENCV

ext/cvmemstorage.h

@@ -0,0 +1,53 @@
+/************************************************************
+
+   cvmemstorage.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVMEMSTORAGE_H
+#define RUBY_OPENCV_CVMEMSTORAGE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVMEMSTORAGE namespace cCvMemStorage{
+#define __NAMESPACE_END_CVMEMSTORAGE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMEMSTORAGE
+    
+void define_ruby_class();
+
+VALUE rb_class();
+VALUE rb_allocate(VALUE klass);
+void free(void *ptr);
+
+VALUE new_object(int blocksize = 0);
+
+__NAMESPACE_END_CVMEMSTORAGE
+
+inline CvMemStorage*
+CVMEMSTORAGE(VALUE object)
+{
+  CvMemStorage *ptr;
+  Data_Get_Struct(object, CvMemStorage, ptr);
+  return ptr;
+}
+
+inline VALUE
+CHECK_CVMEMSTORAGE(VALUE object)
+{
+  if(rb_obj_is_kind_of(object, cCvMemStorage::rb_class()))
+    return object;
+  else{
+    if(!NIL_P(object))
+      rb_warn("invalid CvMemStorage object given. allocate new memory storage automatically.");
+    return cCvMemStorage::new_object();
+  }
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVMEMSTORAGE_H

ext/cvmoments.cpp

@@ -0,0 +1,204 @@
+/************************************************************
+
+   cvmoments.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvmoments.h"
+/*
+ * Document-class: OpenCV::CvMoments
+ *
+ * moments
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMOMENTS
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvMoments", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "spatial", RUBY_METHOD_FUNC(rb_spatial), 2);
+  rb_define_method(rb_klass, "central", RUBY_METHOD_FUNC(rb_central), 2);
+  rb_define_method(rb_klass, "normalized_central", RUBY_METHOD_FUNC(rb_normalized_central), 2);
+  rb_define_method(rb_klass, "hu", RUBY_METHOD_FUNC(rb_hu), 0);     
+  rb_define_method(rb_klass, "gravity_center", RUBY_METHOD_FUNC(rb_gravity_center), 0);
+  rb_define_alias(rb_klass, "center", "gravity_center");
+  rb_define_method(rb_klass, "angle", RUBY_METHOD_FUNC(rb_angle), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvMoments *ptr;
+  return Data_Make_Struct(klass, CvMoments, 0, -1, ptr);
+}
+/*
+ * call-seq:
+ *   CvMoments.new(<i>src[,is_binary = nil]</i>)
+ *
+ * Calculates all moments up to third order of a polygon or rasterized shape.
+ * <i>src</i> should be CvMat or CvPolygon.
+ *
+ * If is_binary = true, all the zero pixel values are treated as zeroes, all the others are treated as 1's.
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE src, is_binary;
+  rb_scan_args(argc, argv, "02", &src, &is_binary);
+  if (NIL_P(src))
+    ;
+  else if (rb_obj_is_kind_of(src, cCvMat::rb_class()) || rb_obj_is_kind_of(src, cCvSeq::rb_class()))
+    cvMoments(CVARR(src), CVMOMENTS(self), TRUE_OR_FALSE(is_binary, 0));
+  else
+    rb_raise(rb_eTypeError, "argument 1 (src) should be %s or %s.", rb_class2name(cCvMat::rb_class()), rb_class2name(cCvSeq::rb_class()));
+  return self;      
+}
+
+/*
+ * call-seq:
+ *   spatial -> float
+ *
+ * Retrieves spatial moment.
+ *
+ * which in case of image moments is defined as:
+ *   Mx_order,y_order=sumx,y(I(x,y)*xx_order*yy_order)
+ *   where I(x,y) is the intensity of the pixel (x, y). 
+ */
+VALUE
+rb_spatial(VALUE self, VALUE x_order, VALUE y_order)
+{
+  return rb_float_new(cvGetSpatialMoment(CVMOMENTS(self), NUM2INT(x_order), NUM2INT(y_order)));
+}
+
+/*
+ * call-seq:
+ *   central -> float
+ *
+ * Retrieves central moment.
+ *
+ * which in case of image moments is defined as:
+ *   μx_order,y_order=sumx,y(I(x,y)*(x-xc)x_order*(y-yc)y_order),
+ *   where xc=M10/M00, yc=M01/M00 - coordinates of the gravity center
+ */
+VALUE
+rb_central(VALUE self, VALUE x_order, VALUE y_order)
+{
+  return rb_float_new(cvGetCentralMoment(CVMOMENTS(self), NUM2INT(x_order), NUM2INT(y_order)));
+}
+
+/*
+ * call-seq:
+ *   normalized_central -> float
+ *
+ * Retrieves normalized central moment.
+ *
+ *  ηx_order,y_order= μx_order,y_order/M00((y_order+x_order)/2+1)
+ */
+VALUE
+rb_normalized_central(VALUE self, VALUE x_order, VALUE y_order)
+{
+  return rb_float_new(cvGetNormalizedCentralMoment(CVMOMENTS(self), NUM2INT(x_order), NUM2INT(y_order)));
+}
+
+/*
+ * call-seq:
+ *   hu -> [hu1, hu2, ... ,hu7]
+ *
+ * Calculates seven Hu invariants.
+ *
+ * seven Hu invariants that are defined as:
+ *   h1=η20+η02
+ *   h2=(η20-η02)²+4η11²
+ *   h3=(η30-3η12)²+ (3η21-η03)²
+ *   h4=(η30+η12)²+ (η21+η03)²
+ *   h5=(η30-3η12)(η30+η12)[(η30+η12)²-3(η21+η03)²]+(3η21-η03)(η21+η03)[3(η30+η12)²-(η21+η03)²]
+ *   h6=(η20-η02)[(η30+η12)²- (η21+η03)²]+4η11(η30+η12)(η21+η03)
+ *   h7=(3η21-η03)(η21+η03)[3(η30+η12)²-(η21+η03)²]-(η30-3η12)(η21+η03)[3(η30+η12)²-(η21+η03)²]
+ * where ηi,j are normalized central moments of 2-nd and 3-rd orders. The computed values are proved to be invariant to the image scaling, rotation, and reflection except the seventh one, whose sign is changed by reflection. 
+ */
+VALUE
+rb_hu(VALUE self)
+{
+  CvHuMoments hu_moments;
+  cvGetHuMoments(CVMOMENTS(self), &hu_moments);
+  return rb_ary_new3(7,
+		     rb_float_new(hu_moments.hu1),
+		     rb_float_new(hu_moments.hu2),
+		     rb_float_new(hu_moments.hu3),
+		     rb_float_new(hu_moments.hu4),
+		     rb_float_new(hu_moments.hu5),
+		     rb_float_new(hu_moments.hu6),
+		     rb_float_new(hu_moments.hu7));
+}
+
+/*
+ * call-seq:
+ *   gravity_center -> cvpoint2d32f
+ *
+ * Return gravity center.
+ */
+VALUE
+rb_gravity_center(VALUE self)
+{
+  CvMoments *moments = CVMOMENTS(self);
+  double
+    m00 = cvGetSpatialMoment(moments, 0, 0),
+    m10 = cvGetSpatialMoment(moments, 1, 0),
+    m01 = cvGetSpatialMoment(moments, 0, 1);
+  return cCvPoint2D32f::new_object(cvPoint2D32f(m10 / m00, m01 / m00));
+}
+
+/*
+ * call-seq:
+ *   angle -> float
+ *
+ * Return angle.
+ */
+VALUE
+rb_angle(VALUE self)
+{
+  CvMoments *moments = CVMOMENTS(self);
+  double
+    m11 = cvGetCentralMoment(moments, 1, 1),
+    m20 = cvGetCentralMoment(moments, 2, 0),
+    m02 = cvGetCentralMoment(moments, 0, 2),
+    mangle = 0.5 * atan(2 * m11 / (m20 - m02));
+  if(!cvIsNaN(mangle) && !cvIsInf(mangle))
+    return rb_float_new(mangle);
+  else
+    return Qnil;
+}
+
+VALUE
+new_object(CvArr *arr, int is_binary = 0)
+{
+  VALUE object = rb_allocate(rb_class());
+  cvMoments(arr, CVMOMENTS(object), TRUE_OR_FALSE(is_binary, 0));
+  return object;
+}
+
+__NAMESPACE_END_CVMOMENTS
+__NAMESPACE_END_OPENCV

ext/cvmoments.h

@@ -0,0 +1,48 @@
+/************************************************************
+
+   cvmoments.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVMOMENTS_H
+#define RUBY_OPENCV_CVMOMENTS_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVMOMENTS namespace cCvMoments{
+#define __NAMESPACE_END_CVMOMENTS }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMOMENTS
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_spatial(VALUE self, VALUE x_order, VALUE y_order);
+VALUE rb_central(VALUE self, VALUE x_order, VALUE y_order);
+VALUE rb_normalized_central(VALUE self, VALUE x_order, VALUE y_order);
+VALUE rb_hu(VALUE self);
+VALUE rb_gravity_center(VALUE self);
+VALUE rb_angle(VALUE self);
+
+VALUE new_object(CvArr *arr, int is_binary);
+
+__NAMESPACE_END_CVMOMENTS
+
+inline CvMoments*
+CVMOMENTS(VALUE object)
+{
+  CvMoments *ptr;
+  Data_Get_Struct(object, CvMoments, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVMOMENTS_H

ext/cvpoint.cpp

@@ -0,0 +1,229 @@
+/************************************************************
+
+   cvpoint.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvpoint.h"
+/*
+ * Document-class: OpenCV::CvPoint
+ *
+ * This class means one point on X axis Y axis. 
+ * X and Y takes the value of the Fixnum. see also CvPoint2D32F
+ * 
+ * C structure is here, very simple.
+ *   typdef struct CvPoint{
+ *     int x;
+ *     int y;
+ *   }
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVPOINT
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvPoint", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "x", RUBY_METHOD_FUNC(rb_x), 0);
+  rb_define_method(rb_klass, "x=", RUBY_METHOD_FUNC(rb_set_x), 1);
+  rb_define_method(rb_klass, "y", RUBY_METHOD_FUNC(rb_y), 0);
+  rb_define_method(rb_klass, "y=", RUBY_METHOD_FUNC(rb_set_y), 1);
+
+  rb_define_method(rb_klass, "to_s", RUBY_METHOD_FUNC(rb_to_s), 0);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+}
+
+/*
+ * call-seq:
+ *   combatible?(obj)
+ *
+ * Return compatibility to CvPoint. Return true if object have method #x and #y.
+ *
+ * For example.
+ *   class MyPoint
+ *     def x
+ *       1
+ *     end
+ *     def y
+ *       2
+ *     end
+ *   end
+ *   mp = MyPoint.new
+ *   CvPoint.compatible?(mp)  #=> true
+ *   CvPoint.new(mp)          #=> same as CvPoint(1, 2)
+ */
+VALUE
+rb_compatible_q(VALUE klass, VALUE object)
+{
+  return (rb_respond_to(object, rb_intern("x")) && rb_respond_to(object, rb_intern("y"))) ? Qtrue : Qfalse;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvPoint *ptr;
+  return Data_Make_Struct(klass, CvPoint, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new -> CvPoint.new(0, 0)
+ *   new(obj) -> CvPoint.new(obj.x.to_i, obj.y.to_i)
+ *   new(x, y)
+ *
+ * Create new 2D-coordinate, (x, y). It is dropped below the decimal point.
+ *
+ * new() is same as new(0, 0)
+ *
+ * new(obj) is same as new(obj.x.to_i, obj.y.to_i)
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE obj, x, y;
+  switch (argc) {
+  case 0:
+    break;
+  case 1:
+    obj = argv[0];
+    if (rb_compatible_q(rb_klass, obj)) {
+      CVPOINT(self)->x = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("x"), 0), rb_intern("to_i"), 0));
+      CVPOINT(self)->y = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("y"), 0), rb_intern("to_i"), 0));
+    }else{
+      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
+    }
+    break;
+  case 2:
+    x = argv[0], y = argv[1];
+    CVPOINT(self)->x = NUM2INT(x);
+    CVPOINT(self)->y = NUM2INT(y);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+  }
+  return Qnil;    
+}
+
+/*
+ * Return parameter on x-axis.
+ */
+VALUE
+rb_x(VALUE self)
+{
+  return INT2FIX(CVPOINT(self)->x);
+}
+
+/*
+ * call-seq:
+ *   x = val
+ *
+ * Set x-axis parameter, return self.
+ * It is dropped below the decimal point.
+ *   pt = CvPoint.new
+ *   pt.x = 1.1
+ *   pt.x           #=> 1
+ *   pt.x = 100.9
+ *   pt.x           #=> 100
+ */
+VALUE
+rb_set_x(VALUE self, VALUE x)
+{
+  CVPOINT(self)->x = NUM2INT(x);
+  return self;
+}
+
+/*
+ * Return parameter on y-axis.
+ */
+VALUE
+rb_y(VALUE self)
+{
+  return INT2FIX(CVPOINT(self)->y);
+}
+
+/*
+ * call-seq:
+ *   y = val
+ *
+ * Set y-axis parameter, return self.
+ * It is dropped below the decimal point.
+ */
+VALUE
+rb_set_y(VALUE self, VALUE y)
+{
+  CVPOINT(self)->y = NUM2INT(y);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   to_s -> "<OpenCV::CvPoint:(self.x,self.y)>"
+ *
+ * Return x and y by String.
+ */
+VALUE
+rb_to_s(VALUE self)
+{
+  const int i = 4;
+  VALUE str[i];
+  str[0] = rb_str_new2("<%s:(%d,%d)>");
+  str[1] = rb_str_new2(rb_class2name(CLASS_OF(self)));
+  str[2] = rb_x(self);
+  str[3] = rb_y(self);
+  return rb_f_sprintf(i, str);
+}
+
+/*
+ * call-seq:
+ *   to_ary -> [x, y]
+ *
+ * Return x and y by Array.
+ */
+VALUE
+rb_to_ary(VALUE self)
+{
+  return rb_ary_new3(2, rb_x(self), rb_y(self));
+}
+
+VALUE
+new_object()
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVPOINT(object) = cvPoint(0, 0);
+  return object;
+}
+
+
+VALUE
+new_object(CvPoint point)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVPOINT(object) = point;
+  return object;
+}
+
+__NAMESPACE_END_CVPOINT
+__NAMESPACE_END_OPENCV

ext/cvpoint.h

@@ -0,0 +1,59 @@
+/************************************************************
+
+   cvpoint.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVPOINT_H
+#define RUBY_OPENCV_CVPOINT_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVPOINT namespace cCvPoint{
+#define __NAMESPACE_END_CVPOINT }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVPOINT
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_compatible_q(VALUE klass, VALUE object);
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_x(VALUE self);
+VALUE rb_set_x(VALUE self, VALUE x);
+VALUE rb_y(VALUE self);
+VALUE rb_set_y(VALUE self, VALUE y);
+
+VALUE rb_to_s(VALUE self);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object();
+VALUE new_object(CvPoint point);
+
+__NAMESPACE_END_CVPOINT
+
+inline CvPoint *CVPOINT(VALUE object){
+  CvPoint *ptr;
+  Data_Get_Struct(object, CvPoint, ptr);
+  return ptr;
+}
+
+inline CvPoint VALUE_TO_CVPOINT(VALUE object){
+  if(cCvPoint::rb_compatible_q(cCvPoint::rb_class(), object)){
+    return cvPoint(NUM2INT(rb_funcall(object, rb_intern("x"), 0)),
+                   NUM2INT(rb_funcall(object, rb_intern("y"), 0)));
+  }else{
+    rb_raise(rb_eTypeError, "require %s or compatible object.", rb_class2name(cCvPoint::rb_class()));
+  }
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVPOINT_H

ext/cvpoint2d32f.cpp

@@ -0,0 +1,213 @@
+/************************************************************
+
+   cvpoint2d32f.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#include"cvpoint2d32f.h"
+/*
+ * Document-class: OpenCV::CvPoint2D32f
+ *
+ * This class means one point on X axis Y axis. 
+ * X and Y takes the value of the Float. see also CvPoint
+ * 
+ * C structure is here, very simple.
+ *   typdef struct CvPoint2D32f{
+ *     float x;
+ *     float y;
+ *   }
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVPOINT2D32F
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvPoint2D32f", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "x", RUBY_METHOD_FUNC(rb_x), 0);
+  rb_define_method(rb_klass, "x=", RUBY_METHOD_FUNC(rb_set_x), 1);
+  rb_define_method(rb_klass, "y", RUBY_METHOD_FUNC(rb_y), 0);
+  rb_define_method(rb_klass, "y=", RUBY_METHOD_FUNC(rb_set_y), 1);
+
+  rb_define_method(rb_klass, "to_s", RUBY_METHOD_FUNC(rb_to_s), 0);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+}
+
+/*
+ * call-seq:
+ *   combatible?(obj)
+ *
+ * Return compatibility to CvPoint2D32f. Return true if object have method #x and #y.
+ *
+ * For example.
+ *   class MyPoint2D32f
+ *     def x
+ *       95.7
+ *     end
+ *     def y
+ *       70.2
+ *     end
+ *   end
+ *   mp = MyPoint2D32f.new
+ *   CvPoint2D32f.compatible?(mp)  #=> true
+ *   CvPoint2D32f.new(mp)          #=> same as CvPoint2D32f(95.7, 70.2)
+ */
+VALUE
+rb_compatible_q(VALUE klass, VALUE object)
+{
+  return (rb_respond_to(object, rb_intern("x")) && rb_respond_to(object, rb_intern("y"))) ? Qtrue : Qfalse;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvPoint2D32f *ptr;
+  return Data_Make_Struct(klass, CvPoint2D32f, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new
+ *   new(obj)
+ *   new(x, y)
+ *
+ * Create new 2D-coordinate, (x, y).
+ *
+ * new() is same as new(0.0, 0.0)
+ *
+ * new(obj) is same as new(obj.x.to_f, obj.y.to_f)
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE obj, x, y;
+  switch (argc) {
+  case 0:
+    break;
+  case 1:
+    obj = argv[0];
+    if(rb_compatible_q(rb_klass, obj)) {
+      CVPOINT2D32F(self)->x = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("x"), 0), rb_intern("to_f"), 0));
+      CVPOINT2D32F(self)->y = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("y"), 0), rb_intern("to_f"), 0));
+    }else{
+      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
+    }
+    break;
+  case 2:
+    x = argv[0], y = argv[1];
+    CVPOINT2D32F(self)->x = NUM2DBL(x);
+    CVPOINT2D32F(self)->y = NUM2DBL(y);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+  }
+  return Qnil;
+}
+
+/*
+ * Return parameter on x-axis.
+ */
+VALUE
+rb_x(VALUE self)
+{
+  return rb_float_new(CVPOINT2D32F(self)->x);
+}
+
+/*
+ * call-seq:
+ *   x = val
+ *
+ * Set x-axis parameter, return self.
+ */
+VALUE
+rb_set_x(VALUE self, VALUE x)
+{
+  CVPOINT2D32F(self)->x = NUM2DBL(x);
+  return self;
+}
+
+/*
+ * Return parameter on y-axis.
+ */
+VALUE
+rb_y(VALUE self)
+{
+  return rb_float_new(CVPOINT2D32F(self)->y);
+}
+
+/*
+ * call-seq:
+ *   y = val
+ *
+ * Set y-axis parameter, return self.
+ */
+VALUE
+rb_set_y(VALUE self, VALUE y)
+{
+  CVPOINT2D32F(self)->y = NUM2DBL(y);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   to_s -> "<OpenCV::CvSize2D32f:(self.x,self.y)>"
+ *
+ * Return x and y by String.
+ */
+VALUE
+rb_to_s(VALUE self)
+{
+  const int i = 4;
+  VALUE str[i];
+  str[0] = rb_str_new2("<%s:(%f,%f)>");
+  str[1] = rb_str_new2(rb_class2name(CLASS_OF(self)));
+  str[2] = rb_x(self);
+  str[3] = rb_y(self);
+  return rb_f_sprintf(i, str);
+}
+
+/*
+ * call-seq:
+ *   to_ary -> [x, y]
+ *
+ * Return x and y by Array.
+ */
+VALUE
+rb_to_ary(VALUE self)
+{
+  return rb_ary_new3(2, rb_x(self), rb_y(self));
+}
+
+VALUE
+new_object(CvPoint2D32f point)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVPOINT2D32F(object) = point;
+  return object;
+}
+
+__NAMESPACE_END_CVPOINT2D32F
+__NAMESPACE_END_OPENCV

ext/cvpoint2d32f.h

@@ -0,0 +1,61 @@
+/************************************************************
+
+   cvpoint2d32f.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVPOINT2D32F_H
+#define RUBY_OPENCV_CVPOINT2D32F_H
+
+#define __NAMESPACE_BEGIN_CVPOINT2D32F namespace cCvPoint2D32f{
+#define __NAMESPACE_END_CVPOINT2D32F }
+
+#include"opencv.h"
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVPOINT2D32F
+    
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_compatible_q(VALUE klass, VALUE object);
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_x(VALUE self);
+VALUE rb_set_x(VALUE self, VALUE x);
+VALUE rb_y(VALUE self);
+VALUE rb_set_y(VALUE self, VALUE y);
+
+VALUE rb_to_s(VALUE self);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object(CvPoint2D32f point);
+
+__NAMESPACE_END_CVPOINT2D32F
+
+inline CvPoint2D32f*
+CVPOINT2D32F(VALUE object)
+{
+  CvPoint2D32f *ptr;
+  Data_Get_Struct(object, CvPoint2D32f, ptr);
+  return ptr;
+}
+
+inline CvPoint2D32f
+VALUE_TO_CVPOINT2D32F(VALUE object)
+{
+  if(cCvPoint2D32f::rb_compatible_q(cCvPoint2D32f::rb_class(), object)){
+    return cvPoint2D32f(NUM2DBL(rb_funcall(object, rb_intern("x"), 0)),
+                        NUM2DBL(rb_funcall(object, rb_intern("y"), 0)));
+  }else{
+    rb_raise(rb_eTypeError, "require %s or compatible object.", rb_class2name(cCvPoint2D32f::rb_class()));
+  }
+}
+
+__NAMESPACE_END_OPENCV
+#endif // RUBY_OPENCV_CVPOINT2D32F_H

ext/cvpoint3d32f.cpp

@@ -0,0 +1,245 @@
+/************************************************************
+
+   cvpoint3d32f.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2008 Masakazu Yonekura
+
+************************************************************/
+#include"cvpoint3d32f.h"
+/*
+ * Document-class: OpenCV::CvPoint3D32f
+ *
+ * This class means one point on X axis Y axis. 
+ * X and Y takes the value of the Float. see also CvPoint
+ * 
+ * C structure is here, very simple.
+ *   typdef struct CvPoint3D32f{
+ *     float x;
+ *     float y;
+ *     float z;
+ *   }
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVPOINT3D32F
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * cvpoint2d32f = rb_define_class_under(opencv, "CvPoint2D32f", rb_cObject);
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  VALUE cvpoint2d32f = cCvPoint2D32f::rb_class();
+  rb_klass = rb_define_class_under(opencv, "CvPoint3D32f", cvpoint2d32f);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "x", RUBY_METHOD_FUNC(rb_x), 0);
+  rb_define_method(rb_klass, "x=", RUBY_METHOD_FUNC(rb_set_x), 1);
+  rb_define_method(rb_klass, "y", RUBY_METHOD_FUNC(rb_y), 0);
+  rb_define_method(rb_klass, "y=", RUBY_METHOD_FUNC(rb_set_y), 1);
+  rb_define_method(rb_klass, "z", RUBY_METHOD_FUNC(rb_z), 0);
+  rb_define_method(rb_klass, "z=", RUBY_METHOD_FUNC(rb_set_z), 1);
+
+  rb_define_method(rb_klass, "to_s", RUBY_METHOD_FUNC(rb_to_s), 0);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+}
+
+/*
+ * call-seq:
+ *   combatible?(obj)
+ *
+ * Return compatibility to CvPoint3D32f. Return true if object have method #x and #y and #z.
+ *
+ * For example.
+ *   class MyPoint3D32f
+ *     def x
+ *       95.7
+ *     end
+ *     def y
+ *       70.2
+ *     end
+ *     def z
+ *       10.0
+ *     end
+ *   end
+ *   mp = MyPoint3D32f.new
+ *   CvPoint3D32f.compatible?(mp)  #=> true
+ *   CvPoint3D32f.new(mp)          #=> same as CvPoint3D32f(95.7, 70.2)
+ */
+VALUE
+rb_compatible_q(VALUE klass, VALUE object)
+{
+  return (rb_respond_to(object, rb_intern("x")) && rb_respond_to(object, rb_intern("y"))) ? Qtrue : Qfalse;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvPoint3D32f *ptr;
+  return Data_Make_Struct(klass, CvPoint3D32f, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new
+ *   new(obj)
+ *   new(x, y, z)
+ *
+ * Create new 3D-coordinate, (x, y, z).
+ *
+ * new() is same as new(0.0, 0.0, 0.0)
+ *
+ * new(obj) is same as new(obj.x.to_f, obj.y.to_f, obj.z.to_f)
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE obj, x, y, z;
+  switch (argc) {
+  case 0:
+    break;
+  case 1:
+    obj = argv[0];
+    if(rb_compatible_q(rb_klass, obj)) {
+      CVPOINT3D32F(self)->x = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("x"), 0), rb_intern("to_f"), 0));
+      CVPOINT3D32F(self)->y = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("y"), 0), rb_intern("to_f"), 0));
+      CVPOINT3D32F(self)->z = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("z"), 0), rb_intern("to_f"), 0));
+    }else{
+      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
+    }
+    break;
+  case 3:
+    x = argv[0], y = argv[1], z = argv[2];
+    CVPOINT3D32F(self)->x = NUM2DBL(x);
+    CVPOINT3D32F(self)->y = NUM2DBL(y);
+    CVPOINT3D32F(self)->z = NUM2DBL(z);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+  }
+  return Qnil;
+}
+
+/*
+ * Return parameter on x-axis.
+ */
+VALUE
+rb_x(VALUE self)
+{
+  return rb_float_new(CVPOINT2D32F(self)->x);
+}
+
+/*
+ * call-seq:
+ *   x = val
+ *
+ * Set x-axis parameter, return self.
+ */
+VALUE
+rb_set_x(VALUE self, VALUE x)
+{
+  CVPOINT2D32F(self)->x = NUM2DBL(x);
+  return self;
+}
+
+/*
+ * Return parameter on y-axis.
+ */
+VALUE
+rb_y(VALUE self)
+{
+  return rb_float_new(CVPOINT2D32F(self)->y);
+}
+
+/*
+ * call-seq:
+ *   y = val
+ *
+ * Set y-axis parameter, return self.
+ */
+VALUE
+rb_set_y(VALUE self, VALUE y)
+{
+  CVPOINT2D32F(self)->y = NUM2DBL(y);
+  return self;
+}
+
+/*
+ * Return parameter on z-axis.
+ */
+VALUE
+rb_z(VALUE self)
+{
+  return rb_float_new(CVPOINT3D32F(self)->z);
+}
+
+/*
+ * call-seq:
+ *   z = val
+ *
+ * Set z-axis parameter, return self.
+ */
+VALUE
+rb_set_z(VALUE self, VALUE z)
+{
+  CVPOINT3D32F(self)->z = NUM2DBL(z);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   to_s -> "<OpenCV::CvSize3D32f:(self.x,self.y,self.z)>"
+ *
+ * Return x and y by String.
+ */
+VALUE
+rb_to_s(VALUE self)
+{
+  const int i = 5;
+  VALUE str[i];
+  str[0] = rb_str_new2("<%s:(%f,%f,%f)>");
+  str[1] = rb_str_new2(rb_class2name(CLASS_OF(self)));
+  str[2] = rb_x(self);
+  str[3] = rb_y(self);
+  str[4] = rb_z(self);
+  return rb_f_sprintf(i, str);
+}
+
+/*
+ * call-seq:
+ *   to_ary -> [x, y, z]
+ *
+ * Return x and y by Array.
+ */
+VALUE
+rb_to_ary(VALUE self)
+{
+  return rb_ary_new3(3, rb_x(self), rb_y(self), rb_z(self));
+}
+
+VALUE
+new_object(CvPoint3D32f point)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVPOINT3D32F(object) = point;
+  return object;
+}
+
+__NAMESPACE_END_CVPOINT3D32F
+__NAMESPACE_END_OPENCV

ext/cvpoint3d32f.h

@@ -0,0 +1,64 @@
+/************************************************************
+
+   cvpoint3d32f.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2008 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVPOINT3D32F_H
+#define RUBY_OPENCV_CVPOINT3D32F_H
+
+#define __NAMESPACE_BEGIN_CVPOINT3D32F namespace cCvPoint3D32f{
+#define __NAMESPACE_END_CVPOINT3D32F }
+
+#include"opencv.h"
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVPOINT3D32F
+    
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_compatible_q(VALUE klass, VALUE object);
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_x(VALUE self);
+VALUE rb_set_x(VALUE self, VALUE x);
+VALUE rb_y(VALUE self);
+VALUE rb_set_y(VALUE self, VALUE y);
+VALUE rb_z(VALUE self);
+VALUE rb_set_z(VALUE self, VALUE z);
+
+VALUE rb_to_s(VALUE self);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object(CvPoint3D32f point);
+
+__NAMESPACE_END_CVPOINT3D32F
+
+inline CvPoint3D32f*
+CVPOINT3D32F(VALUE object)
+{
+  CvPoint3D32f *ptr;
+  Data_Get_Struct(object, CvPoint3D32f, ptr);
+  return ptr;
+}
+
+inline CvPoint3D32f
+VALUE_TO_CVPOINT3D32F(VALUE object)
+{
+  if(cCvPoint3D32f::rb_compatible_q(cCvPoint3D32f::rb_class(), object)){
+    return cvPoint3D32f(NUM2DBL(rb_funcall(object, rb_intern("x"), 0)),
+                        NUM2DBL(rb_funcall(object, rb_intern("y"), 0)),
+                        NUM2DBL(rb_funcall(object, rb_intern("z"), 0)));
+  }else{
+    rb_raise(rb_eTypeError, "require %s or compatible object.", rb_class2name(cCvPoint3D32f::rb_class()));
+  }
+}
+
+__NAMESPACE_END_OPENCV
+#endif // RUBY_OPENCV_CVPOINT3D32F_H

ext/cvrect.cpp

@@ -0,0 +1,340 @@
+/************************************************************
+
+   cvrect.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvrect.h"
+/*
+ * Document-class: OpenCV::CvRect
+ *
+ * This class have coordinate of top-left point(x, y) and size, width and height.
+ * 
+ * 
+ * C stracture is here, very simple.
+ *   typdef struct CvRect{
+ *     int x;
+ *     int y;
+ *     int width;
+ *     int height;
+ *   }
+ * 
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVRECT
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  rb_klass = rb_define_class_under(opencv, "CvRect", rb_cObject);            
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+
+  rb_define_method(rb_klass, "x", RUBY_METHOD_FUNC(rb_x), 0);
+  rb_define_method(rb_klass, "x=", RUBY_METHOD_FUNC(rb_set_x), 1);
+  rb_define_method(rb_klass, "y", RUBY_METHOD_FUNC(rb_y), 0);
+  rb_define_method(rb_klass, "y=", RUBY_METHOD_FUNC(rb_set_y), 1);
+  rb_define_method(rb_klass, "width", RUBY_METHOD_FUNC(rb_width), 0);
+  rb_define_method(rb_klass, "width=", RUBY_METHOD_FUNC(rb_set_width), 1);
+  rb_define_method(rb_klass, "height", RUBY_METHOD_FUNC(rb_height), 0);
+  rb_define_method(rb_klass, "height=", RUBY_METHOD_FUNC(rb_set_height), 1);      
+  rb_define_method(rb_klass, "center", RUBY_METHOD_FUNC(rb_center), 0);
+  rb_define_method(rb_klass, "points", RUBY_METHOD_FUNC(rb_points), 0);
+  rb_define_method(rb_klass, "top_left", RUBY_METHOD_FUNC(rb_top_left), 0);
+  rb_define_method(rb_klass, "top_right", RUBY_METHOD_FUNC(rb_top_right), 0);
+  rb_define_method(rb_klass, "bottom_left", RUBY_METHOD_FUNC(rb_bottom_left), 0);
+  rb_define_method(rb_klass, "bottom_right", RUBY_METHOD_FUNC(rb_bottom_right), 0);
+  rb_define_method(rb_klass, "or", RUBY_METHOD_FUNC(rb_or), 1);
+  rb_define_alias(rb_klass, "|", "or");
+}
+
+/*
+ * call-seq:
+ *   combatible?(obj)
+ *
+ * Return compatibility to CvRect. Return true if object have method #x and #y and #width and #height.
+ *
+ * For example.
+ *   class MyRect
+ *     def x
+ *       1
+ *     end
+ *     def y
+ *       2
+ *     end
+ *     def width
+ *       10
+ *     end
+ *     def height
+ *       20
+ *     end
+ *   end
+ *   mr = MyRect.new
+ *   CvRect.compatible?(mp)  #=> true
+ *   CvRect.new(mp)          #=> same as CvRect(1, 2, 10, 20)
+ */
+VALUE
+rb_compatible_q(VALUE klass, VALUE object)
+{
+  return (rb_respond_to(object, rb_intern("x")) && rb_respond_to(object, rb_intern("y")) && rb_respond_to(object, rb_intern("width")) && rb_respond_to(object, rb_intern("height"))) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   CvRect.bounding
+ *
+ */
+VALUE
+rb_bounding(VALUE klass, VALUE points)
+{
+  /* not yet */
+  return Qnil;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvRect *ptr;
+  return Data_Make_Struct(klass, CvRect, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new -> CvRect.new(0, 0, 0, 0)
+ *   new(obj) -> CvRect.new(obj.x.to_i, obj.y.to_i, obj.width.to_i, obj.height.to_i)
+ *   new(x, y, width, height)
+ *
+ * Create new rectangle area. (x, y) is top-left point, and width, height is size of area.
+ * It is dropped below the decimal point.
+ *
+ * new() is same as new(0, 0, 0, 0)
+ *
+ * new(obj) is same as new(obj.x.to_i, obj.y.to_i, obj.width.to_i, obj.height.to_i)
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object, x, y, width, height;
+  switch (argc) {
+  case 0:
+    break;
+  case 1:
+    object = argv[0];
+    if(rb_compatible_q(rb_klass, object)) {
+      CVRECT(self)->x = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("x"), 0), rb_intern("to_i"), 0));
+      CVRECT(self)->y = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("y"), 0), rb_intern("to_i"), 0));
+      CVRECT(self)->width = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("width"), 0), rb_intern("to_i"), 0));
+      CVRECT(self)->height = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("height"), 0), rb_intern("to_i"), 0));
+    }else{
+      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
+    }
+    break;
+  case 4:
+    x = argv[0], y = argv[1], width = argv[2], height = argv[3];
+    CVRECT(self)->x = NUM2INT(x);
+    CVRECT(self)->y = NUM2INT(y);
+    CVRECT(self)->width = NUM2INT(width);
+    CVRECT(self)->height = NUM2INT(height);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+  }
+  return Qnil;      
+}
+
+/*
+ * Return parameter on x-axis of top-left point.
+ */
+VALUE
+rb_x(VALUE self)
+{
+  return INT2FIX(CVRECT(self)->x);
+}
+
+/*
+ * call-seq:
+ *   x = val
+ *
+ * Set x-axis parameter of top-left point, return self.
+ * It is dropped below the decimal point.
+ */
+VALUE
+rb_set_x(VALUE self, VALUE x)
+{
+  CVRECT(self)->x = NUM2INT(x);
+  return self;
+}
+
+/*
+ * Return parameter on y-axis of top-left point.
+ */
+VALUE
+rb_y(VALUE self)
+{
+  return INT2FIX(CVRECT(self)->y);
+}
+
+/*
+ * call-seq:
+ *   y = val
+ *
+ * Set y-axis parameter of top-left point, return self.
+ * It is dropped below the decimal point.
+ */
+VALUE
+rb_set_y(VALUE self, VALUE y)
+{
+  CVRECT(self)->y = NUM2INT(y);
+  return self;
+}
+
+/*
+ * Return size of x-axis.
+ */
+VALUE
+rb_width(VALUE self)
+{
+  return INT2FIX(CVRECT(self)->width);
+}
+
+/*
+ * call-seq:
+ *   width = val
+ *
+ * Set x-axis size, return self.
+ * It is dropped below the decimal point.
+ */
+VALUE
+rb_set_width(VALUE self, VALUE x)
+{
+  CVRECT(self)->width = NUM2INT(x);
+  return self;
+}
+
+/*
+ * Return size of y-axis.
+ */
+VALUE
+rb_height(VALUE self)
+{
+  return INT2FIX(CVRECT(self)->height);
+}
+
+/*
+ * call-seq:
+ *   height = val
+ *
+ * Set y-axis size, return self.
+ * It is dropped below the decimal point.
+ */
+VALUE
+rb_set_height(VALUE self, VALUE y)
+{
+  CVRECT(self)->height = NUM2INT(y);
+  return self;
+}
+
+/*
+ * Return center point of rectangle.
+ */
+VALUE
+rb_center(VALUE self)
+{
+  CvRect *rect = CVRECT(self);  
+  return cCvPoint2D32f::new_object(cvPoint2D32f((float)rect->x + (float)rect->width / 2.0,
+                                                (float)rect->y + (float)rect->height / 2.0));
+}
+
+/*
+ * Return 4 points (top-left, bottom-left, bottom-right, top-right)
+ */
+VALUE
+rb_points(VALUE self)
+{
+  CvRect *rect = CVRECT(self);
+  return rb_ary_new3(4,
+                     cCvPoint::new_object(cvPoint(rect->x, rect->y)),
+                     cCvPoint::new_object(cvPoint(rect->x, rect->y + rect->height)),
+                     cCvPoint::new_object(cvPoint(rect->x + rect->width, rect->y + rect->height)),
+                     cCvPoint::new_object(cvPoint(rect->x + rect->width, rect->y))
+                     );
+}
+
+/*
+ * Return top-left point of rectangle.
+ */
+VALUE
+rb_top_left(VALUE self)
+{
+  return cCvPoint::new_object(cvPoint(CVRECT(self)->x, CVRECT(self)->y));
+}
+
+/*
+ * Return top-right point of rectangle.
+ */
+VALUE
+rb_top_right(VALUE self)
+{
+  return cCvPoint::new_object(cvPoint(CVRECT(self)->x + CVRECT(self)->width, CVRECT(self)->y));
+}
+
+/*
+ * Return bottom-left point of rectangle.
+ */
+VALUE
+rb_bottom_left(VALUE self)
+{
+  return cCvPoint::new_object(cvPoint(CVRECT(self)->x, CVRECT(self)->y + CVRECT(self)->height));
+}
+
+/*
+ * Return bottom-right point of rectangle.
+ */
+VALUE
+rb_bottom_right(VALUE self)
+{
+  return cCvPoint::new_object(cvPoint(CVRECT(self)->x + CVRECT(self)->width, CVRECT(self)->y + CVRECT(self)->height));
+}
+
+/*
+ * call-seq:
+ *   or(rect) -> cvrect
+ *
+ * Finds bounding rectangle for self and given rectangles.
+ */
+VALUE
+rb_or(VALUE self, VALUE rect)
+{
+  return cCvRect::new_object(cvMaxRect(CVRECT(self), CVRECT(rect)));
+}
+
+VALUE
+new_object(CvRect rect)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVRECT(object) = rect;
+  return object;
+}
+
+__NAMESPACE_END_CVRECT
+__NAMESPACE_END_OPENCV

ext/cvrect.h

@@ -0,0 +1,79 @@
+/************************************************************
+
+   cvrect.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVRECT_H
+#define RUBY_OPENCV_CVRECT_H
+
+#include"opencv.h"
+
+#define __NAMESPACE_BEGIN_CVRECT namespace cCvRect{
+#define __NAMESPACE_END_CVRECT }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVRECT
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_compatible_q(VALUE klass, VALUE object);
+VALUE rb_bounding(VALUE klass, VALUE points);
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_x(VALUE self);
+VALUE rb_set_x(VALUE self, VALUE x);
+VALUE rb_y(VALUE self);
+VALUE rb_set_y(VALUE self, VALUE y);
+VALUE rb_width(VALUE self);
+VALUE rb_set_width(VALUE self, VALUE width);
+VALUE rb_height(VALUE self);
+VALUE rb_set_height(VALUE self, VALUE height);
+
+VALUE rb_center(VALUE self);
+VALUE rb_points(VALUE self);
+VALUE rb_top_left(VALUE self);
+VALUE rb_set_top_left(VALUE self, VALUE point);
+VALUE rb_top_right(VALUE self);
+VALUE rb_set_top_right(VALUE self, VALUE point);
+VALUE rb_bottom_left(VALUE self);
+VALUE rb_set_bottom_left(VALUE self, VALUE point);
+VALUE rb_bottom_right(VALUE self);
+VALUE rb_set_bottom_right(VALUE self, VALUE point);
+
+VALUE rb_or(VALUE self, VALUE rect);
+
+VALUE new_object(CvRect rect);
+
+__NAMESPACE_END_CVRECT
+
+inline CvRect*
+CVRECT(VALUE object)
+{
+  CvRect *ptr;
+  Data_Get_Struct(object, CvRect, ptr);
+  return ptr;
+}
+
+inline CvRect
+VALUE_TO_CVRECT(VALUE object)
+{
+  if(cCvRect::rb_compatible_q(cCvRect::rb_class(), object)){
+    return cvRect(NUM2INT(rb_funcall(object, rb_intern("x"), 0)),
+                  NUM2INT(rb_funcall(object, rb_intern("y"), 0)),
+                  NUM2INT(rb_funcall(object, rb_intern("width"), 0)),
+                  NUM2INT(rb_funcall(object, rb_intern("height"), 0)));
+  }else{
+      rb_raise(rb_eTypeError, "require %s or compatible object.", rb_class2name(cCvRect::rb_class()));
+  }
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVRECT_H

ext/cvscalar.cpp

@@ -0,0 +1,227 @@
+/************************************************************
+
+   cvscalar.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#include "cvscalar.h"
+/*
+ * Document-class: OpenCV::CvScalar
+ *
+ * Element-value of one pixel.
+ * OpenCV supports the image of 4-channels in the maximum.
+ * Therefore, CvScalar has 4-values.
+ * 
+ * C structure is here, very simple.
+ *   typdef struct CvScalar{
+ *     double val[4];
+ *   }CvScalar;
+ *
+ * If obtain CvScalar-object from the method of CvMat(or IplImage),
+ * the channel outside the range is obtained as all 0.
+ *
+ *   image = IplImage::load("opencv.jpg")  #=> 3-channel 8bit-depth BGR image
+ *   pixel = image[10, 20]                 #=> Get pixel value of (10, 20) of image. pixel is CvScalar-object.
+ *   blue, green, red = pixel[0], pixel[1], pixel[2]
+ *   # pixel[3] always 0.
+ *
+ * CvColor is alias of CvScalar.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSCALAR
+
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvScalar", rb_cObject);
+  /* CvScalar: class */
+  rb_define_const(opencv, "CvColor", rb_klass);
+  rb_define_alloc_func(rb_klass, rb_allocate);      
+  rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "[]", RUBY_METHOD_FUNC(rb_aref), 1);
+  rb_define_method(rb_klass, "[]=", RUBY_METHOD_FUNC(rb_aset), 2);
+  rb_define_method(rb_klass, "sub", RUBY_METHOD_FUNC(rb_sub), -1);
+  rb_define_alias(rb_klass, "-", "sub");
+  
+  rb_define_method(rb_klass, "to_s", RUBY_METHOD_FUNC(rb_to_s), 0);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+
+  rb_define_const(rb_klass, "Black", cCvScalar::new_object(cvScalar(0x0,0x0,0x0)));
+  rb_define_const(rb_klass, "Silver", cCvScalar::new_object(cvScalar(0x0c,0x0c,0x0c)));
+  rb_define_const(rb_klass, "Gray", cCvScalar::new_object(cvScalar(0x80,0x80,0x80)));
+  rb_define_const(rb_klass, "White", cCvScalar::new_object(cvScalar(0xff,0xff,0xff)));
+  rb_define_const(rb_klass, "Maroon", cCvScalar::new_object(cvScalar(0x0,0x0,0x80)));
+  rb_define_const(rb_klass, "Red", cCvScalar::new_object(cvScalar(0x0,0x0,0xff)));
+  rb_define_const(rb_klass, "Purple", cCvScalar::new_object(cvScalar(0x80,0x0,0x80)));
+  rb_define_const(rb_klass, "Fuchsia", cCvScalar::new_object(cvScalar(0xff,0x0,0xff)));
+  rb_define_const(rb_klass, "Green", cCvScalar::new_object(cvScalar(0x0,0x80,0x0)));
+  rb_define_const(rb_klass, "Lime", cCvScalar::new_object(cvScalar(0x0,0xff,0x0)));
+  rb_define_const(rb_klass, "Olive", cCvScalar::new_object(cvScalar(0x0,0x80,0x80)));
+  rb_define_const(rb_klass, "Yellow", cCvScalar::new_object(cvScalar(0x0,0xff,0xff)));
+  rb_define_const(rb_klass, "Navy", cCvScalar::new_object(cvScalar(0x80,0x0,0x0)));
+  rb_define_const(rb_klass, "Blue", cCvScalar::new_object(cvScalar(0xff,0x0,0x0)));
+  rb_define_const(rb_klass, "Teal", cCvScalar::new_object(cvScalar(0x80,0x80,0x0)));
+  rb_define_const(rb_klass, "Aqua", cCvScalar::new_object(cvScalar(0xff,0xff,0x0)));
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvScalar *ptr;
+  return Data_Make_Struct(klass, CvScalar, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new(<i>[d1][,d2][,d3][,d4]</i>)
+ *
+ * Create new Scalar. Argument should be Fixnum (or nil as 0).
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE val[4];
+  rb_scan_args(argc, argv, "04", &val[0], &val[1], &val[2], &val[3]);
+  for (int i = 0; i < 4; i++) {
+    CVSCALAR(self)->val[i] = NIL_P(val[i]) ? 0 : NUM2DBL(val[i]);
+  }
+  return self;
+}
+
+/*
+ * call-seq:
+ *   [<i>index</i>]
+ *
+ * Return value of <i>index</i> dimension.
+ */
+VALUE
+rb_aref(VALUE self, VALUE index)
+{
+  int idx = NUM2INT(index);
+  if (!(idx < 0) && idx < 4) {
+    return rb_float_new(CVSCALAR(self)->val[idx]);
+  }else{
+    rb_raise(rb_eIndexError, "scalar index should be 0...4");
+  }
+}
+
+/*
+ * call-seq:
+ *   [<i>index</i>] = <i>value</i>
+ *
+ * Set value of <i>index</i> dimension to <i>value</i>
+ */
+VALUE
+rb_aset(VALUE self, VALUE index, VALUE value)
+{
+  int idx = NUM2INT(index);
+  if (!(idx < 0) && idx < 4) {
+    CVSCALAR(self)->val[idx] = NUM2DBL(value);
+    return self;
+  }else{
+    rb_raise(rb_eIndexError, "scalar index should be 0...4");
+  }
+}
+
+/*
+ * call-seq:
+ *   sub(val[,mask])
+ *
+ * Return new CvScalar if <i>val</i> is CvScalar or compatible object.
+ *   self[I] - val[I]
+ * Or return new CvMat if <i>val</i> is CvMat or subclass.
+ */
+VALUE
+rb_sub(int argc, VALUE *argv, VALUE self)
+{
+  VALUE val, mask;
+  rb_scan_args(argc, argv, "11", &val, &mask);
+  if(rb_obj_is_kind_of(val, cCvMat::rb_class())){
+    VALUE dest = cCvMat::new_object(cvGetSize(CVARR(val)), cvGetElemType(CVARR(val)));
+    cvSubRS(CVARR(val), *CVSCALAR(self), CVARR(dest), MASK(mask));
+    return dest;
+  }else{
+    CvScalar *src = CVSCALAR(self), scl = VALUE_TO_CVSCALAR(val);
+    return new_object(cvScalar(src->val[0] - scl.val[0],
+                               src->val[1] - scl.val[1],
+                               src->val[2] - scl.val[2],
+                               src->val[3] - scl.val[3]));
+  }
+}
+
+/*
+ * call-seq:
+ *   to_s -> "<OpeCV::CvScalar:#{self[0]},#{self[1]},#{self[2]},#{self[3]}>"
+ *
+ * Return values by String.
+ */
+VALUE
+rb_to_s(VALUE self)
+{
+  const int i = 6;
+  VALUE str[i];
+  str[0] = rb_str_new2("<%s:%d,%d,%d,%d>");
+  str[1] = rb_str_new2(rb_class2name(CLASS_OF(self)));
+  str[2] = rb_aref(self, INT2FIX(0));
+  str[3] = rb_aref(self, INT2FIX(1));
+  str[4] = rb_aref(self, INT2FIX(2));
+  str[5] = rb_aref(self, INT2FIX(3));
+  return rb_f_sprintf(i, str);
+}
+
+/*
+ * call-seq:
+ *   to_ary -> [self[0],self[1],self[2],self[3]]
+ *
+ * Return values by Array.
+ */
+VALUE
+rb_to_ary(VALUE self)
+{
+  return rb_ary_new3(4,
+		     rb_aref(self, INT2FIX(0)),
+		     rb_aref(self, INT2FIX(1)),
+		     rb_aref(self, INT2FIX(2)),
+		     rb_aref(self, INT2FIX(3)));
+}
+
+VALUE
+new_object()
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVSCALAR(object) = cvScalar(0);
+  return object;
+}
+
+VALUE
+new_object(CvScalar scalar)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVSCALAR(object) = scalar;
+  return object;
+}
+
+__NAMESPACE_END_CVSCALAR
+__NAMESPACE_END_OPENCV
+

ext/cvscalar.h

@@ -0,0 +1,63 @@
+/************************************************************
+
+   cvscalar.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSCALAR_H
+#define RUBY_OPENCV_CVSCALAR_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSCALAR namespace cCvScalar{
+#define __NAMESPACE_END_CVSCALAR }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSCALAR
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_compatible_q(VALUE klass, VALUE object);
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_aref(VALUE self, VALUE index);
+VALUE rb_aset(VALUE self, VALUE index, VALUE value);
+VALUE rb_sub(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_to_s(VALUE self);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object();
+VALUE new_object(CvScalar scalar);
+
+__NAMESPACE_END_CVSCALAR
+
+inline CvScalar*
+CVSCALAR(VALUE object)
+{
+  CvScalar *ptr;
+  Data_Get_Struct(object, CvScalar, ptr);
+  return ptr;
+}
+
+inline CvScalar
+VALUE_TO_CVSCALAR(VALUE object)
+{
+  if(FIXNUM_P(object))
+    return cvScalarAll(FIX2INT(object));
+  return cvScalar(NUM2INT(rb_funcall(object, rb_intern("[]"), 1, INT2FIX(0))),
+                  NUM2INT(rb_funcall(object, rb_intern("[]"), 1, INT2FIX(1))),
+                  NUM2INT(rb_funcall(object, rb_intern("[]"), 1, INT2FIX(2))),
+                  NUM2INT(rb_funcall(object, rb_intern("[]"), 1, INT2FIX(3))));
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSCALAR_H

ext/cvseq.cpp

@@ -0,0 +1,583 @@
+/************************************************************
+
+   cvseq.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvseq.h"
+/*
+ * Document-class: OpenCV::CvSeq
+ *
+ * Generic Sequence class. CvSeq has the method like Array (push, pop, select, etc...).
+ * But, CvSeq cannot store the object of a different class.
+ * When storing object in CvSeq, conversion is automatically tried,
+ * and the object occurs the error if it cannot be done.
+ *
+ * e.g.
+ *   seq = CvSeq.new(CvPoint)    # Argument mean "this sequence contain only this class's object"
+ *   seq.push(CvPoint.new(0, 0)) # => it's ok
+ *   seq.push("hello")           # => try convert "hello" to CvPoint. but can't do it. raise error.
+ *
+ * If the sequecne contain object of class A.
+ * When storing object(named "obj") of class B to the sequence.
+ *   Try automatically : A.from_B(obj) => object of class A.
+ *
+ * CvSeq has the circulation structure internally.
+ * That is, when the sequence has three values ("a","b","c"),
+ * seq[0] and seq[3] are same "a", and seq[-1] and seq[2] are same "c".
+ *
+ * The sequence might have another sequence outside. see below. 
+ * Each sequece has h_prev, h_next, v_prev, v_next method.
+ * If the adjoining sequence exists, each method return the adjoining sequence.
+ * Otherwise return nil.
+ *
+ * link:../images/CvSeq_relationmap.png
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSEQ
+    
+// contain sequence-block class
+st_table *seqblock_klass = st_init_numtable();
+    
+VALUE
+seqblock_class(void *ptr)
+{
+  VALUE klass;
+  if(!st_lookup(seqblock_klass, (st_data_t)ptr, (st_data_t*)&klass)){
+    rb_raise(rb_eTypeError, "Invalid sequence error.");
+  }
+  return klass;
+}
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  rb_klass = rb_define_class_under(opencv, "CvSeq", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "total", RUBY_METHOD_FUNC(rb_total), 0);
+  rb_define_alias(rb_klass, "length", "total");
+  rb_define_alias(rb_klass, "size", "total");
+  rb_define_method(rb_klass, "empty?", RUBY_METHOD_FUNC(rb_empty_q), 0);
+  rb_define_method(rb_klass, "[]", RUBY_METHOD_FUNC(rb_aref), 1);
+  rb_define_method(rb_klass, "first", RUBY_METHOD_FUNC(rb_first), 0);
+  rb_define_method(rb_klass, "last", RUBY_METHOD_FUNC(rb_last), 0);
+  rb_define_method(rb_klass, "index", RUBY_METHOD_FUNC(rb_index), 1);
+  
+  rb_define_method(rb_klass, "h_prev", RUBY_METHOD_FUNC(rb_h_prev), 0);
+  rb_define_method(rb_klass, "h_next", RUBY_METHOD_FUNC(rb_h_next), 0);
+  rb_define_method(rb_klass, "v_prev", RUBY_METHOD_FUNC(rb_v_prev), 0);
+  rb_define_method(rb_klass, "v_next", RUBY_METHOD_FUNC(rb_v_next), 0);
+
+  rb_define_method(rb_klass, "push", RUBY_METHOD_FUNC(rb_push), -2);
+  rb_define_alias(rb_klass, "<<", "push");
+  rb_define_method(rb_klass, "pop", RUBY_METHOD_FUNC(rb_pop), 0);
+  rb_define_method(rb_klass, "unshift", RUBY_METHOD_FUNC(rb_unshift), -2);
+  rb_define_alias(rb_klass, "push_front", "unshift");
+  rb_define_method(rb_klass, "shift", RUBY_METHOD_FUNC(rb_shift), 0);
+  rb_define_alias(rb_klass, "pop_front", "shift");
+  rb_define_method(rb_klass, "each", RUBY_METHOD_FUNC(rb_each), 0);
+  rb_define_method(rb_klass, "each_index", RUBY_METHOD_FUNC(rb_each_index), 0);
+  rb_define_method(rb_klass, "each_with_index", RUBY_METHOD_FUNC(rb_each_with_index), 0);
+  rb_define_method(rb_klass, "insert", RUBY_METHOD_FUNC(rb_insert), 2);
+  rb_define_method(rb_klass, "remove", RUBY_METHOD_FUNC(rb_remove), 1);
+  rb_define_method(rb_klass, "clear", RUBY_METHOD_FUNC(rb_clear), 0);
+
+  rb_define_alias(rb_klass, "delete_at", "remove");
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, mark_root_object, free, 0);
+}
+    
+void
+free(void *ptr)
+{
+  if(ptr){
+    unresist_object(ptr);
+    st_delete(seqblock_klass, (st_data_t*)&ptr, 0);
+  }
+}
+
+void
+resist_class_information_of_sequence(CvSeq *seq, VALUE klass)
+{
+  st_insert(seqblock_klass, (st_data_t)seq, (st_data_t)klass);
+}
+
+/*
+ * call-seq:
+ *   CvSeq.new(<i>type[,storage]</i>)
+ *
+ * Return a new CvSeq. <i>type</i> should be following classes.
+ *
+ * * CvIndex
+ * * CvPoint
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE klass, storage;
+  rb_scan_args(argc, argv, "11", &klass, &storage);
+  if(!rb_obj_is_kind_of(klass, rb_cClass))
+    rb_raise(rb_eTypeError, "argument 1 (sequence-block class) should be %s.", rb_class2name(rb_cClass));
+  CvSeq *seq = 0;
+  storage = CHECK_CVMEMSTORAGE(storage);
+  int type = 0, size = 0;
+  if(klass == cCvIndex::rb_class()){
+    type = CV_SEQ_ELTYPE_INDEX;
+    size = sizeof(CvIndex);
+  }else if(klass == cCvPoint::rb_class()){
+    type = CV_SEQ_ELTYPE_POINT;
+    size = sizeof(CvPoint);
+  }else if(klass == cCvPoint2D32f::rb_class()){
+    type = CV_SEQ_ELTYPE_POINT;
+    size = sizeof(CvPoint2D32f);
+  }else if(klass == cCvPoint3D32f::rb_class()){
+    type = CV_SEQ_ELTYPE_POINT3D;
+    size = sizeof(CvPoint3D32f);
+  }
+  auto_extend(self);
+  // todo: more various class will be support.
+  if(!size)
+    rb_raise(rb_eTypeError, "unsupport %s class for sequence-block.", rb_class2name(klass));
+  seq = cvCreateSeq(type, sizeof(CvSeq), size, CVMEMSTORAGE(storage));
+  DATA_PTR(self) = seq;
+  resist_root_object(seq, storage);
+  // resist class information of this sequence.
+  st_insert(seqblock_klass, (st_data_t)seq, (st_data_t)klass);
+  return self;
+}
+    
+/*
+ * call-seq:
+ *   total -> int
+ *
+ * Return total number of sequence-block.
+ */
+VALUE
+rb_total(VALUE self)
+{
+  return INT2FIX(CVSEQ(self)->total);
+}
+
+/*
+ * call-seq:
+ *   empty? -> true or false.
+ *
+ * Return <tt>true</tt> if contain no object, otherwize return <tt>false</tt>.
+ */
+VALUE
+rb_empty_q(VALUE self)
+{
+  return CVSEQ(self)->total == 0 ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   [<i>index</i>] -> obj or nil
+ *
+ * Return sequence-block at <i>index</i>.
+ */
+VALUE
+rb_aref(VALUE self, VALUE index)
+{
+  CvSeq *seq = CVSEQ(self);
+  if(!(seq->total > 0))
+    return Qnil;
+  return REFER_OBJECT(seqblock_class(seq), cvGetSeqElem(seq, NUM2INT(index) % seq->total), self);
+}
+
+/*
+ * call-seq:
+ *   first -> obj or nil
+ *
+ * Return first sequence-block.
+ */
+VALUE
+rb_first(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  if(!(seq->total > 0))
+    return Qnil;
+  return REFER_OBJECT(seqblock_class(seq), cvGetSeqElem(seq, 0), self);
+}
+
+/*
+ * call-seq:
+ *   last -> obj or nil
+ *
+ * Return last sequence-block.
+ */
+VALUE
+rb_last(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  if(!(seq->total > 0))
+    return Qnil;
+  return REFER_OBJECT(seqblock_class(seq), cvGetSeqElem(seq, -1), self);
+}
+    
+/*when storing it in CvSeq. 
+ * call-seq:
+ *   index(<i>obj</i>) -> int or nil
+ *
+ * Return the index of the first object in <i>self</i>. Return <tt>nil</tt> if no match is found.
+ */
+VALUE
+rb_index(VALUE self, VALUE object)
+{
+  CvSeq *seq = CVSEQ(self);
+  int index;
+  if(CLASS_OF(object) == seqblock_class(seq)){
+    index = cvSeqElemIdx(seq, DATA_PTR(object));
+    if(!(index < 0))
+      return INT2FIX(index);
+  }else{
+    rb_warn("sequence-block class unmatch.");
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   h_prev -> seq or nil
+ *
+ * Return the sequence horizontally located in previous.
+ * Return <tt>nil</tt> if not existing.
+ */
+VALUE
+rb_h_prev(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  if (seq->h_prev) {
+    return new_sequence(CLASS_OF(self), seq->h_prev, seqblock_class(seq), lookup_root_object(seq));
+      //new_sequence(seq->h_prev, CLASS_OF(self), seqblock_class(seq), lookup_root_object(seq));
+  } else
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   h_next -> seq or nil
+ *
+ * Return the sequence horizontally located in next.
+ * Return <tt>nil</tt> if not existing.
+ */
+VALUE
+rb_h_next(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  if (seq->h_next) {
+    return new_sequence(CLASS_OF(self), seq->h_next, seqblock_class(seq), lookup_root_object(seq));
+      //new_sequence(seq->h_next, CLASS_OF(self), seqblock_class(seq), lookup_root_object(seq));
+  } else
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   v_prev -> seq or nil
+ *
+ * Return the sequence vertically located in previous.
+ * Return <tt>nil</tt> if not existing.
+ */
+VALUE
+rb_v_prev(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  if (seq->v_prev) {
+    return new_sequence(CLASS_OF(self), seq->v_prev, seqblock_class(seq), lookup_root_object(seq));
+  } else
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   v_prev -> seq or nil
+ *
+ * Return the sequence vertically located in next.
+ * Return <tt>nil</tt> if not existing.
+ */
+VALUE
+rb_v_next(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  if (seq->v_next) {    
+    return new_sequence(CLASS_OF(self), seq->v_next, seqblock_class(seq), lookup_root_object(seq));
+  } else
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   push(<i>obj, ...</i>) -> self
+ *     
+ * Append - Pushes the given object(s) on the end of this sequence. This expression return the sequence itself,
+ * so several append may be chainded together.
+ */
+VALUE
+rb_push(VALUE self, VALUE args)
+{
+  CvSeq *seq = CVSEQ(self);
+  VALUE klass = seqblock_class(seq), object;
+  void *buffer = 0;      
+  for(int i = 0; i < RARRAY(args)->len; i++){
+    object = RARRAY(args)->ptr[i];
+    if(CLASS_OF(object) == klass){
+      cvSeqPush(seq, DATA_PTR(object));          
+    }else if(rb_obj_is_kind_of(object, rb_klass) && CLASS_OF(object) == klass){ // object is CvSeq
+      buffer = cvCvtSeqToArray(CVSEQ(object), cvAlloc(CVSEQ(object)->total * CVSEQ(object)->elem_size));
+      cvSeqPushMulti(seq, buffer, CVSEQ(object)->total);
+      cvFree((void**)&buffer);
+    }else{
+      object = CONVERT(object, klass);
+      cvSeqPush(seq, DATA_PTR(object));
+    }
+  }
+  return self;
+}
+    
+/*
+ * call-seq:
+ *   pop -> obj or nil
+ *
+ * Remove the last sequence-block from <i>self</i> and return it,
+ * or <tt>nil</tt> if the sequence is empty.
+ */
+VALUE
+rb_pop(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  if(!(seq->total > 0)){
+    return Qnil;
+  }
+  VALUE object = GENERIC_OBJECT(seqblock_class(seq), malloc(seq->elem_size));
+  cvSeqPop(seq, DATA_PTR(object));
+  return object;
+}
+
+/*
+ * call-seq:
+ *   clear -> self
+ *
+ * Clears sequence. Removes all elements from the sequence.
+ */
+VALUE
+rb_clear(VALUE self)
+{
+  cvClearSeq(CVSEQ(self));
+  return self;
+}
+
+/*
+ * call-seq:
+ *   unshift -> self
+ *
+ * Prepends objects to the front of sequence. other elements up one.
+ */
+VALUE
+rb_unshift(VALUE self, VALUE args)
+{
+  CvSeq *seq = CVSEQ(self);
+  VALUE klass = seqblock_class(seq), object;
+  void *buffer = 0;      
+  for(int i = 0; i < RARRAY(args)->len; i++){
+    object = RARRAY(args)->ptr[i];
+    if(CLASS_OF(object) == klass){
+      cvSeqPushFront(seq, DATA_PTR(object));
+    }else if(rb_obj_is_kind_of(object, rb_klass) && CLASS_OF(object) == klass){
+      buffer = cvCvtSeqToArray(CVSEQ(object), cvAlloc(CVSEQ(object)->total * CVSEQ(object)->elem_size));
+      cvSeqPushMulti(seq, buffer, CVSEQ(object)->total, 1);
+      cvFree((void**)&buffer);
+    }else{
+      object = CONVERT(object, klass);
+      cvSeqPushFront(seq, DATA_PTR(object));
+    }
+  }
+  return self;
+}
+
+/*
+ * call-seq:
+ *   shift -> obj or nil
+ *
+ * Returns the first element of <i>self</i> and removes it (shifting all other elements down by one). Returns <tt>nil</tt> if the array is empty.
+ */
+VALUE
+rb_shift(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  if(!(seq->total > 0)){
+    return Qnil;
+  }
+  VALUE object = GENERIC_OBJECT(seqblock_class(seq), malloc(seq->elem_size));
+  cvSeqPopFront(seq, DATA_PTR(object));
+  return object;
+}
+
+/*
+ * call-seq:
+ *   each{|obj| ... } -> self
+ *
+ * Calls block once for each sequence-block in <i>self</i>,
+ * passing that sequence-block as a parameter.
+ *   seq = CvSeq.new(CvIndex)
+ *   seq.push(5, 6, 7)
+ *   seq.each{|x| print x, " -- "
+ * produces:
+ *   5 -- 6 -- 7 --
+ */
+VALUE
+rb_each(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  if(seq->total > 0){
+    VALUE klass = seqblock_class(seq);
+    for(int i = 0; i < seq->total; i++){
+      rb_yield(REFER_OBJECT(klass, cvGetSeqElem(seq, i), self));
+    }
+  }
+  return self;
+}
+
+/*
+ * call-seq:
+ *    each_index{|index| ... } -> self
+ *
+ * Same as CvSeq#each, but passes the index of the element instead of the element itself.
+ */
+VALUE
+rb_each_index(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  for(int i = 0; i < seq->total; i++)
+    rb_yield(INT2FIX(i));
+  return self;
+}
+
+/*
+ * call-seq:
+ *   each_with_index{|obj, i| ... } -> self
+ *
+ * Calls block with two arguments, the sequence-block and its index, for each sequence-block in sequence.
+ */
+VALUE
+rb_each_with_index(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  VALUE klass = seqblock_class(seq);
+  for(int i = 0; i < seq->total; i++)
+    rb_yield_values(2, REFER_OBJECT(klass, cvGetSeqElem(seq, i), self), INT2FIX(i));
+  return self;
+}
+
+/*
+ * call-seq:
+ *   insert(<i>index,obj</i>) -> self
+ *
+ * Inserts the given values before element with the given index (which may be negative).
+ */
+VALUE
+rb_insert(VALUE self, VALUE index, VALUE object)
+{
+  Check_Type(index, T_FIXNUM);
+  CvSeq *seq = CVSEQ(self);
+  VALUE klass = seqblock_class(seq);
+  if(CLASS_OF(object) != klass)
+    object = CONVERT(object, klass);
+  cvSeqInsert(seq, FIX2INT(index), DATA_PTR(object));
+  return self;
+}
+
+/*
+ * call-seq:
+ *   remove(<i>index</i>) -> obj or nil
+ *
+ * Deletes the elements at the specified index.
+ */
+VALUE
+rb_remove(VALUE self, VALUE index)
+{
+  cvSeqRemove(CVSEQ(self), FIX2INT(index));
+  return self;
+}
+
+/*
+ * call-seq:
+ *   clone
+ *
+ * Return copy of sequence.
+ */
+VALUE
+rb_clone(VALUE self)
+{
+  CvSeq *seq = CVSEQ(self);
+  VALUE storage = cCvMemStorage::new_object();
+  return new_sequence(CLASS_OF(self), cvCloneSeq(seq), seqblock_class(seq), storage);
+}
+
+/*
+VALUE
+new_object(CvSeq *seq, VALUE klass)
+{
+  VALUE storage = cCvMemStorage::new_object();
+  VALUE object = REFER_OBJECT(rb_klass, seq, storage);
+  st_insert(seqblock_klass, (st_data_t)seq, (st_data_t)klass);
+  return object;
+}
+
+VALUE
+new_object(CvSeq *seq, VALUE klass, VALUE storage)
+{
+  VALUE object = REFER_OBJECT(rb_klass, seq, storage);
+  st_insert(seqblock_klass, (st_data_t)seq, (st_data_t)klass);
+  return object;
+}
+*/
+
+
+VALUE
+new_sequence(VALUE klass, CvSeq *seq, VALUE element_klass, VALUE storage)
+{
+  resist_root_object(seq, storage);
+  if (!NIL_P(element_klass))
+    st_insert(seqblock_klass, (st_data_t)seq, (st_data_t)element_klass);  
+  VALUE object = Data_Wrap_Struct(klass, mark_root_object, free, seq);
+  auto_extend(object);
+  return object;
+}
+
+VALUE
+auto_extend(VALUE object)
+{
+  CvSeq *seq = CVSEQ(object);
+  if(CV_IS_SEQ_POINT_SET(seq)){
+    rb_extend_object(object, mPointSet::rb_module());
+  }
+  return object;
+}
+
+__NAMESPACE_END_CVSEQ
+__NAMESPACE_END_OPENCV

ext/cvseq.h

@@ -0,0 +1,71 @@
+/************************************************************
+
+   cvseq.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSEQ_H
+#define RUBY_OPENCV_CVSEQ_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSEQ namespace cCvSeq{
+#define __NAMESPACE_END_CVSEQ }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSEQ
+
+VALUE rb_class();
+void define_ruby_class();
+
+VALUE seqblock_class(void *ptr);
+
+VALUE rb_allocate(VALUE klass);
+void free(void *ptr);
+void resist_class_information_of_sequence(CvSeq *seq, VALUE klass);
+
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_total(VALUE self);
+VALUE rb_empty_q(VALUE self);
+VALUE rb_aref(VALUE self, VALUE index);
+VALUE rb_first(VALUE self);
+VALUE rb_last(VALUE self);
+VALUE rb_index(VALUE self, VALUE object);
+VALUE rb_h_prev(VALUE self);
+VALUE rb_h_next(VALUE self);
+VALUE rb_v_prev(VALUE self);
+VALUE rb_v_next(VALUE self);
+VALUE rb_push(VALUE self, VALUE args);
+VALUE rb_pop(VALUE self);
+VALUE rb_unshift(VALUE self, VALUE args);
+VALUE rb_shift(VALUE self);
+VALUE rb_each(VALUE self);
+VALUE rb_each_index(VALUE self);
+VALUE rb_each_with_index(VALUE self);
+VALUE rb_insert(VALUE self, VALUE index, VALUE object);
+VALUE rb_remove(VALUE self, VALUE index);
+VALUE rb_clear(VALUE self);
+VALUE rb_clone(VALUE self);
+
+VALUE new_object(CvSeq *seq, VALUE klass);
+VALUE new_object(CvSeq *seq, VALUE klass, VALUE storage);
+//VALUE new_object(CvSeq *seq, VALUE storage, VALUE klass);
+VALUE new_sequence(VALUE klass, CvSeq *seq, VALUE element_klass, VALUE storage);
+VALUE auto_extend(VALUE object);
+
+__NAMESPACE_END_CVSEQ
+
+inline CvSeq*
+CVSEQ(VALUE object)
+{
+  CvSeq *ptr;
+  Data_Get_Struct(object, CvSeq, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSEQ_H

ext/cvset.cpp

@@ -0,0 +1,63 @@
+/************************************************************
+
+   cvseq.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvset.h"
+/*
+ * Document-class: OpenCV::CvSet
+ *
+ * Collection of nodes.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSET
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * cvseq = rb_define_class_under(opencv, "CvSeq", rb_cObject); 
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv(), cvseq = cCvSeq::rb_class();
+  rb_klass = rb_define_class_under(opencv, "CvSet", cvseq);
+  rb_define_method(rb_klass, "active_count", RUBY_METHOD_FUNC(rb_active_count), 0);
+  rb_define_method(rb_klass, "free?", RUBY_METHOD_FUNC(rb_free_q), 0);
+}
+
+/*
+ * ?
+ */
+VALUE
+rb_active_count(VALUE self)
+{
+  return INT2FIX(CVSET(self)->active_count);
+}
+
+/*
+ * ?
+ */
+VALUE
+rb_free_q(VALUE self)
+{
+  return CVSET(self)->free_elems->flags < 0 ? Qtrue : Qfalse;
+}
+
+__NAMESPACE_END_CVSET
+__NAMESPACE_END_OPENCV

ext/cvset.h

@@ -0,0 +1,39 @@
+/************************************************************
+
+   cvset.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSET_H
+#define RUBY_OPENCV_CVSET_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSET namespace cCvSet{
+#define __NAMESPACE_END_CVSET }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSET
+
+VALUE rb_class();
+void define_ruby_class();
+
+VALUE rb_active_count(VALUE self);
+VALUE rb_free_q(VALUE self);
+
+__NAMESPACE_END_CVSET
+
+inline CvSet*
+CVSET(VALUE object)
+{
+  CvSet *ptr;
+  Data_Get_Struct(object, CvSet, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSET_H

ext/cvsize.cpp

@@ -0,0 +1,223 @@
+/************************************************************
+
+   cvsize.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#include"cvsize.h"
+/*
+ * Document-class: OpenCV::CvSize
+ *
+ * This class means one size on X axis Y axis. 
+ * X and Y takes the value of the Fixnum.
+ * 
+ * C structure is here, very simple.
+ *   typdef struct CvSize{
+ *     int width;
+ *     int height;
+ *   }
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSIZE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvSize", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "width", RUBY_METHOD_FUNC(rb_width), 0);
+  rb_define_method(rb_klass, "width=", RUBY_METHOD_FUNC(rb_set_width), 1);
+  rb_define_method(rb_klass, "height", RUBY_METHOD_FUNC(rb_height), 0);
+  rb_define_method(rb_klass, "height=", RUBY_METHOD_FUNC(rb_set_height), 1);
+  
+  rb_define_method(rb_klass, "to_s", RUBY_METHOD_FUNC(rb_to_s), 0);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+}
+
+/*
+ * call-seq:
+ *   compatible?(obj)
+ *
+ * Return compatibility to CvSize. Return true if object have method #width and #height.
+ *
+ * For example.
+ *   class MySize
+ *     def width
+ *       10
+ *     end
+ *     def height
+ *       20
+ *     end
+ *   end
+ *   mp = MySize.new
+ *   CvSize.compatible?(mp)  #=> true
+ *   CvSize.new(mp)          #=> same as CvSize(10, 20)
+ */
+VALUE
+rb_compatible_q(VALUE klass, VALUE object)
+{
+  return (rb_respond_to(object, rb_intern("width")) && rb_respond_to(object, rb_intern("height"))) ? Qtrue : Qfalse;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvSize *ptr;
+  return Data_Make_Struct(klass, CvSize, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new
+ *   new(obj)
+ *   new(width, height)
+ *
+ * Create new size of 2D, (width, height). It is dropped below the decimal point.
+ *
+ * new() is same as new(0, 0)
+ *
+ * new(obj) is same as new(obj.x.to_i, obj.y.to_i)
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE obj, x, y;
+  switch (argc) {
+  case 0:
+    break;
+  case 1:
+    obj = argv[0];
+    if(rb_compatible_q(rb_klass, obj)) {
+      CVSIZE(self)->width = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("width"), 0), rb_intern("to_i"), 0));
+      CVSIZE(self)->height = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("height"), 0), rb_intern("to_i"), 0));
+    }else{
+      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
+    }
+    break;
+  case 2:
+    x = argv[0], y = argv[1];
+    CVSIZE(self)->width = NUM2INT(x);
+    CVSIZE(self)->height = NUM2INT(y);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+  }
+  return Qnil;      
+}
+
+/*
+ * Return size of x-axis.
+ */
+VALUE
+rb_width(VALUE self)
+{
+  return INT2FIX(CVSIZE(self)->width);
+}
+
+/*
+ * call-seq:
+ *   width = val
+ *
+ * Set x-axis size, return self.
+ * It is dropped below the decimal point.
+ */
+VALUE
+rb_set_width(VALUE self, VALUE x)
+{
+  CVSIZE(self)->width = NUM2INT(x);
+  return self;
+}
+
+/*
+ * Return size of yaxis.
+ */
+VALUE
+rb_height(VALUE self)
+{
+  return INT2FIX(CVSIZE(self)->height);
+}
+
+/*
+ * call-seq:
+ *   height = val
+ *
+ * Set y-axis size, return self.
+ * It is dropped below the decimal point.
+ */
+VALUE
+rb_set_height(VALUE self, VALUE y)
+{
+  CVSIZE(self)->height = NUM2INT(y);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   to_s -> "<OpenCV::CvSize:widthxheight>"
+ *
+ * Return width and height by String.
+ */
+VALUE
+rb_to_s(VALUE self)
+{
+  const int i = 4;
+  VALUE str[i];
+  str[0] = rb_str_new2("<%s:%dx%d>");
+  str[1] = rb_str_new2(rb_class2name(CLASS_OF(self)));
+  str[2] = rb_width(self);
+  str[3] = rb_height(self);
+  return rb_f_sprintf(i, str);
+}
+
+/*
+ * call-seq:
+ *   to_ary -> [width, height]
+ *
+ * Return width and height by Array.
+ */
+VALUE
+rb_to_ary(VALUE self)
+{
+  return rb_ary_new3(2, rb_width(self), rb_height(self));
+}
+
+VALUE
+new_object()
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVSIZE(object) = cvSize(0, 0);
+  return object;
+}
+
+VALUE
+new_object(CvSize size)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVSIZE(object) = size;
+  return object;
+}
+
+__NAMESPACE_END_CVSIZE
+__NAMESPACE_END_OPENCV

ext/cvsize.h

@@ -0,0 +1,63 @@
+/************************************************************
+
+   cvsize.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSIZE_H
+#define RUBY_OPENCV_CVSIZE_H
+
+#include"opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSIZE namespace cCvSize{
+#define __NAMESPACE_END_CVSIZE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSIZE
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_compatible_q(VALUE klass, VALUE object);
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_width(VALUE self);
+VALUE rb_set_width(VALUE self, VALUE width);
+VALUE rb_height(VALUE self);
+VALUE rb_set_height(VALUE self, VALUE height);
+
+VALUE rb_to_s(VALUE self);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object();
+VALUE new_object(CvSize size);
+
+__NAMESPACE_END_CVSIZE
+
+inline CvSize*
+CVSIZE(VALUE object)
+{
+  CvSize *ptr;
+  Data_Get_Struct(object, CvSize, ptr);
+  return ptr;
+}
+
+inline CvSize
+VALUE_TO_CVSIZE(VALUE object)
+{
+  if(cCvSize::rb_compatible_q(cCvSize::rb_class(), object)){
+    return cvSize(NUM2INT(rb_funcall(object, rb_intern("width"), 0)),
+                  NUM2INT(rb_funcall(object, rb_intern("height"), 0)));
+  }else{
+    rb_raise(rb_eTypeError, "require %s or compatible object.", rb_class2name(cCvSize::rb_class()));
+  }
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSIZE_H

ext/cvsize2d32f.cpp

@@ -0,0 +1,180 @@
+/************************************************************
+
+   cvsize2d32f.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvsize2d32f.h"
+/*
+ * Document-class: OpenCV::CvSize2D32f
+ *
+ * This class means one size on X axis Y axis. 
+ * X and Y takes the value of the Float.
+ * 
+ * C structure is here, very simple.
+ *   typdef struct CvSize2D32f{
+ *     float width;
+ *     float height;
+ *   }CvSize2D32f;
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSIZE2D32F
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvSize2D32f", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
+  rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "width", RUBY_METHOD_FUNC(rb_width), 0);
+  rb_define_method(rb_klass, "width=", RUBY_METHOD_FUNC(rb_set_width), 1);
+  rb_define_method(rb_klass, "height", RUBY_METHOD_FUNC(rb_height), 0);
+  rb_define_method(rb_klass, "height=", RUBY_METHOD_FUNC(rb_set_height), 1);
+}
+
+/*
+ * call-seq:
+ *   compatible?(obj)
+ *
+ * Return compatibility to CvSize2D32f. Return true if object have method #width and #height.
+ *
+ * For example.
+ *   class MySize
+ *     def width
+ *       10.1
+ *     end
+ *     def height
+ *       20.2
+ *     end
+ *   end
+ *   mp = MySize.new
+ *   CvSize2D32f.compatible?(mp)  #=> true
+ *   CvSize2D32f.new(mp)          #=> same as CvSize2D32f.new(10.1, 20.2)
+ */
+VALUE
+rb_compatible_q(VALUE klass, VALUE object)
+{
+  return (rb_respond_to(object, rb_intern("width")) && rb_respond_to(object, rb_intern("height"))) ? Qtrue : Qfalse;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvSize2D32f *ptr;
+  return Data_Make_Struct(klass, CvSize2D32f, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new
+ *   new(obj)
+ *   new(width, height)
+ *
+ * Create new size of 2D, (width, height).
+ *
+ * new() is same as new(0.0, 0.0)
+ *
+ * new(obj) is same as new(obj.x.to_f, obj.y.to_f)
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE obj, x, y;
+  switch(argc){
+  case 0:
+    break;
+  case 1:
+    obj = argv[0];
+    if(rb_compatible_q(rb_klass, obj)){
+      CVSIZE2D32F(self)->width = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("width"), 0), rb_intern("to_f"), 0));
+      CVSIZE2D32F(self)->height = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("height"), 0), rb_intern("to_f"), 0));
+    }else{
+      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
+    }
+    break;
+  case 2:
+    x = argv[0], y = argv[1];
+    CVSIZE2D32F(self)->width = NUM2DBL(x);
+    CVSIZE2D32F(self)->height = NUM2DBL(y);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+  }
+  return self;      
+}
+
+/*
+ * Return size of x-axis.
+ */
+VALUE
+rb_width(VALUE self)
+{
+  return rb_float_new(CVSIZE2D32F(self)->width);
+}
+
+/*
+ * call-seq:
+ *   width = val
+ *
+ * Set x-axis size, return self.     
+ */
+VALUE
+rb_set_width(VALUE self, VALUE x)
+{
+  CVSIZE2D32F(self)->width = NUM2DBL(x);
+  return self;
+}
+
+/*
+ * Return size of yaxis.
+ */
+VALUE
+rb_height(VALUE self)
+{
+  return rb_float_new(CVSIZE2D32F(self)->height);
+}
+
+/*
+ * call-seq:
+ *   height = val
+ *
+ * Set y-axis size, return self.
+ */
+VALUE
+rb_set_height(VALUE self, VALUE y)
+{
+  CVSIZE2D32F(self)->height = NUM2DBL(y);
+  return self;
+}
+
+VALUE
+new_object(CvSize2D32f size)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVSIZE2D32F(object) = size;
+  return object;
+}
+
+__NAMESPACE_END_CVSIZE2D32F
+__NAMESPACE_END_OPENCV

ext/cvsize2d32f.h

@@ -0,0 +1,59 @@
+/************************************************************
+
+   cvsize2d32f.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSIZE2D32F_H
+#define RUBY_OPENCV_CVSIZE2D32F_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSIZE2D32F namespace cCvSize2D32f{
+#define __NAMESPACE_END_CVSIZE2D32F }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSIZE2D32F
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_compatible_q(VALUE klass, VALUE object);
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_width(VALUE self);
+VALUE rb_set_width(VALUE self, VALUE width);
+VALUE rb_height(VALUE self);
+VALUE rb_set_height(VALUE self, VALUE height);
+
+VALUE new_object(CvSize2D32f size);
+
+__NAMESPACE_END_CVSIZE2D32F
+
+inline CvSize2D32f*
+CVSIZE2D32F(VALUE object)
+{
+  CvSize2D32f *ptr;
+  Data_Get_Struct(object, CvSize2D32f, ptr);
+  return ptr;
+}
+
+inline CvSize2D32f
+VALUE_TO_CVSIZE2D32F(VALUE object)
+{
+  if(cCvSize2D32f::rb_compatible_q(cCvSize2D32f::rb_class(), object)){
+    return cvSize2D32f(NUM2DBL(rb_funcall(object, rb_intern("width"), 0)),
+                       NUM2DBL(rb_funcall(object, rb_intern("height"), 0)));
+  }else{
+    rb_raise(rb_eTypeError, "require %s or compatible object.", rb_class2name(cCvSize2D32f::rb_class()));
+  }
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSIZE2D32F_H

ext/cvslice.cpp

@@ -0,0 +1,82 @@
+/************************************************************
+
+   cvslice.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvslice.h"
+/*
+ * Document-class: OpenCV::CvClice
+ *
+ * C structure is here, very simple.
+ *   typdef struct CvSlice{
+ *     int start_index;
+ *     int end_index;
+ *   }CvSlice;
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSLICE
+
+VALUE rb_klass;
+    
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  rb_klass = rb_define_class_under(opencv, "CvSlice", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
+  rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), 2);
+}
+
+/*
+ * call-seq:
+ *   compatible?(<i>obj</i>)
+ *
+ * same Object#kind_of(Range)
+ */
+VALUE
+rb_compatible_q(VALUE klass, VALUE object)
+{
+  return rb_obj_is_kind_of(object, rb_cRange);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvSlice *ptr;
+  return Data_Make_Struct(klass, CvSlice, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new(<i>start, end</i>)
+ *
+ * Create new slice object.
+ */
+VALUE
+rb_initialize(VALUE self, VALUE start, VALUE end)
+{
+  CVSLICE(self)->start_index = NUM2INT(start);
+  CVSLICE(self)->end_index = NUM2INT(end);
+  return self;
+}
+
+__NAMESPACE_END_CVSLICE
+__NAMESPACE_END_OPENCV

ext/cvslice.h

@@ -0,0 +1,53 @@
+/************************************************************
+
+   cvslice.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSLICE_H
+#define RUBY_OPENCV_CVSLICE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSLICE namespace cCvSlice{
+#define __NAMESPACE_END_CVSLICE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSLICE
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_compatible_q(VALUE klass, VALUE object);
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(VALUE self, VALUE start, VALUE end);
+
+__NAMESPACE_END_CVSLICE
+
+inline CvSlice*
+CVSLICE(VALUE object)
+{
+  CvSlice *ptr;
+  Data_Get_Struct(object, CvSlice, ptr);
+  return ptr;
+}
+
+inline CvSlice
+VALUE_TO_CVSLICE(VALUE object)
+{
+  if(cCvSlice::rb_compatible_q(cCvSlice::rb_class(), object)){
+    return cvSlice(NUM2INT(rb_funcall(object, rb_intern("begin"), 0)),
+                   rb_funcall(object, rb_intern("exclude_end?"), 0) ? NUM2INT(rb_funcall(object, rb_intern("end"), 0)) : NUM2INT(rb_funcall(object, rb_intern("end"), 0)) - 1);
+  }else{
+    rb_raise(rb_eTypeError, "require %s or compatible object.", rb_class2name(cCvSlice::rb_class()));
+  }
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSLICE_H

ext/cvsparsemat.cpp

@@ -0,0 +1,44 @@
+/***********************************************************
+
+   cvsparse.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvsparsemat.h"
+/*
+ * Document-class: OpenCV::CvSparseMat
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSPARSEMAT
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * cvmat = rb_define_class_under(opencv, "CvMat", rb_cObject);
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv(), cvmat = cCvMat::rb_class();
+  
+  rb_klass = rb_define_class_under(opencv, "CvSparseMat", cvmat);
+}
+
+__NAMESPACE_END_CVSPARSEMAT
+__NAMESPACE_END_OPENCV
+

ext/cvsparsemat.h

@@ -0,0 +1,28 @@
+/************************************************************
+
+   cvsparsemat.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSPARSEMAT_H
+#define RUBY_OPENCV_CVSPARSEMAT_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSPARSEMAT namespace cCvSparseMat{
+#define __NAMESPACE_END_CVSPARSEMAT }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSPARSEMAT
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+__NAMESPACE_END_CVSPARSEMAT
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSPARSEMAT_H

ext/cvtermcriteria.cpp

@@ -0,0 +1,183 @@
+/************************************************************
+
+   cvtermcriteria.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include"cvtermcriteria.h"
+/*
+ * Document-class: OpenCV::CvTermCriteria
+ *
+ * CvTermCriteria has parameter "max" and "eps".
+ * "max" is the maximum repetition frequency.
+ * "eps" is a minimum difference value during current and previous state
+ * (It is different to which state "eps" refer depending on the method).
+ *
+ * Because the name of CvTermCriteria seems to be very long, it has alias named CvTerm.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVTERMCRITERIA
+
+VALUE rb_klass;
+    
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvTermCriteria", rb_cObject);
+  /* CvTermCriteria: class */
+  rb_define_const(opencv, "CvTerm", rb_klass);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "max", RUBY_METHOD_FUNC(rb_max), 0);
+  rb_define_method(rb_klass, "max=", RUBY_METHOD_FUNC(rb_set_max), 1);
+  rb_define_method(rb_klass, "eps", RUBY_METHOD_FUNC(rb_eps), 0);
+  rb_define_method(rb_klass, "eps=", RUBY_METHOD_FUNC(rb_set_eps), 1);
+  rb_define_alias(rb_klass, "epsilon", "eps");
+  rb_define_alias(rb_klass, "epsilon=", "eps=");
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvTermCriteria *ptr;
+  return Data_Make_Struct(klass, CvTermCriteria, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   CvTermCriteria.new([max = 0][,eps = 0.0]) -> obj
+ *   CvTermCriteria.new(int) = CvTermCriteria.new(int, 0.0)
+ *   CvTermCriteria.new(float) = CvTermCriteria.new(0, float)
+ *
+ * Create new term criteria.
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE max, eps;
+  rb_scan_args(argc, argv, "02", &max, &eps);
+  int type = 0;
+  if (!NIL_P(max)) {type |= CV_TERMCRIT_ITER;}
+  if (!NIL_P(eps)) {type |= CV_TERMCRIT_EPS;}
+  *CVTERMCRITERIA(self) = cvTermCriteria(type, IF_INT(max, 0), IF_DBL(eps, 0.0));
+  return self;
+}
+
+/*
+ * call-seq:
+ *   max -> int or nil
+ *
+ * Return the maximum repetition frequency.
+ */
+VALUE
+rb_max(VALUE self)
+{
+  CvTermCriteria *ptr = CVTERMCRITERIA(self);
+  if (ptr->type & CV_TERMCRIT_ITER)
+    return INT2NUM(ptr->max_iter);
+  else
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   max = <i>val</i> -> self
+ *
+ * Set the maximum repetition frequency.
+ * If <i>val</i> is 0 (or negative value), repetition frequency is disregarded.
+ */
+VALUE
+rb_set_max(VALUE self, VALUE max_value)
+{
+  CvTermCriteria *ptr = CVTERMCRITERIA(self);
+  int max = NUM2INT(max_value);
+  if (max > 0) {
+    ptr->type |= CV_TERMCRIT_ITER;
+    ptr->max_iter = max;
+  } else {
+    ptr->type ^= CV_TERMCRIT_ITER;
+    ptr->max_iter = 0;
+  }
+  return self;
+}
+
+/*
+ * call-seq:
+ *   eps -> float or nil
+ *
+ * Return the minimum difference value during current and previous state.
+ */
+VALUE
+rb_eps(VALUE self)
+{
+  CvTermCriteria *ptr = CVTERMCRITERIA(self);
+  if(ptr->type & CV_TERMCRIT_EPS)
+    return rb_float_new(ptr->epsilon);
+  else
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   eps = <i>val</i> -> self
+ *
+ * Set the minimum difference value during current and previous state.
+ * If <i>val</i> is 0.0 (or negative value), the minimum difference value
+ * during current and previous state is disregarded.
+ */
+VALUE
+rb_set_eps(VALUE self, VALUE eps_value)
+{
+  CvTermCriteria *ptr = CVTERMCRITERIA(self);
+  double eps = NUM2DBL(eps_value);
+  if (eps > 0) {
+    ptr->type = ptr->type | CV_TERMCRIT_EPS;
+    ptr->epsilon = eps;
+  } else {
+    ptr->type = ptr->type ^ CV_TERMCRIT_EPS;
+    ptr->epsilon = 0;
+  }
+  return self;
+}
+
+VALUE
+rb_to_ary(VALUE self)
+{
+  CvTermCriteria *ptr = CVTERMCRITERIA(self);
+  VALUE ary = rb_ary_new();
+  if (ptr->type & CV_TERMCRIT_ITER)
+    rb_ary_push(ary, INT2FIX(ptr->max_iter));
+  if (ptr->type & CV_TERMCRIT_EPS)
+    rb_ary_push(ary, rb_float_new(ptr->epsilon));
+  return ary;
+}
+
+VALUE
+new_object(CvTermCriteria criteria)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVTERMCRITERIA(object) = criteria;
+  return object;
+}
+
+__NAMESPACE_END_CVTERMCRITERIA
+__NAMESPACE_END_OPENCV

ext/cvtermcriteria.h

@@ -0,0 +1,71 @@
+/************************************************************
+
+   cvtermcriteria.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVTERMCRITERIA_H
+#define RUBY_OPENCV_CVTERMCRITERIA_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVTERMCRITERIA namespace cCvTermCriteria{
+#define __NAMESPACE_END_CVTERMCRITERIA }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVTERMCRITERIA
+
+VALUE rb_class();
+
+void define_ruby_class();    
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_max(VALUE self);
+VALUE rb_set_max(VALUE self, VALUE max_value);
+VALUE rb_eps(VALUE self);
+VALUE rb_set_eps(VALUE self, VALUE eps_value);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object(CvTermCriteria criteria);
+
+__NAMESPACE_END_CVTERMCRITERIA
+
+inline CvTermCriteria*
+CVTERMCRITERIA(VALUE object)
+{
+  CvTermCriteria *ptr;
+  Data_Get_Struct(object, CvTermCriteria, ptr);
+  return ptr;
+}
+
+inline CvTermCriteria
+VALUE_TO_CVTERMCRITERIA(VALUE object)
+{
+  if (rb_obj_is_kind_of(object, cCvTermCriteria::rb_class())) {
+    return *CVTERMCRITERIA(object);
+  }
+  switch (TYPE(object)) {
+  case T_NIL:
+    return cvTermCriteria(CV_TERMCRIT_ITER, 0, 0);
+  case T_FIXNUM:
+    return cvTermCriteria(CV_TERMCRIT_ITER, NUM2INT(object), 0);
+  case T_FLOAT:
+    return cvTermCriteria(CV_TERMCRIT_EPS, 0, NUM2DBL(object));
+  case T_ARRAY:
+    if (RARRAY(object)->len == 2) {
+      return cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,
+                            NUM2INT(rb_ary_entry(object, 0)),
+                            NUM2DBL(rb_ary_entry(object, 1)));
+    }
+  }
+  rb_raise(rb_eTypeError, "");
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVTERMCRITERIA_H

ext/cvtwopoints.cpp

@@ -0,0 +1,98 @@
+/************************************************************
+
+   cvtwopoints.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvtwopoints.h"
+/*
+ * Document-class: OpenCV::CvTwopoints
+ *
+ * This class means one twopoints on X axis Y axis. 
+ * X and Y takes the value of the Fixnum. see also CvTwopoints2D32F
+ * 
+ * C structure is here, very simple.
+ *   typdef struct CvTwopoints{
+ *     int x;
+ *     int y;
+ *   }
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVTWOPOINTS
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvTwoPoints", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "point1", RUBY_METHOD_FUNC(rb_point1), 0);
+  rb_define_method(rb_klass, "point2", RUBY_METHOD_FUNC(rb_point2), 0);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvTwoPoints *ptr;
+  return Data_Make_Struct(klass, CvTwoPoints, 0, -1, ptr);
+}
+
+VALUE
+rb_cvseqblock(VALUE self)
+{
+  return Qnil;
+}
+
+
+/*
+ * Return point 1.
+ */
+VALUE
+rb_point1(VALUE self)
+{
+  return cCvPoint::new_object(CVTWOPOINTS(self)->p1);
+}
+
+/*
+ * Return point2.
+ */
+VALUE
+rb_point2(VALUE self)
+{
+  return cCvPoint::new_object(CVTWOPOINTS(self)->p2);
+}
+
+/*
+ * call-seq:
+ *   to_ary -> [self.point1, self.point2]
+ *
+ * Return 2 point by Array.
+ */
+VALUE
+rb_to_ary(VALUE self)
+{
+  return rb_ary_new3(2, rb_point1(self), rb_point2(self));
+}
+
+__NAMESPACE_END_CVTWOPOINTS
+__NAMESPACE_END_OPENCV

ext/cvtwopoints.h

@@ -0,0 +1,50 @@
+/************************************************************
+
+   cvtwopoints.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVTWOPOINTS_H
+#define RUBY_OPENCV_CVTWOPOINTS_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVTWOPOINTS namespace cCvTwoPoints{
+#define __NAMESPACE_END_CVTWOPOINTS }
+
+__NAMESPACE_BEGIN_OPENCV
+
+typedef struct CvTwoPoints{
+  CvPoint p1;
+  CvPoint p2;
+} CvTwoPoints;
+
+__NAMESPACE_BEGIN_CVTWOPOINTS
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+
+VALUE rb_point1(VALUE self);
+VALUE rb_point2(VALUE self);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object(CvTwoPoints twopoints);
+
+__NAMESPACE_END_CVTWOPOINTS
+
+inline CvTwoPoints*
+CVTWOPOINTS(VALUE object){
+  CvTwoPoints *ptr;
+  Data_Get_Struct(object, CvTwoPoints, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVTWOPOINTS_H

ext/cvvector.cpp

@@ -0,0 +1,206 @@
+/************************************************************
+
+   cvvector.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvvector.h"
+/*
+ * Document-class: OpenCV::CvVector
+ *
+ * 2D vector (X axis and Y axis) 
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVVECTOR
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvVector", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "x", RUBY_METHOD_FUNC(rb_x), 0);
+  rb_define_method(rb_klass, "x=", RUBY_METHOD_FUNC(rb_set_x), 1);
+  rb_define_method(rb_klass, "y", RUBY_METHOD_FUNC(rb_y), 0);
+  rb_define_method(rb_klass, "y=", RUBY_METHOD_FUNC(rb_set_y), 1);
+
+  rb_define_method(rb_klass, "to_s", RUBY_METHOD_FUNC(rb_to_s), 0);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+}
+
+/*
+ * call-seq:
+ *   combatible?(obj)
+ *
+ * Return compatibility to CvVector. Return true if object have method #x and #y.
+ *
+ * For example.
+ *   class MyVector
+ *     def x
+ *       1.0
+ *     end
+ *     def y
+ *       2.0
+ *     end
+ *   end
+ *   mv = MyVector.new
+ *   CvVector.compatible?(mv)  #=> true
+ *   CvVector.new(mv)          #=> same as CvVector(1.0, 2.0)
+ */
+VALUE
+rb_compatible_q(VALUE klass, VALUE object)
+{
+  return (rb_respond_to(object, rb_intern("x")) && rb_respond_to(object, rb_intern("y"))) ? Qtrue : Qfalse;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvVector *ptr;
+  return Data_Make_Struct(klass, CvVector, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new -> CvVector.new(0.0, 0.0)
+ *   new(obj) -> CvVector.new(obj.x.to_f, obj.y.to_f)
+ *   new(x, y)
+ *
+ * Create new 2D-vector, (x, y).
+ *
+ * new() is same as new(0, 0)
+ *
+ * new(obj) is same as new(obj.x.to_f, obj.y.to_f)
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE obj, x, y;
+  switch (argc) {
+  case 0:
+    break;
+  case 1:
+    obj = argv[0];
+    if (rb_compatible_q(rb_klass, obj)) {
+      CVVECTOR(self)->x = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("x"), 0), rb_intern("to_i"), 0));
+      CVVECTOR(self)->y = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("y"), 0), rb_intern("to_i"), 0));
+    }else{
+      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
+    }
+    break;
+  case 2:
+    x = argv[0], y = argv[1];
+    CVVECTOR(self)->x = NUM2INT(x);
+    CVVECTOR(self)->y = NUM2INT(y);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+  }
+  return Qnil;    
+}
+
+/*
+ * Return parameter on vector of x-axis.
+ */
+VALUE
+rb_x(VALUE self)
+{
+  return INT2FIX(CVVECTOR(self)->x);
+}
+
+/*
+ * call-seq:
+ *   x = val
+ *
+ * Set vector of x-axis, return self.
+ */
+VALUE
+rb_set_x(VALUE self, VALUE x)
+{
+  CVVECTOR(self)->x = NUM2INT(x);
+  return self;
+}
+
+/*
+ * Return parameter on vector of y-axis.
+ */
+VALUE
+rb_y(VALUE self)
+{
+  return INT2FIX(CVVECTOR(self)->y);
+}
+
+/*
+ * call-seq:
+ *   y = val
+ *
+ * Set vector of y-axis, return self.
+ */
+VALUE
+rb_set_y(VALUE self, VALUE y)
+{
+  CVVECTOR(self)->y = NUM2INT(y);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   to_s -> "<OpenCV::CvVector:(self.x,self.y)>"
+ *
+ * Return x and y by String.
+ */
+VALUE
+rb_to_s(VALUE self)
+{
+  const int i = 4;
+  VALUE str[i];
+  str[0] = rb_str_new2("<%s:(%d,%d)>");
+  str[1] = rb_str_new2(rb_class2name(CLASS_OF(self)));
+  str[2] = rb_x(self);
+  str[3] = rb_y(self);
+  return rb_f_sprintf(i, str);
+}
+
+/*
+ * call-seq:
+ *   to_ary -> [x, y]
+ *
+ * Return x and y by Array.
+ */
+VALUE
+rb_to_ary(VALUE self)
+{
+  return rb_ary_new3(2, rb_x(self), rb_y(self));
+}
+
+VALUE
+new_object(CvVector point)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVVECTOR(object) = point;
+  return object;
+}
+
+__NAMESPACE_END_CVVECTOR
+__NAMESPACE_END_OPENCV

ext/cvvector.h

@@ -0,0 +1,54 @@
+/************************************************************
+
+   cvvector.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVVECTOR_H
+#define RUBY_OPENCV_CVVECTOR_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVVECTOR namespace cCvVector{
+#define __NAMESPACE_END_CVVECTOR }
+
+typedef struct CvVector{
+  float x;
+  float y;
+} CvVector;
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVVECTOR
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_compatible_q(VALUE klass, VALUE object);
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_x(VALUE self);
+VALUE rb_set_x(VALUE self, VALUE x);
+VALUE rb_y(VALUE self);
+VALUE rb_set_y(VALUE self, VALUE y);
+
+VALUE rb_to_s(VALUE self);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object(CvVector vector);
+
+__NAMESPACE_END_CVVECTOR
+
+inline CvVector *CVVECTOR(VALUE object){
+  CvVector *ptr;
+  Data_Get_Struct(object, CvVector, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVVECTOR_H

ext/cvvideowriter.cpp

@@ -0,0 +1,116 @@
+/************************************************************
+
+   cvvideowriter.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvvideowriter.h"
+/*
+ * Document-class: OpenCV::CvVideoWriter
+ *
+ * Create video stream from images.
+ *
+ * C structure is "black box".
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVVIDEOWRITER
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if(rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  rb_klass = rb_define_class_under(opencv, "CvVideoWriter", rb_cObject);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "write", RUBY_METHOD_FUNC(rb_write), 1);
+  rb_define_method(rb_klass, "close", RUBY_METHOD_FUNC(rb_close), 0);
+}
+
+/*
+ * call-seq:
+ *   CvVideoWriter.new(<i>filanem, fourcc, fps, size</i>) -> cvvideowriter
+ *   CvVideoWriter.new(<i>filanem, fourcc, fps, size</i>){|vw| ... } -> nil
+ *
+ * Open new video writer. If block given, writer is closed automatically when end of block.
+ * 
+ * note: if <i>fourcc</i> is nil, popup codec select dialog (Windows only).
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE filename, fourcc, fps, size;
+  rb_scan_args(argc, argv, "40", &filename, &fourcc, &fps, &size);
+  char codec[4] = {' ', ' ', ' ', ' '};
+  int codec_number;
+  Check_Type(filename, T_STRING);
+  if (RSTRING(filename)->len == 0)
+    rb_raise(rb_eArgError, "argument 1 (file name) dose not given");
+  if (NIL_P(fourcc))
+    codec_number = -1;
+  else {
+    Check_Type(fourcc, T_STRING);
+    if (RSTRING(fourcc)->len > 4)
+      rb_raise(rb_eStandardError, "argument 2 (fourcc) should be specific 4-character. (i.e \"PIM1\",\"MJPG\")");
+    else {
+      for (int i = 0; i < RSTRING(fourcc)->len; i++)
+        codec[i] = RSTRING(fourcc)->ptr[i];
+      codec_number = CV_FOURCC(codec[0], codec[1], codec[2], codec[3]);
+    }
+  }
+  DATA_PTR(self) = cvCreateVideoWriter(StringValueCStr(filename), codec_number, FIX2INT(fps), VALUE_TO_CVSIZE(size));
+  if (rb_block_given_p()) {
+    rb_yield(self);
+    rb_close(self);
+    return Qnil;
+  } else {
+    return self;
+  }
+}
+
+/*
+ * call-seq:
+ *   write(<i>frame</i>)
+ *
+ * Write image as frame of video stream.
+ * <i>frame</i> should be CvMat or subclass.
+ */
+VALUE
+rb_write(VALUE self, VALUE frame)
+{
+  if (!rb_obj_is_kind_of(frame, cCvMat::rb_class()))
+    rb_raise(rb_eTypeError, "argument 1 (frame) should be %s or subclass", rb_class2name(cCvMat::rb_class()));
+  cvWriteFrame(CVVIDEOWRITER(self), IPLIMAGE(frame));
+  return self;
+}
+
+/*
+ * Close vidoe writer.
+ */
+VALUE
+rb_close(VALUE self)
+{
+  CvVideoWriter *writer = CVVIDEOWRITER(self);
+  cvReleaseVideoWriter(&writer);
+  return Qnil;
+}
+
+
+__NAMESPACE_END_CVVIDEOWRITER
+__NAMESPACE_END_OPENCV

ext/cvvideowriter.h

@@ -0,0 +1,41 @@
+/************************************************************
+
+   cvvideowriter.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVVIDEOWRITER_H
+#define RUBY_OPENCV_CVVIDEOWRITER_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVVIDEOWRITER namespace cCvVideoWriter{
+#define __NAMESPACE_END_CVVIDEOWRITER }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVVIDEOWRITER
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_write(VALUE self, VALUE frame);
+VALUE rb_close(VALUE self);
+
+__NAMESPACE_END_CVVIDEOWRITER
+
+inline CvVideoWriter*
+CVVIDEOWRITER(VALUE object)
+{
+  CvVideoWriter *ptr;
+  Data_Get_Struct(object, CvVideoWriter, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVVIDEOWRITER_H

ext/extconf.rb

@@ -0,0 +1,61 @@
+#!/usr/env ruby
+#/usr/local/bin/ruby
+=begin
+create Makefile script for Ruby/OpenCV
+
+usage : ruby extconf.rb
+        make && make install
+
+VC : ruby extconf.rb
+     nmake
+=end
+require "mkmf"
+
+# option "opencv"
+# extconf.rb --with-opencv-lib=/path/to/opencv/lib
+# extconf.rb --with-opencv-include=/path/to/opencv/include
+
+dir_config("opencv", "/usr/local/include/opencv", "/usr/local/lib")
+dir_config("ffcall", "/usr/local/include", "/usr/local/lib")
+
+opencv_libraries = ["cxcore", "cv", "highgui"]
+
+puts ">> check require libraries..."
+case CONFIG["arch"]
+when /mswin32/
+  have_library("msvcrt", nil)
+  opencv_libraries.each{|lib|
+    have_library(lib)
+  }
+else
+  opencv_libraries.each{|lib|
+    raise "lib#{lib} not found." unless have_library(lib)
+  }
+  #have_library("ml")
+  have_library("stdc++")
+end
+
+# check require headers
+puts ">> check require headers..."
+opencv_libraries.map{|lib| "#{lib}.h"}.each{|header|
+  raise "#{header} not found." unless have_header(header)
+}
+#have_header("ml.h")
+have_header("stdarg.h")
+
+# check require functions.
+# todo
+
+# optional libraies check.
+puts ">> ----- optional -----"
+puts ">> check ffcall..."
+# check ffcall
+if have_library("callback") && have_header("callback.h")
+  puts ">> support OpenCV::GUI"
+else
+  puts ">> ! unsupport OpenCV::GUI (if need it. install ffcall)"
+  puts "http://www.haible.de/bruno/packages-ffcall.html"
+end
+
+# step-final. create Makefile
+create_makefile("opencv")

ext/gui.cpp

@@ -0,0 +1,65 @@
+/************************************************************
+
+  gui.cpp -
+
+  $Author: lsxi $
+
+  Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifdef HAVE_CALLBACK_H
+
+#include "gui.h"
+/*
+ * Document-module: OpenCV::GUI
+ *
+ * OpenCV simple GUI interface. Provides Window, Trackbar.
+ * This GUI work on GTK or Microsoft Windows native GUI.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_GUI
+    
+VALUE rb_module;
+
+VALUE
+rb_module_GUI()
+{
+  return rb_module;
+}
+
+void
+define_ruby_module()
+{
+  if(rb_module)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");      
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  rb_module = rb_define_module_under(opencv, "GUI");
+  rb_define_singleton_method(rb_module, "wait_key", RUBY_METHOD_FUNC(rb_wait_key), -1);
+}
+
+/*
+ * call-seq:
+ *   wait_key(<i>[delay]</i>) -> int or nil
+ *
+ * Waits for a pressed key each GUI wedget.
+ * Return the code of the pressed key or nil if no key were pressed until the specified timeout has elapsed.
+ * <i>delay</i> should be Fixnum. Wait <i>delay</i> millisecond.
+ */
+VALUE
+rb_wait_key(int argc, VALUE *argv, VALUE self)
+{
+  VALUE delay;
+  rb_scan_args(argc, argv, "01", &delay);
+  int keycode = 0;
+  return ((keycode = cvWaitKey(IF_INT(delay, 0))) < 0) ? Qnil : INT2FIX(keycode);
+}
+
+__NAMESPACE_END_GUI
+__NAMESPACE_END_OPENCV
+
+#endif // HAVE_CALLBACK_H

ext/gui.h

@@ -0,0 +1,33 @@
+/************************************************************
+
+   gui.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifdef HAVE_CALLBACK_H
+
+#define __NAMESPACE_BEGIN_GUI namespace mGUI{
+#define __NAMESPACE_END_GUI }
+
+#ifndef RUBY_OPENCV_GUI_H
+#define RUBY_OPENCV_GUI_H
+
+#include "opencv.h"
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_GUI
+
+VALUE rb_module_GUI();
+void define_ruby_module();
+
+VALUE rb_wait_key(int argc, VALUE *argv, VALUE self);
+
+__NAMESPACE_END_GUI
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_GUI_H
+
+#endif // HAVE_CALLBACK_H

ext/iplconvkernel.cpp

@@ -0,0 +1,177 @@
+/************************************************************
+
+   iplconvkernel.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include"iplconvkernel.h"
+/*
+ * Document-class: OpenCV::IplConvKernel
+ *
+ * Structuring element can be used in the morphological operations.
+ *
+ * CvMat#erode, CvMat#dilate, CvMat#morphology_open, CvMat#morphology_close,
+ * CvMat#morphology_gradient, CvMat#morphology_tophat, CvMat#morphology_blackhat
+ *
+ * Create by IplConvKernel.new or CvMat#to_IplConvKernel
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_IPLCONVKERNEL
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();  
+  rb_klass = rb_define_class_under(opencv, "IplConvKernel", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "size", RUBY_METHOD_FUNC(rb_size), 0);
+  rb_define_method(rb_klass, "cols", RUBY_METHOD_FUNC(rb_cols), 0);
+  rb_define_alias(rb_klass, "columns", "cols");
+  rb_define_method(rb_klass, "rows", RUBY_METHOD_FUNC(rb_rows), 0);
+  rb_define_method(rb_klass, "anchor", RUBY_METHOD_FUNC(rb_anchor), 0);
+  rb_define_method(rb_klass, "anchor_x", RUBY_METHOD_FUNC(rb_anchor_x), 0);
+  rb_define_method(rb_klass, "anchor_y", RUBY_METHOD_FUNC(rb_anchor_y), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  return OPENCV_OBJECT(klass, 0);
+}
+
+/*
+ * call-seq:
+ *   IplConvKernel.new(shape, rows, cols, anchor_x, anchor_y)
+ *
+ * Creates structuring element.
+ *  shape
+ *    Shape of the structuring element; may have the following values:
+ *     :rect
+ *     :cross
+ *     :ellipse
+ *  cols
+ *    Number of columns in the structuring element. 
+ *  rows
+ *    Number of rows in the structuring element. 
+ *  anchor_x
+ *    Relative horizontal offset of the anchor point. 
+ *  anchor_y
+ *    Relative vertical offset of the anchor point.
+ *
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE shape, rows, cols, anchor_x, anchor_y;
+  rb_scan_args(argc, argv, "50", &shape, &rows, &cols, &anchor_x, &anchor_y);
+  Check_Type(shape, T_SYMBOL);
+  const char *shape_name = rb_id2name(SYM2ID(shape));
+  int shape_type = 0;
+  if (!strcmp(shape_name, "rect"))
+    shape_type = CV_SHAPE_RECT;
+  else if (!strcmp(shape_name, "corss"))
+    shape_type = CV_SHAPE_CROSS;
+  else if (!strcmp(shape_name, "ellipse"))
+    shape_type = CV_SHAPE_ELLIPSE;
+  else
+    rb_raise(rb_eTypeError, "argument 1 (shape) should be :rect or :cross or :ellipse.");
+  DATA_PTR(self) = cvCreateStructuringElementEx(NUM2INT(cols), NUM2INT(rows), NUM2INT(anchor_x), NUM2INT(anchor_y), shape_type);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   size -> cvsize
+ *
+ * Return the structuring element's size.
+ */
+VALUE
+rb_size(VALUE self)
+{
+  IplConvKernel *kernel = IPLCONVKERNEL(self);
+  return cCvSize::new_object(cvSize(kernel->nCols, kernel->nRows));
+}
+
+/*
+ * call-seq:
+ *   cols -> int
+ *
+ * Return number of columns in the structuring element.
+ */
+VALUE
+rb_cols(VALUE self)
+{
+  return INT2NUM(IPLCONVKERNEL(self)->nCols);
+}
+
+/*
+ * call-seq:
+ *   rows -> int
+ *
+ * Return number of rows in the structuring element.
+ */
+VALUE
+rb_rows(VALUE self)
+{
+  return INT2NUM(IPLCONVKERNEL(self)->nRows);
+}
+
+/*
+ * call-seq:
+ *   anchor -> cvpoint
+ *
+ * Return anchor of the structuring element.
+ */
+VALUE
+rb_anchor(VALUE self)
+{
+  IplConvKernel *kernel = IPLCONVKERNEL(self);
+  return cCvPoint::new_object(cvPoint(kernel->anchorX, kernel->anchorY));
+}
+
+/*
+ * call-seq:
+ *   anchor_x -> int
+ *
+ * Return relative horizontal offset of the anchor point.
+ */
+VALUE
+rb_anchor_x(VALUE self)
+{
+  return INT2NUM(IPLCONVKERNEL(self)->anchorX);
+}
+
+/*
+ * call-seq:
+ *   anchor_y -> int
+ *
+ * Return relative vertical offset of the anchor point.
+ */
+VALUE
+rb_anchor_y(VALUE self)
+{
+  return INT2NUM(IPLCONVKERNEL(self)->anchorY);
+}
+
+__NAMESPACE_END_IPLCONVKERNEL
+__NAMESPACE_END_OPENCV

ext/iplconvkernel.h

@@ -0,0 +1,52 @@
+/************************************************************
+
+   iplconvkernel.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_IPLCONVKERNEL_H
+#define RUBY_OPENCV_IPLCONVKERNEL_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_IPLCONVKERNEL namespace cIplConvKernel{
+#define __NAMESPACE_END_IPLCONVKERNEL }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_IPLCONVKERNEL
+
+VALUE rb_class();
+VALUE rb_allocate(VALUE klass);
+
+void define_ruby_class();
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_size(VALUE self);
+VALUE rb_cols(VALUE self);
+VALUE rb_rows(VALUE self);
+VALUE rb_anchor(VALUE self);
+VALUE rb_anchor_x(VALUE self);
+VALUE rb_anchor_y(VALUE self);
+
+__NAMESPACE_END_IPLCONVKERNEL
+
+inline IplConvKernel*
+IPLCONVKERNEL(VALUE object)
+{
+  IplConvKernel *ptr;
+  if (NIL_P(object))
+    return NULL;
+  else if (rb_obj_is_kind_of(object, cIplConvKernel::rb_class())) {
+    Data_Get_Struct(object, IplConvKernel, ptr);
+    return ptr;
+  } else {
+    rb_warn("invalid kernel. use default kernel (3x3 rectangle).");
+    return NULL;
+  }
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_IPLCONVKERNEL_H

ext/iplimage.cpp

@@ -0,0 +1,238 @@
+/************************************************************
+
+   iplimage.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "iplimage.h"
+/*
+ * Document-class: OpenCV::IplImage
+ *
+ * IPL(Intel Image Processing Library) Image class. 
+ *
+ * IplImage is subclass of CvMat. IplImage support ROI(region of interest) and COI(color of interest).
+ * Most of CvMat method support ROI, and some of CvMat method support COI.
+ *
+ * =What is ROI?
+ * region of interest.
+ *
+ * =What is COI?
+ * color of interest.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_IPLIMAGE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * cvmat = rb_define_class_under(opencv, "CvMat", rb_cObject);
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  VALUE cvmat = cCvMat::rb_class();
+  rb_klass = rb_define_class_under(opencv, "IplImage", cvmat);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "load", RUBY_METHOD_FUNC(rb_load_image), -1);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1); 
+  rb_define_method(rb_klass, "get_roi", RUBY_METHOD_FUNC(rb_get_roi), 0);
+  rb_define_alias(rb_klass, "roi", "get_roi");
+  rb_define_method(rb_klass, "set_roi", RUBY_METHOD_FUNC(rb_set_roi), 1);
+  rb_define_alias(rb_klass, "roi=", "set_roi");
+  rb_define_method(rb_klass, "reset_roi", RUBY_METHOD_FUNC(rb_reset_roi), 0);
+  rb_define_method(rb_klass, "get_coi", RUBY_METHOD_FUNC(rb_get_coi), 0);
+  rb_define_alias(rb_klass, "coi", "get_coi");
+  rb_define_method(rb_klass, "set_coi", RUBY_METHOD_FUNC(rb_set_coi), 1);
+  rb_define_alias(rb_klass, "coi=", "set_coi");
+  rb_define_method(rb_klass, "reset_coi", RUBY_METHOD_FUNC(rb_reset_coi), 0); 
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  return OPENCV_OBJECT(rb_klass, 0);
+}
+
+/*
+ * call-seq:
+ *   new(<i>width, height[, depth = CV_8U][, channel = 3]</i>)
+ *
+ * Create width * height image. Each element-value set 0.
+ *
+ * Each element possigle range is set by <i>depth</i>. Default is unsigned 8bit.
+ *
+ * Number of channel is set by <i>channel</i>. <i>channel</i> should be 1..4.
+ *
+ * note: width = col, height = row, on CvMat. It is noted not to make a mistake
+ * because the order of arguument is differenct to CvMat.
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE width, height, depth, channel;
+  rb_scan_args(argc, argv, "22", &width, &height, &depth, &channel);
+  int _depth = argc < 3 ? CV_8U : FIX2INT(depth);
+  int _channel = argc < 4 ? 3 : FIX2INT(channel);
+  DATA_PTR(self) = cvCreateImage(cvSize(FIX2INT(width), FIX2INT(height)), cvCvToIplDepth(_depth), _channel);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   IplImage::load(<i>filename[,iscolor = nil]</i>)
+ *
+ * Load an image from file.
+ *  iscolor = true, the loaded image is forced to be color 3-channel image.
+ *  iscolor = false, the loaded image is forced to be grayscale.
+ *  iscolor = nil, the loaded image will be loaded as is (depend on the file).
+ * Currently the following file format are supported.
+ * * Windows bitmaps - BMP,DIB
+ * * JPEG files - JPEG,JPG,JPE
+ * * Portable Network Graphics - PNG
+ * * Portable image format - PBM,PGM,PPM
+ * * Sun rasters - SR,RAS     
+ * * TIFF files - TIFF,TIF
+ */
+VALUE
+rb_load_image(int argc, VALUE *argv, VALUE self)
+{
+  VALUE filename, iscolor;
+  rb_scan_args(argc, argv, "11", &filename, &iscolor);
+  Check_Type(filename, T_STRING);
+  int _iscolor;
+  switch (TYPE(iscolor)) {
+  case T_FALSE:
+    _iscolor = 0;
+    break;
+  case T_TRUE:
+    _iscolor = 1;
+    break;
+  case T_NIL:
+    _iscolor = -1;
+    break;
+  default:
+    rb_warn("argument 2 should be true(color)/false(non-color) or nil(auto).");
+    _iscolor = -1;        
+  }
+  IplImage *image;
+  if ((image = cvLoadImage(StringValueCStr(filename), _iscolor)) == NULL) {
+    rb_raise(rb_eStandardError, "file does not exist or invalid format image.");
+  }
+  return OPENCV_OBJECT(rb_klass, image);
+}
+
+/*
+ * Get ROI as CvRect.
+ */
+VALUE
+rb_get_roi(VALUE self)
+{
+  return cCvRect::new_object(cvGetImageROI(IPLIMAGE(self)));
+}
+
+/*
+ * call-seq:
+ *   set_roi(<i>rect</i>)
+ *   set_roi(<i>rect</i>){|image| ...}
+ *
+ * Set ROI. <i>rect</i> should be CvRect or compatible object.
+ * Return self.
+ */
+VALUE
+rb_set_roi(VALUE self, VALUE roi)
+{
+  VALUE block = rb_block_given_p() ? rb_block_proc() : 0;
+  if (block) {
+    CvRect prev_roi = cvGetImageROI(IPLIMAGE(self));
+    cvSetImageROI(IPLIMAGE(self), VALUE_TO_CVRECT(roi));
+    rb_yield_values(1, self);
+    cvSetImageROI(IPLIMAGE(self), prev_roi);
+  } else {
+    cvSetImageROI(IPLIMAGE(self), VALUE_TO_CVRECT(roi));
+  }
+  return self;
+}
+
+
+/*
+ * Reset ROI setting. Same as IplImage#roi = nil. Return self.
+ */
+VALUE
+rb_reset_roi(VALUE self)
+{
+  cvResetImageROI(IPLIMAGE(self));
+  return self;
+}
+
+/*
+ * Return COI as Fixnum.
+ */
+VALUE
+rb_get_coi(VALUE self)
+{
+  return INT2FIX(cvGetImageCOI(IPLIMAGE(self)));
+}
+
+/*
+ * call-seq:
+ *   set_coi(<i>coi</i>)
+ *   set_coi(<i>coi</i>){|image| ...}
+ *
+ * Set COI. <i>coi</i> should be Fixnum.
+ * Return self.
+ */
+VALUE
+rb_set_coi(VALUE self, VALUE coi)
+{
+  VALUE block = rb_block_given_p() ? rb_block_proc() : 0;
+  if (block) {
+    int prev_coi = cvGetImageCOI(IPLIMAGE(self));
+    cvSetImageCOI(IPLIMAGE(self), FIX2INT(coi));
+    rb_yield_values(1, self);
+    cvSetImageCOI(IPLIMAGE(self), prev_coi);
+  } else {
+    cvSetImageCOI(IPLIMAGE(self), FIX2INT(coi));
+  }
+  return self;
+}
+
+/*
+ * Reset COI setting. Same as IplImage#coi = 0. Return self.
+ */
+VALUE
+rb_reset_coi(VALUE self)
+{
+  cvSetImageCOI(IPLIMAGE(self), 0);
+  return self;
+}
+
+
+VALUE
+new_object(int width, int height, int type)
+{
+  return OPENCV_OBJECT(rb_klass, cvCreateImage(cvSize(width, height), cvCvToIplDepth(type), CV_MAT_CN(type)));
+}
+
+VALUE
+new_object(CvSize size, int type)
+{
+  return OPENCV_OBJECT(rb_klass, cvCreateImage(size, cvCvToIplDepth(type), CV_MAT_CN(type)));
+}
+
+__NAMESPACE_END_IPLIMAGE
+__NAMESPACE_END_OPENCV

ext/iplimage.h

@@ -0,0 +1,54 @@
+/************************************************************
+
+   iplimage.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_IPLIMAGE_H
+#define RUBY_OPENCV_IPLIMAGE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_IPLIMAGE namespace cIplImage{
+#define __NAMESPACE_END_IPLIMAGE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_IPLIMAGE
+
+VALUE rb_class();
+
+void define_ruby_class();    
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_load_image(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_color_model(VALUE self);
+
+VALUE rb_get_roi(VALUE self);
+VALUE rb_set_roi(VALUE self, VALUE roi);
+VALUE rb_reset_roi(VALUE self);
+
+VALUE rb_get_coi(VALUE self);
+VALUE rb_set_coi(VALUE self, VALUE coi);
+VALUE rb_reset_coi(VALUE self);
+
+VALUE new_object(int width, int height, int type);
+VALUE new_object(CvSize size, int type);
+__NAMESPACE_END_IPLIMAGE
+
+inline IplImage*
+IPLIMAGE(VALUE object)
+{
+  IplImage *ptr, stub;
+  Data_Get_Struct(object, IplImage, ptr);
+  return cvGetImage(ptr, &stub);
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_IPLIMAGE_H

ext/mouseevent.cpp

@@ -0,0 +1,184 @@
+/************************************************************
+
+   mouseevent.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2007 Masakazu Yonekura
+
+************************************************************/
+#ifdef HAVE_CALLBACK_H
+
+#include "mouseevent.h"
+/*
+ * Document-module: OpenCV::GUI::MouseEvent
+ *
+ * MouseEvent object.
+ * have
+ * see OpenCV::GUI::Window#set_mouse_callback.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_GUI
+__NAMESPACE_BEGIN_MOUSEEVENT
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * GUI = rb_define_module_under(opencv, "GUI");
+   * cvpoint = rb_define_class_under(opencv, "CvPoint", rb_cObject);
+   */
+  VALUE GUI = rb_module_GUI();
+  VALUE cvpoint = cCvPoint::rb_class();
+  rb_klass = rb_define_class_under(GUI, "MouseEvent", cvpoint);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "event", RUBY_METHOD_FUNC(rb_event), 0);
+  rb_define_method(rb_klass, "left_button?", RUBY_METHOD_FUNC(rb_left_button_q), 0);
+  rb_define_method(rb_klass, "right_button?", RUBY_METHOD_FUNC(rb_right_button_q), 0);
+  rb_define_method(rb_klass, "middle_button?", RUBY_METHOD_FUNC(rb_middle_button_q), 0);
+  rb_define_method(rb_klass, "ctrl_key?", RUBY_METHOD_FUNC(rb_ctrl_key_q), 0);
+  rb_define_method(rb_klass, "shift_key?", RUBY_METHOD_FUNC(rb_shift_key_q), 0);
+  rb_define_method(rb_klass, "alt_key?", RUBY_METHOD_FUNC(rb_alt_key_q), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  MouseEvent *ptr;
+  return Data_Make_Struct(klass, MouseEvent, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   event -> symbol
+ *
+ * Return Symbol about mouse event.
+ *
+ * Currently, return these symbol:
+ *   :move
+ *     When mouse move.
+ *   :right_button_down
+ *     When mouse right button down.
+ *   :left_button_down
+ *     When mosue left button down.
+ *   :middle_button_down
+ *     When mosue middle button down.
+ *   :left_button_up
+ *     When mouse left button down.
+ *   :right_button_up
+ *     When mouse right button down.
+ *   :middle_button_up
+ *     When mouse middle button down.
+ *
+ * note: original OpenCV define "double-click" event(e.g. CV_EVENT_LBUTTONDBLCLK).
+ * But never call these event. Is it bug?
+ */
+VALUE rb_event(VALUE self)
+{
+  switch(MOUSEEVENT(self)->event) {
+  case CV_EVENT_MOUSEMOVE:
+    return ID2SYM(rb_intern("move"));
+  case CV_EVENT_LBUTTONDOWN:
+    return ID2SYM(rb_intern("left_button_down"));
+  case CV_EVENT_RBUTTONDOWN:
+    return ID2SYM(rb_intern("right_button_down"));
+  case CV_EVENT_MBUTTONDOWN:
+    return ID2SYM(rb_intern("middle_button_down"));
+  case CV_EVENT_LBUTTONUP:
+    return ID2SYM(rb_intern("left_button_up"));
+  case CV_EVENT_RBUTTONUP:
+    return ID2SYM(rb_intern("right_button_up"));
+  case CV_EVENT_MBUTTONUP:
+    return ID2SYM(rb_intern("middle_button_up"));
+  case CV_EVENT_LBUTTONDBLCLK:
+    return ID2SYM(rb_intern("left_button_double_click"));
+  case CV_EVENT_RBUTTONDBLCLK:
+    return ID2SYM(rb_intern("right_button_double_click"));
+  case CV_EVENT_MBUTTONDBLCLK:
+    return ID2SYM(rb_intern("middle_button_double_click"));
+  }
+  return Qnil;
+}
+
+/*
+ * Return true when mouse left button is pushed. Otherwise return false.
+ */
+VALUE
+rb_left_button_q(VALUE self)
+{
+  return MOUSEEVENT(self)->flag & CV_EVENT_FLAG_LBUTTON ? Qtrue : Qfalse;
+}
+
+/*
+ * Return true when mouse right button is pushed. Otherwise return false.
+ */
+VALUE
+rb_right_button_q(VALUE self)
+{
+  return MOUSEEVENT(self)->flag & CV_EVENT_FLAG_RBUTTON ? Qtrue : Qfalse;
+}
+
+/*
+ * Return true when mouse middle button is pushed. Otherwise return false.
+ */
+VALUE
+rb_middle_button_q(VALUE self)
+{
+  return MOUSEEVENT(self)->flag & CV_EVENT_FLAG_MBUTTON ? Qtrue : Qfalse;
+}
+
+/*
+ * Return true when CTRL key is pushed. Otherwise return false.
+ */
+VALUE
+rb_ctrl_key_q(VALUE self)
+{
+  return MOUSEEVENT(self)->flag & CV_EVENT_FLAG_CTRLKEY ? Qtrue : Qfalse;
+}
+
+/*
+ * Return true when shift key is pushed. Otherwise return false.
+ */
+VALUE
+rb_shift_key_q(VALUE self)
+{
+  return MOUSEEVENT(self)->flag & CV_EVENT_FLAG_SHIFTKEY ? Qtrue : Qfalse;
+}
+
+/*
+ * Return true when ALT key is pushed. Otherwise return false.
+ */
+VALUE
+rb_alt_key_q(VALUE self)
+{
+  return MOUSEEVENT(self)->flag & CV_EVENT_FLAG_ALTKEY ? Qtrue : Qfalse;
+}
+
+VALUE
+new_object(int flag, int y, int x, int event)
+{
+  VALUE object = rb_allocate(rb_class());
+  MouseEvent *mouseevent = MOUSEEVENT(object);
+  mouseevent->point.x = x;
+  mouseevent->point.y = y;
+  mouseevent->event = event;
+  mouseevent->flag = flag;
+  return object;
+}
+
+__NAMESPACE_END_MOUSEEVENT
+__NAMESPACE_END_GUI
+__NAMESPACE_END_OPENCV
+
+#endif // HAVE_CALLBACK_H

ext/mouseevent.h

@@ -0,0 +1,59 @@
+/************************************************************
+
+   mouseevent.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifdef HAVE_CALLBACK_H
+
+#define __NAMESPACE_BEGIN_MOUSEEVENT namespace cMouseEvent{
+#define __NAMESPACE_END_MOUSEEVENT }
+
+#ifndef RUBY_OPENCV_GUI_MOUSEEVENT_H
+#define RUBY_OPENCV_GUI_MOUSEEVENT_H
+
+#include"opencv.h"
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_GUI
+__NAMESPACE_BEGIN_MOUSEEVENT
+
+typedef struct MouseEvent{
+  CvPoint point;
+  int event;
+  int flag;
+}MouseEvent;
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+
+VALUE rb_event(VALUE self);
+
+VALUE rb_left_button_q(VALUE self);
+VALUE rb_right_button_q(VALUE self);
+VALUE rb_middle_button_q(VALUE self);
+VALUE rb_ctrl_key_q(VALUE self);
+VALUE rb_shift_key_q(VALUE self);
+VALUE rb_alt_key_q(VALUE self);
+
+VALUE new_object(int event, int x, int y, int flag);
+
+inline MouseEvent *MOUSEEVENT(VALUE object){
+  MouseEvent *ptr;
+  Data_Get_Struct(object, MouseEvent, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_MOUSEEVENT
+__NAMESPACE_END_GUI
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_GUI_MOUSEEVENT_H
+
+#endif // HAVE_CALLBACK_H

ext/opencv.cpp

@@ -0,0 +1,481 @@
+/************************************************************
+
+  opencv.cpp -
+
+  $Author: lsxi $
+
+  Copyright (C) 2005-2008 Masakazu Yonekura
+
+************************************************************/
+/*
+ * Document-module: OpenCV
+ *
+ * =What is OpenCV?
+ *
+ * OpenCV is "Open Source Computer Vision Library".
+ * OpenCV is developed by Intel and many opensource developers.
+ * This library include many useful function for computer vision, such as object-detection.
+ *
+ * OpenCV is developed at
+ * sourceforge.net[http://sourceforge.net/projects/opencvlibrary]
+ *
+ * =What is Ruby/OpenCV?
+ * Ruby/OpenCV is manual Wrapper of OpenCV (not use SWIG).
+ * This library seem to be *Ruby*.
+ * * object-oriented
+ * * support Garbage Collection by Ruby
+ * Ruby/OpenCV is developed
+ * http://rubyforge.org/projects/opencv  (Official)
+ * and
+ * http://blueruby.mydns.jp/pages/opencv (Japanese)
+ *
+ * =How to install
+ * 
+ * Show INSTALL
+ *
+ * =How to generate this documentation?
+ * This document created by rdoc.
+ * If you have Ruby 1.8 or later, you might use rdoc command.
+ * for example
+ *   > cd opencv
+ *   > rdoc
+ * and show "./doc/index.html"
+ */
+#include "opencv.h"
+
+__NAMESPACE_BEGIN_OPENCV
+
+
+/*
+ * Hashtable for protect from GC
+ */
+st_table *root_table = st_init_numtable();
+
+/*
+ * Mark root object. (protect from GC)
+ */
+void
+mark_root_object(void *ptr)
+{
+  VALUE value;
+  if(ptr && st_lookup(root_table, (st_data_t)ptr, (st_data_t*)&value)){      
+    rb_gc_mark(value);
+  }
+}
+
+/*
+ * Look-up Root root object.
+ */
+VALUE
+lookup_root_object(void *ptr)
+{
+  VALUE value = 0;
+  if(ptr)
+    st_lookup(root_table, (st_data_t)ptr, (st_data_t*)&value);
+  return value;
+}
+
+/*
+ * Resist root object.
+ */
+void
+resist_root_object(void *ptr, VALUE root)
+{
+  st_insert(root_table, (st_data_t)ptr, (st_data_t)root);
+}
+
+/*
+ * Delete mark symbol from hashtable only, not free memory.
+ */
+void
+unresist_object(void *ptr)
+{
+  st_delete(root_table, (st_data_t*)&ptr, 0);
+}
+
+/*
+ * Delete mark symbol from hash table, then free memory.
+ */
+void
+free_object(void *ptr)
+{
+  if(ptr){      
+    unresist_object(ptr);
+    cvFree(&ptr);
+  }
+}
+
+/*
+ * Release OpenCV specific structure(i.e CvMat, IplImage..) from memory and delete from hashtable.
+ */
+void
+release_object(void *ptr)
+{
+  if(ptr){
+    unresist_object(ptr);
+    cvRelease(&ptr);
+  }
+}
+
+VALUE rb_module;
+VALUE rb_opencv_constants;
+
+VALUE
+rb_module_opencv()
+{
+  return rb_module;
+}
+
+/*
+ * convert OpenCV internal error to Ruby exception.
+ */
+int
+error_callback(int status,
+               const char *function_name,
+               const char *error_message,
+               const char *file_name,
+               int line,
+               void *user_data)
+{
+  int error_code = (CvStatus)cvGetErrStatus();
+  if(error_code){
+    OPENCV_RSTERR(); // = CV_StsOk
+    rb_warn("OpenCV error code (%d) : %s (%d in %s)", error_code, function_name, line, file_name);
+    rb_raise(mCvError::by_code(error_code), "%s", error_message);
+  }
+  return 0;
+}
+
+void
+define_ruby_module()
+{
+  if(rb_module)
+    return;
+  rb_module = rb_define_module("OpenCV");
+  
+  /* 0: 8bit unsigned */
+  rb_define_const(rb_module, "CV_8U", INT2FIX(CV_8U));
+  /* 1: 8bit signed */
+  rb_define_const(rb_module, "CV_8S", INT2FIX(CV_8S));
+  /* 2: 16bit unsigned */
+  rb_define_const(rb_module, "CV_16U", INT2FIX(CV_16U));
+  /* 3: 16bit signed */
+  rb_define_const(rb_module, "CV_16S", INT2FIX(CV_16S));
+  /* 4: 32bit signed */
+  rb_define_const(rb_module, "CV_32S", INT2FIX(CV_32S));
+  /* 5: 32bit floating-point */
+  rb_define_const(rb_module, "CV_32F", INT2FIX(CV_32F));
+  /* 6: 64bit floating-point */
+  rb_define_const(rb_module, "CV_64F", INT2FIX(CV_64F));
+  
+  
+  VALUE inversion_method = rb_hash_new();
+  /* {:lu, :svd, :svd_sym(:svd_symmetric)}: Inversion method */
+  rb_define_const(rb_module, "INVERSION_METHOD", inversion_method);
+  RESIST_CVMETHOD(inversion_method, "lu", CV_LU);
+  RESIST_CVMETHOD(inversion_method, "svd", CV_SVD);
+  RESIST_CVMETHOD(inversion_method, "svd_sym", CV_SVD_SYM);
+  RESIST_CVMETHOD(inversion_method, "svd_symmetric", CV_SVD_SYM);
+    
+  VALUE dxt_flag = rb_hash_new();
+  /* {:forward, :inverse, :scale, :rows}: DFT and DCT flags */
+  rb_define_const(rb_module, "DXT_FLAG", dxt_flag);
+  RESIST_CVMETHOD(dxt_flag, "forward", CV_DXT_FORWARD);
+  RESIST_CVMETHOD(dxt_flag, "inverse", CV_DXT_INVERSE);
+  RESIST_CVMETHOD(dxt_flag, "scale", CV_DXT_SCALE);
+  RESIST_CVMETHOD(dxt_flag, "rows", CV_DXT_ROWS);
+    
+  VALUE interpolation_method = rb_hash_new();
+  /* {:nn, :linear, :area, :cubic}: Interpolation method */
+  rb_define_const(rb_module, "INTERPOLATION_METHOD", interpolation_method);
+  RESIST_CVMETHOD(interpolation_method, "nn", CV_INTER_NN);
+  RESIST_CVMETHOD(interpolation_method, "linear", CV_INTER_LINEAR);
+  RESIST_CVMETHOD(interpolation_method, "area", CV_INTER_AREA);
+  RESIST_CVMETHOD(interpolation_method, "cubic", CV_INTER_CUBIC);
+  
+  VALUE warp_flag = rb_hash_new();
+  /* {:fill_outliers, :inverse_map}: Warp affine optional flags */
+  rb_define_const(rb_module, "WARP_FLAG", warp_flag);
+  RESIST_CVMETHOD(warp_flag, "fill_outliers", CV_WARP_FILL_OUTLIERS);
+  RESIST_CVMETHOD(warp_flag, "inverse_map", CV_WARP_INVERSE_MAP);    
+  
+  VALUE depth = rb_hash_new();
+  /* {:cv8u, :cv8s, :cv16u, :cv16s, :cv32s, :cv32f, :cv64f}: Depth of each pixel. */
+  rb_define_const(rb_module, "DEPTH", depth);
+  RESIST_CVMETHOD(depth, "cv8u", CV_8U);
+  RESIST_CVMETHOD(depth, "cv8s", CV_8S);
+  RESIST_CVMETHOD(depth, "cv16u", CV_16U);
+  RESIST_CVMETHOD(depth, "cv16s", CV_16S);
+  RESIST_CVMETHOD(depth, "cv32s", CV_32S);
+  RESIST_CVMETHOD(depth, "cv32f", CV_32F);
+  RESIST_CVMETHOD(depth, "cv64f", CV_64F);
+  
+  VALUE connectivity = rb_hash_new();
+  /* {:aa(:anti_alias)}: Determined by the closeness of pixel values */
+  rb_define_const(rb_module, "CONNECTIVITY", connectivity);
+  RESIST_CVMETHOD(depth, "aa", CV_AA);
+  RESIST_CVMETHOD(depth, "anti_alias", CV_AA);
+
+  VALUE retrieval_mode = rb_hash_new();
+  /* {:external, :list, :ccomp, :tree}: Retrieval mode */
+  rb_define_const(rb_module, "RETRIEVAL_MODE", retrieval_mode);
+  RESIST_CVMETHOD(retrieval_mode, "external", CV_RETR_EXTERNAL);
+  RESIST_CVMETHOD(retrieval_mode, "list", CV_RETR_LIST);
+  RESIST_CVMETHOD(retrieval_mode, "ccomp", CV_RETR_CCOMP);
+  RESIST_CVMETHOD(retrieval_mode, "tree", CV_RETR_TREE);
+
+  VALUE approx_chain_method = rb_hash_new();
+  /* {:code, :approx_none, :approx_simple, :apporx_tc89_11, :approx_tc89_kcos}: Approximation method */
+  rb_define_const(rb_module, "APPROX_CHAIN_METHOD", approx_chain_method);
+  RESIST_CVMETHOD(approx_chain_method, "code", CV_CHAIN_CODE);
+  RESIST_CVMETHOD(approx_chain_method, "approx_none", CV_CHAIN_APPROX_NONE);
+  RESIST_CVMETHOD(approx_chain_method, "approx_simple", CV_CHAIN_APPROX_SIMPLE);
+  RESIST_CVMETHOD(approx_chain_method, "approx_tc89_l1", CV_CHAIN_APPROX_TC89_L1);
+  RESIST_CVMETHOD(approx_chain_method, "approx_tc89_kcos", CV_CHAIN_APPROX_TC89_KCOS);
+  
+  VALUE approx_poly_method = rb_hash_new();
+  /* {:dp}: Approximation method (polygon) */
+  rb_define_const(rb_module, "APPROX_POLY_METHOD", approx_poly_method);
+  RESIST_CVMETHOD(approx_poly_method, "dp", CV_POLY_APPROX_DP);
+
+  VALUE match_template_method = rb_hash_new();
+  /* {:sqdiff, :sqdiff_normed, :ccorr, :ccorr_normed, :ccoeff, :ccoeff_normed}: Match template method */
+  rb_define_const(rb_module, "MATCH_TEMPLATE_METHOD", match_template_method);
+  RESIST_CVMETHOD(match_template_method, "sqdiff", CV_TM_SQDIFF);
+  RESIST_CVMETHOD(match_template_method, "sqdiff_normed", CV_TM_SQDIFF_NORMED);
+  RESIST_CVMETHOD(match_template_method, "ccorr", CV_TM_CCORR);
+  RESIST_CVMETHOD(match_template_method, "ccorr_normed", CV_TM_CCORR_NORMED);
+  RESIST_CVMETHOD(match_template_method, "ccoeff", CV_TM_CCOEFF);
+  RESIST_CVMETHOD(match_template_method, "ccoeff_normed", CV_TM_CCOEFF_NORMED);
+
+  /* color convert methods */
+  rb_define_module_function(rb_module, "BGR2BGRA", RUBY_METHOD_FUNC(rb_BGR2BGRA), 1);
+  rb_define_module_function(rb_module, "RGB2RGBA", RUBY_METHOD_FUNC(rb_RGB2RGBA), 1);
+  rb_define_module_function(rb_module, "BGRA2BGR", RUBY_METHOD_FUNC(rb_BGRA2BGR), 1);
+  rb_define_module_function(rb_module, "RGBA2RGB", RUBY_METHOD_FUNC(rb_RGBA2RGB), 1);
+  rb_define_module_function(rb_module, "BGR2RGBA", RUBY_METHOD_FUNC(rb_BGR2RGBA), 1);
+  rb_define_module_function(rb_module, "RGB2BGRA", RUBY_METHOD_FUNC(rb_RGB2BGRA), 1);
+  rb_define_module_function(rb_module, "RGBA2BGR", RUBY_METHOD_FUNC(rb_RGBA2BGR), 1);
+  rb_define_module_function(rb_module, "BGRA2RGB", RUBY_METHOD_FUNC(rb_BGRA2RGB), 1);
+  rb_define_module_function(rb_module, "BGR2RGB", RUBY_METHOD_FUNC(rb_BGR2RGB), 1);
+  rb_define_module_function(rb_module, "RGB2BGR", RUBY_METHOD_FUNC(rb_RGB2BGR), 1);
+  rb_define_module_function(rb_module, "BGRA2RGBA", RUBY_METHOD_FUNC(rb_BGRA2RGBA), 1);
+  rb_define_module_function(rb_module, "RGBA2BGRA", RUBY_METHOD_FUNC(rb_RGBA2BGRA), 1);
+  rb_define_module_function(rb_module, "BGR2GRAY", RUBY_METHOD_FUNC(rb_BGR2GRAY), 1);
+  rb_define_module_function(rb_module, "RGB2GRAY", RUBY_METHOD_FUNC(rb_RGB2GRAY), 1);
+  rb_define_module_function(rb_module, "GRAY2BGR", RUBY_METHOD_FUNC(rb_GRAY2BGR), 1);
+  rb_define_module_function(rb_module, "GRAY2RGB", RUBY_METHOD_FUNC(rb_GRAY2RGB), 1);
+  rb_define_module_function(rb_module, "GRAY2BGRA", RUBY_METHOD_FUNC(rb_GRAY2BGRA), 1);
+  rb_define_module_function(rb_module, "GRAY2RGBA", RUBY_METHOD_FUNC(rb_GRAY2RGBA), 1);
+  rb_define_module_function(rb_module, "BGRA2GRAY", RUBY_METHOD_FUNC(rb_BGRA2GRAY), 1);
+  rb_define_module_function(rb_module, "RGBA2GRAY", RUBY_METHOD_FUNC(rb_RGBA2GRAY), 1);
+  rb_define_module_function(rb_module, "BGR2BGR565", RUBY_METHOD_FUNC(rb_BGR2BGR565), 1);
+  rb_define_module_function(rb_module, "RGB2BGR565", RUBY_METHOD_FUNC(rb_RGB2BGR565), 1);
+  rb_define_module_function(rb_module, "BGR5652BGR", RUBY_METHOD_FUNC(rb_BGR5652BGR), 1);
+  rb_define_module_function(rb_module, "BGR5652RGB", RUBY_METHOD_FUNC(rb_BGR5652RGB), 1);
+  rb_define_module_function(rb_module, "BGRA2BGR565", RUBY_METHOD_FUNC(rb_BGRA2BGR565), 1);
+  rb_define_module_function(rb_module, "RGBA2BGR565", RUBY_METHOD_FUNC(rb_RGBA2BGR565), 1);
+  rb_define_module_function(rb_module, "BGR5652BGRA", RUBY_METHOD_FUNC(rb_BGR5652BGRA), 1);
+  rb_define_module_function(rb_module, "BGR5652RGBA", RUBY_METHOD_FUNC(rb_BGR5652RGBA), 1);
+  rb_define_module_function(rb_module, "GRAY2BGR565", RUBY_METHOD_FUNC(rb_GRAY2BGR565), 1);
+  rb_define_module_function(rb_module, "BGR5652GRAY", RUBY_METHOD_FUNC(rb_BGR5652GRAY), 1);
+  rb_define_module_function(rb_module, "BGR2BGR555", RUBY_METHOD_FUNC(rb_BGR2BGR555), 1);
+  rb_define_module_function(rb_module, "RGB2BGR555", RUBY_METHOD_FUNC(rb_RGB2BGR555), 1);
+  rb_define_module_function(rb_module, "BGR5552BGR", RUBY_METHOD_FUNC(rb_BGR5552BGR), 1);
+  rb_define_module_function(rb_module, "BGR5552RGB", RUBY_METHOD_FUNC(rb_BGR5552RGB), 1);
+  rb_define_module_function(rb_module, "BGRA2BGR555", RUBY_METHOD_FUNC(rb_BGRA2BGR555), 1);
+  rb_define_module_function(rb_module, "RGBA2BGR555", RUBY_METHOD_FUNC(rb_RGBA2BGR555), 1);
+  rb_define_module_function(rb_module, "BGR5552BGRA", RUBY_METHOD_FUNC(rb_BGR5552BGRA), 1);
+  rb_define_module_function(rb_module, "BGR5552RGBA", RUBY_METHOD_FUNC(rb_BGR5552RGBA), 1);
+  rb_define_module_function(rb_module, "GRAY2BGR555", RUBY_METHOD_FUNC(rb_GRAY2BGR555), 1);
+  rb_define_module_function(rb_module, "BGR5552GRAY", RUBY_METHOD_FUNC(rb_BGR5552GRAY), 1);
+  rb_define_module_function(rb_module, "BGR2XYZ", RUBY_METHOD_FUNC(rb_BGR2XYZ), 1);
+  rb_define_module_function(rb_module, "RGB2XYZ", RUBY_METHOD_FUNC(rb_RGB2XYZ), 1);
+  rb_define_module_function(rb_module, "XYZ2BGR", RUBY_METHOD_FUNC(rb_XYZ2BGR), 1);
+  rb_define_module_function(rb_module, "XYZ2RGB", RUBY_METHOD_FUNC(rb_XYZ2RGB), 1);
+  rb_define_module_function(rb_module, "BGR2YCrCb", RUBY_METHOD_FUNC(rb_BGR2YCrCb), 1);
+  rb_define_module_function(rb_module, "RGB2YCrCb", RUBY_METHOD_FUNC(rb_RGB2YCrCb), 1);
+  rb_define_module_function(rb_module, "YCrCb2BGR", RUBY_METHOD_FUNC(rb_YCrCb2BGR), 1);
+  rb_define_module_function(rb_module, "YCrCb2RGB", RUBY_METHOD_FUNC(rb_YCrCb2RGB), 1);
+  rb_define_module_function(rb_module, "BGR2HSV", RUBY_METHOD_FUNC(rb_BGR2HSV), 1);
+  rb_define_module_function(rb_module, "RGB2HSV", RUBY_METHOD_FUNC(rb_RGB2HSV), 1);
+  rb_define_module_function(rb_module, "BGR2Lab", RUBY_METHOD_FUNC(rb_BGR2Lab), 1);
+  rb_define_module_function(rb_module, "RGB2Lab", RUBY_METHOD_FUNC(rb_RGB2Lab), 1);
+  rb_define_module_function(rb_module, "BayerBG2BGR", RUBY_METHOD_FUNC(rb_BayerBG2BGR), 1);
+  rb_define_module_function(rb_module, "BayerGB2BGR", RUBY_METHOD_FUNC(rb_BayerGB2BGR), 1);
+  rb_define_module_function(rb_module, "BayerRG2BGR", RUBY_METHOD_FUNC(rb_BayerRG2BGR), 1);
+  rb_define_module_function(rb_module, "BayerGR2BGR", RUBY_METHOD_FUNC(rb_BayerGR2BGR), 1);
+  rb_define_module_function(rb_module, "BayerBG2RGB", RUBY_METHOD_FUNC(rb_BayerBG2RGB), 1);
+  rb_define_module_function(rb_module, "BayerGB2RGB", RUBY_METHOD_FUNC(rb_BayerGB2RGB), 1);
+  rb_define_module_function(rb_module, "BayerRG2RGB", RUBY_METHOD_FUNC(rb_BayerRG2RGB), 1);
+  rb_define_module_function(rb_module, "BayerGR2RGB", RUBY_METHOD_FUNC(rb_BayerGR2RGB), 1);
+  rb_define_module_function(rb_module, "BGR2Luv", RUBY_METHOD_FUNC(rb_BGR2Luv), 1);
+  rb_define_module_function(rb_module, "RGB2Luv", RUBY_METHOD_FUNC(rb_RGB2Luv), 1);
+  rb_define_module_function(rb_module, "BGR2HLS", RUBY_METHOD_FUNC(rb_BGR2HLS), 1);
+  rb_define_module_function(rb_module, "RGB2HLS", RUBY_METHOD_FUNC(rb_RGB2HLS), 1);
+  rb_define_module_function(rb_module, "HSV2BGR", RUBY_METHOD_FUNC(rb_HSV2BGR), 1);
+  rb_define_module_function(rb_module, "HSV2RGB", RUBY_METHOD_FUNC(rb_HSV2RGB), 1);
+  rb_define_module_function(rb_module, "Lab2BGR", RUBY_METHOD_FUNC(rb_Lab2BGR), 1);
+  rb_define_module_function(rb_module, "Lab2RGB", RUBY_METHOD_FUNC(rb_Lab2RGB), 1);
+  rb_define_module_function(rb_module, "Luv2BGR", RUBY_METHOD_FUNC(rb_Luv2BGR), 1);
+  rb_define_module_function(rb_module, "Luv2RGB", RUBY_METHOD_FUNC(rb_Luv2RGB), 1);
+  rb_define_module_function(rb_module, "HLS2BGR", RUBY_METHOD_FUNC(rb_HLS2BGR), 1);
+  rb_define_module_function(rb_module, "HLS2RGB", RUBY_METHOD_FUNC(rb_HLS2RGB), 1);
+}
+
+#define CREATE_CVTCOLOR_FUNC(rb_func_name, c_const_name, src_cn, dest_cn) \
+  VALUE rb_func_name(VALUE klass, VALUE image)				\
+  {									\
+    VALUE dest;								\
+    if (!rb_obj_is_kind_of(image, cCvMat::rb_class()))			\
+      rb_raise(rb_eTypeError, "argument 1 should be %s.", rb_class2name(cCvMat::rb_class())); \
+    int type = cvGetElemType(CVARR(image));				\
+    if (CV_MAT_CN(type) != src_cn)					\
+      rb_raise(rb_eTypeError, "argument 1 should be %d-channel.", src_cn); \
+    dest = cIplImage::new_object(cvGetSize(CVARR(image)), CV_MAKETYPE(CV_MAT_DEPTH(type), dest_cn)); \
+    cvCvtColor(CVARR(image), CVARR(dest), c_const_name);		\
+    return dest;							\
+  }
+
+CREATE_CVTCOLOR_FUNC(rb_BGR2BGRA, CV_BGR2BGRA, 3, 4);
+CREATE_CVTCOLOR_FUNC(rb_RGB2RGBA, CV_RGB2RGBA, 3, 4);
+CREATE_CVTCOLOR_FUNC(rb_BGRA2BGR, CV_BGRA2BGR, 4, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGBA2RGB, CV_RGBA2RGB, 4, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR2RGBA, CV_BGR2RGBA, 3, 4);
+CREATE_CVTCOLOR_FUNC(rb_RGB2BGRA, CV_RGB2BGRA, 3, 4);
+CREATE_CVTCOLOR_FUNC(rb_RGBA2BGR, CV_RGBA2BGR, 4, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGRA2RGB, CV_BGRA2RGB, 4, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR2RGB, CV_BGR2RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGB2BGR, CV_RGB2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGRA2RGBA, CV_BGRA2RGBA, 4, 4);
+CREATE_CVTCOLOR_FUNC(rb_RGBA2BGRA, CV_RGBA2BGRA, 4, 4);
+CREATE_CVTCOLOR_FUNC(rb_BGR2GRAY, CV_BGR2GRAY, 3, 1);
+CREATE_CVTCOLOR_FUNC(rb_RGB2GRAY, CV_RGB2GRAY, 3, 1);
+CREATE_CVTCOLOR_FUNC(rb_GRAY2BGR, CV_GRAY2BGR, 1, 3);
+CREATE_CVTCOLOR_FUNC(rb_GRAY2RGB, CV_GRAY2RGB, 1, 3);
+CREATE_CVTCOLOR_FUNC(rb_GRAY2BGRA, CV_GRAY2BGRA, 1, 4);
+CREATE_CVTCOLOR_FUNC(rb_GRAY2RGBA, CV_GRAY2RGBA, 1, 4);
+CREATE_CVTCOLOR_FUNC(rb_BGRA2GRAY, CV_BGRA2GRAY, 4, 1);
+CREATE_CVTCOLOR_FUNC(rb_RGBA2GRAY, CV_RGBA2GRAY, 4, 1);
+CREATE_CVTCOLOR_FUNC(rb_BGR2BGR565, CV_BGR2BGR565, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGB2BGR565, CV_RGB2BGR565, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR5652BGR, CV_BGR5652BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR5652RGB, CV_BGR5652RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGRA2BGR565, CV_BGRA2BGR565, 4, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGBA2BGR565, CV_RGBA2BGR565, 4, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR5652BGRA, CV_BGR5652BGRA, 3, 4);
+CREATE_CVTCOLOR_FUNC(rb_BGR5652RGBA, CV_BGR5652RGBA, 3, 4);
+CREATE_CVTCOLOR_FUNC(rb_GRAY2BGR565, CV_GRAY2BGR565, 1, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR5652GRAY, CV_BGR5652GRAY, 3, 1);
+CREATE_CVTCOLOR_FUNC(rb_BGR2BGR555, CV_BGR2BGR555, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGB2BGR555, CV_RGB2BGR555, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR5552BGR, CV_BGR5552BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR5552RGB, CV_BGR5552RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGRA2BGR555, CV_BGRA2BGR555, 4, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGBA2BGR555, CV_RGBA2BGR555, 4, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR5552BGRA, CV_BGR5552BGRA, 3, 4);
+CREATE_CVTCOLOR_FUNC(rb_BGR5552RGBA, CV_BGR5552RGBA, 3, 4);
+CREATE_CVTCOLOR_FUNC(rb_GRAY2BGR555, CV_GRAY2BGR555, 1, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR5552GRAY, CV_BGR5552GRAY, 3, 1);
+CREATE_CVTCOLOR_FUNC(rb_BGR2XYZ, CV_BGR2XYZ, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGB2XYZ, CV_RGB2XYZ, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_XYZ2BGR, CV_XYZ2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_XYZ2RGB, CV_XYZ2RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR2YCrCb, CV_BGR2YCrCb, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGB2YCrCb, CV_RGB2YCrCb, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_YCrCb2BGR, CV_YCrCb2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_YCrCb2RGB, CV_YCrCb2RGB, 0, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR2HSV, CV_BGR2HSV, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGB2HSV, CV_RGB2HSV, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR2Lab, CV_BGR2Lab, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGB2Lab, CV_RGB2Lab, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BayerBG2BGR, CV_BayerBG2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BayerGB2BGR, CV_BayerGB2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BayerRG2BGR, CV_BayerRG2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BayerGR2BGR, CV_BayerGR2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BayerBG2RGB, CV_BayerBG2RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BayerGB2RGB, CV_BayerGB2RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BayerRG2RGB, CV_BayerRG2RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BayerGR2RGB, CV_BayerGR2RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR2Luv, CV_BGR2Luv, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGB2Luv, CV_RGB2Luv, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_BGR2HLS, CV_BGR2HLS, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_RGB2HLS, CV_RGB2HLS, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_HSV2BGR, CV_HSV2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_HSV2RGB, CV_HSV2RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_Lab2BGR, CV_Lab2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_Lab2RGB, CV_Lab2RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_Luv2BGR, CV_Luv2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_Luv2RGB, CV_Luv2RGB, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_HLS2BGR, CV_HLS2BGR, 3, 3);
+CREATE_CVTCOLOR_FUNC(rb_HLS2RGB, CV_HLS2RGB, 3, 3);
+
+__NAMESPACE_END_OPENCV
+
+extern "C"{
+  void
+  Init_opencv()
+  {
+    cvRedirectError((CvErrorCallback)mOpenCV::error_callback);
+    
+    mOpenCV::define_ruby_module();
+    
+    mOpenCV::mCvError::define_ruby_module();
+    mOpenCV::cCvPoint::define_ruby_class();
+    mOpenCV::cCvPoint2D32f::define_ruby_class();
+    mOpenCV::cCvPoint3D32f::define_ruby_class();
+    mOpenCV::cCvSize::define_ruby_class();
+    mOpenCV::cCvSize2D32f::define_ruby_class();
+    mOpenCV::cCvRect::define_ruby_class();
+    mOpenCV::cCvScalar::define_ruby_class();
+    mOpenCV::cCvSlice::define_ruby_class();
+    mOpenCV::cCvTermCriteria::define_ruby_class();
+    mOpenCV::cCvBox2D::define_ruby_class();
+    mOpenCV::cCvFont::define_ruby_class();
+    mOpenCV::cIplConvKernel::define_ruby_class();
+    mOpenCV::cCvMoments::define_ruby_class();
+    mOpenCV::cCvConvexityDefect::define_ruby_class();
+
+    mOpenCV::cCvMemStorage::define_ruby_class();
+
+    mOpenCV::cCvSeq::define_ruby_class();
+    mOpenCV::mCurve::define_ruby_module();
+    mOpenCV::mPointSet::define_ruby_module();
+    mOpenCV::mPoint3DSet::define_ruby_module();
+    mOpenCV::cCvSet::define_ruby_class();
+    mOpenCV::cCvChain::define_ruby_class();
+    mOpenCV::cCvChainCode::define_ruby_class();
+    mOpenCV::cCvContour::define_ruby_class();
+    mOpenCV::cCvContourTree::define_ruby_class();
+
+    mOpenCV::cCvMat::define_ruby_class();
+    mOpenCV::cIplImage::define_ruby_class();
+    mOpenCV::cCvMatND::define_ruby_class();
+    mOpenCV::cCvSparseMat::define_ruby_class();
+    mOpenCV::cCvHistogram::define_ruby_class();
+    mOpenCV::cCvCapture::define_ruby_class();
+
+    mOpenCV::cCvIndex::define_ruby_class();
+    mOpenCV::cCvLine::define_ruby_class();
+    mOpenCV::cCvTwoPoints::define_ruby_class();
+    mOpenCV::cCvCircle32f::define_ruby_class();
+
+    mOpenCV::cCvConDensation::define_ruby_class();
+
+    mOpenCV::cCvConnectedComp::define_ruby_class();
+    mOpenCV::cCvAvgComp::define_ruby_class();
+    mOpenCV::cCvHaarClassifierCascade::define_ruby_class();
+#ifdef HAVE_CALLBACK_H
+    mOpenCV::mGUI::define_ruby_module();
+    mOpenCV::mGUI::cWindow::define_ruby_class();
+    mOpenCV::mGUI::cTrackbar::define_ruby_class();
+    mOpenCV::mGUI::cMouseEvent::define_ruby_class();
+#endif
+
+#ifdef HAVE_ML_H
+    /* feature support.
+      mOpenCV::mMachineLearning::define_ruby_module();
+    */
+#endif
+  }
+}

ext/opencv.h

@@ -0,0 +1,356 @@
+/************************************************************
+
+    opencv.h -
+
+    $Author: lsxi $
+
+    Copyright (C) 2005-2007 Masakazu Yonekura
+
+ ************************************************************/
+#ifndef RUBY_OPENCV_H
+#define RUBY_OPENCV_H
+
+#define __NAMESPACE_BEGIN_OPENCV namespace mOpenCV{
+#define __NAMESPACE_END_OPENCV }
+
+/* include headers */
+#include <ruby.h>
+#include <version.h>
+
+#ifdef RUBY_WIN32_H
+#ifdef write
+#undef write
+#endif // write
+#endif // RUBY_WIN32_H
+
+#ifndef ANYARGS
+#define ANYARGS ()
+#endif
+
+extern "C"{
+#include <st.h>
+#ifdef HAVE_CALLBACK_H
+#include <callback.h> // callhack.h is ffcall header
+#endif
+
+#ifdef HAVE_STDARG_H
+#include <stdarg.h>
+#define va_init_list(a,b) va_start(a,b)
+#else
+#include <varargs.h>
+#define va_init_list(a,b) va_start(a)
+#endif
+}
+
+// standard c headers
+#include <math.h>
+#include <limits.h>
+#include <float.h>
+#include <assert.h>
+
+// OpenCV headers
+#include <cxcore.h>
+#include <cv.h>
+#include <highgui.h>
+#include <cxmisc.h>
+#ifdef HAVE_ML_H
+#include <ml.h>
+#endif
+
+// Ruby/OpenCV headers
+#include "cverror.h"
+#include "cvpoint.h"
+#include "cvpoint2d32f.h"
+#include "cvsize.h"
+#include "cvsize2d32f.h"
+#include "cvrect.h"
+#include "cvscalar.h"
+#include "cvslice.h"
+#include "cvtermcriteria.h"
+#include "cvbox2d.h"
+#include "cvfont.h"
+#include "iplconvkernel.h"
+#include "cvmoments.h"
+#include "cvconvexitydefect.h"
+#include "cvpoint3d32f.h"
+
+#include "cvmemstorage.h"
+
+#include "cvseq.h"
+#include "curve.h"
+#include "pointset.h"
+#include "point3dset.h"
+#include "cvset.h"
+#include "cvchain.h"
+#include "cvchaincode.h"
+#include "cvcontour.h"
+#include "cvcontourtree.h"
+
+#include "cvmat.h"
+#include "iplimage.h"
+#include "cvmatnd.h"
+#include "cvsparsemat.h"
+#include "cvhistogram.h"
+#include "cvcapture.h"
+
+#include "cvindex.h"
+#include "cvline.h"
+#include "cvtwopoints.h"
+#include "cvcircle32f.h"
+
+#include "cvcondensation.h"
+
+#include "cvconnectedcomp.h"
+#include "cvavgcomp.h"
+#include "cvhaarclassifiercascade.h"
+
+// GUI
+#include "gui.h"
+#include "window.h"
+#include "trackbar.h"
+#include "mouseevent.h"
+
+// memory management wrapper
+#define CVALLOC(type) (type*)cvAlloc(sizeof(type))
+
+// useful macros
+#define IF_INT(val, ifnone) NIL_P(val) ? ifnone : NUM2INT(val)
+#define IF_DBL(val, ifnone) NIL_P(val) ? ifnone : NUM2DBL(val)
+#define IF_STRING(str) NIL_P(str) ? NULL : TYPE(str) == T_STRING ? rb
+#define IF_BOOL(val, t, f, ifnone) val == Qtrue ? t : val == Qfalse ? f : ifnone
+
+#define IF_DEPTH(val, ifnone) NIL_P(val) ? ifnone : FIX2INT(val)
+
+#define RESIST_CVMETHOD(hash, str, value) rb_hash_aset(hash, ID2SYM(rb_intern(str)), INT2FIX(value))
+
+#define maxint(a,b) ({int _a = (a), _b = (b); _a > _b ? _a : _b; })
+
+// OpenCV module
+__NAMESPACE_BEGIN_OPENCV
+
+void mark_root_object(void *ptr);
+VALUE lookup_root_object(void *ptr);
+void resist_root_object(void *ptr, VALUE root);
+void unresist_object(void *ptr);
+void free_object(void *ptr);
+void release_object(void *ptr);
+
+VALUE rb_module_opencv();
+void define_ruby_module();
+
+// Ruby/OpenCV inline functions  
+inline CvArr*
+CVARR(VALUE object)
+{
+  CvArr *ptr;
+  Data_Get_Struct(object, CvArr, ptr);
+  return ptr;
+}  
+
+inline VALUE
+OPENCV_OBJECT(VALUE klass, void *ptr)
+{
+  return Data_Wrap_Struct(klass, 0, release_object, ptr);
+}
+
+inline VALUE
+GENERIC_OBJECT(VALUE klass, void *ptr)
+{
+  return Data_Wrap_Struct(klass, 0, 0, ptr);
+}
+
+inline VALUE
+DEPEND_OBJECT(VALUE klass, void *ptr, VALUE root)
+{
+  resist_root_object(ptr, root);
+  return Data_Wrap_Struct(klass, mark_root_object, free_object, ptr);
+}
+
+inline VALUE
+REFER_OBJECT(VALUE klass, void *ptr, VALUE root)
+{
+  resist_root_object(ptr, root);
+  return Data_Wrap_Struct(klass, mark_root_object, unresist_object, ptr);
+}
+
+inline VALUE
+CONVERT(VALUE object, VALUE klass)
+{
+  VALUE method_name = rb_str_concat(rb_str_new2("from_"), rb_str_new2(rb_obj_classname(object)));
+  VALUE result = rb_funcall(klass, rb_intern(StringValueCStr(method_name)), 1, object);
+  if(CLASS_OF(result) != klass)
+    rb_raise(rb_eTypeError, "require %s, but return %s.", rb_class2name(klass), rb_class2name(CLASS_OF(result)));
+  return result;
+}
+
+inline int
+CVMETHOD(const char *name, VALUE method, int ifnone = 0)
+{
+  VALUE value;
+  switch(TYPE(method)){
+  case T_NIL:
+    return ifnone;
+  case T_FIXNUM:
+    return FIX2INT(method);
+    case T_STRING:
+      method = rb_str_intern(method);
+    case T_SYMBOL:
+      value = rb_hash_aref(rb_const_get(rb_module_opencv(), rb_intern(name)), method);
+      if(NIL_P(value)){
+        rb_warn("invalid opencv method type (see OpenCV::%s)", name);
+        return ifnone;
+      }else{
+        return FIX2INT(value);
+      }if (rb_obj_is_kind_of(value, rb_cNumeric))
+  default:
+    rb_raise(rb_eTypeError, "");
+  }
+  return 0;
+}
+
+inline int
+TRUE_OR_FALSE(VALUE object, int ifnone)
+{
+  int value = ifnone;
+  switch (TYPE(object)) {
+  case T_TRUE:
+    value = 1;
+    break;
+  case T_FALSE:
+    value = 0;
+    break;
+  case T_NIL:
+    break;
+  default:
+    rb_warn("argument should be true or false.");
+  }
+  return value;
+}
+
+VALUE rb_BGR2BGRA(VALUE klass, VALUE image);
+VALUE rb_RGB2RGBA(VALUE klass, VALUE image);
+VALUE rb_BGRA2BGR(VALUE klass, VALUE image);
+VALUE rb_RGBA2RGB(VALUE klass, VALUE image);
+VALUE rb_BGR2RGBA(VALUE klass, VALUE image);
+VALUE rb_RGB2BGRA(VALUE klass, VALUE image);
+VALUE rb_RGBA2BGR(VALUE klass, VALUE image);
+VALUE rb_BGRA2RGB(VALUE klass, VALUE image);
+VALUE rb_BGR2RGB(VALUE klass, VALUE image);
+VALUE rb_RGB2BGR(VALUE klass, VALUE image);
+VALUE rb_BGRA2RGBA(VALUE klass, VALUE image);
+VALUE rb_RGBA2BGRA(VALUE klass, VALUE image);
+VALUE rb_BGR2GRAY(VALUE klass, VALUE image);
+VALUE rb_RGB2GRAY(VALUE klass, VALUE image);
+VALUE rb_GRAY2BGR(VALUE klass, VALUE image);
+VALUE rb_GRAY2RGB(VALUE klass, VALUE image);
+VALUE rb_GRAY2BGRA(VALUE klass, VALUE image);
+VALUE rb_GRAY2RGBA(VALUE klass, VALUE image);
+VALUE rb_BGRA2GRAY(VALUE klass, VALUE image);
+VALUE rb_RGBA2GRAY(VALUE klass, VALUE image);
+VALUE rb_BGR2BGR565(VALUE klass, VALUE image);
+VALUE rb_RGB2BGR565(VALUE klass, VALUE image);
+VALUE rb_BGR5652BGR(VALUE klass, VALUE image);
+VALUE rb_BGR5652RGB(VALUE klass, VALUE image);
+VALUE rb_BGRA2BGR565(VALUE klass, VALUE image);
+VALUE rb_RGBA2BGR565(VALUE klass, VALUE image);
+VALUE rb_BGR5652BGRA(VALUE klass, VALUE image);
+VALUE rb_BGR5652RGBA(VALUE klass, VALUE image);
+VALUE rb_GRAY2BGR565(VALUE klass, VALUE image);
+VALUE rb_BGR5652GRAY(VALUE klass, VALUE image);
+VALUE rb_BGR2BGR555(VALUE klass, VALUE image);
+VALUE rb_RGB2BGR555(VALUE klass, VALUE image);
+VALUE rb_BGR5552BGR(VALUE klass, VALUE image);
+VALUE rb_BGR5552RGB(VALUE klass, VALUE image);
+VALUE rb_BGRA2BGR555(VALUE klass, VALUE image);
+VALUE rb_RGBA2BGR555(VALUE klass, VALUE image);
+VALUE rb_BGR5552BGRA(VALUE klass, VALUE image);
+VALUE rb_BGR5552RGBA(VALUE klass, VALUE image);
+VALUE rb_GRAY2BGR555(VALUE klass, VALUE image);
+VALUE rb_BGR5552GRAY(VALUE klass, VALUE image);
+VALUE rb_BGR2XYZ(VALUE klass, VALUE image);
+VALUE rb_RGB2XYZ(VALUE klass, VALUE image);
+VALUE rb_XYZ2BGR(VALUE klass, VALUE image);
+VALUE rb_XYZ2RGB(VALUE klass, VALUE image);
+VALUE rb_BGR2YCrCb(VALUE klass, VALUE image);
+VALUE rb_RGB2YCrCb(VALUE klass, VALUE image);
+VALUE rb_YCrCb2BGR(VALUE klass, VALUE image);
+VALUE rb_YCrCb2RGB(VALUE klass, VALUE image);
+VALUE rb_BGR2HSV(VALUE klass, VALUE image);
+VALUE rb_RGB2HSV(VALUE klass, VALUE image);
+VALUE rb_BGR2Lab(VALUE klass, VALUE image);
+VALUE rb_RGB2Lab(VALUE klass, VALUE image);
+VALUE rb_BayerBG2BGR(VALUE klass, VALUE image);
+VALUE rb_BayerGB2BGR(VALUE klass, VALUE image);
+VALUE rb_BayerRG2BGR(VALUE klass, VALUE image);
+VALUE rb_BayerGR2BGR(VALUE klass, VALUE image);
+VALUE rb_BayerBG2RGB(VALUE klass, VALUE image);
+VALUE rb_BayerGB2RGB(VALUE klass, VALUE image);
+VALUE rb_BayerRG2RGB(VALUE klass, VALUE image);
+VALUE rb_BayerGR2RGB(VALUE klass, VALUE image);
+VALUE rb_BGR2Luv(VALUE klass, VALUE image);
+VALUE rb_RGB2Luv(VALUE klass, VALUE image);
+VALUE rb_BGR2HLS(VALUE klass, VALUE image);
+VALUE rb_RGB2HLS(VALUE klass, VALUE image);
+VALUE rb_HSV2BGR(VALUE klass, VALUE image);
+VALUE rb_HSV2RGB(VALUE klass, VALUE image);
+VALUE rb_Lab2BGR(VALUE klass, VALUE image);
+VALUE rb_Lab2RGB(VALUE klass, VALUE image);
+VALUE rb_Luv2BGR(VALUE klass, VALUE image);
+VALUE rb_Luv2RGB(VALUE klass, VALUE image);
+VALUE rb_HLS2BGR(VALUE klass, VALUE image);
+VALUE rb_HLS2RGB(VALUE klass, VALUE image);
+
+__NAMESPACE_END_OPENCV
+
+inline VALUE
+extract_options_from_args_bang(VALUE ary)
+{
+  return (RARRAY(ary)->len > 0 && rb_obj_is_kind_of(RARRAY(ary)->ptr[RARRAY(ary)->len -1], rb_cHash)) ? rb_ary_pop(ary) : rb_hash_new();
+}
+
+/*
+inline VALUE
+assert_valid_keys(VALUE keys, VALUE valid_keys)
+{
+  VALUE unknown_keys = rb_funcall(keys, rb_intern("-"), 1, rb_funcall(valid_keys, rb_intern("flatten"), 0));
+  if (NUM2INT(rb_funcall(unknown_keys, rb_intern("empty?"), 0)) != 0){
+    rb_raise(rb_eArgError, "Unknown key(s): %s",
+             RSTRING(rb_funcall(unknown_keys, rb_intern("join"), 1, rb_str_new2(", ")))->ptr);
+  }
+  return Qnil;  
+}
+*/
+ /*
+inline void
+assert_valid_keys(VALUE options, int n, ...){
+  va_list valid_keys;  
+  if (!(n > 0)) {return;}
+  VALUE unknown_keys = rb_funcall(options, rb_intern("keys"), 0);
+  va_start(valid_keys, n);
+  for (int i = 0; i < n; i++)
+    rb_ary_delete(unknown_keys, ID2SYM(rb_intern(va_arg(valid_keys, char*))));
+  if (RARRAY(unknown_keys)->len > 0)
+    rb_raise(rb_eArgError, "Unknown key(s): %s",
+             RSTRING(rb_funcall(unknown_keys, rb_intern("join"), 1, rb_str_new2(", ")))->ptr);
+  va_end(valid_keys);
+}
+
+inline VALUE
+validate_option(VALUE options, const *char key, char *ifnone, int n, ...){
+  va_list valid_values;
+  VALUE value = rb_hash_aref(options, ID2SYM(rb_intern(key)));
+  if (!value || !(n > 0)) {return ifnone;}
+  va_start(valid_values, n); 
+  for (int i = 0; i < n; i++){    
+    if (!strcmp(StringValueCStr(value), va_arg(valid_values, char*))){
+      rb_warn("Option :%s value :%s does not defined. Default value :%s is used.", StringValueCStr(value), );
+      return ifnone;
+    }
+  }
+  va_end(valid_values);
+  return value;
+}
+
+#define OPTIONS(value, hash, key, default) value = ((value = rb_hash_aref(hash, ID2SYM(rb_intern(key)))) ? value : default)
+ */
+#endif // RUBY_OPENCV_H

ext/point3dset.cpp

@@ -0,0 +1,41 @@
+/************************************************************
+
+   point3dset.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2008 Masakazu Yonekura
+
+************************************************************/
+#include"point3dset.h"
+/*
+ * Document-class: OpenCV::Point3DSet
+ */
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_POINT3D_SET
+
+VALUE module;
+
+VALUE
+rb_module()
+{
+  return module;
+}
+
+void
+define_ruby_module()
+{
+  if(module)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  module = rb_define_module_under(opencv, "Point3DSet");
+}
+
+__NAMESPACE_END_POINT3D_SET
+__NAMESPACE_END_OPENCV

ext/point3dset.h

@@ -0,0 +1,31 @@
+/************************************************************
+
+   point3dset.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2008 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_POINT3DSET_H
+#define RUBY_OPENCV_POINT3DSET_H
+
+#define __NAMESPACE_BEGIN_POINT3D_SET namespace mPoint3DSet{
+#define __NAMESPACE_END_POINT3D_SET }
+
+#include"opencv.h"
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_POINT3D_SET
+
+VALUE rb_module();
+
+void define_ruby_module();
+
+__NAMESPACE_END_POINT3D_SET
+
+#define POINT3D_SET_P(object) rb_obj_is_kind_of(object, cCvSeq::rb_class()) && CV_IS_SEQ_POINT3D_SET(CVSEQ(object))
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_POINT3DSET_H