bonanza-ruby-opencv 0.0.13.20140330211753

data/examples/snake.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# snake.rb
+require "rubygems"
+require "opencv"
+include OpenCV
+
+puts <<USAGE
+usage:
+  left-click: set a point
+  right-click: do snake
+USAGE
+
+window = GUI::Window.new "snake demo"
+image = CvMat.new(256, 256, :cv8u, 1).clear!
+image.circle!(CvPoint.new(128,128), 40, color: CvColor::White, thickness: -1)
+display = image.GRAY2BGR
+
+window.show display
+
+points = []
+
+window.on_mouse{|mouse|
+  case mouse.event
+  when :left_button_down
+    display.circle!(mouse, 1, color: CvColor::Red, thickness: 2)
+    puts "set point (#{mouse.x},#{mouse.y})"
+    points << CvPoint.new(mouse.x, mouse.y)
+    window.show display
+  when :right_button_down
+    if points.length < 3
+      puts "please set more point!"
+      next
+    end
+    snake_points = image.snake_image(points, 1.0, 0.5, 1.5, CvSize.new(3, 3), 100)
+    display = image.GRAY2BGR
+    display.poly_line!([snake_points], color: CvColor::Red, is_closed: true, thickness: 2)
+    window.show display
+    points.clear
+  end
+}
+
+GUI::wait_key
+

data/ext/opencv/algorithm.cpp

