jf-ruby-opencv 0.0.18

data/ext/opencv/cvsize2d32f.h

@@ -0,0 +1,64 @@
+/************************************************************
+
+   cvsize2d32f.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSIZE2D32F_H
+#define RUBY_OPENCV_CVSIZE2D32F_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSIZE2D32F namespace cCvSize2D32f {
+#define __NAMESPACE_END_CVSIZE2D32F }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSIZE2D32F
+
+VALUE rb_class();
+
+void init_ruby_class();
+
+VALUE rb_compatible_q(VALUE klass, VALUE object);
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_width(VALUE self);
+VALUE rb_set_width(VALUE self, VALUE width);
+VALUE rb_height(VALUE self);
+VALUE rb_set_height(VALUE self, VALUE height);
+
+VALUE rb_to_s(VALUE self);
+VALUE rb_to_ary(VALUE self);
+
+VALUE new_object(CvSize2D32f size);
+
+__NAMESPACE_END_CVSIZE2D32F
+
+inline CvSize2D32f*
+CVSIZE2D32F(VALUE object)
+{
+  CvSize2D32f *ptr;
+  Data_Get_Struct(object, CvSize2D32f, ptr);
+  return ptr;
+}
+
+inline CvSize2D32f
+VALUE_TO_CVSIZE2D32F(VALUE object)
+{
+  if (cCvSize2D32f::rb_compatible_q(cCvSize2D32f::rb_class(), object)) {
+    return cvSize2D32f(NUM2DBL(rb_funcall(object, rb_intern("width"), 0)),
+                       NUM2DBL(rb_funcall(object, rb_intern("height"), 0)));
+  }
+  else {
+    raise_compatible_typeerror(object, cCvSize2D32f::rb_class());
+  }
+  throw "Should never reach here";
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSIZE2D32F_H

data/ext/opencv/cvslice.cpp

@@ -0,0 +1,126 @@
+/************************************************************
+
+   cvslice.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvslice.h"
+/*
+ * Document-class: OpenCV::CvSlice
+ *
+ * C structure is here, very simple.
+ *   typdef struct CvSlice {
+ *     int start_index;
+ *     int end_index;
+ *   } CvSlice;
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSLICE
+
+VALUE rb_klass;
+    
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvSlice *ptr;
+  return Data_Make_Struct(klass, CvSlice, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new(start, end)
+ *
+ * Create new slice object.
+ */
+VALUE
+rb_initialize(VALUE self, VALUE start, VALUE end)
+{
+  CvSlice *self_ptr = CVSLICE(self);
+  self_ptr->start_index = NUM2INT(start);
+  self_ptr->end_index = NUM2INT(end);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   start_index
+ *
+ */
+VALUE
+rb_start_index_aref(VALUE self)
+{
+  return INT2NUM(CVSLICE(self)->start_index);
+}
+
+/*
+ * call-seq:
+ *   end_index
+ *
+ */
+VALUE
+rb_end_index_aref(VALUE self)
+{
+  return INT2NUM(CVSLICE(self)->end_index);
+}
+
+/*
+ * call-seq:
+ *   start_index = index
+ *
+ */
+VALUE
+rb_start_index_aset(VALUE self, VALUE index)
+{
+  CVSLICE(self)->start_index = NUM2INT(index);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   end_index = index
+ *
+ */
+VALUE
+rb_end_index_aset(VALUE self, VALUE index)
+{
+  CVSLICE(self)->end_index = NUM2INT(index);
+  return self;
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+#endif
+
+  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, "CvSlice", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), 2);
+  rb_define_method(rb_klass, "start_index", RUBY_METHOD_FUNC(rb_start_index_aref), 0);
+  rb_define_method(rb_klass, "end_index", RUBY_METHOD_FUNC(rb_end_index_aref), 0);
+  rb_define_method(rb_klass, "start_index=", RUBY_METHOD_FUNC(rb_start_index_aset), 1);
+  rb_define_method(rb_klass, "end_index=", RUBY_METHOD_FUNC(rb_end_index_aset), 1);
+}
+
+__NAMESPACE_END_CVSLICE
+__NAMESPACE_END_OPENCV
+

