jf-ruby-opencv 0.0.18

data/ext/opencv/pointset.h

@@ -0,0 +1,68 @@
+/************************************************************
+
+   pointset.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_POINTSET_H
+#define RUBY_OPENCV_POINTSET_H
+
+#define __NAMESPACE_BEGIN_POINT_SET namespace mPointSet {
+#define __NAMESPACE_END_POINT_SET }
+
+#include "opencv.h"
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_POINT_SET
+
+VALUE rb_module();
+
+void init_ruby_module();
+VALUE rb_contour_area(int argc, VALUE *argv, VALUE self);
+VALUE rb_fit_ellipse2(VALUE self);
+VALUE rb_convex_hull2(int argc, VALUE *argv, VALUE self);
+VALUE rb_fit_line(int argc, VALUE *argv, VALUE self);
+VALUE rb_check_contour_convexity(VALUE self);
+VALUE rb_convexity_defects(VALUE self, VALUE hull);
+VALUE rb_min_area_rect2(VALUE self);
+VALUE rb_min_enclosing_circle(VALUE self);
+
+__NAMESPACE_END_POINT_SET
+
+#define POINT_SET_P(object) rb_obj_is_kind_of(object, cCvSeq::rb_class()) && CV_IS_SEQ_POINT_SET(CVSEQ(object))
+
+/*
+inline CvPoint*
+POINTSET(VALUE object)
+{
+  CvPoint *pointset = (CvPoint*)cvAlloc(CVSEQ(object)->total * sizeof(CvPoint));  
+  cvCvtSeqToArray(CVSEQ(object), pointset, CV_WHOLE_SEQ);
+  if (cCvSeq::seqblock_class(CVSEQ(object)) == cCvPoint2D32f::rb_class()) {
+    for(int i =0; i < CVSEQ(object)->total; i++)
+      pointset[i] = cvPointFrom32f(((CvPoint2D32f*)pointset)[i]);
+  }
+  return pointset;
+}
+
+inline CvPoint2D32f*
+POINTSET2D32f(VALUE object)
+{
+  CvPoint2D32f *pointset = (CvPoint2D32f*)cvAlloc(CVSEQ(object)->total * sizeof(CvPoint2D32f));
+  cvCvtSeqToArray(CVSEQ(object), pointset, CV_WHOLE_SEQ);
+  if (cCvSeq::seqblock_class(CVSEQ(object)) == cCvPoint::rb_class()) {
+    for(int i = 0; i < CVSEQ(object)->total; i++)
+      pointset[i] = cvPointTo32f(((CvPoint*)pointset)[i]);
+  }
+  return pointset;
+}
+*/
+
+int CVPOINTS_FROM_POINT_SET(VALUE object, CvPoint **pointset);
+CvSeq* VALUE_TO_POINT_SET(VALUE object);
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_POINTSET_H

data/ext/opencv/trackbar.cpp