@@ -0,0 +1,291 @@
+/************************************************************
+
+   algorithm.cpp -
+
+   $Author: ser1zw $
+
+   Copyright (C) 2013 ser1zw
+
+************************************************************/
+#include <stdio.h>
+#include "algorithm.h"
+/*
+ * Document-class: OpenCV::Algorithm
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_ALGORITHM
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+VALUE
+rb_set_int(VALUE self, VALUE parameter, VALUE value)
+{
+  Check_Type(parameter, T_STRING);
+  try {
+    ALGORITHM(self)->setInt(StringValueCStr(parameter), NUM2INT(value));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+VALUE
+rb_set_double(VALUE self, VALUE parameter, VALUE value)
+{
+  Check_Type(parameter, T_STRING);
+  try {
+    ALGORITHM(self)->setDouble(StringValueCStr(parameter), NUM2DBL(value));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+VALUE
+rb_set_bool(VALUE self, VALUE parameter, VALUE value)
+{
+  Check_Type(parameter, T_STRING);
+  try {
+    bool val = TRUE_OR_FALSE(value) ? true : false;
+    ALGORITHM(self)->setBool(StringValueCStr(parameter), val);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+VALUE
+rb_set_string(VALUE self, VALUE parameter, VALUE value)
+{
+  Check_Type(parameter, T_STRING);
+  Check_Type(value, T_STRING);
+  try {
+    ALGORITHM(self)->setString(StringValueCStr(parameter), StringValueCStr(value));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+VALUE
+rb_set_mat(VALUE self, VALUE parameter, VALUE value)
+{
+  Check_Type(parameter, T_STRING);
+  try {
+    CvMat* val = CVMAT_WITH_CHECK(value);
+    cv::Mat mat(val);
+    ALGORITHM(self)->setMat(StringValueCStr(parameter), mat);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+VALUE
+rb_set_matvector(VALUE self, VALUE parameter, VALUE value)
+{
+  Check_Type(parameter, T_STRING);
+  Check_Type(value, T_ARRAY);
+  try {
+    long len = RARRAY_LEN(value);
+    VALUE* value_ptr = RARRAY_PTR(value);
+    std::vector<cv::Mat> mat_vector;
+    for (int i = 0; i < len; i++) {
+      CvMat* val = CVMAT_WITH_CHECK(value_ptr[i]);
+      cv::Mat mat(val);
+      mat_vector.push_back(mat);
+    }
+    ALGORITHM(self)->setMatVector(StringValueCStr(parameter), mat_vector);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+VALUE
+rb_set_algorithm(VALUE self, VALUE parameter, VALUE value)
+{
+  Check_Type(parameter, T_STRING);
+  try {
+    ALGORITHM(self)->setAlgorithm(StringValueCStr(parameter), ALGORITHM(value));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+
+VALUE
+rb_get_int(VALUE self, VALUE parameter)
+{
+  Check_Type(parameter, T_STRING);
+  int value = 0;
+  try {
+    value = ALGORITHM(self)->getInt(StringValueCStr(parameter));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return INT2NUM(value);
+}
+
+VALUE
+rb_get_double(VALUE self, VALUE parameter)
+{
+  Check_Type(parameter, T_STRING);
+  double value = 0.0;
+  try {
+    value = ALGORITHM(self)->getDouble(StringValueCStr(parameter));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return DBL2NUM(value);
+}
+
+VALUE
+rb_get_bool(VALUE self, VALUE parameter)
+{
+  Check_Type(parameter, T_STRING);
+  bool value = false;
+  try {
+    value = ALGORITHM(self)->getBool(StringValueCStr(parameter));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return value ? Qtrue : Qfalse;
+}
+
+VALUE
+rb_get_string(VALUE self, VALUE parameter)
+{
+  Check_Type(parameter, T_STRING);
+  std::string value = "";
+  try {
+    value = ALGORITHM(self)->getString(StringValueCStr(parameter));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return rb_str_new_cstr(value.c_str());
+}
+
+VALUE
+rb_get_mat(VALUE self, VALUE parameter)
+{
+  Check_Type(parameter, T_STRING);
+  VALUE mat = Qnil;
+  try {
+    cv::Mat value = ALGORITHM(self)->getMat(StringValueCStr(parameter));
+    cv::Size size = value.size();
+    mat = cCvMat::new_object(size.height, size.width, value.type());
+    cv::Mat dst(CVMAT(mat));
+    value.copyTo(dst);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return mat;
+}
+
+VALUE
+rb_get_matvector(VALUE self, VALUE parameter)
+{
+  Check_Type(parameter, T_STRING);
+  VALUE array = Qnil;
+  try {
+    std::vector<cv::Mat> value = ALGORITHM(self)->getMatVector(StringValueCStr(parameter));
+    int len = value.size();
+    array = rb_ary_new2(len);
+    for (int i = 0; i < len; i++) {
+      cv::Mat m = value[i];
+      cv::Size size = m.size();
+      VALUE mat = cCvMat::new_object(size.height, size.width, m.type());
+      cv::Mat dst(CVMAT(mat));
+      m.copyTo(dst);
+      rb_ary_store(array, i, mat);
+    }
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return array;
+}
+
+VALUE
+rb_name(VALUE self)
+{
+  VALUE name = Qnil;
+  try {
+    name = rb_str_new_cstr(ALGORITHM(self)->name().c_str());
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return name;
+}
+
+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, "Algorithm", rb_cObject);
+  rb_define_method(rb_klass, "set_int", RUBY_METHOD_FUNC(rb_set_int), 2);
+  rb_define_method(rb_klass, "set_double", RUBY_METHOD_FUNC(rb_set_double), 2);
+  rb_define_method(rb_klass, "set_bool", RUBY_METHOD_FUNC(rb_set_bool), 2);
+  rb_define_method(rb_klass, "set_string", RUBY_METHOD_FUNC(rb_set_string), 2);
+  rb_define_method(rb_klass, "set_mat", RUBY_METHOD_FUNC(rb_set_mat), 2);
+  rb_define_method(rb_klass, "set_matvector", RUBY_METHOD_FUNC(rb_set_matvector), 2);
+  rb_define_method(rb_klass, "set_algorithm", RUBY_METHOD_FUNC(rb_set_algorithm), 2);
+
+  rb_define_method(rb_klass, "get_int", RUBY_METHOD_FUNC(rb_get_int), 1);
+  rb_define_method(rb_klass, "get_double", RUBY_METHOD_FUNC(rb_get_double), 1);
+  rb_define_method(rb_klass, "get_bool", RUBY_METHOD_FUNC(rb_get_bool), 1);
+  rb_define_method(rb_klass, "get_string", RUBY_METHOD_FUNC(rb_get_string), 1);
+  rb_define_method(rb_klass, "get_mat", RUBY_METHOD_FUNC(rb_get_mat), 1);
+  rb_define_method(rb_klass, "get_matvector", RUBY_METHOD_FUNC(rb_get_matvector), 1);
+
+  rb_define_method(rb_klass, "name", RUBY_METHOD_FUNC(rb_name), 0);
+}
+
+__NAMESPACE_END_ALGORITM
+__NAMESPACE_END_OPENCV
+

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 init_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/curve.cpp

@@ -0,0 +1,127 @@
+/************************************************************
+
+   curve.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#include "curve.h"
+/*
+ * Document-class: OpenCV::Curve
+ *
+ * Curve sequence
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CURVE
+
+VALUE module;
+    
+VALUE
+rb_module()
+{
+  return module;
+}
+
+/*
+ * If the curve is closed, return true. Otherwise return false.
+ * @overload closed?
+ * @return [Boolean] Closed or not
+ * @opencv_func CV_IS_SEQ_CLOSED
+ */
+VALUE
+rb_closed_q(VALUE self)
+{
+  return CV_IS_SEQ_CLOSED(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * If the curve is convex, return true. Otherwise return false.
+ * @overload convex?
+ * @return [Boolean] Convex or not
+ * @opencv_func CV_IS_SEQ_CONVEX
+ */
+VALUE
+rb_convex_q(VALUE self)
+{
+  return CV_IS_SEQ_CONVEX(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * If the curve is hole(inner contour), return true. Otherwise return false.
+ * @overload hole?
+ * @return [Boolean] Hole or not
+ * @opencv_func CV_IS_SEQ_HOLE
+ */
+VALUE
+rb_hole_q(VALUE self)
+{  
+  return CV_IS_SEQ_HOLE(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * If the curve is simple, return true. Otherwise return false.
+ * @overload simple?
+ * @return [Boolean] Simple or not
+ * @opencv_func CV_IS_SEQ_SIMPLE
+ */
+VALUE
+rb_simple_q(VALUE self)
+{
+  return CV_IS_SEQ_SIMPLE(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * Calculates length of a curve
+ * @overload arc_length(slice = nil, is_closed = nil)
+ *   @param slice [Range,CvSlice,nil] Starting and ending points of the curve.
+ *     By default, the whole curve length is calculated.
+ *   @param is_closed [Boolean,nil] Indicates whether the curve is closed or not.
+ *     There are 3 cases:
+ *     * is_closed = true  - the curve is assumed to be unclosed.
+ *     * is_closed = false - the curve is assumed to be closed.
+ *     * is_closed = nil (default) use self#closed?
+ * @return [Number] Length of the curve
+ * @opencv_func cvArcLength
+ */
+VALUE
+rb_arc_length(int argc, VALUE *argv, VALUE self)
+{
+  VALUE slice, is_closed;
+  rb_scan_args(argc, argv, "02", &slice, &is_closed);
+  double length = 0;
+  try {
+    length = cvArcLength(CVARR(self),
+			 NIL_P(slice) ? CV_WHOLE_SEQ : VALUE_TO_CVSLICE(slice),
+			 TRUE_OR_FALSE(is_closed, -1));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return rb_float_new(length);
+}
+
+void
+init_ruby_module()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+#endif
+
+  if (module)
+    return;
+
+  VALUE opencv = rb_module_opencv();
+  module = rb_define_module_under(opencv, "Curve");
+  rb_define_method(module, "closed?", RUBY_METHOD_FUNC(rb_closed_q), 0);
+  rb_define_method(module, "convex?", RUBY_METHOD_FUNC(rb_convex_q), 0);
+  rb_define_method(module, "hole?", RUBY_METHOD_FUNC(rb_hole_q), 0);
+  rb_define_method(module, "simple?", RUBY_METHOD_FUNC(rb_simple_q), 0);
+  rb_define_method(module, "arc_length", RUBY_METHOD_FUNC(rb_arc_length), -1);
+}
+
+__NAMESPACE_END_CURVE
+__NAMESPACE_END_OPENCV
+