opencv 0.0.6

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

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

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