bonanza-ruby-opencv 0.0.13.20140330211753

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 init_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
+ */
+__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;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, mark_root_object, unregister_object, NULL);
+}
+
+/*
+ * Create a new chain code
+ * @overload new(storage=nil)
+ *   @param storage [CvMemStorage,nil] Sequence location (If storage is nil, allocates a new storage automatically)
+ * @return [CvChain] New CvChain instance
+ * @opencv_func cvCreateSeq (seq_flags=CV_SEQ_ELTYPE_CODE)
+ */
+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;
+}
+
+/*
+ * Returns Freeman chain code origin
+ * @overload origin
+ * @return [CvPoint] Origin of the chain code
+ */
+VALUE
+rb_origin(VALUE self)
+{
+  return cCvPoint::new_object(CVCHAIN(self)->origin);
+}
+
+/*
+ * Set Freeman chain code origin
+ * @overload origin=value
+ *   @param value [CvPoint] Origin of the chain code
+ * @return [CvChain] self
+ */
+VALUE
+rb_set_origin(VALUE self, VALUE origin)
+{
+  CVCHAIN(self)->origin = VALUE_TO_CVPOINT(origin);  
+  return self;
+}
+
+/*
+ * Returns the chain codes
+ * @overload codes
+ * @return [Array<Fixnum>] Chain codes
+ * @opencv_func cvStartReadChainPoints
+ * @opencv_func CV_READ_SEQ_ELEM
+ */
+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;
+}
+
+/*
+ * Returns the points of the chain codes
+ * @overload points
+ * @return [Array<CvPoint>] Points of the chain codes
+ * @opencv_func cvStartReadChainPoints
+ * @opencv_func CV_READ_CHAIN_POINT
+ */
+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;
+}
+
+/*
+ * Approximates Freeman chains with a polygonal curve
+ * @overload approx_chain(options)
+ *   @param options [Hash] Parameters
+ *   @option options [Symbol] :method Approximation method (see the description of CvMat#find_contours)
+ *   @option options [Number] :minimal_perimeter Approximates only those contours whose perimeters
+ *     are not less than minimal_perimeter. Other chains are removed from the resulting structure.
+ *   @option options [Boolean] :recursive Recursion flag. If it is true, the function approximates
+ *     all chains that can be obtained from chain by using the h_next or v_next links.
+ *     Otherwise, the single input chain is approximated.
+ * @return [CvSeq<CvPoint>] Polygonal curve
+ * @opencv_func cvApproxChains
+ */
+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);
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+  VALUE cvseq = rb_define_class_under(opencv, "CvSeq");
+  VALUE curve = rb_define_module_under(opencv, "Curve");
+#endif
+
+  if (rb_klass)
+    return;
+
+  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_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");
+}
+
+__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 init_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,126 @@
+/************************************************************
+
+   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;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvCircle32f *ptr;
+  return Data_Make_Struct(klass, CvCircle32f, 0, -1, ptr);
+}
+
+/*
+ * Returns center point of the circle
+ * @overload center
+ * @return [CvPoint2D32f] Center point of the circle
+ */
+VALUE
+rb_center(VALUE self)
+{
+  return cCvPoint2D32f::new_object(CVCIRCLE32F(self)->center);
+}
+
+/*
+ * Returns radius of the circle
+ * @overload radius
+ * @return [Number] Radius of the circle
+ */
+VALUE
+rb_radius(VALUE self)
+{
+  return rb_float_new(CVCIRCLE32F(self)->radius);
+}
+
+/*
+ * Accesses to parameters of the circle by array-like interface ([X-coordinate, Y-coordinate, radius])
+ * @overload []
+ *   @param index [Integer] Index
+ * @return [Number] X-coordinate, Y-coordinate or radius of the circle
+ */
+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;
+}
+
+/*
+ * Returns parameters of the circle as an array which contains [center<CvPoint2D32f>, radius<Number>]
+ * @overload to_ary
+ * @return [Array<CvPoint2D32f,Number>] An array which contains [center, 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;
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+#endif
+
+  if (rb_klass)
+    return;
+
+  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");
+}
+
+__NAMESPACE_END_CVCIRCLE32F
+__NAMESPACE_END_OPENCV