opencv 0.0.6

data/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

data/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

data/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

data/ext/pointset.cpp

@@ -0,0 +1,238 @@
+/************************************************************
+
+   pointset.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include"pointset.h"
+/*
+ * Document-class: OpenCV::PointSet
+ */
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_POINT_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, "PointSet");
+  rb_define_method(module, "contour_area", RUBY_METHOD_FUNC(rb_contour_area), -1);
+  rb_define_method(module, "fit_ellipse", RUBY_METHOD_FUNC(rb_fit_ellipse), 0);
+  
+  rb_define_method(module, "convex_hull", RUBY_METHOD_FUNC(rb_convex_hull), -1);
+  rb_define_method(module, "check_contour_convexity", RUBY_METHOD_FUNC(rb_check_contour_convexity), 0);
+  rb_define_alias(module, "convexity?", "check_contour_convexity");
+  rb_define_method(module, "convexity_defects", RUBY_METHOD_FUNC(rb_convexity_defects), -1);
+  rb_define_method(module, "min_area_rect", RUBY_METHOD_FUNC(rb_min_area_rect), 0);
+  rb_define_method(module, "min_enclosing_circle", RUBY_METHOD_FUNC(rb_min_enclosing_circle), 0);
+}
+
+VALUE
+rb_extend_object(VALUE self, VALUE object)
+{
+  CvSeq *seq = 0;
+  if(!rb_obj_is_kind_of(object, cCvSeq::rb_class()))
+    rb_raise(rb_eTypeError, "object is not %s.\n", rb_class2name(cCvSeq::rb_class()));
+  
+  if(!CV_IS_SEQ(seq))
+    rb_raise(rb_eTypeError, "object is not sequence.");  
+  return rb_call_super(1, &object);
+}
+
+/*
+ * call-seq:
+ *   contour_area -> float
+ *
+ * Calculates area of the whole contour or contour section.
+ * 
+ * note: Orientation of the contour affects the area sign, thus the method may return negative result.
+ */
+VALUE
+rb_contour_area(int argc, VALUE *argv, VALUE self)
+{
+  VALUE slice;
+  rb_scan_args(argc, argv, "01", &slice);
+  return rb_float_new(cvContourArea(CVARR(self), NIL_P(slice) ? CV_WHOLE_SEQ : VALUE_TO_CVSLICE(slice)));
+}
+
+/*
+ * call-seq:
+ *   fit_ellipse -> cvbox2d
+ *
+ * Return fits ellipse to set of 2D points.
+ */
+VALUE
+rb_fit_ellipse(VALUE self)
+{
+  return cCvBox2D::new_object(cvFitEllipse2(CVARR(self)));
+}
+
+/*
+ * call-seq:
+ *   convex_hull(<i>[reverse = fasle]</i>) -> cvcontour
+ *
+ * Finds convex hull of 2D point set using Sklansky's algorithm.
+ * 
+ * <i>reverse</i> is desired orientation of convex hull.
+ * If reverse is false mean clockwise, otherwise counter clockwise.
+ */
+VALUE
+rb_convex_hull(int argc, VALUE *argv, VALUE self)
+{
+  VALUE reverse, storage;
+  rb_scan_args(argc, argv, "01", &reverse);
+  storage = cCvMemStorage::new_object();
+  CvSeq *hull = cvConvexHull2(CVSEQ(self), CVMEMSTORAGE(storage), TRUE_OR_FALSE(reverse, 0) ? CV_COUNTER_CLOCKWISE : CV_CLOCKWISE, 1);
+  if(CV_IS_SEQ_HOLE(CVSEQ(self)))
+    hull->flags |= CV_SEQ_FLAG_HOLE;
+  return cCvSeq::new_sequence(cCvContour::rb_class(), hull, cCvPoint::rb_class(), storage);
+}
+
+/*
+ * call-seq:
+ *   check_contour_convexity -> true or false
+ *
+ * Tests whether the input contour is convex or not. The contour must be simple, i.e. without self-intersections.
+ */
+VALUE
+rb_check_contour_convexity(VALUE self)
+{
+  return cvCheckContourConvexity(CVARR(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   convexity_defects(<i>[reverse = false]</i>) -> cvseq(include CvConvexityDefect)
+ *
+ * Finds convexity defects of contour.
+ */
+VALUE
+rb_convexity_defects(int argc, VALUE *argv, VALUE self)
+{
+  VALUE reverse, storage;
+  rb_scan_args(argc, argv, "01", &reverse);
+  storage = cCvMemStorage::new_object();
+  CvSeq *hull, *convex;
+  hull = cvConvexHull2(CVSEQ(self), CVMEMSTORAGE(storage), TRUE_OR_FALSE(reverse, 0) ? CV_COUNTER_CLOCKWISE : CV_CLOCKWISE, 0);
+  convex = cvConvexityDefects(CVSEQ(self), hull, CVMEMSTORAGE(storage));
+  return cCvSeq::new_sequence(cCvSeq::rb_class(), convex, cCvConvexityDefect::rb_class(), storage);
+}
+
+/*
+ * call-seq:
+ *   min_area_rect -> cvbox2d
+ *
+ * Finds circumscribed rectangle of minimal area for given 2D point set.
+ */
+VALUE
+rb_min_area_rect(VALUE self)
+{
+  VALUE storage = cCvMemStorage::new_object();
+  return cCvBox2D::new_object(cvMinAreaRect2(CVARR(self), CVMEMSTORAGE(storage)));
+}
+
+/*
+ * call-seq:
+ *   min_enclosing_circle -> cvcircle32f
+ *
+ * Finds circumscribed circle of minimal area for given 2D point set.
+ */
+VALUE
+rb_min_enclosing_circle(VALUE self)
+{
+  VALUE circle = cCvCircle32f::rb_allocate(cCvCircle32f::rb_class());
+  cvMinEnclosingCircle(CVARR(self), &CVCIRCLE32F(circle)->center, &CVCIRCLE32F(circle)->radius);
+  return circle;
+}
+
+VALUE
+rb_calc_pgh(VALUE self)
+{
+  /* not yet */
+  return Qnil;
+}
+
+__NAMESPACE_END_POINT_SET
+
+int
+CVPOINTS_FROM_POINT_SET(VALUE object, CvPoint **pointset)
+{
+  VALUE storage;
+  CvSeq *seq = 0;
+  CvPoint2D32f p32;
+  if(rb_obj_is_kind_of(object, cCvSeq::rb_class())){
+    if(CV_IS_SEQ_POINT_SET(CVSEQ(object))){ 
+      *pointset = (CvPoint*)cvCvtSeqToArray(CVSEQ(object), cvAlloc(CVSEQ(object)->total * CVSEQ(object)->elem_size));
+      return CVSEQ(object)->total;
+    }else{
+      rb_raise(rb_eTypeError, "sequence is not contain %s or %s.", rb_class2name(cCvPoint::rb_class()), rb_class2name(cCvPoint2D32f::rb_class()));
+    }
+  }else if(rb_obj_is_kind_of(object, cCvMat::rb_class())){
+    /* to do */
+    rb_raise(rb_eNotImpError, "CvMat to CvSeq conversion not implemented.");
+  }else if(rb_obj_is_kind_of(object, rb_cArray)){
+    *pointset = (CvPoint*)cvAlloc(RARRAY(object)->len * sizeof(CvPoint));
+    for(int i = 0; i < RARRAY(object)->len; i++){
+      (*pointset)[i].x = NUM2INT(rb_funcall(rb_ary_entry(object, i), rb_intern("x"), 0));
+      (*pointset)[i].y = NUM2INT(rb_funcall(rb_ary_entry(object, i), rb_intern("y"), 0));
+    }
+    return RARRAY(object)->len;
+  }else{
+    rb_raise(rb_eTypeError, "Can't convert CvSeq(PointSet).");
+  }  
+}
+
+CvSeq*
+VALUE_TO_POINT_SET(VALUE object)
+{
+  CvSeq *seq = 0;
+  VALUE tmp, storage;
+  int length;
+  CvPoint2D32f p32;
+  if(rb_obj_is_kind_of(object, cCvSeq::rb_class())){
+    seq = CVSEQ(object);
+    if(CV_IS_SEQ_POINT_SET(seq)){
+      return seq;
+    }else{
+      rb_raise(rb_eTypeError, "sequence is not contain %s or %s.", rb_class2name(cCvPoint::rb_class()), rb_class2name(cCvPoint2D32f::rb_class()));
+    }
+  }else if(rb_obj_is_kind_of(object, cCvMat::rb_class())){
+    /* to do */
+    rb_raise(rb_eNotImpError, "CvMat to CvSeq conversion not implemented.");
+  }else if(rb_obj_is_kind_of(object, rb_cArray)){
+    //pointset = cCvSeq::new_sequence(cCvSeq::rb_class(), )
+    length = RARRAY(object)->len;
+    storage = cCvMemStorage::new_object();
+    seq = cvCreateSeq(CV_SEQ_POINT_SET, sizeof(CvSeq), sizeof(CvPoint), CVMEMSTORAGE(storage));    
+    for(int i = 0; i < RARRAY(object)->len; i++){
+      p32.x = NUM2DBL(rb_funcall(rb_ary_entry(object, i), rb_intern("x"), 0));
+      p32.y = NUM2DBL(rb_funcall(rb_ary_entry(object, i), rb_intern("y"), 0));
+      cvSeqPush(seq, &p32);
+    }
+    tmp = cCvSeq::new_sequence(cCvSeq::rb_class(), seq, cCvPoint2D32f::rb_class(), storage);
+    return seq;
+  }else{
+    rb_raise(rb_eTypeError, "Can't convert CvSeq(PointSet).");
+  }  
+}
+
+__NAMESPACE_END_OPENCV