@@ -0,0 +1,127 @@
+/************************************************************
+
+   trackbar.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#include "trackbar.h"
+/*
+ * Document-class: OpenCV::GUI::Trackbar
+ *
+ * Simple Trackbar wedget. OpenCV::GUI::Window can treat trackbar.
+ * Trackbar can treat only positive-integer value.
+ */
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_GUI
+__NAMESPACE_BEGIN_TRACKBAR
+
+VALUE rb_klass;
+
+VALUE rb_class() {
+  return rb_klass;
+}
+
+VALUE rb_allocate(VALUE klass) {
+  Trackbar *ptr;
+  return Data_Make_Struct(klass, Trackbar, trackbar_mark, trackbar_free, ptr);
+}
+
+void trackbar_mark(void *ptr) {
+  rb_gc_mark(((Trackbar*)ptr)->block);
+}
+
+void trackbar_free(void *ptr) {
+  Trackbar *trackbar = (Trackbar*)ptr;
+  free(trackbar->name);
+  free(trackbar);
+}
+
+/*
+ * call-seq:
+ *   new(name,maxval[,val],&block)
+ *   new(name,maxval[,val]){|value| ... }
+ *
+ * Create new Trackbar.
+ * <i>name</i> should be String.
+ * <i>maxval</i> and <i>val</i> should be Integer.
+ * When Trackbar adjuster changed, block will be called.
+ */
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE name, maxval, val, block;
+  rb_scan_args(argc, argv, "21&", &name, &maxval, &val, &block);
+  if (NIL_P(block))
+    rb_raise(rb_eArgError, "block not given.");
+  Check_Type(name, T_STRING);
+  Trackbar *trackbar = TRACKBAR(self);
+  trackbar->name = strcpy(ALLOC_N(char, RSTRING_LEN(name) + 1), StringValueCStr(name));
+  trackbar->maxval = NUM2INT(maxval);
+  trackbar->val = IF_INT(val, 0);
+  trackbar->block = block;
+  return self;
+}
+
+/*
+ * Return trackbar name.
+ */
+VALUE rb_name(VALUE self) {
+  return rb_str_new2(TRACKBAR(self)->name);
+}
+
+/*
+ * Return the maximum value that can be taken this trackbar.
+ */
+VALUE rb_max(VALUE self) {
+  return INT2NUM(TRACKBAR(self)->maxval);
+}
+
+/*
+ * Return the value of this trackbar.
+ */
+VALUE rb_value(VALUE self) {
+  return INT2NUM(TRACKBAR(self)->val);
+}
+
+/*
+ * call-seq:
+ *   value  = <i>val</i>
+ *
+ * Set trackbar value.
+ */
+VALUE rb_set_value(VALUE self, VALUE val) {
+  TRACKBAR(self)->val = NUM2INT(val);
+  return self;
+}
+
+void init_ruby_class() {
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+  VALUE GUI = rb_define_module_under(opencv, "GUI");
+#endif
+
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * GUI = rb_define_module_under(opencv, "GUI");
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE GUI = rb_module_GUI();
+  rb_klass = rb_define_class_under(GUI, "Trackbar", 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, "name", RUBY_METHOD_FUNC(rb_name), 0);
+  rb_define_method(rb_klass, "max", RUBY_METHOD_FUNC(rb_max), 0);
+  rb_define_method(rb_klass, "value", RUBY_METHOD_FUNC(rb_value), 0);
+  rb_define_method(rb_klass, "value=", RUBY_METHOD_FUNC(rb_set_value), 1);
+}
+      
+__NAMESPACE_END_TRACKBAR
+__NAMESPACE_END_GUI
+__NAMESPACE_END_OPENCV
+

data/ext/opencv/trackbar.h

