jf-ruby-opencv 0.0.18

data/ext/opencv/cvmat.h

@@ -0,0 +1,290 @@
+/************************************************************
+
+   cvmat.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVMAT_H
+#define RUBY_OPENCV_CVMAT_H
+
+#include "opencv.h"
+
+
+#define __NAMESPACE_BEGIN_CVMAT namespace cCvMat {
+#define __NAMESPACE_END_CVMAT }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMAT
+
+VALUE rb_class();
+
+void init_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_load_imageM(int argc, VALUE *argv, VALUE self);
+VALUE rb_encode_imageM(int argc, VALUE *argv, VALUE self);
+VALUE rb_decode_imageM(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_method_missing(int argc, VALUE *argv, VALUE self);
+VALUE rb_to_s(VALUE self);
+VALUE rb_inside_q(VALUE self, VALUE object);
+VALUE rb_to_IplConvKernel(VALUE self, VALUE anchor);
+VALUE rb_create_mask(VALUE self);
+
+VALUE rb_width(VALUE self);
+VALUE rb_height(VALUE self);
+VALUE rb_depth(VALUE self);
+VALUE rb_channel(VALUE self);
+VALUE rb_data(VALUE self);
+
+VALUE rb_clone(VALUE self);
+VALUE rb_copy(int argc, VALUE *argv, VALUE self);
+VALUE copy(VALUE mat);
+
+VALUE rb_to_8u(VALUE self);
+VALUE rb_to_8s(VALUE self);
+VALUE rb_to_16u(VALUE self);
+VALUE rb_to_16s(VALUE self);
+VALUE rb_to_32s(VALUE self);
+VALUE rb_to_32f(VALUE self);
+VALUE rb_to_64f(VALUE self);
+VALUE rb_vector_q(VALUE self);
+VALUE rb_square_q(VALUE self);
+// cxcore function
+VALUE rb_to_CvMat(VALUE self);
+VALUE rb_to_IplImage(VALUE self);
+VALUE rb_sub_rect(VALUE self, VALUE args);
+VALUE rb_get_rows(int argc, VALUE* argv, VALUE self);
+VALUE rb_get_cols(VALUE self, VALUE col);
+VALUE rb_each_row(VALUE self);
+VALUE rb_each_col(VALUE self);
+VALUE rb_diag(int argc, VALUE *argv, VALUE self);
+VALUE rb_size(VALUE self);
+VALUE rb_dims(VALUE self);
+VALUE rb_dim_size(VALUE self, VALUE index);
+VALUE rb_aref(VALUE self, VALUE args);
+VALUE rb_aset(VALUE self, VALUE args);
+VALUE rb_set_data(VALUE self, VALUE data);
+VALUE rb_set(int argc, VALUE *argv, VALUE self);
+VALUE rb_set_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_set_zero(VALUE self);
+VALUE rb_set_zero_bang(VALUE self);
+VALUE rb_set_identity(int argc, VALUE *argv, VALUE self);
+VALUE rb_set_identity_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_range(VALUE self, VALUE start, VALUE end);
+VALUE rb_range_bang(VALUE self, VALUE start, VALUE end);
+/* Transforms and Permutations */
+VALUE rb_reshape(int argc, VALUE *argv, VALUE self);
+VALUE rb_repeat(VALUE self, VALUE object);
+VALUE rb_flip(int argc, VALUE *argv, VALUE self);
+VALUE rb_flip_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_split(VALUE self);
+VALUE rb_merge(VALUE klass, VALUE args);
+VALUE rb_rand_shuffle(int argc, VALUE *argv, VALUE klass);
+VALUE rb_rand_shuffle_bang(int argc, VALUE *argv, VALUE klass);
+
+VALUE rb_lut(VALUE self, VALUE lut);
+VALUE rb_convert_scale(VALUE self, VALUE hash);
+VALUE rb_convert_scale_abs(VALUE self, VALUE hash);
+VALUE rb_add(int argc, VALUE *argv, VALUE self);
+VALUE rb_sub(int argc, VALUE *argv, VALUE self);    
+VALUE rb_mul(int argc, VALUE *argv, VALUE self);
+VALUE rb_mat_mul(int argc, VALUE *argv, VALUE self);
+VALUE rb_div(int argc, VALUE *argv, VALUE self);    
+VALUE rb_and(int argc, VALUE *argv, VALUE self);
+VALUE rb_or(int argc, VALUE *argv, VALUE self);
+VALUE rb_xor(int argc, VALUE *argv, VALUE self);
+VALUE rb_not(VALUE self);
+VALUE rb_not_bang(VALUE self);
+VALUE rb_cmp_internal(VALUE self, VALUE val, int operand);
+VALUE rb_eq(VALUE self, VALUE val);
+VALUE rb_gt(VALUE self, VALUE val);
+VALUE rb_ge(VALUE self, VALUE val);
+VALUE rb_lt(VALUE self, VALUE val);
+VALUE rb_le(VALUE self, VALUE val);
+VALUE rb_ne(VALUE self, VALUE val);
+VALUE rb_in_range(VALUE self, VALUE min, VALUE max);
+VALUE rb_abs_diff(VALUE self, VALUE val);
+VALUE rb_normalize(int argc, VALUE *argv, VALUE self);
+VALUE rb_add_weighted(VALUE klass, VALUE src1, VALUE alpha, VALUE src2, VALUE beta, VALUE gamma);
+/* Statistics */
+VALUE rb_count_non_zero(VALUE self);
+VALUE rb_sum(VALUE self);
+VALUE rb_avg(int argc, VALUE *argv, VALUE self);
+VALUE rb_avg_sdv(int argc, VALUE *argv, VALUE self);
+VALUE rb_sdv(int argc, VALUE *argv, VALUE self);
+VALUE rb_min_max_loc(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_norm(int argc, VALUE *argv, VALUE self);
+VALUE rb_dot_product(VALUE self, VALUE mat);
+VALUE rb_cross_product(VALUE self, VALUE mat);
+// VALUE rb_gemm();
+VALUE rb_transform(int argc, VALUE *argv, VALUE self);
+VALUE rb_perspective_transform(VALUE self, VALUE mat);
+VALUE rb_mul_transposed(int argc, VALUE *argv, VALUE self);
+VALUE rb_trace(VALUE self);
+VALUE rb_transpose(VALUE self);
+VALUE rb_det(VALUE self);
+VALUE rb_invert(int argc, VALUE *argv, VALUE self);
+VALUE rb_solve(int argc, VALUE *argv, VALUE self);
+VALUE rb_svd(int argc, VALUE *argv, VALUE self);
+VALUE rb_eigenvv(int argc, VALUE *argv, VALUE self);
+VALUE rb_eigenvv_bang(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_dft(int argc, VALUE *argv, VALUE self);
+VALUE rb_dct(int argc, VALUE *argv, VALUE self);
+
+/* drawing function*/
+VALUE rb_line(int argc, VALUE *argv, VALUE self);
+VALUE rb_line_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_rectangle(int argc, VALUE *argv, VALUE self);
+VALUE rb_rectangle_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_circle(int argc, VALUE *argv, VALUE self);
+VALUE rb_circle_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_ellipse(int argc, VALUE *argv, VALUE self);
+VALUE rb_ellipse_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_ellipse_box(int argc, VALUE *argv, VALUE self);
+VALUE rb_ellipse_box_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_fill_poly(int argc, VALUE *argv, VALUE self);
+VALUE rb_fill_poly_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_fill_convex_poly(int argc, VALUE *argv, VALUE self);
+VALUE rb_fill_convex_poly_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_poly_line(int argc, VALUE *argv, VALUE self);
+VALUE rb_poly_line_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_put_text(int argc, VALUE *argv, VALUE self);
+VALUE rb_put_text_bang(int argc, VALUE *argv, VALUE self);
+
+/* cv function */
+VALUE rb_sobel(int argc, VALUE *argv, VALUE self);
+VALUE rb_laplace(int argc, VALUE *argv, VALUE self);
+VALUE rb_canny(int argc, VALUE *argv, VALUE self);
+VALUE rb_pre_corner_detect(int argc, VALUE *argv, VALUE self);
+VALUE rb_corner_eigenvv(int argc, VALUE *argv, VALUE self);
+VALUE rb_corner_min_eigen_val(int argc, VALUE *argv, VALUE self);
+VALUE rb_corner_harris(int argc, VALUE *argv, VALUE self);
+VALUE rb_find_chessboard_corners(int argc, VALUE *argv, VALUE self);
+VALUE rb_find_corner_sub_pix(VALUE self, VALUE corners, VALUE win_size, VALUE zero_zone, VALUE criteria);
+VALUE rb_good_features_to_track(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_rect_sub_pix(int argc, VALUE *argv, VALUE self);
+VALUE rb_quadrangle_sub_pix(int argc, VALUE *argv, VALUE self);
+VALUE rb_resize(int argc, VALUE *argv, VALUE self);
+VALUE rb_warp_affine(int argc, VALUE *argv, VALUE self);
+VALUE rb_rotation_matrix2D(VALUE self, VALUE center, VALUE angle, VALUE scale);
+VALUE rb_get_perspective_transform(VALUE self, VALUE source, VALUE dest);
+VALUE rb_warp_perspective(int argc, VALUE *argv, VALUE self);
+VALUE rb_find_homography(int argc, VALUE *argv, VALUE self);
+VALUE rb_remap(int argc, VALUE *argv, VALUE self);
+VALUE rb_log_polar(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_erode(int argc, VALUE *argv, VALUE self);
+VALUE rb_erode_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_dilate(int argc, VALUE *argv, VALUE self);
+VALUE rb_dilate_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_morphology(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_smooth(int argc, VALUE *argv, VALUE self);
+VALUE rb_copy_make_border(int argc, VALUE *argv, VALUE self);
+VALUE rb_filter2d(int argc, VALUE *argv, VALUE self);
+VALUE rb_integral(int argc, VALUE *argv, VALUE self);
+VALUE rb_threshold(int argc, VALUE *argv, VALUE self);
+VALUE rb_adaptive_threshold(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_pyr_down(int argc, VALUE *argv, VALUE self);
+VALUE rb_pyr_up(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_flood_fill(int argc, VALUE *argv, VALUE self);
+VALUE rb_flood_fill_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_find_contours(int argc, VALUE *argv, VALUE self);
+VALUE rb_find_contours_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_draw_contours(int argc, VALUE *argv, VALUE self);
+VALUE rb_draw_contours_bang(int argc, VALUE *argv, VALUE self);
+VALUE rb_draw_chessboard_corners(VALUE self, VALUE pattern_size, VALUE corners, VALUE pattern_was_found);
+VALUE rb_draw_chessboard_corners_bang(VALUE self, VALUE pattern_size, VALUE corners, VALUE pattern_was_found);
+VALUE rb_pyr_mean_shift_filtering(int argc, VALUE *argv, VALUE self);
+VALUE rb_watershed(VALUE self, VALUE markers);
+VALUE rb_moments(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_hough_lines(int argc, VALUE *argv, VALUE self);
+VALUE rb_hough_circles(int argc, VALUE *argv, VALUE self);
+VALUE rb_dist_transform(int argc, VALUE *argv, VALUE self);
+VALUE rb_inpaint(VALUE self, VALUE inpaint_method, VALUE mask, VALUE radius);
+
+VALUE rb_equalize_hist(VALUE self);
+
+VALUE rb_apply_color_map(VALUE self, VALUE colormap);
+
+/* Matching*/
+VALUE rb_match_template(int argc, VALUE *argv, VALUE self);
+VALUE rb_match_shapes(int argc, VALUE *argv, VALUE self);
+
+/* Object Tracking */
+VALUE rb_mean_shift(VALUE self, VALUE window, VALUE criteria);
+VALUE rb_cam_shift(VALUE self, VALUE window, VALUE criteria);
+VALUE rb_snake_image(int argc, VALUE *argv, VALUE self);
+/* Optical Flow */
+VALUE rb_optical_flow_hs(int argc, VALUE *argv, VALUE self);
+VALUE rb_optical_flow_lk(VALUE self, VALUE prev, VALUE win_size);
+VALUE rb_optical_flow_bm(int argc, VALUE *argv, VALUE self);
+VALUE rb_optical_flow_pyr_lk(int argc, VALUE *argv, VALUE self);
+
+/* Epipolar Geometory */
+VALUE rb_find_fundamental_mat(int argc, VALUE *argv, VALUE klass);
+VALUE rb_compute_correspond_epilines(VALUE klass, VALUE points, VALUE which_image, VALUE fundamental_matrix);
+
+/* Feature detection and description */
+VALUE rb_extract_surf(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_subspace_project(VALUE self, VALUE w, VALUE mean);
+VALUE rb_subspace_reconstruct(VALUE self, VALUE w, VALUE mean);
+
+// HighGUI function
+VALUE rb_save_image(int argc, VALUE *argv, VALUE self);
+
+VALUE new_object(int rows, int cols, int type);
+VALUE new_object(CvSize size, int type);
+VALUE new_mat_kind_object(CvSize size, VALUE ref_obj);
+VALUE new_mat_kind_object(CvSize size, VALUE ref_obj, int cvmat_depth, int channel);
+
+CvMat* prepare_decoding(int argc, VALUE *argv, int* iscolor, int* need_release);
+
+__NAMESPACE_END_CVMAT
+
+inline CvMat*
+CVMAT(VALUE object)
+{
+  CvMat *ptr, stub;
+  Data_Get_Struct(object, CvMat, ptr);
+  return cvGetMat(ptr, &stub);
+}
+
+inline CvMat*
+CVMAT_WITH_CHECK(VALUE object)
+{
+  if (!rb_obj_is_kind_of(object, cCvMat::rb_class()))
+    raise_typeerror(object, cCvMat::rb_class());
+  return CVMAT(object);
+}
+
+inline CvMat*
+MASK(VALUE object)
+{
+  if (NIL_P(object))
+    return NULL;
+  else {
+    CvMat* obj_ptr = CVMAT_WITH_CHECK(object);
+    if (CV_MAT_DEPTH(obj_ptr->type) == CV_8UC1 &&
+	CV_MAT_CN(obj_ptr->type) == 1)
+      return obj_ptr;
+    else
+      rb_raise(rb_eTypeError, "Mask should be 8bit 1-channel matrix.");
+  }
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVMAT_H

data/ext/opencv/cvmemstorage.cpp

@@ -0,0 +1,73 @@
+/************************************************************
+
+   cvmemstorage.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#include "cvmemstorage.h"
+/*
+ * Document-class: OpenCV::CvMemStorage
+ *
+ * Internal memory management class used by CvSeq.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMEMSTORAGE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvMemStorage *storage = rb_cvCreateMemStorage(0);
+  return Data_Wrap_Struct(klass, 0, cvmemstorage_free, storage);
+}
+
+void
+cvmemstorage_free(void *ptr)
+{
+  try {
+    cvReleaseMemStorage((CvMemStorage**)&ptr);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+}
+
+VALUE
+new_object(int blocksize)
+{
+  CvMemStorage *storage = rb_cvCreateMemStorage(blocksize);
+  return Data_Wrap_Struct(rb_klass, 0, cvmemstorage_free, storage);
+}
+
+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, "CvMemStorage", rb_cObject);
+}
+
+__NAMESPACE_END_CVMEMSTORAGE
+__NAMESPACE_END_OPENCV
+

data/ext/opencv/cvmemstorage.h

@@ -0,0 +1,50 @@
+/************************************************************
+
+   cvmemstorage.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVMEMSTORAGE_H
+#define RUBY_OPENCV_CVMEMSTORAGE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVMEMSTORAGE namespace cCvMemStorage {
+#define __NAMESPACE_END_CVMEMSTORAGE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVMEMSTORAGE
+    
+void init_ruby_class();
+
+VALUE rb_class();
+VALUE rb_allocate(VALUE klass);
+void cvmemstorage_free(void *ptr);
+
+VALUE new_object(int blocksize = 0);
+
+__NAMESPACE_END_CVMEMSTORAGE
+
+inline CvMemStorage*
+CVMEMSTORAGE(VALUE object)
+{
+  CvMemStorage *ptr;
+  Data_Get_Struct(object, CvMemStorage, ptr);
+  return ptr;
+}
+
+inline VALUE
+CHECK_CVMEMSTORAGE(VALUE object)
+{
+  if (rb_obj_is_kind_of(object, cCvMemStorage::rb_class())) {
+    return object;
+  }
+  return cCvMemStorage::new_object();
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVMEMSTORAGE_H

data/ext/opencv/cvmoments.cpp

@@ -0,0 +1,293 @@
+/************************************************************
+
+   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;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvMoments *ptr;
+  return Data_Make_Struct(klass, CvMoments, 0, -1, ptr);
+}
+/*
+ * call-seq:
+ *   CvMoments.new(src[,is_binary = nil])
+ *
+ * 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;
+}
+
+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, "CvMoments", 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, "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);
+}
+
+__NAMESPACE_END_CVMOMENTS
+__NAMESPACE_END_OPENCV
+