ruby-opencv 0.0.10 → 0.0.11.pre

data/ext/opencv/algorithm.h

@@ -0,0 +1,38 @@
+/************************************************************
+
+   algorithm.h
+
+   $Author: ser1zw $
+
+   Copyright (C) 2013 ser1zw
+
+************************************************************/
+#ifndef RUBY_OPENCV_ALGORITHM_H
+#define RUBY_OPENCV_ALGORITHM_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_ALGORITHM namespace cAlgorithm {
+#define __NAMESPACE_END_ALGORITM }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_ALGORITHM
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+__NAMESPACE_END_ALGORITM
+
+inline cv::Algorithm*
+ALGORITHM(VALUE object)
+{
+  cv::Algorithm *ptr;
+  Data_Get_Struct(object, cv::Algorithm, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_ALGORITHM_H
+

data/ext/opencv/cvmat.cpp

@@ -254,7 +254,7 @@ void define_ruby_class()
   rb_define_method(rb_klass, "range", RUBY_METHOD_FUNC(rb_range), 2);
   rb_define_method(rb_klass, "range!", RUBY_METHOD_FUNC(rb_range_bang), 2);
 
-  rb_define_method(rb_klass, "reshape", RUBY_METHOD_FUNC(rb_reshape), 1);
+  rb_define_method(rb_klass, "reshape", RUBY_METHOD_FUNC(rb_reshape), -1);
   rb_define_method(rb_klass, "repeat", RUBY_METHOD_FUNC(rb_repeat), 1);
   rb_define_method(rb_klass, "flip", RUBY_METHOD_FUNC(rb_flip), -1);
   rb_define_method(rb_klass, "flip!", RUBY_METHOD_FUNC(rb_flip_bang), -1);
@@ -352,6 +352,7 @@ void define_ruby_class()
   rb_define_method(rb_klass, "resize", RUBY_METHOD_FUNC(rb_resize), -1);
   rb_define_method(rb_klass, "warp_affine", RUBY_METHOD_FUNC(rb_warp_affine), -1);
   rb_define_singleton_method(rb_klass, "rotation_matrix2D", RUBY_METHOD_FUNC(rb_rotation_matrix2D), 3);
+  rb_define_singleton_method(rb_klass, "get_perspective_transform", RUBY_METHOD_FUNC(rb_get_perspective_transform), 2);
   rb_define_method(rb_klass, "warp_perspective", RUBY_METHOD_FUNC(rb_warp_perspective), -1);
   rb_define_singleton_method(rb_klass, "find_homography", RUBY_METHOD_FUNC(rb_find_homograpy), -1);
   rb_define_method(rb_klass, "remap", RUBY_METHOD_FUNC(rb_remap), -1);
@@ -392,6 +393,7 @@ void define_ruby_class()
   rb_define_method(rb_klass, "inpaint", RUBY_METHOD_FUNC(rb_inpaint), 3);
 
   rb_define_method(rb_klass, "equalize_hist", RUBY_METHOD_FUNC(rb_equalize_hist), 0);
+  rb_define_method(rb_klass, "apply_color_map", RUBY_METHOD_FUNC(rb_apply_color_map), 1);
   rb_define_method(rb_klass, "match_template", RUBY_METHOD_FUNC(rb_match_template), -1);
   rb_define_method(rb_klass, "match_shapes", RUBY_METHOD_FUNC(rb_match_shapes), -1);
   rb_define_method(rb_klass, "match_descriptors", RUBY_METHOD_FUNC(rb_match_descriptors), -1);
@@ -411,6 +413,9 @@ void define_ruby_class()
 
   rb_define_method(rb_klass, "extract_surf", RUBY_METHOD_FUNC(rb_extract_surf), -1);
 
+  rb_define_method(rb_klass, "subspace_project", RUBY_METHOD_FUNC(rb_subspace_project), 2);
+  rb_define_method(rb_klass, "subspace_reconstruct", RUBY_METHOD_FUNC(rb_subspace_reconstruct), 2);
+
   rb_define_method(rb_klass, "save_image", RUBY_METHOD_FUNC(rb_save_image), -1);
   rb_define_alias(rb_klass, "save", "save_image");
 
@@ -1598,25 +1603,22 @@ rb_range_bang(VALUE self, VALUE start, VALUE end)
 
 /*
  * call-seq:
- *   reshape(<i>[:rows => num][, :channel => cn]</i>) -> cvmat(refer self)
+ *   reshape(cn, rows=0) -> cvmat(refer self)
  *
  * Change shape of matrix/image without copying data.
  *
- * e.g.
- *  mat = CvMat.new(3, 3, CV_8U, 3)  #=> 3x3 3-channel matrix
- *  vec = mat.reshape(:rows => 1)    #=> 1x9 3-channel matrix
- *  ch1 = mat.reshape(:channel => 1) #=> 9x9 1-channel matrix
+ * Parameter:
+ *   * cn - New number of channels. If the parameter is 0, the number of channels remains the same.
+ *   * rows - New number of rows. If the parameter is 0, the number of rows remains the same.
  */
 VALUE
-rb_reshape(VALUE self, VALUE hash)
+rb_reshape(int argc, VALUE *argv, VALUE self)
 {
-  Check_Type(hash, T_HASH);
-  VALUE channel = LOOKUP_HASH(hash, "channel");
-  VALUE rows = LOOKUP_HASH(hash, "rows");
+  VALUE cn, rows;
   CvMat *mat = NULL;
+  rb_scan_args(argc, argv, "11", &cn, &rows);
   try {
-    mat = cvReshape(CVARR(self), RB_CVALLOC(CvMat), NIL_P(channel) ? 0 : NUM2INT(channel),
-		    NIL_P(rows) ? 0 : NUM2INT(rows));
+    mat = cvReshape(CVARR(self), RB_CVALLOC(CvMat), NUM2INT(cn), IF_INT(rows, 0));
   }
   catch (cv::Exception& e) {
     if (mat != NULL)
@@ -2378,38 +2380,50 @@ rb_abs_diff(VALUE self, VALUE val)
 
 /*
  * call-seq:
- *   normalize(...) -> cvmat
+ *   normalize(alpha=1, beta=0, norm_type=NORM_L2, dtype=-1, mask=nil) -> cvmat
+ *
+ * Normalizes the norm or value range of an array.
  *
- * Normalizes the norm or value range of an array
+ * Parameters:
+ *   * alpha - norm value to normalize to or the lower range boundary in case of the range normalization.
+ *   * beta - upper range boundary in case of the range normalization; it is not used for the norm normalization.
+ *   * norm_type - normalization type.
+ *   * dtype - when negative, the output array has the same type as src; otherwise, it has the same number of channels as src and the depth
+ *   * mask - optional operation mask.
  */
 VALUE
 rb_normalize(int argc, VALUE *argv, VALUE self)
 {
-  VALUE alphaVal, betaVal, normTypeVal, maskVal;
-  rb_scan_args(argc, argv, "04", &alphaVal, &betaVal, &normTypeVal, &maskVal);
-  
-  const double alpha = alphaVal != Qnil ? NUM2DBL(alphaVal) : 1.0;
-  const double beta = betaVal != Qnil ? NUM2DBL(betaVal) : 0.0;
-  const int normType = normTypeVal != Qnil ? NUM2INT(normTypeVal) : cv::NORM_L2;
-  
-  VALUE dest = new_mat_kind_object(cvGetSize(CVARR(self)), self);
+  VALUE alpha_val, beta_val, norm_type_val, dtype_val, mask_val;
+  rb_scan_args(argc, argv, "05", &alpha_val, &beta_val, &norm_type_val, &dtype_val, &mask_val);
+
+  double alpha = NIL_P(alpha_val) ? 1.0 : NUM2DBL(alpha_val);
+  double beta = NIL_P(beta_val) ? 0.0 : NUM2DBL(beta_val);
+  int norm_type = NIL_P(norm_type_val) ? cv::NORM_L2 : NUM2INT(norm_type_val);
+  int dtype = NIL_P(dtype_val) ? -1 : NUM2INT(dtype_val);
+  VALUE dst;
+
   try {
-    const cv::Mat selfMat(CVMAT(self));
-    cv::Mat destMat(CVMAT(dest));
-    
-    if (NIL_P(maskVal)) {
-      cv::normalize(selfMat, destMat, alpha, beta, normType);
+    cv::Mat self_mat(CVMAT(self));
+    cv::Mat dst_mat;
+
+    if (NIL_P(mask_val)) {
+      cv::normalize(self_mat, dst_mat, alpha, beta, norm_type, dtype);
     }
     else {
-      cv::Mat maskMat(MASK(maskVal));
-      cv::normalize(selfMat, destMat, alpha, beta, normType, -1, maskMat);
+      cv::Mat mask(MASK(mask_val));
+      cv::normalize(self_mat, dst_mat, alpha, beta, norm_type, dtype, mask);
     }
-    
-  } catch (cv::Exception& e) {
+    dst = new_mat_kind_object(cvGetSize(CVARR(self)), self, dst_mat.depth(), dst_mat.channels());
+
+    CvMat tmp = dst_mat;
+    cvCopy(&tmp, CVMAT(dst));
+  }
+  catch (cv::Exception& e) {
     raise_cverror(e);
   }
 
-  return dest;
+  return dst;
 }
 
 /*
@@ -4040,6 +4054,40 @@ rb_rotation_matrix2D(VALUE self, VALUE center, VALUE angle, VALUE scale)
   return map_matrix;
 }
 
+/*
+ * call-seq:
+ *   CvMat.get_perspective_transform(<i>from_points,to_points</i>) -> cvmat
+ *
+ * Calculates a perspective transform from four pairs of the corresponding points.
+ * Returns a matrix suitable for use with warp_perspective
+ */
+VALUE
+rb_get_perspective_transform(VALUE self, VALUE source, VALUE dest)
+{
+  Check_Type(source, T_ARRAY);
+  Check_Type(dest, T_ARRAY);
+
+  int count = RARRAY_LEN(source);
+
+  CvPoint2D32f* source_buff = ALLOCA_N(CvPoint2D32f, count);
+  CvPoint2D32f* dest_buff = ALLOCA_N(CvPoint2D32f, count);
+
+  for (int i = 0; i < count; i++) {
+    source_buff[i] = *(CVPOINT2D32F(RARRAY_PTR(source)[i]));
+    dest_buff[i] = *(CVPOINT2D32F(RARRAY_PTR(dest)[i]));
+  }
+
+  VALUE map_matrix = new_object(cvSize(3, 3), CV_MAKETYPE(CV_32F, 1));
+
+  try {
+    cvGetPerspectiveTransform(source_buff, dest_buff, CVMAT(map_matrix));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return map_matrix;
+}
+
 /*
  * call-seq:
  *   warp_perspective(<i>map_matrix[,flags = CV_INTER_LINEAR | CV_WARP_FILL_OUTLIERS][,fillval=0])</i>) -> cvmat
@@ -5198,6 +5246,35 @@ rb_equalize_hist(VALUE self)
   return dest;
 }
 
+/*
+ * call-seq:
+ *   apply_color_map(colormap) -> cvmat
+ *
+ * Applies a GNU Octave/MATLAB equivalent colormap on a given image.
+ *
+ * Parameters:
+ *   colormap - The colormap to apply.
+ */
+VALUE
+rb_apply_color_map(VALUE self, VALUE colormap)
+{
+  VALUE dst;
+  try {
+    cv::Mat dst_mat;
+    cv::Mat self_mat(CVMAT(self));
+
+    cv::applyColorMap(self_mat, dst_mat, NUM2INT(colormap));
+    CvMat tmp = dst_mat;
+    dst = new_object(tmp.rows, tmp.cols, tmp.type);
+    cvCopy(&tmp, CVMAT(dst));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return dst;
+}
+
 /*
  * call-seq:
  *   match_template(<i>template[,method = :sqdiff]</i>) -> cvmat(result)
@@ -5309,7 +5386,6 @@ rb_match_descriptors(int argc, VALUE *argv, VALUE self)
 {
   VALUE images, detector_type, descriptor_type, matcher_type;
   rb_scan_args(argc, argv, "13", &images, &detector_type, &descriptor_type, &matcher_type);
-
   if (RARRAY_LEN(images) == 0) {
     return rb_hash_new();
   }
@@ -5323,54 +5399,58 @@ rb_match_descriptors(int argc, VALUE *argv, VALUE self)
     matcher_type = rb_str_new2("FlannBased");
   }
 
-  cv::Mat queryImage = CVMAT(self);
-  std::vector<cv::Mat> trainImages;
-  for(int i=0; i < RARRAY_LEN(images); i++) {
-    trainImages.push_back(CVMAT_WITH_CHECK(RARRAY_PTR(images)[i]));
-  }
-
-  cv::Ptr<cv::FeatureDetector> featureDetector = cv::FeatureDetector::create(RSTRING_PTR(detector_type));
-  if (featureDetector.empty()) {
-    rb_raise(rb_eArgError, "Could not create feature detector by given detector type: %s", RSTRING_PTR(detector_type));
-  }
-  cv::Ptr<cv::DescriptorExtractor> descriptorExtractor = cv::DescriptorExtractor::create(RSTRING_PTR(descriptor_type));
-  if (descriptorExtractor.empty()) {
-    rb_raise(rb_eArgError, "Could not create descriptor extractor by given descriptor type: %s", RSTRING_PTR(descriptor_type));
-  }
-  cv::Ptr<cv::DescriptorMatcher> descriptorMatcher;
+  VALUE _matches = rb_hash_new();
   try {
-    descriptorMatcher = cv::DescriptorMatcher::create(RSTRING_PTR(matcher_type));
-  }
-  catch(cv::Exception& e) {
-    rb_raise(rb_eArgError, "Could not create descriptor matcher by given matcher type: %s", RSTRING_PTR(matcher_type));
-  }
-
-  std::vector<cv::KeyPoint> queryKeypoints;
-  std::vector<std::vector<cv::KeyPoint> > trainKeypoints;
-  featureDetector->detect(queryImage, queryKeypoints);
-  featureDetector->detect(trainImages, trainKeypoints);
-
-  cv::Mat queryDescriptors;
-  std::vector<cv::Mat> trainDescriptors;
-  descriptorExtractor->compute(queryImage, queryKeypoints, queryDescriptors);
-  descriptorExtractor->compute(trainImages, trainKeypoints, trainDescriptors);
+    cv::Mat queryImage(CVMAT(self));
+    std::vector<cv::Mat> trainImages;
+    for(int i = 0, n = RARRAY_LEN(images); i < n; i++) {
+      trainImages.push_back(CVMAT_WITH_CHECK(RARRAY_PTR(images)[i]));
+    }
 
-  std::vector<cv::DMatch> matches;
-  descriptorMatcher->add(trainDescriptors);
-  descriptorMatcher->train();
-  descriptorMatcher->match(queryDescriptors, matches);
+    cv::Ptr<cv::FeatureDetector> featureDetector = cv::FeatureDetector::create(StringValueCStr(detector_type));
+    if (featureDetector.empty()) {
+      rb_raise(rb_eArgError, "Could not create feature detector by given detector type: %s", StringValueCStr(detector_type));
+    }
+    cv::Ptr<cv::DescriptorExtractor> descriptorExtractor = cv::DescriptorExtractor::create(StringValueCStr(descriptor_type));
+    if (descriptorExtractor.empty()) {
+      rb_raise(rb_eArgError, "Could not create descriptor extractor by given descriptor type: %s", StringValueCStr(descriptor_type));
+    }
+    cv::Ptr<cv::DescriptorMatcher> descriptorMatcher;
+    try {
+      descriptorMatcher = cv::DescriptorMatcher::create(StringValueCStr(matcher_type));
+    }
+    catch(cv::Exception& e) {
+      rb_raise(rb_eArgError, "Could not create descriptor matcher by given matcher type: %s", StringValueCStr(matcher_type));
+    }
 
-  VALUE _matches = rb_hash_new();
-  for (size_t i=0; i<matches.size(); i++) {
-    VALUE match = INT2FIX(matches[i].imgIdx);
-    VALUE count = rb_hash_lookup(_matches, match);
-    if (NIL_P(count)) {
-      count = INT2FIX(1);
-    } else {
-      count = INT2FIX(FIX2INT(count) + 1);
+    std::vector<cv::KeyPoint> queryKeypoints;
+    std::vector<std::vector<cv::KeyPoint> > trainKeypoints;
+    featureDetector->detect(queryImage, queryKeypoints);
+    featureDetector->detect(trainImages, trainKeypoints);
+    cv::Mat queryDescriptors;
+    std::vector<cv::Mat> trainDescriptors;
+    descriptorExtractor->compute(queryImage, queryKeypoints, queryDescriptors);
+    descriptorExtractor->compute(trainImages, trainKeypoints, trainDescriptors);
+    std::vector<cv::DMatch> matches;
+    descriptorMatcher->add(trainDescriptors);
+    descriptorMatcher->train();
+    descriptorMatcher->match(queryDescriptors, matches);
+
+    for (size_t i = 0, n = matches.size(); i < n; i++) {
+      VALUE match = INT2FIX(matches[i].imgIdx);
+      VALUE count = rb_hash_lookup(_matches, match);
+      if (NIL_P(count)) {
+	count = INT2FIX(1);
+      } else {
+	count = INT2FIX(FIX2INT(count) + 1);
+      }
+      rb_hash_aset(_matches, match, count);
     }
-    rb_hash_aset(_matches, match, count);
   }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
   return _matches;
 }
 
@@ -5800,6 +5880,55 @@ rb_extract_surf(int argc, VALUE *argv, VALUE self)
   return rb_assoc_new(_keypoints, _descriptors);
 }
 
+
+/*
+ * call-seq:
+ *   subspace_project(w, mean) -> cvmat
+ */
+VALUE
+rb_subspace_project(VALUE self, VALUE w, VALUE mean)
+{
+  VALUE projection;
+  try {
+    cv::Mat w_mat(CVMAT_WITH_CHECK(w));
+    cv::Mat mean_mat(CVMAT_WITH_CHECK(mean));
+    cv::Mat self_mat(CVMAT(self));
+    cv::Mat pmat = cv::subspaceProject(w_mat, mean_mat, self_mat);
+    projection = new_object(pmat.rows, pmat.cols, pmat.type());
+    CvMat tmp = pmat;
+    cvCopy(&tmp, CVMAT(projection));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return projection;
+}
+
+/*
+ * call-seq:
+ *   subspace_reconstruct(w, mean) -> cvmat
+ */
+VALUE
+rb_subspace_reconstruct(VALUE self, VALUE w, VALUE mean)
+{
+  VALUE result;
+  try {
+    cv::Mat w_mat(CVMAT_WITH_CHECK(w));
+    cv::Mat mean_mat(CVMAT_WITH_CHECK(mean));
+    cv::Mat self_mat(CVMAT(self));
+    cv::Mat rmat = cv::subspaceReconstruct(w_mat, mean_mat, self_mat);
+    result = new_object(rmat.rows, rmat.cols, rmat.type());
+    CvMat tmp = rmat;
+    cvCopy(&tmp, CVMAT(result));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return result;
+}
+
 VALUE
 new_object(int rows, int cols, int type)
 {

data/ext/opencv/cvmat.h

@@ -78,7 +78,7 @@ 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(VALUE self, VALUE hash);
+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);
@@ -175,6 +175,7 @@ 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_homograpy(int argc, VALUE *argv, VALUE self);
 VALUE rb_remap(int argc, VALUE *argv, VALUE self);
@@ -214,6 +215,9 @@ 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);
@@ -236,6 +240,9 @@ VALUE rb_compute_correspond_epilines(VALUE klass, VALUE points, VALUE which_imag
 /* 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);