opencv 0.0.6

data/ext/cvtermcriteria.cpp

@@ -0,0 +1,183 @@
+/************************************************************
+
+   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_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  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=");
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+}
+
+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;}
+  *CVTERMCRITERIA(self) = cvTermCriteria(type, IF_INT(max, 0), IF_DBL(eps, 0.0));
+  return self;
+}
+
+/*
+ * 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
+rb_to_ary(VALUE self)
+{
+  CvTermCriteria *ptr = CVTERMCRITERIA(self);
+  VALUE ary = rb_ary_new();
+  if (ptr->type & CV_TERMCRIT_ITER)
+    rb_ary_push(ary, INT2FIX(ptr->max_iter));
+  if (ptr->type & CV_TERMCRIT_EPS)
+    rb_ary_push(ary, rb_float_new(ptr->epsilon));
+  return ary;
+}
+
+VALUE
+new_object(CvTermCriteria criteria)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVTERMCRITERIA(object) = criteria;
+  return object;
+}
+
+__NAMESPACE_END_CVTERMCRITERIA
+__NAMESPACE_END_OPENCV

data/ext/cvtermcriteria.h

@@ -0,0 +1,71 @@
+/************************************************************
+
+   cvtermcriteria.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVTERMCRITERIA_H
+#define RUBY_OPENCV_CVTERMCRITERIA_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVTERMCRITERIA namespace cCvTermCriteria{
+#define __NAMESPACE_END_CVTERMCRITERIA }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVTERMCRITERIA
+
+VALUE rb_class();
+
+void define_ruby_class();    
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_max(VALUE self);
+VALUE rb_set_max(VALUE self, VALUE max_value);
+VALUE rb_eps(VALUE self);
+VALUE rb_set_eps(VALUE self, VALUE eps_value);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object(CvTermCriteria criteria);
+
+__NAMESPACE_END_CVTERMCRITERIA
+
+inline CvTermCriteria*
+CVTERMCRITERIA(VALUE object)
+{
+  CvTermCriteria *ptr;
+  Data_Get_Struct(object, CvTermCriteria, ptr);
+  return ptr;
+}
+
+inline CvTermCriteria
+VALUE_TO_CVTERMCRITERIA(VALUE object)
+{
+  if (rb_obj_is_kind_of(object, cCvTermCriteria::rb_class())) {
+    return *CVTERMCRITERIA(object);
+  }
+  switch (TYPE(object)) {
+  case T_NIL:
+    return cvTermCriteria(CV_TERMCRIT_ITER, 0, 0);
+  case T_FIXNUM:
+    return cvTermCriteria(CV_TERMCRIT_ITER, NUM2INT(object), 0);
+  case T_FLOAT:
+    return cvTermCriteria(CV_TERMCRIT_EPS, 0, NUM2DBL(object));
+  case T_ARRAY:
+    if (RARRAY(object)->len == 2) {
+      return cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,
+                            NUM2INT(rb_ary_entry(object, 0)),
+                            NUM2DBL(rb_ary_entry(object, 1)));
+    }
+  }
+  rb_raise(rb_eTypeError, "");
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVTERMCRITERIA_H

data/ext/cvtwopoints.cpp

@@ -0,0 +1,98 @@
+/************************************************************
+
+   cvtwopoints.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvtwopoints.h"
+/*
+ * Document-class: OpenCV::CvTwopoints
+ *
+ * This class means one twopoints on X axis Y axis. 
+ * X and Y takes the value of the Fixnum. see also CvTwopoints2D32F
+ * 
+ * C structure is here, very simple.
+ *   typdef struct CvTwopoints{
+ *     int x;
+ *     int y;
+ *   }
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVTWOPOINTS
+
+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, "CvTwoPoints", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "point1", RUBY_METHOD_FUNC(rb_point1), 0);
+  rb_define_method(rb_klass, "point2", RUBY_METHOD_FUNC(rb_point2), 0);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvTwoPoints *ptr;
+  return Data_Make_Struct(klass, CvTwoPoints, 0, -1, ptr);
+}
+
+VALUE
+rb_cvseqblock(VALUE self)
+{
+  return Qnil;
+}
+
+
+/*
+ * Return point 1.
+ */
+VALUE
+rb_point1(VALUE self)
+{
+  return cCvPoint::new_object(CVTWOPOINTS(self)->p1);
+}
+
+/*
+ * Return point2.
+ */
+VALUE
+rb_point2(VALUE self)
+{
+  return cCvPoint::new_object(CVTWOPOINTS(self)->p2);
+}
+
+/*
+ * call-seq:
+ *   to_ary -> [self.point1, self.point2]
+ *
+ * Return 2 point by Array.
+ */
+VALUE
+rb_to_ary(VALUE self)
+{
+  return rb_ary_new3(2, rb_point1(self), rb_point2(self));
+}
+
+__NAMESPACE_END_CVTWOPOINTS
+__NAMESPACE_END_OPENCV

data/ext/cvtwopoints.h