@@ -0,0 +1,69 @@
+/************************************************************
+
+   trackbar.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_GUI_H
+#include "gui.h"
+#endif
+
+#ifndef RUBY_OPENCV_GUI_TRACKBAR_H
+#define RUBY_OPENCV_GUI_TRACKBAR_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_TRACKBAR namespace cTrackbar {
+#define __NAMESPACE_END_TRACKBAR }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_GUI
+
+typedef struct Trackbar {
+  char *name;
+  int maxval;
+  int val;
+  VALUE block;
+} Trackbar;
+
+__NAMESPACE_BEGIN_TRACKBAR
+
+VALUE rb_class();
+
+void init_ruby_class();
+VALUE rb_allocate(VALUE klass);
+
+void trackbar_mark(void *ptr);
+void trackbar_free(void *ptr);
+
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_name(VALUE self);
+VALUE rb_max(VALUE self);
+VALUE rb_value(VALUE self);
+VALUE rb_set_value(VALUE self, VALUE val);
+
+__NAMESPACE_END_TRACKBAR
+
+inline Trackbar*
+TRACKBAR(VALUE object) {
+  Trackbar *ptr;
+  Data_Get_Struct(object, Trackbar, ptr);
+  return ptr;
+}
+
+inline Trackbar*
+TRACKBAR_WITH_CHECK(VALUE object) {
+  if (!rb_obj_is_kind_of(object, cTrackbar::rb_class())) {
+    raise_typeerror(object, cTrackbar::rb_class());
+  }
+  return TRACKBAR(object);
+}
+
+__NAMESPACE_END_GUI
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_GUI_TRACKBAR_H
+

data/ext/opencv/window.cpp

@@ -0,0 +1,377 @@
+/************************************************************
+
+   window.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "window.h"
+
+/*
+ * Document-class: OpenCV::GUI::Window
+ *
+ * Simple Window wedget to show images(CvMat/IplImage).
+ *
+ * Sample:
+ *   image = OpenCV::IplImage::load("opencv.bmp")     #=> load image
+ *   window = OpenCV::GUI::Window.new("simple viewer")#=> create new window named "simaple viewer"
+ *   window.show(image)                               #=> show image
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_GUI
+__NAMESPACE_BEGIN_WINDOW
+
+int num_windows = 0;
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  Window *ptr;
+  return Data_Make_Struct(klass, Window, window_mark, window_free, ptr);
+}
+
+void
+window_mark(void *ptr)
+{
+  Window* window_ptr = (Window*)ptr;
+  rb_gc_mark(window_ptr->name);
+  rb_gc_mark(window_ptr->image);
+  rb_gc_mark(window_ptr->trackbars);
+  rb_gc_mark(window_ptr->blocks);
+}
+
+void
+window_free(void *ptr)
+{
+  free(ptr);
+}
+
+/*
+ * Creates a window.
+ *
+ * @overload new(name, flags = CV_WINDOW_AUTOSIZE)
+ *   @param name [String] Name of the window in the window caption that may be used as a window identifier.
+ *   @param flags [Integer] Flags of the window. The supported flags are:
+ *     * CV_WINDOW_AUTOSIZE - If this is set, the window size is automatically adjusted
+ *       to fit the displayed image, and you cannot change the window size manually.
+ *     * CV_WINDOW_NORMAL - If this is set, the user can resize the window (no constraint).
+ *     * CV_WINDOW_OPENGL - If this is set, the window will be created with OpenGL support.
+ * @opencv_func cvNamedWindow
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE name, flags;
+  rb_scan_args(argc, argv, "11", &name, &flags);
+  Check_Type(name, T_STRING);
+  char* name_str = StringValueCStr(name);
+  if (cvGetWindowHandle(name_str) != NULL) {
+    rb_raise(rb_eStandardError, "window name should be unique.");
+  }      
+  
+  int mode = CV_WINDOW_AUTOSIZE;
+  if (argc == 2) {
+    Check_Type(flags, T_FIXNUM);
+    mode = FIX2INT(flags);
+  }
+
+  Window* self_ptr = WINDOW(self);
+  self_ptr->name = name;
+  self_ptr->trackbars = rb_ary_new();
+  self_ptr->blocks = rb_ary_new();
+  try {
+    cvNamedWindow(name_str, mode);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  num_windows++;
+  return self;
+}
+
+/*
+ * Return alive status of window. Return true if alive, otherwise return false.
+ */
+VALUE
+rb_alive_q(VALUE self)
+{
+  const char* name_str = GET_WINDOW_NAME(self);
+  return (cvGetWindowHandle(name_str) == NULL) ? Qfalse : Qtrue;
+}
+
+/*
+ * Destroys a window. alive status of window be false.
+ */
+VALUE
+rb_destroy(VALUE self)
+{
+  const char* name_str = GET_WINDOW_NAME(self);
+  try {
+    cvDestroyWindow(name_str);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  num_windows--;
+  return self;
+}
+
+/*
+ * Destorys all the windows.
+ */
+VALUE
+rb_destroy_all(VALUE klass)
+{
+  if (num_windows > 0) {
+    try {
+      cvDestroyAllWindows();
+    }
+    catch (cv::Exception& e) {
+      raise_cverror(e);
+    }
+    num_windows = 0;
+  }
+  return Qnil;
+}
+
+/*
+ * Resizes window to the specified size.
+ *
+ * @overload resize(size)
+ *   @param size [CvSize] The new window size.
+ * @overload resize(width, height)
+ *   @param width [Integer] The new window width.
+ *   @param height [Integer] The new window height.
+ * @opencv_func cvResizeWindow
+ */
+VALUE
+rb_resize(int argc, VALUE *argv, VALUE self)
+{
+  int width = 0;
+  int height = 0;
+  switch (argc) {
+  case 1: {
+    CvSize size = VALUE_TO_CVSIZE(argv[0]);
+    width = size.width;
+    height = size.height;
+    break;
+  }
+  case 2:
+    width = NUM2INT(argv[0]);
+    height = NUM2INT(argv[1]);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (1 or 2)");
+    break;
+  }
+  try {
+    cvResizeWindow(GET_WINDOW_NAME(self), width, height);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return self;
+}
+
+/*
+ * Moves window to the specified position.
+ *
+ * @overload move(point)
+ *   @param point [CvPoint] The new coordinate of the window.
+ * @overload move(x, y)
+ *   @param x [Integer] The new x-coordinate of the window.
+ *   @param y [Integer] The new y-coordinate of the window.
+ * @opencv_func cvMoveWindow
+ */
+VALUE
+rb_move(int argc, VALUE *argv, VALUE self)
+{
+  int x = 0;
+  int y = 0;
+  switch (argc) {
+  case 1: {
+    CvPoint point = VALUE_TO_CVPOINT(argv[0]);
+    x = point.x;
+    y = point.y;
+    break;
+  }
+  case 2:
+    x = NUM2INT(argv[0]);
+    y = NUM2INT(argv[1]);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (1 or 2)");
+    break;
+  }
+  try {
+    cvMoveWindow(GET_WINDOW_NAME(self), x, y);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return self;
+}
+      
+/*
+ * Displays an image in the specified window.
+ *
+ * @overload show_image(image)
+ *   @param image [CvMat] Image to be shown.
+ * @opencv_func cvShowImage
+ */
+VALUE
+rb_show_image(VALUE self, VALUE img)
+{
+  CvArr* image = CVARR_WITH_CHECK(img);
+  WINDOW(self)->image = img;
+  try {
+    cvShowImage(GET_WINDOW_NAME(self), image);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return self;
+}
+
+void
+trackbar_callback(int value, void* block)
+{
+  rb_funcall((VALUE)block, rb_intern("call"), 1, INT2NUM(value));
+}
+
+/*
+ * Creates or sets a trackbar and attaches it to the specified window.
+ *
+ * @overload set_trackbar(trackbar)
+ *   @param trackbar [TrackBar] The trackbar to set.
+ *
+ * @overload set_trackbar(name, count, value = nil) { |value| ... }
+ *   @param name [String] Name of the created trackbar.
+ *   @param count [Integer] Maximal position of the slider. The minimal position is always 0.
+ *   @param value [Integer] Optional value to an integer variable whose value reflects the position of the slider.
+ *     Upon creation, the slider position is defined by this variable.
+ *   @yield [value] Function to be called every time the slider changes position.
+ *   @yieldparam value [Integer] The trackbar position.
+ * @opencv_func cv::createTrackbar
+ */
+VALUE
+rb_set_trackbar(int argc, VALUE *argv, VALUE self)
+{
+  VALUE trackbar;
+  if (argc == 1) {
+    trackbar = argv[0];
+  }
+  else {
+    trackbar = cTrackbar::rb_initialize(argc, argv, cTrackbar::rb_allocate(cTrackbar::rb_class()));
+  }
+  Trackbar *trackbar_ptr = TRACKBAR_WITH_CHECK(trackbar);
+  try {
+    cv::createTrackbar(trackbar_ptr->name, GET_WINDOW_NAME(self), &(trackbar_ptr->val), trackbar_ptr->maxval,
+		       (cv::TrackbarCallback)trackbar_callback, (void*)(trackbar_ptr->block));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  rb_ary_push(WINDOW(self)->trackbars, trackbar);
+  
+  return trackbar;
+}
+
+void
+on_mouse(int event, int x, int y, int flags, void* param)
+{
+  VALUE block = (VALUE)param;
+  if (rb_obj_is_kind_of(block, rb_cProc)) {
+    rb_funcall(block, rb_intern("call"), 1, cMouseEvent::new_object(event, x, y, flags));
+  }
+}
+
+/*
+ * Sets mouse handler for the specified window.
+ *
+ * @overload set_mouse_callback { |mouse_event| ... }
+ *   @yield [mouse_event] Mouse callback.
+ *   @yieldparam mouse_event [MouseEvent] Mouse event
+ *
+ * @example display mouse event on console
+ *   window = OpenCV::GUI::Window.new "sample window"
+ *   image = OpenCV::IplImage::load "sample.png"
+ *   window.show(image)
+ *   window.set_mouse_callback {|mouse|  
+ *     e = "#{mouse.x}, #{mouse.y} : #{mouse.event} : "
+ *     e << "<L>" if mouse.left_button?
+ *     e << "<R>" if mouse.right_button?
+ *     e << "<M>" if mouse.middle_button?
+ *     e << "[CTRL]" if mouse.ctrl_key?
+ *     e << "[SHIFT]" if mouse.shift_key?
+ *     e << "[ALT]" if mouse.alt_key?
+ *     puts e
+ *   }
+ *   OpenCV::GUI::wait_key
+ */
+VALUE
+rb_set_mouse_callback(int argc, VALUE* argv, VALUE self)
+{
+  if (!rb_block_given_p()) {
+    rb_raise(rb_eArgError, "block not given.");
+  }
+
+  VALUE block = Qnil;
+  rb_scan_args(argc, argv, "0&", &block);
+  try {
+    cvSetMouseCallback(GET_WINDOW_NAME(self), on_mouse, (void*)block);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  rb_ary_push(WINDOW(self)->blocks, block);
+  return block;
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+  VALUE GUI = rb_define_module_under(opencv, "GUI");
+#endif
+
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * GUI = rb_define_module_under(opencv, "GUI");
+   *
+   * note: this comment is used by rdoc.
+   */
+  VALUE GUI = rb_module_GUI();
+  rb_klass = rb_define_class_under(GUI, "Window", 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, "alive?", RUBY_METHOD_FUNC(rb_alive_q), 0);
+  rb_define_method(rb_klass, "destroy", RUBY_METHOD_FUNC(rb_destroy), 0);
+  rb_define_singleton_method(rb_klass, "destroy_all", RUBY_METHOD_FUNC(rb_destroy_all), 0);
+  rb_define_method(rb_klass, "resize", RUBY_METHOD_FUNC(rb_resize), -1);
+  rb_define_method(rb_klass, "move", RUBY_METHOD_FUNC(rb_move), -1);
+  rb_define_method(rb_klass, "show_image", RUBY_METHOD_FUNC(rb_show_image), 1);
+  rb_define_alias(rb_klass, "show", "show_image");
+  rb_define_method(rb_klass, "set_trackbar", RUBY_METHOD_FUNC(rb_set_trackbar), -1);
+  rb_define_method(rb_klass, "set_mouse_callback", RUBY_METHOD_FUNC(rb_set_mouse_callback), -1);
+  rb_define_alias(rb_klass, "on_mouse", "set_mouse_callback");
+}
+
+__NAMESPACE_END_WINDOW
+__NAMESPACE_END_GUI
+__NAMESPACE_END_OPENCV
+