opencv 0.0.6

data/ext/cvmoments.cpp

@@ -0,0 +1,204 @@
+/************************************************************
+
+   cvmoments.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvmoments.h"
+/*
+ * Document-class: OpenCV::CvMoments
+ *
+ * moments
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMOMENTS
+
+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_alias(rb_klass, "center", "gravity_center");
+  rb_define_method(rb_klass, "angle", RUBY_METHOD_FUNC(rb_angle), 0);
+}
+
+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))
+    ;
+  else if (rb_obj_is_kind_of(src, cCvMat::rb_class()) || rb_obj_is_kind_of(src, cCvSeq::rb_class()))
+    cvMoments(CVARR(src), CVMOMENTS(self), TRUE_OR_FALSE(is_binary, 0));
+  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;      
+}
+
+/*
+ * 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)
+{
+  return rb_float_new(cvGetSpatialMoment(CVMOMENTS(self), NUM2INT(x_order), NUM2INT(y_order)));
+}
+
+/*
+ * 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)
+{
+  return rb_float_new(cvGetCentralMoment(CVMOMENTS(self), NUM2INT(x_order), NUM2INT(y_order)));
+}
+
+/*
+ * 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)
+{
+  return rb_float_new(cvGetNormalizedCentralMoment(CVMOMENTS(self), NUM2INT(x_order), NUM2INT(y_order)));
+}
+
+/*
+ * call-seq:
+ *   hu -> [hu1, hu2, ... ,hu7]
+ *
+ * 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)
+{
+  CvHuMoments hu_moments;
+  cvGetHuMoments(CVMOMENTS(self), &hu_moments);
+  return rb_ary_new3(7,
+		     rb_float_new(hu_moments.hu1),
+		     rb_float_new(hu_moments.hu2),
+		     rb_float_new(hu_moments.hu3),
+		     rb_float_new(hu_moments.hu4),
+		     rb_float_new(hu_moments.hu5),
+		     rb_float_new(hu_moments.hu6),
+		     rb_float_new(hu_moments.hu7));
+}
+
+/*
+ * call-seq:
+ *   gravity_center -> cvpoint2d32f
+ *
+ * Return gravity center.
+ */
+VALUE
+rb_gravity_center(VALUE self)
+{
+  CvMoments *moments = CVMOMENTS(self);
+  double
+    m00 = cvGetSpatialMoment(moments, 0, 0),
+    m10 = cvGetSpatialMoment(moments, 1, 0),
+    m01 = cvGetSpatialMoment(moments, 0, 1);
+  return cCvPoint2D32f::new_object(cvPoint2D32f(m10 / m00, m01 / m00));
+}
+
+/*
+ * call-seq:
+ *   angle -> float
+ *
+ * Return angle.
+ */
+VALUE
+rb_angle(VALUE self)
+{
+  CvMoments *moments = CVMOMENTS(self);
+  double
+    m11 = cvGetCentralMoment(moments, 1, 1),
+    m20 = cvGetCentralMoment(moments, 2, 0),
+    m02 = cvGetCentralMoment(moments, 0, 2),
+    mangle = 0.5 * atan(2 * m11 / (m20 - m02));
+  if(!cvIsNaN(mangle) && !cvIsInf(mangle))
+    return rb_float_new(mangle);
+  else
+    return Qnil;
+}
+
+VALUE
+new_object(CvArr *arr, int is_binary = 0)
+{
+  VALUE object = rb_allocate(rb_class());
+  cvMoments(arr, CVMOMENTS(object), TRUE_OR_FALSE(is_binary, 0));
+  return object;
+}
+
+__NAMESPACE_END_CVMOMENTS
+__NAMESPACE_END_OPENCV

data/ext/cvmoments.h

@@ -0,0 +1,48 @@
+/************************************************************
+
+   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 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;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVMOMENTS_H

data/ext/cvpoint.cpp

@@ -0,0 +1,229 @@
+/************************************************************
+
+   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);
+}
+
+/*
+ * 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)
+{
+  VALUE obj, x, y;
+  switch (argc) {
+  case 0:
+    break;
+  case 1:
+    obj = argv[0];
+    if (rb_compatible_q(rb_klass, obj)) {
+      CVPOINT(self)->x = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("x"), 0), rb_intern("to_i"), 0));
+      CVPOINT(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];
+    CVPOINT(self)->x = NUM2INT(x);
+    CVPOINT(self)->y = NUM2INT(y);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+  }
+  return Qnil;    
+}
+
+/*
+ * Return parameter on x-axis.
+ */
+VALUE
+rb_x(VALUE self)
+{
+  return INT2FIX(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 INT2FIX(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)
+{
+  return rb_ary_new3(2, rb_x(self), rb_y(self));
+}
+
+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