ruby-opencv 0.0.8.pre

data/ext/opencv/cvcapture.h

@@ -0,0 +1,72 @@
+/************************************************************
+
+   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 cvcapture_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_get_millisecond(VALUE self);
+VALUE rb_set_millisecond(VALUE self, VALUE value);
+VALUE rb_get_frames(VALUE self);
+VALUE rb_set_frames(VALUE self, VALUE value);
+VALUE rb_get_avi_ratio(VALUE self);
+VALUE rb_set_avi_ratio(VALUE self, VALUE value);
+VALUE rb_get_size(VALUE self);
+VALUE rb_set_size(VALUE self, VALUE value);
+VALUE rb_get_width(VALUE self);
+VALUE rb_set_width(VALUE self, VALUE value);
+VALUE rb_get_height(VALUE self);
+VALUE rb_set_height(VALUE self, VALUE value);
+VALUE rb_get_fps(VALUE self);
+VALUE rb_set_fps(VALUE self, VALUE value);
+VALUE rb_get_fourcc(VALUE self);
+VALUE rb_get_frame_count(VALUE self);
+VALUE rb_get_format(VALUE self);
+VALUE rb_get_mode(VALUE self);
+VALUE rb_get_brightness(VALUE self);
+VALUE rb_get_contrast(VALUE self);
+VALUE rb_get_saturation(VALUE self);
+VALUE rb_get_hue(VALUE self);
+VALUE rb_get_gain(VALUE self);
+VALUE rb_get_exposure(VALUE self);
+VALUE rb_get_convert_rgb(VALUE self);
+VALUE rb_get_rectification(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

data/ext/opencv/cvchain.cpp

@@ -0,0 +1,233 @@
+/************************************************************
+
+   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) rb_get_option_table(rb_klass, "APPROX_CHAIN_OPTION", op)
+#define APPROX_CHAIN_METHOD(op) CVMETHOD("APPROX_CHAIN_METHOD", LOOKUP_HASH(op, "method"), CV_CHAIN_APPROX_SIMPLE)
+#define APPROX_CHAIN_PARAMETER(op) NUM2INT(LOOKUP_HASH(op, "parameter"))
+#define APPROX_CHAIN_MINIMAL_PERIMETER(op) NUM2INT(LOOKUP_HASH(op, "minimal_perimeter"))
+#define APPROX_CHAIN_RECURSIVE(op) TRUE_OR_FALSE(LOOKUP_HASH(op, "recursive"))
+
+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_perimeter")), INT2FIX(0));
+  rb_hash_aset(approx_chain_option, ID2SYM(rb_intern("recursive")), Qfalse);
+
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "origin", RUBY_METHOD_FUNC(rb_origin), 0);
+  rb_define_method(rb_klass, "origin=", RUBY_METHOD_FUNC(rb_set_origin), 1);
+  rb_define_method(rb_klass, "codes", RUBY_METHOD_FUNC(rb_codes), 0);
+  rb_define_method(rb_klass, "points", RUBY_METHOD_FUNC(rb_points), 0);
+  rb_define_method(rb_klass, "approx_chains", RUBY_METHOD_FUNC(rb_approx_chains), -1);
+  rb_define_alias(rb_klass, "approx", "approx_chains");
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, mark_root_object, unregister_object, NULL);
+}
+
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  CvMemStorage *storage;
+  VALUE storage_value;
+  if (rb_scan_args(argc, argv, "01", &storage_value) > 0) {
+    storage_value = CHECK_CVMEMSTORAGE(storage_value);
+    storage = CVMEMSTORAGE(storage_value);
+  }
+  else
+    storage = rb_cvCreateMemStorage(0);
+  try {
+    DATA_PTR(self) = (CvChain*)cvCreateSeq(CV_SEQ_ELTYPE_CODE, sizeof(CvChain),
+					   sizeof(int), storage);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  CvSeq* self_ptr = CVSEQ(self);
+  cCvSeq::register_elem_class(self_ptr, rb_cFixnum);
+  register_root_object(self_ptr, storage_value);
+
+  return self;
+}
+
+/*
+ * 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;
+  int total = chain->total;
+  VALUE ary = rb_ary_new2(total);
+  try {
+    cvStartReadChainPoints(chain, &reader);
+    for (int i = 0; i < total; ++i) {
+      CV_READ_SEQ_ELEM(reader.code, (*((CvSeqReader*)&(reader))));
+      rb_ary_store(ary, i, INT2FIX(reader.code));
+    }
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  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;
+  int total = chain->total;
+  VALUE ary = rb_ary_new2(total);
+  try {
+    cvStartReadChainPoints(chain, &reader);
+    for (int i = 0; i < total; ++i) {
+      CV_READ_CHAIN_POINT(p, reader);
+      rb_ary_store(ary, i, cCvPoint::new_object(p));
+    }
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   approx_chains(<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_chains(int argc, VALUE *argv, VALUE self)
+{
+  VALUE approx_chain_option;
+  rb_scan_args(argc, argv, "01", &approx_chain_option);
+
+  approx_chain_option = APPROX_CHAIN_OPTION(approx_chain_option);
+  VALUE 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_PERIMETER(approx_chain_option),
+			      APPROX_CHAIN_RECURSIVE(approx_chain_option));
+
+  if (seq && seq->total > 0) {
+    return cCvSeq::new_sequence(cCvChain::rb_class(), seq, cCvPoint::rb_class(), storage);
+  }
+  return Qnil;
+}
+
+VALUE
+new_object()
+{
+  VALUE storage = cCvMemStorage::new_object();
+  CvSeq *seq = NULL;
+  try {
+    seq = cvCreateSeq(CV_SEQ_CHAIN_CONTOUR, sizeof(CvChain), sizeof(int), CVMEMSTORAGE(storage));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return cCvSeq::new_sequence(cCvChain::rb_class(), seq, T_FIXNUM, storage);
+}
+
+__NAMESPACE_END_CVCHAIN
+__NAMESPACE_END_OPENCV

data/ext/opencv/cvchain.h

@@ -0,0 +1,46 @@
+/************************************************************
+
+  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_allocate(VALUE klass);
+
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_origin(VALUE self);
+VALUE rb_set_origin(VALUE self, VALUE origin);
+VALUE rb_codes(VALUE self);
+VALUE rb_points(VALUE self);
+VALUE rb_approx_chains(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

data/ext/opencv/cvcircle32f.cpp

@@ -0,0 +1,116 @@
+/************************************************************
+
+   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, "[]", RUBY_METHOD_FUNC(rb_aref), 1);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+  rb_define_alias(rb_klass, "to_a", "to_ary");
+}
+
+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);
+}
+
+/*
+ * call-seq:
+ *   [<i>index</i>]
+ *
+ * Return value of <i>index</i> dimension.
+ */
+VALUE
+rb_aref(VALUE self, VALUE index)
+{
+  switch (NUM2INT(index)) {
+  case 0:
+    return DBL2NUM(CVCIRCLE32F(self)->center.x);
+    break;
+  case 1:
+    return DBL2NUM(CVCIRCLE32F(self)->center.y);
+    break;
+  case 2:
+    return DBL2NUM(CVCIRCLE32F(self)->radius);
+    break;
+  default:
+    rb_raise(rb_eIndexError, "index should be 0...3");
+    break;
+  }
+  return Qnil;
+}
+
+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