ruby-opencv 0.0.8.pre

data/ext/opencv/cvsurfparams.h

@@ -0,0 +1,58 @@
+/************************************************************
+
+   cvsurfparams.h -
+
+   $Author: ser1zw $
+
+   Copyright (C) 2011 ser1zw
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSURFPARAMS_H
+#define RUBY_OPENCV_CVSURFPARAMS_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSURFPARAMS namespace cCvSURFParams {
+#define __NAMESPACE_END_CVSURFPARAMS }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSURFPARAMS
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_get_hessian_threshold(VALUE self);
+VALUE rb_set_hessian_threshold(VALUE self, VALUE value);
+VALUE rb_get_extended(VALUE self);
+VALUE rb_set_extended(VALUE self, VALUE value);
+VALUE rb_get_n_octaves(VALUE self);
+VALUE rb_set_n_octaves(VALUE self, VALUE value);
+VALUE rb_get_n_octave_layers(VALUE self);
+VALUE rb_set_n_octave_layers(VALUE self, VALUE value);
+
+VALUE new_object(CvSURFPoint *cvsurfparams);
+
+__NAMESPACE_END_CVSURFPARAMS
+
+inline CvSURFParams*
+CVSURFPARAMS(VALUE object)
+{
+  CvSURFParams* ptr;
+  Data_Get_Struct(object, CvSURFParams, ptr);
+  return ptr;
+}
+
+inline CvSURFParams*
+CVSURFPARAMS_WITH_CHECK(VALUE object)
+{
+  if (!rb_obj_is_kind_of(object, cCvSURFParams::rb_class()))
+    raise_typeerror(object, cCvSURFParams::rb_class());
+  return CVSURFPARAMS(object);
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSURFPARAMS_H

data/ext/opencv/cvsurfpoint.cpp

@@ -0,0 +1,223 @@
+/************************************************************
+
+   cvsurfpoint.cpp -
+
+   $Author: ser1zw $
+
+   Copyright (C) 2011 ser1zw
+
+************************************************************/
+#include "cvsurfpoint.h"
+/*
+ * Document-class: OpenCV::CvSURFPoint
+ *
+ * C structure is here.
+ *   typedef struct CvSURFPoint {
+ *     CvPoint2D32f pt; // position of the feature within the image
+ *     int laplacian;   // -1, 0 or +1. sign of the laplacian at the point.
+ *                      // can be used to speedup feature comparison
+ *                      // (normally features with laplacians of different
+ *                      // signs can not match)
+ *     int size;        // size of the feature
+ *     float dir;       // orientation of the feature: 0..360 degrees
+ *     float hessian;   // value of the hessian (can be used to
+ *                      // approximately estimate the feature strengths)
+ *   } CvSURFPoint;
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSURFPOINT
+
+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, "CvSURFPoint", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), 5);
+  rb_define_method(rb_klass, "pt", RUBY_METHOD_FUNC(rb_get_pt), 0);
+  rb_define_method(rb_klass, "pt=", RUBY_METHOD_FUNC(rb_set_pt), 1);
+  rb_define_method(rb_klass, "laplacian", RUBY_METHOD_FUNC(rb_get_laplacian), 0);
+  rb_define_method(rb_klass, "laplacian=", RUBY_METHOD_FUNC(rb_set_laplacian), 1);
+  rb_define_method(rb_klass, "size", RUBY_METHOD_FUNC(rb_get_size), 0);
+  rb_define_method(rb_klass, "size=", RUBY_METHOD_FUNC(rb_set_size), 1);
+  rb_define_method(rb_klass, "dir", RUBY_METHOD_FUNC(rb_get_dir), 0);
+  rb_define_method(rb_klass, "dir=", RUBY_METHOD_FUNC(rb_set_dir), 1);
+  rb_define_method(rb_klass, "hessian", RUBY_METHOD_FUNC(rb_get_hessian), 0);
+  rb_define_method(rb_klass, "hessian=", RUBY_METHOD_FUNC(rb_set_hessian), 1);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvSURFPoint *ptr;
+  return Data_Make_Struct(klass, CvSURFPoint, 0, -1, ptr);
+}
+
+/* 
+ * call-seq:
+ *   CvSURFPoint.new(<i>pt,laplacian,size,dir,hessian</i>) -> cvsurfpoint
+ *
+ * Create a CvSURFPoint
+ */
+VALUE
+rb_initialize(VALUE self, VALUE pt, VALUE laplacian, VALUE size, VALUE dir, VALUE hessian)
+{
+  CvSURFPoint *self_ptr = CVSURFPOINT(self);
+  self_ptr->pt = VALUE_TO_CVPOINT2D32F(pt);
+  self_ptr->laplacian = NUM2INT(laplacian);
+  self_ptr->size = NUM2INT(size);
+  self_ptr->dir = (float)NUM2DBL(dir);
+  self_ptr->hessian = (float)NUM2DBL(hessian);
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *   pt -> cvpoint2d32f
+ * Return position of the feature as CvPoint2D32f.
+ */
+VALUE
+rb_get_pt(VALUE self)
+{
+  return REFER_OBJECT(cCvPoint2D32f::rb_class(), &CVSURFPOINT(self)->pt, self);
+}
+
+/*
+ * call-seq:
+ *   pt = <i>value</i>
+ *
+ * Set position of the feature to <i>value</i>
+ */
+VALUE
+rb_set_pt(VALUE self, VALUE value)
+{
+  CVSURFPOINT(self)->pt = VALUE_TO_CVPOINT2D32F(value);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   laplacian -> number
+ * Return sign of the laplacian at the point (-1, 0 or +1)
+ */
+VALUE
+rb_get_laplacian(VALUE self)
+{
+  return INT2NUM(CVSURFPOINT(self)->laplacian);
+}
+
+/*
+ * call-seq:
+ *   laplacian = <i>value</i> (-1, 0 or +1)
+ * Set sign of the laplacian at the point
+ */
+VALUE
+rb_set_laplacian(VALUE self, VALUE value)
+{
+  int val = NUM2INT(value);
+  CVSURFPOINT(self)->laplacian = (val > 0) ? 1 : (val < 0) ? -1 : 0;
+  return self;
+}
+
+/*
+ * call-seq:
+ *   size -> number
+ * Return size of feature
+ */
+VALUE
+rb_get_size(VALUE self)
+{
+  return INT2NUM(CVSURFPOINT(self)->size);
+}
+
+/*
+ * call-seq:
+ *   size = <i>value</i>
+ * Return size of feature
+ */
+VALUE
+rb_set_size(VALUE self, VALUE value)
+{
+  CVSURFPOINT(self)->size = NUM2INT(value);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   dir -> number
+ * Return orientation of the feature: 0..360 degrees
+ */
+VALUE
+rb_get_dir(VALUE self)
+{
+  return DBL2NUM((double)(CVSURFPOINT(self)->dir));
+}
+
+/*
+ * call-seq:
+ *   dir = <i>value</i>
+ * Set orientation of the feature: 0..360 degrees
+ */
+VALUE
+rb_set_dir(VALUE self, VALUE value)
+{
+  CVSURFPOINT(self)->dir = (float)NUM2DBL(value);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   hessian -> number
+ * Return value of the hessian
+ */
+VALUE
+rb_get_hessian(VALUE self)
+{
+  return DBL2NUM((double)(CVSURFPOINT(self)->hessian));
+}
+
+/*
+ * call-seq:
+ *   hessian = <i>value</i>
+ * Set value of the hessian
+ */
+VALUE
+rb_set_hessian(VALUE self, VALUE value)
+{
+  CVSURFPOINT(self)->hessian = (float)NUM2DBL(value);
+  return self;
+}
+
+VALUE
+new_object()
+{
+  return rb_allocate(rb_klass);
+}
+
+VALUE
+new_object(CvSURFPoint* cvsurfpoint)
+{
+  VALUE object = rb_allocate(rb_klass);
+  CvSURFPoint *ptr = CVSURFPOINT(object);
+  ptr = cvsurfpoint;
+  return object;
+}
+
+__NAMESPACE_END_CVSURFPOINT
+__NAMESPACE_END_OPENCV

data/ext/opencv/cvsurfpoint.h

@@ -0,0 +1,52 @@
+/************************************************************
+
+   cvsurfpoint.h -
+
+   $Author: ser1zw $
+
+   Copyright (C) 2011 ser1zw
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSURFPOINT_H
+#define RUBY_OPENCV_CVSURFPOINT_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSURFPOINT namespace cCvSURFPoint {
+#define __NAMESPACE_END_CVSURFPOINT }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSURFPOINT
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(VALUE self, VALUE pt, VALUE laplacian, VALUE size, VALUE dir, VALUE hessian);
+VALUE rb_get_pt(VALUE self);
+VALUE rb_set_pt(VALUE self, VALUE value);
+VALUE rb_get_laplacian(VALUE self);
+VALUE rb_set_laplacian(VALUE self, VALUE value);
+VALUE rb_get_size(VALUE self);
+VALUE rb_set_size(VALUE self, VALUE value);
+VALUE rb_get_dir(VALUE self);
+VALUE rb_set_dir(VALUE self, VALUE value);
+VALUE rb_get_hessian(VALUE self);
+VALUE rb_set_hessian(VALUE self, VALUE value);
+
+VALUE new_object(CvSURFPoint *cvsurfpoint);
+
+__NAMESPACE_END_CVSURFPOINT
+
+inline CvSURFPoint*
+CVSURFPOINT(VALUE object)
+{
+  CvSURFPoint* ptr;
+  Data_Get_Struct(object, CvSURFPoint, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSURFPOINT_H

data/ext/opencv/cvtermcriteria.cpp

@@ -0,0 +1,192 @@
+/************************************************************
+
+   cvtermcriteria.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvtermcriteria.h"
+/*
+ * Document-class: OpenCV::CvTermCriteria
+ *
+ * CvTermCriteria has parameter "max" and "eps".
+ * "max" is the maximum repetition frequency.
+ * "eps" is a minimum difference value during current and previous state
+ * (It is different to which state "eps" refer depending on the method).
+ *
+ * Because the name of CvTermCriteria seems to be very long, it has alias named CvTerm.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVTERMCRITERIA
+
+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, "CvTermCriteria", rb_cObject);
+  /* CvTermCriteria: class */
+  rb_define_const(opencv, "CvTerm", rb_klass);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "type", RUBY_METHOD_FUNC(rb_type), 0);
+  rb_define_method(rb_klass, "max", RUBY_METHOD_FUNC(rb_max), 0);
+  rb_define_method(rb_klass, "max=", RUBY_METHOD_FUNC(rb_set_max), 1);
+  rb_define_method(rb_klass, "eps", RUBY_METHOD_FUNC(rb_eps), 0);
+  rb_define_method(rb_klass, "eps=", RUBY_METHOD_FUNC(rb_set_eps), 1);
+  rb_define_alias(rb_klass, "epsilon", "eps");
+  rb_define_alias(rb_klass, "epsilon=", "eps=");
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvTermCriteria *ptr;
+  return Data_Make_Struct(klass, CvTermCriteria, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   CvTermCriteria.new([max = 0][,eps = 0.0]) -> obj
+ *   CvTermCriteria.new(int) = CvTermCriteria.new(int, 0.0)
+ *   CvTermCriteria.new(float) = CvTermCriteria.new(0, float)
+ *
+ * Create new term criteria.
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE max, eps;
+  rb_scan_args(argc, argv, "02", &max, &eps);
+  int type = 0;
+  if (!NIL_P(max))
+    type |= CV_TERMCRIT_ITER;
+  if (!NIL_P(eps))
+    type |= CV_TERMCRIT_EPS;
+  try {
+    *CVTERMCRITERIA(self) = cvTermCriteria(type, IF_INT(max, 0), IF_DBL(eps, 0.0));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return self;
+}
+
+/*
+ * call-seq:
+ *   type -> int
+ *
+ * Return a combination of CV_TERMCRIT_ITER and CV_TERMCRIT_EPS
+ */
+VALUE
+rb_type(VALUE self)
+{
+  return INT2NUM(CVTERMCRITERIA(self)->type);
+}
+
+/*
+ * call-seq:
+ *   max -> int or nil
+ *
+ * Return the maximum repetition frequency.
+ */
+VALUE
+rb_max(VALUE self)
+{
+  CvTermCriteria *ptr = CVTERMCRITERIA(self);
+  if (ptr->type & CV_TERMCRIT_ITER)
+    return INT2NUM(ptr->max_iter);
+  else
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   max = <i>val</i> -> self
+ *
+ * Set the maximum repetition frequency.
+ * If <i>val</i> is 0 (or negative value), repetition frequency is disregarded.
+ */
+VALUE
+rb_set_max(VALUE self, VALUE max_value)
+{
+  CvTermCriteria *ptr = CVTERMCRITERIA(self);
+  int max = NUM2INT(max_value);
+  if (max > 0) {
+    ptr->type |= CV_TERMCRIT_ITER;
+    ptr->max_iter = max;
+  }
+  else {
+    ptr->type ^= CV_TERMCRIT_ITER;
+    ptr->max_iter = 0;
+  }
+  return self;
+}
+
+/*
+ * call-seq:
+ *   eps -> float or nil
+ *
+ * Return the minimum difference value during current and previous state.
+ */
+VALUE
+rb_eps(VALUE self)
+{
+  CvTermCriteria *ptr = CVTERMCRITERIA(self);
+  if (ptr->type & CV_TERMCRIT_EPS)
+    return rb_float_new(ptr->epsilon);
+  else
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   eps = <i>val</i> -> self
+ *
+ * Set the minimum difference value during current and previous state.
+ * If <i>val</i> is 0.0 (or negative value), the minimum difference value
+ * during current and previous state is disregarded.
+ */
+VALUE
+rb_set_eps(VALUE self, VALUE eps_value)
+{
+  CvTermCriteria *ptr = CVTERMCRITERIA(self);
+  double eps = NUM2DBL(eps_value);
+  if (eps > 0) {
+    ptr->type = ptr->type | CV_TERMCRIT_EPS;
+    ptr->epsilon = eps;
+  }
+  else {
+    ptr->type = ptr->type ^ CV_TERMCRIT_EPS;
+    ptr->epsilon = 0;
+  }
+  return self;
+}
+
+VALUE
+new_object(CvTermCriteria criteria)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVTERMCRITERIA(object) = criteria;
+  return object;
+}
+
+__NAMESPACE_END_CVTERMCRITERIA
+__NAMESPACE_END_OPENCV