change module name to Cv

ext/opencv/mat_imgproc.cppe

@@ -0,0 +1,181 @@
+// -*- mode: c++; coding: utf-8 -*-
+#include "opencv2/imgproc.hpp"
+
+#include "mat.hpp"
+#include "size.hpp"
+#include "error.hpp"
+
+/*
+ * Document-class: OpenCV::Mat
+ */
+namespace rubyopencv {
+  namespace Mat {
+    /*
+     * Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
+     *
+     * @overload sobel(ddepth, dx, dy, ksize = 3, scale = 1, delta = 0, border_type = BORDER_DEFAULT)
+     *   @param ddepth [Integer] Output image depth
+     *   @param dx [Integer] Order of the derivative x.
+     *   @param dy [Integer] Order of the derivative y.
+     *   @param ksize [Integer] Size of the extended Sobel kernel; it must be 1, 3, 5, or 7.
+     *   @param scale [Number] Optional scale factor for the computed derivative values; by default, no scaling is applied.
+     *   @param delta [Number] Optional delta value that is added to the results prior to storing them in the output image.
+     *   @param border_type [Integer] Pixel extrapolation method.
+     * @return [Mat] Output image.
+     * @opencv_func cv::Sovel
+     */
+    VALUE rb_sobel(int argc, VALUE *argv, VALUE self) {
+      VALUE ddepth, dx, dy, ksize, scale, delta, border_type;
+      rb_scan_args(argc, argv, "34", &ddepth ,&dx, &dy, &ksize, &scale, &delta, &border_type);
+      int ksize_value = NIL_P(ksize) ? 3 : NUM2INT(ksize);
+      double scale_value = NIL_P(scale) ? 1.0 : NUM2DBL(scale);
+      double delta_value = NIL_P(delta) ? 0.0 : NUM2DBL(delta);
+      int border_type_value = NIL_P(border_type) ? cv::BORDER_DEFAULT : NUM2INT(border_type);
+
+      cv::Mat* selfptr = obj2mat(self);
+      cv::Mat* destptr = empty_mat();
+      try {
+	cv::Sobel(*selfptr, *destptr, NUM2INT(ddepth), NUM2INT(dx), NUM2INT(dy),
+		  ksize_value, scale_value, delta_value, border_type_value);
+      }
+      catch (cv::Exception& e) {
+	delete destptr;
+	Error::raise(e);
+      }
+
+      return mat2obj(destptr, CLASS_OF(self));
+    }
+
+    /**
+     * Finds edges in an image using the [Canny86] algorithm.
+     *
+     * @overload canny(threshold1, threshold2, aperture_size = 3, l2gradient = false)
+     *   @param threshold1 [Number] First threshold for the hysteresis procedure.
+     *   @param threshold2 [Number] Second threshold for the hysteresis procedure.
+     *   @param aperture_size [Integer] Aperture size for the Sobel operator.
+     *   @param l2gradient [Boolean] a flag, indicating whether a more accurate L_2 =\sqrt{ (dI/dx)^2 + (dI/dy)^2 } norm
+     *     should be used to calculate the image gradient magnitude (l2gradient=true),
+     *     or whether the default L_1 norm =|dI/dx|+|dI/dy| is enough (l2gradient=false).
+     * @opencv_func cv::Canny
+     */
+    VALUE rb_canny(int argc, VALUE *argv, VALUE self) {
+      VALUE threshold1, threshold2, aperture_size, l2gradient;
+      rb_scan_args(argc, argv, "22", &threshold1, &threshold2, &aperture_size, &l2gradient);
+
+      int aperture_size_value = NIL_P(aperture_size) ? 3 : NUM2INT(aperture_size);
+      bool l2gradient_value = RTEST(l2gradient) ? true : false;
+
+      cv::Mat* selfptr = obj2mat(self);
+      cv::Mat* destptr = empty_mat();
+      try {
+	cv::Canny(*selfptr, *destptr, NUM2DBL(threshold1), NUM2DBL(threshold2),
+		  aperture_size_value, l2gradient_value);
+      }
+      catch (cv::Exception& e) {
+	delete destptr;
+	Error::raise(e);
+      }
+
+      return mat2obj(destptr, CLASS_OF(self));
+    }
+
+    /*
+     * Calculates the Laplacian of an image.
+     *
+     * @overload laplacian(ddepth, ksize = 1, scale = 1, delta = 0, border_type = BORDER_DEFAULT)
+     *   @param ddepth [Integer] Desired depth of the destination image.
+     *   @param ksize [Integer] Aperture size used to compute the second-derivative filters.
+     *     The size must be positive and odd.
+     *   @param scale [Number] Optional scale factor for the computed Laplacian values. By default, no scaling is applied.
+     *   @param delta [Number] Optional delta value that is added to the results prior to storing them in the output image.
+     *   @param border_type [Integer] Pixel extrapolation method.
+     * @return [Mat] Output image.
+     * @opencv_func cv::Laplacian
+     */
+    VALUE rb_laplacian(int argc, VALUE *argv, VALUE self) {
+      VALUE ddepth, ksize, scale, delta, border_type;
+      rb_scan_args(argc, argv, "14", &ddepth, &ksize, &scale, &delta, &border_type);
+      int ksize_value = NIL_P(ksize) ? 3 : NUM2INT(ksize);
+      double scale_value = NIL_P(scale) ? 1.0 : NUM2DBL(scale);
+      double delta_value = NIL_P(delta) ? 0.0 : NUM2DBL(delta);
+      int border_type_value = NIL_P(border_type) ? cv::BORDER_DEFAULT : NUM2INT(border_type);
+
+      cv::Mat* selfptr = obj2mat(self);
+      cv::Mat* destptr = empty_mat();
+      try {
+	cv::Laplacian(*selfptr, *destptr, NUM2INT(ddepth), ksize_value, scale_value,
+		      delta_value, border_type_value);
+      }
+      catch (cv::Exception& e) {
+	delete destptr;
+	Error::raise(e);
+      }
+
+      return mat2obj(destptr, CLASS_OF(self));
+    }
+
+    /**
+     * Converts an image from one color space to another.
+     *
+     * @overload cvt_color(code, dcn = 0)
+     *   @param code [Integer] Color space conversion code
+     *   @param dcn [Integer] Number of channels in the destination image; if the parameter is 0,
+     *     the number of the channels is derived automatically from src and code
+     * @return [Mat] Output image
+     * @opencv_func cv::cvtColor
+     */
+    VALUE rb_cvt_color(int argc, VALUE *argv, VALUE self) {
+      VALUE code, dcn;
+      rb_scan_args(argc, argv, "11", &code, &dcn);
+      int dcn_value = NIL_P(dcn) ? 0 : NUM2INT(dcn);
+
+      cv::Mat* destptr = empty_mat();
+      cv::Mat* selfptr = obj2mat(self);
+      try {
+	cv::cvtColor(*selfptr, *destptr, NUM2INT(code), dcn_value);
+      }
+      catch (cv::Exception& e) {
+	delete destptr;
+	Error::raise(e);
+      }
+
+      return mat2obj(destptr, CLASS_OF(self));
+    }
+
+    /*
+     * Resizes an image.
+     *
+     * @overload resize(size, interpolation = INTER_LINEAR)
+     *   @param size [Size] Output image size.
+     *   @param interpolation [Integer] Interpolation method:
+     *     * <tt>INTER_NEAREST</tt> - A nearest-neighbor interpolation
+     *	   * <tt>INTER_LINEAR</tt> - A bilinear interpolation (used by default)
+     *	   * <tt>INTER_AREA</tt> - Resampling using pixel area relation. It may be a preferred method for
+     *       image decimation, as it gives moire'-free results. But when the image is zoomed,
+     *       it is similar to the <tt>INTER_NEAREST</tt> method.
+     *     * <tt>INTER_CUBIC</tt> - A bicubic interpolation over 4x4 pixel neighborhood
+     *	   * <tt>INTER_LANCZOS4</tt> - A Lanczos interpolation over 8x8 pixel neighborhood
+     * @return [Mat] Output image.
+     * @opencv_func cv::Resize
+     */
+    VALUE rb_resize(int argc, VALUE *argv, VALUE self) {
+      VALUE size, inv_scale_x, inv_scale_y, interpolation;
+      rb_scan_args(argc, argv, "13", &size, &inv_scale_x, &inv_scale_y, &interpolation);
+      cv::Size* sizeptr = Size::obj2size(size);
+      cv::Mat* selfptr = obj2mat(self);
+      cv::Mat* destptr = empty_mat();
+      double sx = NIL_P(inv_scale_x) ? 0 : NUM2DBL(inv_scale_x);
+      double sy = NIL_P(inv_scale_y) ? 0 : NUM2DBL(inv_scale_y);
+      int method = NIL_P(interpolation) ? CV_INTER_LINEAR : NUM2INT(interpolation);
+
+      try {
+	cv::resize(*selfptr, *destptr, *sizeptr, sx, sy, method);
+      }
+      catch (cv::Exception& e) {
+	Error::raise(e);
+      }
+
+      return mat2obj(destptr, CLASS_OF(self));
+    }
+  }
+}