bonanza-ruby-opencv 0.0.13.20140330211753

data/ext/opencv/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 init_ruby_class();    
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_type(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 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_LEN(object) == 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, "Invalid type");
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVTERMCRITERIA_H

data/ext/opencv/cvtwopoints.cpp

@@ -0,0 +1,122 @@
+/************************************************************
+
+   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;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvTwoPoints *ptr;
+  return Data_Make_Struct(klass, CvTwoPoints, 0, -1, ptr);
+}
+
+/*
+ * 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:
+ *   [<i>index</i>]
+ *
+ * Return value of <i>index</i> dimension.
+ */
+VALUE
+rb_aref(VALUE self, VALUE index)
+{
+  switch (NUM2INT(index)) {
+  case 0:
+    return cCvPoint::new_object(CVTWOPOINTS(self)->p1);
+    break;
+  case 1:
+    return cCvPoint::new_object(CVTWOPOINTS(self)->p2);
+    break;
+  default:
+    rb_raise(rb_eIndexError, "index should be 0...2");
+    break;
+  }
+  return Qnil;
+}
+
+/*
+ * 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));
+}
+
+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, "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, "[]", RUBY_METHOD_FUNC(rb_aref), 1);
+  rb_define_method(rb_klass, "to_ary", RUBY_METHOD_FUNC(rb_to_ary), 0);
+  rb_define_alias(rb_klass, "to_a", "to_ary");
+}
+
+__NAMESPACE_END_CVTWOPOINTS
+__NAMESPACE_END_OPENCV
+

data/ext/opencv/cvtwopoints.h

@@ -0,0 +1,51 @@
+/************************************************************
+
+   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 init_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+
+VALUE rb_point1(VALUE self);
+VALUE rb_point2(VALUE self);
+VALUE rb_aref(VALUE self, VALUE index);
+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/opencv/cvutils.cpp

@@ -0,0 +1,221 @@
+/************************************************************
+
+  cvutils.cpp -
+
+  $Author: ser1zw $
+
+  Copyright (C) 2011 ser1zw
+
+************************************************************/
+#include "cvutils.h"
+
+void
+raise_typeerror(VALUE object, VALUE expected_class)
+{
+  raise_typeerror(object, rb_class2name(expected_class));
+}
+
+void
+raise_typeerror(VALUE object, const char* expected_class_name)
+{
+  rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
+  	   rb_obj_classname(object), expected_class_name);
+}
+
+void
+raise_compatible_typeerror(VALUE object, VALUE expected_class)
+{
+  raise_compatible_typeerror(object, rb_class2name(expected_class));
+}
+
+void
+raise_compatible_typeerror(VALUE object, const char* expected_class_name)
+{
+  rb_raise(rb_eTypeError, "wrong argument type %s (expected %s or compatible object)",
+  	   rb_obj_classname(object), expected_class_name);
+}
+
+/*
+ * Allocates a memory buffer
+ * see cv::fastMalloc()
+ */
+void*
+rbFastMalloc(size_t size)
+{
+  uchar* udata = (uchar*)xmalloc(size + sizeof(void*) + CV_MALLOC_ALIGN);
+  if(!udata) {
+    rb_raise(rb_eNoMemError, "Failed to allocate memory");
+  }
+  uchar** adata = cv::alignPtr((uchar**)udata + 1, CV_MALLOC_ALIGN);
+  adata[-1] = udata;
+  return adata;
+}
+
+/*
+ * Allocates a memory buffer
+ * When memory allocation is failed, run GC and retry it
+ */
+void*
+rb_cvAlloc(size_t size)
+{
+  return rbFastMalloc(size);
+}
+
+/*
+ * Creates CvMat and underlying data
+ * When memory allocation is failed, run GC and retry it
+ */
+CvMat*
+rb_cvCreateMat(int rows, int cols, int type)
+{
+  CvMat* mat = NULL;
+  try {
+    mat = cvCreateMatHeader(rows, cols, type);
+    if (mat) {
+      // see OpenCV's cvCreateData()
+      size_t step = mat->step;
+      size_t total_size = step * mat->rows + sizeof(int) + CV_MALLOC_ALIGN;
+
+      mat->refcount = (int*)rbFastMalloc(total_size);
+      mat->data.ptr = (uchar*)cvAlignPtr(mat->refcount + 1, CV_MALLOC_ALIGN);
+      *mat->refcount = 1;
+    }
+    else {
+      rb_raise(rb_eRuntimeError, "Failed to create mat header");
+    }
+  }
+  catch(cv::Exception& e) {
+    if (mat) {
+      cvReleaseMat(&mat);
+    }
+    rb_raise(rb_eRuntimeError, "%s", e.what());
+  }
+  return mat;
+}
+
+/*
+ * Creates CvMatND and underlying data
+ * When memory allocation is failed, run GC and retry it
+ */
+CvMatND* 
+rb_cvCreateMatND(int dims, const int* sizes, int type)
+{
+  CvMatND* ptr = NULL;
+  try {
+    ptr = cvCreateMatND(dims, sizes, type);
+  }
+  catch(cv::Exception& e) {
+    if (e.code != CV_StsNoMem)
+      rb_raise(rb_eRuntimeError, "%s", e.what());
+
+    rb_gc_start();
+    try {
+      ptr = cvCreateMatND(dims, sizes, type);
+    }
+    catch (cv::Exception& e) {
+      if (e.code == CV_StsNoMem)
+	rb_raise(rb_eNoMemError, "%s", e.what());
+      else
+	rb_raise(rb_eRuntimeError, "%s", e.what());
+    }
+  }
+  return ptr;
+}
+
+/*
+ * Create IplImage header and allocate underlying data
+ * When memory allocation is failed, run GC and retry it
+ */
+IplImage*
+rb_cvCreateImage(CvSize size, int depth, int channels)
+{
+  IplImage* ptr = NULL;
+  try {
+    ptr = cvCreateImageHeader(size, depth, channels);
+    if (ptr) {
+      // see OpenCV's cvCreateData()
+      ptr->imageData = ptr->imageDataOrigin = (char*)rbFastMalloc((size_t)ptr->imageSize);
+    }
+    else {
+      rb_raise(rb_eRuntimeError, "Failed to create image header");
+    }
+  }
+  catch(cv::Exception& e) {
+    if (ptr) {
+      cvReleaseImage(&ptr);
+    }
+    rb_raise(rb_eRuntimeError, "%s", e.what());
+  }
+  return ptr;
+}
+
+/*
+ * Creates a structuring element
+ * When memory allocation is failed, run GC and retry it
+ */
+IplConvKernel*
+rb_cvCreateStructuringElementEx(int cols, int rows,
+				int anchorX, int anchorY,
+				int shape, int *values)
+{
+  IplConvKernel* ptr = NULL;
+  try {
+    ptr = cvCreateStructuringElementEx(cols, rows, anchorX, anchorY, shape, values);
+  }
+  catch(cv::Exception& e) {
+    if (e.code != CV_StsNoMem)
+      rb_raise(rb_eRuntimeError, "%s", e.what());
+
+    rb_gc_start();
+    try {
+      ptr = cvCreateStructuringElementEx(cols, rows, anchorX, anchorY, shape, values);
+    }
+    catch (cv::Exception& e) {
+      if (e.code == CV_StsNoMem)
+	rb_raise(rb_eNoMemError, "%s", e.what());
+      else
+	rb_raise(rb_eRuntimeError, "%s", e.what());
+    }
+  }
+  return ptr;
+}
+
+/*
+ * Creates memory storage
+ * When memory allocation is failed, run GC and retry it
+ */
+CvMemStorage*
+rb_cvCreateMemStorage(int block_size)
+{
+  CvMemStorage* ptr = NULL;
+  try {
+    ptr = cvCreateMemStorage(block_size);
+  }
+  catch(cv::Exception& e) {
+    if (e.code != CV_StsNoMem)
+      rb_raise(rb_eRuntimeError, "%s", e.what());
+
+    rb_gc_start();
+    try {
+      ptr = cvCreateMemStorage(block_size);
+    }
+    catch (cv::Exception& e) {
+      if (e.code == CV_StsNoMem)
+	rb_raise(rb_eNoMemError, "%s", e.what());
+      else
+	rb_raise(rb_eRuntimeError, "%s", e.what());
+    }
+  }
+  return ptr;
+}
+
+VALUE
+rb_get_option_table(VALUE klass, const char* table_name, VALUE option)
+{
+  VALUE table = rb_const_get(klass, rb_intern(table_name));
+  if (NIL_P(option))
+    return table;
+  else
+    return rb_funcall(table, rb_intern("merge"), 1, option);
+}
+