ruby-opencv 0.0.9-x86-mswin32

data/ext/opencv/cvmoments.cpp

@@ -0,0 +1,287 @@
+/************************************************************
+
+   cvmoments.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvmoments.h"
+/*
+ * Document-class: OpenCV::CvMoments
+ *
+ * moments
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMOMENTS
+
+#define DEFINE_CVMOMENTS_ACCESSOR(elem) \
+  rb_define_method(rb_klass, #elem, RUBY_METHOD_FUNC(rb_##elem), 0)
+
+#define CVMOMENTS_ACCESSOR(elem) \
+  VALUE rb_##elem(VALUE self) { return DBL2NUM(CVMOMENTS(self)->elem); }
+
+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, "CvMoments", rb_cObject);
+  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, "spatial", RUBY_METHOD_FUNC(rb_spatial), 2);
+  rb_define_method(rb_klass, "central", RUBY_METHOD_FUNC(rb_central), 2);
+  rb_define_method(rb_klass, "normalized_central", RUBY_METHOD_FUNC(rb_normalized_central), 2);
+  rb_define_method(rb_klass, "hu", RUBY_METHOD_FUNC(rb_hu), 0);     
+  rb_define_method(rb_klass, "gravity_center", RUBY_METHOD_FUNC(rb_gravity_center), 0);
+  rb_define_method(rb_klass, "angle", RUBY_METHOD_FUNC(rb_angle), 0);
+
+  DEFINE_CVMOMENTS_ACCESSOR(m00);
+  DEFINE_CVMOMENTS_ACCESSOR(m10);
+  DEFINE_CVMOMENTS_ACCESSOR(m01);
+  DEFINE_CVMOMENTS_ACCESSOR(m20);
+  DEFINE_CVMOMENTS_ACCESSOR(m11);
+  DEFINE_CVMOMENTS_ACCESSOR(m02);
+  DEFINE_CVMOMENTS_ACCESSOR(m30);
+  DEFINE_CVMOMENTS_ACCESSOR(m21);
+  DEFINE_CVMOMENTS_ACCESSOR(m12);
+  DEFINE_CVMOMENTS_ACCESSOR(m03);
+
+  DEFINE_CVMOMENTS_ACCESSOR(mu20);
+  DEFINE_CVMOMENTS_ACCESSOR(mu11);
+  DEFINE_CVMOMENTS_ACCESSOR(mu02);
+  DEFINE_CVMOMENTS_ACCESSOR(mu30);
+  DEFINE_CVMOMENTS_ACCESSOR(mu21);
+  DEFINE_CVMOMENTS_ACCESSOR(mu12);
+  DEFINE_CVMOMENTS_ACCESSOR(mu03);
+
+  DEFINE_CVMOMENTS_ACCESSOR(inv_sqrt_m00);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvMoments *ptr;
+  return Data_Make_Struct(klass, CvMoments, 0, -1, ptr);
+}
+/*
+ * call-seq:
+ *   CvMoments.new(<i>src[,is_binary = nil]</i>)
+ *
+ * Calculates all moments up to third order of a polygon or rasterized shape.
+ * <i>src</i> should be CvMat or CvPolygon.
+ *
+ * If is_binary = true, all the zero pixel values are treated as zeroes, all the others are treated as 1's.
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE src, is_binary;
+  rb_scan_args(argc, argv, "02", &src, &is_binary);
+  if (!NIL_P(src)) {
+    if (rb_obj_is_kind_of(src, cCvMat::rb_class()) || rb_obj_is_kind_of(src, cCvSeq::rb_class())) {
+      try {
+	cvMoments(CVARR(src), CVMOMENTS(self), TRUE_OR_FALSE(is_binary, 0));
+      }
+      catch (cv::Exception& e) {
+	raise_cverror(e);
+      }
+    }
+    else
+      rb_raise(rb_eTypeError, "argument 1 (src) should be %s or %s.",
+	       rb_class2name(cCvMat::rb_class()), rb_class2name(cCvSeq::rb_class()));
+  }
+  return self;      
+}
+
+CVMOMENTS_ACCESSOR(m00);
+CVMOMENTS_ACCESSOR(m10);
+CVMOMENTS_ACCESSOR(m01);
+CVMOMENTS_ACCESSOR(m20);
+CVMOMENTS_ACCESSOR(m11);
+CVMOMENTS_ACCESSOR(m02);
+CVMOMENTS_ACCESSOR(m30);
+CVMOMENTS_ACCESSOR(m21);
+CVMOMENTS_ACCESSOR(m12);
+CVMOMENTS_ACCESSOR(m03);
+
+CVMOMENTS_ACCESSOR(mu20);
+CVMOMENTS_ACCESSOR(mu11);
+CVMOMENTS_ACCESSOR(mu02);
+CVMOMENTS_ACCESSOR(mu30);
+CVMOMENTS_ACCESSOR(mu21);
+CVMOMENTS_ACCESSOR(mu12);
+CVMOMENTS_ACCESSOR(mu03);
+
+CVMOMENTS_ACCESSOR(inv_sqrt_m00);
+
+/*
+ * call-seq:
+ *   spatial -> float
+ *
+ * Retrieves spatial moment.
+ *
+ * which in case of image moments is defined as:
+ *   Mx_order,y_order=sumx,y(I(x,y)*xx_order*yy_order)
+ *   where I(x,y) is the intensity of the pixel (x, y). 
+ */
+VALUE
+rb_spatial(VALUE self, VALUE x_order, VALUE y_order)
+{
+  double result = 0;
+  try {
+    result = cvGetSpatialMoment(CVMOMENTS(self), NUM2INT(x_order), NUM2INT(y_order));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return rb_float_new(result);
+}
+
+/*
+ * call-seq:
+ *   central -> float
+ *
+ * Retrieves central moment.
+ *
+ * which in case of image moments is defined as:
+ *   μx_order,y_order=sumx,y(I(x,y)*(x-xc)x_order*(y-yc)y_order),
+ *   where xc=M10/M00, yc=M01/M00 - coordinates of the gravity center
+ */
+VALUE
+rb_central(VALUE self, VALUE x_order, VALUE y_order)
+{
+  double result = 0;
+  try {
+    result = cvGetCentralMoment(CVMOMENTS(self), NUM2INT(x_order), NUM2INT(y_order));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return rb_float_new(result);
+}
+
+/*
+ * call-seq:
+ *   normalized_central -> float
+ *
+ * Retrieves normalized central moment.
+ *
+ *  ηx_order,y_order= μx_order,y_order/M00((y_order+x_order)/2+1)
+ */
+VALUE
+rb_normalized_central(VALUE self, VALUE x_order, VALUE y_order)
+{
+  double result = 0;
+  try {
+    result = cvGetNormalizedCentralMoment(CVMOMENTS(self), NUM2INT(x_order), NUM2INT(y_order));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return rb_float_new(result);
+}
+
+/*
+ * call-seq:
+ *   hu -> cvhumoments
+ *
+ * Calculates seven Hu invariants.
+ *
+ * seven Hu invariants that are defined as:
+ *   h1=η20+η02
+ *   h2=(η20-η02)²+4η11²
+ *   h3=(η30-3η12)²+ (3η21-η03)²
+ *   h4=(η30+η12)²+ (η21+η03)²
+ *   h5=(η30-3η12)(η30+η12)[(η30+η12)²-3(η21+η03)²]+(3η21-η03)(η21+η03)[3(η30+η12)²-(η21+η03)²]
+ *   h6=(η20-η02)[(η30+η12)²- (η21+η03)²]+4η11(η30+η12)(η21+η03)
+ *   h7=(3η21-η03)(η21+η03)[3(η30+η12)²-(η21+η03)²]-(η30-3η12)(η21+η03)[3(η30+η12)²-(η21+η03)²]
+ * where ηi,j are normalized central moments of 2-nd and 3-rd orders. The computed values are proved to be invariant to the image scaling, rotation, and reflection except the seventh one, whose sign is changed by reflection. 
+ */
+VALUE
+rb_hu(VALUE self)
+{
+  return cCvHuMoments::new_object(CVMOMENTS(self));
+}
+
+/*
+ * call-seq:
+ *   gravity_center -> cvpoint2d32f
+ *
+ * Return gravity center.
+ */
+VALUE
+rb_gravity_center(VALUE self)
+{
+  CvMoments *moments = CVMOMENTS(self);
+  CvPoint2D32f point;
+  double m00 = 0, m01 = 0, m10 = 0;
+  try {
+    m00 = cvGetSpatialMoment(moments, 0, 0);
+    m10 = cvGetSpatialMoment(moments, 1, 0);
+    m01 = cvGetSpatialMoment(moments, 0, 1);
+    point = cvPoint2D32f(m10 / m00, m01 / m00);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return cCvPoint2D32f::new_object(point);
+}
+
+/*
+ * call-seq:
+ *   angle -> float
+ *
+ * Return angle.
+ */
+VALUE
+rb_angle(VALUE self)
+{
+  CvMoments *moments = CVMOMENTS(self);
+  double m11 = 0, m20 = 0, m02 = 0;
+  try {
+    m11 = cvGetCentralMoment(moments, 1, 1);
+    m20 = cvGetCentralMoment(moments, 2, 0);
+    m02 = cvGetCentralMoment(moments, 0, 2);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  double mangle = 0.5 * atan(2 * m11 / (m20 - m02));
+  if (cvIsNaN(mangle) || cvIsInf(mangle))
+    return Qnil;
+  else
+    return rb_float_new(mangle);
+}
+
+VALUE
+new_object(CvArr *arr, int is_binary = 0)
+{
+  VALUE object = rb_allocate(rb_klass);
+  try {
+    cvMoments(arr, CVMOMENTS(object), is_binary);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return object;
+}
+
+__NAMESPACE_END_CVMOMENTS
+__NAMESPACE_END_OPENCV

data/ext/opencv/cvmoments.h

@@ -0,0 +1,75 @@
+/************************************************************
+
+   cvmoments.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVMOMENTS_H
+#define RUBY_OPENCV_CVMOMENTS_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVMOMENTS namespace cCvMoments {
+#define __NAMESPACE_END_CVMOMENTS }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMOMENTS
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_spatial(VALUE self, VALUE x_order, VALUE y_order);
+VALUE rb_central(VALUE self, VALUE x_order, VALUE y_order);
+VALUE rb_normalized_central(VALUE self, VALUE x_order, VALUE y_order);
+VALUE rb_hu(VALUE self);
+VALUE rb_gravity_center(VALUE self);
+VALUE rb_angle(VALUE self);
+
+VALUE rb_m00(VALUE self);
+VALUE rb_m10(VALUE self);
+VALUE rb_m01(VALUE self);
+VALUE rb_m20(VALUE self);
+VALUE rb_m11(VALUE self);
+VALUE rb_m02(VALUE self);
+VALUE rb_m30(VALUE self);
+VALUE rb_m21(VALUE self);
+VALUE rb_m12(VALUE self);
+VALUE rb_m03(VALUE self);
+VALUE rb_mu20(VALUE self);
+VALUE rb_mu11(VALUE self);
+VALUE rb_mu02(VALUE self);
+VALUE rb_mu30(VALUE self);
+VALUE rb_mu21(VALUE self);
+VALUE rb_mu12(VALUE self);
+VALUE rb_mu03(VALUE self);
+VALUE rb_inv_sqrt_m00(VALUE self);
+
+VALUE new_object(CvArr *arr, int is_binary);
+
+__NAMESPACE_END_CVMOMENTS
+
+inline CvMoments*
+CVMOMENTS(VALUE object)
+{
+  CvMoments *ptr;
+  Data_Get_Struct(object, CvMoments, ptr);
+  return ptr;
+}
+
+inline CvMoments*
+CVMOMENTS_WITH_CHECK(VALUE object)
+{
+  if (!rb_obj_is_kind_of(object, cCvMoments::rb_class()))
+    raise_typeerror(object, cCvMoments::rb_class());
+  return CVMOMENTS(object);
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVMOMENTS_H

data/ext/opencv/cvpoint.cpp

@@ -0,0 +1,228 @@
+/************************************************************
+
+   cvpoint.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvpoint.h"
+/*
+ * Document-class: OpenCV::CvPoint
+ *
+ * This class means one point on X axis Y axis. 
+ * X and Y takes the value of the Fixnum. see also CvPoint2D32F
+ * 
+ * C structure is here, very simple.
+ *   typdef struct CvPoint {
+ *     int x;
+ *     int y;
+ *   }
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVPOINT
+
+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, "CvPoint", 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);
+  rb_define_alias(rb_klass, "to_a", "to_ary");
+}
+
+/*
+ * call-seq:
+ *   combatible?(obj)
+ *
+ * Return compatibility to CvPoint. Return true if object have method #x and #y.
+ *
+ * For example.
+ *   class MyPoint
+ *     def x
+ *       1
+ *     end
+ *     def y
+ *       2
+ *     end
+ *   end
+ *   mp = MyPoint.new
+ *   CvPoint.compatible?(mp)  #=> true
+ *   CvPoint.new(mp)          #=> same as CvPoint(1, 2)
+ */
+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)
+{
+  CvPoint *ptr;
+  return Data_Make_Struct(klass, CvPoint, 0, -1, ptr);
+}
+
+/*
+ * call-seq:
+ *   new -> CvPoint.new(0, 0)
+ *   new(obj) -> CvPoint.new(obj.x.to_i, obj.y.to_i)
+ *   new(x, y)
+ *
+ * Create new 2D-coordinate, (x, y). It is dropped below the decimal point.
+ *
+ * new() is same as new(0, 0)
+ *
+ * new(obj) is same as new(obj.x.to_i, obj.y.to_i)
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  CvPoint* self_ptr = CVPOINT(self);
+  switch (argc) {
+  case 0:
+    break;
+  case 1: {
+    CvPoint point = VALUE_TO_CVPOINT(argv[0]);
+    self_ptr->x = point.x;
+    self_ptr->y = point.y;
+    break;
+  }
+  case 2:
+    self_ptr->x = NUM2INT(argv[0]);
+    self_ptr->y = NUM2INT(argv[1]);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    break;
+  }
+  return self;
+}
+
+/*
+ * Return parameter on x-axis.
+ */
+VALUE
+rb_x(VALUE self)
+{
+  return INT2NUM(CVPOINT(self)->x);
+}
+
+/*
+ * call-seq:
+ *   x = val
+ *
+ * Set x-axis parameter, return self.
+ * It is dropped below the decimal point.
+ *   pt = CvPoint.new
+ *   pt.x = 1.1
+ *   pt.x           #=> 1
+ *   pt.x = 100.9
+ *   pt.x           #=> 100
+ */
+VALUE
+rb_set_x(VALUE self, VALUE x)
+{
+  CVPOINT(self)->x = NUM2INT(x);
+  return self;
+}
+
+/*
+ * Return parameter on y-axis.
+ */
+VALUE
+rb_y(VALUE self)
+{
+  return INT2NUM(CVPOINT(self)->y);
+}
+
+/*
+ * call-seq:
+ *   y = val
+ *
+ * Set y-axis parameter, return self.
+ * It is dropped below the decimal point.
+ */
+VALUE
+rb_set_y(VALUE self, VALUE y)
+{
+  CVPOINT(self)->y = NUM2INT(y);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   to_s -> "<OpenCV::CvPoint:(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)
+{
+  CvPoint* self_ptr = CVPOINT(self);
+  return rb_ary_new3(2, INT2NUM(self_ptr->x), INT2NUM(self_ptr->y));
+}
+
+VALUE
+new_object()
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVPOINT(object) = cvPoint(0, 0);
+  return object;
+}
+
+
+VALUE
+new_object(CvPoint point)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVPOINT(object) = point;
+  return object;
+}
+
+__NAMESPACE_END_CVPOINT
+__NAMESPACE_END_OPENCV