bantic-ruby-opencv 0.0.8

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

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

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

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

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

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