data/ext/opencv/cvslice.h

@@ -0,0 +1,61 @@
+/************************************************************
+
+   cvslice.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSLICE_H
+#define RUBY_OPENCV_CVSLICE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVSLICE namespace cCvSlice {
+#define __NAMESPACE_END_CVSLICE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSLICE
+
+VALUE rb_class();
+
+void init_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(VALUE self, VALUE start, VALUE end);
+VALUE rb_start_index_aref(VALUE self);
+VALUE rb_end_index_aref(VALUE self);
+VALUE rb_start_index_aset(VALUE self, VALUE index);
+VALUE rb_end_index_aset(VALUE self, VALUE index);
+
+__NAMESPACE_END_CVSLICE
+
+inline CvSlice*
+CVSLICE(VALUE object)
+{
+  CvSlice *ptr;
+  Data_Get_Struct(object, CvSlice, ptr);
+  return ptr;
+}
+
+inline CvSlice
+VALUE_TO_CVSLICE(VALUE object)
+{
+  if (rb_obj_is_kind_of(object, cCvSlice::rb_class())) {
+    CvSlice* ptr = CVSLICE(object);
+    return *ptr;
+  }
+  else if (rb_obj_is_kind_of(object, rb_cRange)) {
+    return cvSlice(NUM2INT(rb_funcall(object, rb_intern("begin"), 0)),
+                   rb_funcall(object, rb_intern("exclude_end?"), 0) ? NUM2INT(rb_funcall(object, rb_intern("end"), 0)) : NUM2INT(rb_funcall(object, rb_intern("end"), 0)) - 1);
+  }
+  else {
+    raise_compatible_typeerror(object, cCvSlice::rb_class());
+  }
+  throw "Should never reach here";
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSLICE_H

data/ext/opencv/cvsurfparams.cpp

@@ -0,0 +1,208 @@
+/************************************************************
+
+   cvsurfparams.cpp -
+
+   $Author: ser1zw $
+
+   Copyright (C) 2011 ser1zw
+
+************************************************************/
+#include "cvsurfparams.h"
+/*
+ * Document-class: OpenCV::CvSURFParams
+ *
+ * C structure is here.
+ *   typedef struct CvSURFParams {
+ *     int extended;
+ *     double hessianThreshold;
+ *     int nOctaves;
+ *     int nOctaveLayers;
+ *   } CvSURFParams;
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVSURFPARAMS
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvSURFParams *ptr;
+  return Data_Make_Struct(klass, CvSURFParams, 0, -1, ptr);
+}
+
+/*
+ * Create a CvSURFParams
+ *
+ * @overload CvSURFParams.new(hessian_threshold, extended = false, n_octaves = 3, n_octave_layers = 4)
+ *   @param hessian_threshold [Number]
+ *   @param extended [Boolean] If <tt>true</tt>, exteneded descriptors (128 elements each),
+ *     otherwise basic descriptors (64 elements each)
+ *   @param n_octaves [Integer] Number of octaves to be used for extraction
+ *   @param n_octave_layers [Integer] Number of layers within each octave
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  CvSURFParams *self_ptr = CVSURFPARAMS(self);
+  VALUE h_thresh, ext, noct, noctl;
+  rb_scan_args(argc, argv, "13", &h_thresh, &ext, &noct, &noctl);
+
+  self_ptr->hessianThreshold = NUM2DBL(h_thresh);
+  self_ptr->extended = NIL_P(ext) ? 0 : BOOL2INT(ext);
+  self_ptr->nOctaves = NIL_P(noct) ? 3 : NUM2INT(noct);
+  self_ptr->nOctaveLayers = NIL_P(noctl) ? 4 : NUM2INT(noctl);
+    
+  return self;
+}
+
+/*
+ * call-seq:
+ *   hessian_threshold -> number
+ * Return threshold of hessian
+ */
+VALUE
+rb_get_hessian_threshold(VALUE self)
+{
+  return DBL2NUM(CVSURFPARAMS(self)->hessianThreshold);
+}
+
+/*
+ * call-seq:
+ *   hessian_threshold = <i>value</i>
+ *
+ * Set threshold of hessian to <i>value</i>
+ */
+VALUE
+rb_set_hessian_threshold(VALUE self, VALUE value)
+{
+  CVSURFPARAMS(self)->hessianThreshold = NUM2DBL(value);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   extended -> bool
+ * Return the type of descripters
+ *   false: basic descriptors (64 elements each)
+ *   true : exteneded descriptors (128 elements each)
+ */
+VALUE
+rb_get_extended(VALUE self)
+{
+  return INT2BOOL(CVSURFPARAMS(self)->extended);
+}
+
+/*
+ * call-seq:
+ *   extended = <i>value</i>
+ * Set the type of descripters
+ *   false: basic descriptors (64 elements each)
+ *   true : exteneded descriptors (128 elements each)
+ */
+VALUE
+rb_set_extended(VALUE self, VALUE value)
+{
+  CVSURFPARAMS(self)->extended = BOOL2INT(value);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   n_octaves -> fixnum
+ * Return the number of octaves to be used for extraction
+ */
+VALUE
+rb_get_n_octaves(VALUE self)
+{
+  return INT2NUM(CVSURFPARAMS(self)->nOctaves);
+}
+
+/*
+ * call-seq:
+ *   n_octaves = <i>value</i>
+ * Set the number of octaves to be used for extraction
+ */
+VALUE
+rb_set_n_octaves(VALUE self, VALUE value)
+{
+  CVSURFPARAMS(self)->nOctaves = NUM2INT(value);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   n_octave_layers -> fixnum
+ * Return the number of layers within each octave
+ */
+VALUE
+rb_get_n_octave_layers(VALUE self)
+{
+  return INT2NUM(CVSURFPARAMS(self)->nOctaveLayers);
+}
+
+/*
+ * call-seq:
+ *   n_octave_layers = <i>value</i>
+ * Set the number of layers within each octave
+ */
+VALUE
+rb_set_n_octave_layers(VALUE self, VALUE value)
+{
+  CVSURFPARAMS(self)->nOctaveLayers = NUM2INT(value);
+  return self;
+}
+
+VALUE
+new_object()
+{
+  return rb_allocate(rb_klass);
+}
+
+VALUE
+new_object(CvSURFParams* cvsurfparams)
+{
+  VALUE object = rb_allocate(rb_klass);
+  CvSURFParams *ptr = CVSURFPARAMS(object);
+  ptr = cvsurfparams;
+  return object;
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+#endif
+
+  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, "CvSURFParams", rb_cObject);
+  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, "hessian_threshold", RUBY_METHOD_FUNC(rb_get_hessian_threshold), 0);
+  rb_define_method(rb_klass, "hessian_threshold=", RUBY_METHOD_FUNC(rb_set_hessian_threshold), 1);
+  rb_define_method(rb_klass, "extended", RUBY_METHOD_FUNC(rb_get_extended), 0);
+  rb_define_method(rb_klass, "extended=", RUBY_METHOD_FUNC(rb_set_extended), 1);
+  rb_define_method(rb_klass, "n_octaves", RUBY_METHOD_FUNC(rb_get_n_octaves), 0);
+  rb_define_method(rb_klass, "n_octaves=", RUBY_METHOD_FUNC(rb_set_n_octaves), 1);
+  rb_define_method(rb_klass, "n_octave_layers", RUBY_METHOD_FUNC(rb_get_n_octave_layers), 0);
+  rb_define_method(rb_klass, "n_octave_layers=", RUBY_METHOD_FUNC(rb_set_n_octave_layers), 1);
+}
+
+__NAMESPACE_END_CVSURFPARAMS
+__NAMESPACE_END_OPENCV
+