@@ -0,0 +1,50 @@
+/************************************************************
+
+   cvtwopoints.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVTWOPOINTS_H
+#define RUBY_OPENCV_CVTWOPOINTS_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVTWOPOINTS namespace cCvTwoPoints{
+#define __NAMESPACE_END_CVTWOPOINTS }
+
+__NAMESPACE_BEGIN_OPENCV
+
+typedef struct CvTwoPoints{
+  CvPoint p1;
+  CvPoint p2;
+} CvTwoPoints;
+
+__NAMESPACE_BEGIN_CVTWOPOINTS
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+
+VALUE rb_point1(VALUE self);
+VALUE rb_point2(VALUE self);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object(CvTwoPoints twopoints);
+
+__NAMESPACE_END_CVTWOPOINTS
+
+inline CvTwoPoints*
+CVTWOPOINTS(VALUE object){
+  CvTwoPoints *ptr;
+  Data_Get_Struct(object, CvTwoPoints, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVTWOPOINTS_H

data/ext/cvvector.cpp

@@ -0,0 +1,206 @@
+/************************************************************
+
+   cvvector.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvvector.h"
+/*
+ * Document-class: OpenCV::CvVector
+ *
+ * 2D vector (X axis and Y axis) 
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVVECTOR
+
+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, "CvVector", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "compatible?", RUBY_METHOD_FUNC(rb_compatible_q), 1);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "x", RUBY_METHOD_FUNC(rb_x), 0);
+  rb_define_method(rb_klass, "x=", RUBY_METHOD_FUNC(rb_set_x), 1);
+  rb_define_method(rb_klass, "y", RUBY_METHOD_FUNC(rb_y), 0);
+  rb_define_method(rb_klass, "y=", RUBY_METHOD_FUNC(rb_set_y), 1);
+
+  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);
+}
+
+/*
+ * call-seq:
+ *   combatible?(obj)
+ *
+ * Return compatibility to CvVector. Return true if object have method #x and #y.
+ *
+ * For example.
+ *   class MyVector
+ *     def x
+ *       1.0
+ *     end
+ *     def y
+ *       2.0
+ *     end
+ *   end
+ *   mv = MyVector.new
+ *   CvVector.compatible?(mv)  #=> true
+ *   CvVector.new(mv)          #=> same as CvVector(1.0, 2.0)
+ */
+VALUE
+rb_compatible_q(VALUE klass, VALUE object)
+{
+  return (rb_respond_to(object, rb_intern("x")) && rb_respond_to(object, rb_intern("y"))) ? Qtrue : Qfalse;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvVector *ptr;
+  return Data_Make_Struct(klass, CvVector, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new -> CvVector.new(0.0, 0.0)
+ *   new(obj) -> CvVector.new(obj.x.to_f, obj.y.to_f)
+ *   new(x, y)
+ *
+ * Create new 2D-vector, (x, y).
+ *
+ * new() is same as new(0, 0)
+ *
+ * new(obj) is same as new(obj.x.to_f, obj.y.to_f)
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE obj, x, y;
+  switch (argc) {
+  case 0:
+    break;
+  case 1:
+    obj = argv[0];
+    if (rb_compatible_q(rb_klass, obj)) {
+      CVVECTOR(self)->x = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("x"), 0), rb_intern("to_i"), 0));
+      CVVECTOR(self)->y = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("y"), 0), rb_intern("to_i"), 0));
+    }else{
+      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
+    }
+    break;
+  case 2:
+    x = argv[0], y = argv[1];
+    CVVECTOR(self)->x = NUM2INT(x);
+    CVVECTOR(self)->y = NUM2INT(y);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+  }
+  return Qnil;    
+}
+
+/*
+ * Return parameter on vector of x-axis.
+ */
+VALUE
+rb_x(VALUE self)
+{
+  return INT2FIX(CVVECTOR(self)->x);
+}
+
+/*
+ * call-seq:
+ *   x = val
+ *
+ * Set vector of x-axis, return self.
+ */
+VALUE
+rb_set_x(VALUE self, VALUE x)
+{
+  CVVECTOR(self)->x = NUM2INT(x);
+  return self;
+}
+
+/*
+ * Return parameter on vector of y-axis.
+ */
+VALUE
+rb_y(VALUE self)
+{
+  return INT2FIX(CVVECTOR(self)->y);
+}
+
+/*
+ * call-seq:
+ *   y = val
+ *
+ * Set vector of y-axis, return self.
+ */
+VALUE
+rb_set_y(VALUE self, VALUE y)
+{
+  CVVECTOR(self)->y = NUM2INT(y);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   to_s -> "<OpenCV::CvVector:(self.x,self.y)>"
+ *
+ * Return x and y by String.
+ */
+VALUE
+rb_to_s(VALUE self)
+{
+  const int i = 4;
+  VALUE str[i];
+  str[0] = rb_str_new2("<%s:(%d,%d)>");
+  str[1] = rb_str_new2(rb_class2name(CLASS_OF(self)));
+  str[2] = rb_x(self);
+  str[3] = rb_y(self);
+  return rb_f_sprintf(i, str);
+}
+
+/*
+ * call-seq:
+ *   to_ary -> [x, y]
+ *
+ * Return x and y by Array.
+ */
+VALUE
+rb_to_ary(VALUE self)
+{
+  return rb_ary_new3(2, rb_x(self), rb_y(self));
+}
+
+VALUE
+new_object(CvVector point)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVVECTOR(object) = point;
+  return object;
+}
+
+__NAMESPACE_END_CVVECTOR
+__NAMESPACE_END_OPENCV