ruby-opencv 0.0.8-mswin32

data/examples/houghcircle.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# houghcircle.rb
+require "rubygems"
+require "opencv"
+include OpenCV
+
+original_window = GUI::Window.new "original"
+hough_window = GUI::Window.new "hough circles"
+
+image = IplImage::load "stuff.jpg"
+gray = image.BGR2GRAY
+
+result = image.clone
+original_window.show image
+detect = gray.hough_circles(CV_HOUGH_GRADIENT, 2.0, 10, 200, 50)
+puts detect.size
+detect.each{|circle|
+  puts "#{circle.center.x},#{circle.center.y} - #{circle.radius}"
+  result.circle! circle.center, circle.radius, :color => CvColor::Red, :thickness => 3
+}
+hough_window.show result
+GUI::wait_key

data/examples/inpaint.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# inpaint.rb
+require "rubygems"
+require "opencv"
+include OpenCV
+
+puts <<EOS
+Inpainting sample
+
+Usage:
+  'dilate' bar - Adjust mask to inpaint (Non-black areas indicate the area that needs to be inpainted).
+  'radius' bar - Adjust radius of a circular neighborhood of each point inpainted.
+  'n' key - Inpaint using Navier-Stokes based method
+  't' key - Inpaint using Alexandru Telea's method
+  'c' key - Clear the inpaint window
+  'ESC' key - exit"
+EOS
+
+owindow = GUI::Window.new('original')
+mwindow = GUI::Window.new('mask')
+iwindow = GUI::Window.new('inpaint')
+
+image = IplImage::load('inpaint.png')
+noimage = image.zero
+b, g, r = image.split
+original_mask = r.threshold(0x00, 0xFF, CV_THRESH_BINARY_INV) & b.threshold(0x00, 0xFF, CV_THRESH_BINARY_INV)
+mask = original_mask.copy
+
+num_dilate = 3
+mwindow.set_trackbar("dilate", 10, num_dilate) { |v|
+  num_dilate = v
+  mask = original_mask.dilate(nil, num_dilate)
+  mwindow.show mask  
+}
+
+radius = 5
+mwindow.set_trackbar("radius", 10, radius) { |v|
+  radius = v
+}
+
+owindow.show image
+mwindow.show mask
+iwindow.show noimage
+
+while key = GUI::wait_key
+  case key.chr
+  when "\e" # esc
+    exit
+  when "n"
+    iwindow.show image.inpaint(:ns, mask, radius)
+  when "t"
+    iwindow.show image.inpaint(:telea, mask, radius)
+  when "c"
+    iwindow.show noimage
+  end
+end
+

data/examples/match_kdtree.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8-unix -*- 
+
+# A sample of matching SURF feature points using kd-tree
+# See http://tech.groups.yahoo.com/group/OpenCV/message/62318
+
+require 'opencv'
+include OpenCV
+
+USE_EXTENDED_DESCRIPTOR = true
+THRESHOLD = 1500
+DESCRIPTOR_SIZE = USE_EXTENDED_DESCRIPTOR ? 128 : 64
+
+img1 = CvMat.load('lenna.jpg', CV_LOAD_IMAGE_GRAYSCALE)
+img2 = CvMat.load('lenna-rotated.jpg', CV_LOAD_IMAGE_GRAYSCALE)
+
+puts 'Extracting features from img1 using SURF...'
+param = CvSURFParams.new(THRESHOLD, USE_EXTENDED_DESCRIPTOR)
+kp1, desc1 = img1.extract_surf(param)
+puts "found #{kp1.size} keypoints from img1"
+
+puts 'Extracting features from img2 using SURF...'
+kp2, desc2 = img2.extract_surf(param)
+puts "found #{kp2.size} keypoints from img2"
+
+puts 'Matching keypoints...'
+desc1mat = CvMat.new(kp1.size, DESCRIPTOR_SIZE, :cv32f, 1)
+desc2mat = CvMat.new(kp2.size, DESCRIPTOR_SIZE, :cv32f, 1)
+desc1.each_with_index { |desc, i|
+  desc.each_with_index { |d, j|
+    desc1mat[i, j] = CvScalar.new(d)
+  }
+}
+desc2.each_with_index { |desc, i|
+  desc.each_with_index { |d, j|
+    desc2mat[i, j] = CvScalar.new(d)
+  }
+}
+
+feature_tree = CvFeatureTree.new(desc1mat)
+results, distances = feature_tree.find_features(desc2mat, 1, 250)
+
+reverse_lookup = []
+reverse_lookup_dist = []
+kp1.size.times { |i|
+  reverse_lookup << -1
+  reverse_lookup_dist << Float::MAX
+}
+
+match_count = 0
+kp2.size.times { |j|
+  i = results[j][0].to_i
+  d = distances[j][0]
+  if (d < reverse_lookup_dist[i])
+    match_count += 1 if reverse_lookup_dist[i] == Float::MAX
+    reverse_lookup[i] = j
+    reverse_lookup_dist[i] = d
+  end
+}
+puts "found #{match_count} putative correspondences"
+
+points1 = []
+points2 = []
+kp2.size.times { |j|
+  i = results[j][0].to_i
+  if (j == reverse_lookup[i])
+    points1 << kp1[i].pt
+    points2 << kp2[j].pt
+  end
+}
+
+width = img1.cols + img2.cols
+height = (img1.rows > img2.rows) ? img1.rows : img2.rows
+correspond = IplImage.new(width, height, :cv8u, 1);
+correspond.set_roi(CvRect.new(0, 0, img1.cols, img1.rows))
+img1.copy(correspond)
+correspond.set_roi(CvRect.new(img1.cols, 0, img1.cols + img2.cols, img2.rows))
+img2.copy(correspond)
+correspond.reset_roi
+
+points1.zip(points2) { |pt1, pt2|
+  pt2.x += img1.cols
+  correspond.line!(pt1, pt2, :color => CvColor::White)
+}
+
+GUI::Window.new('Object Correspond').show correspond
+GUI::wait_key
+

data/examples/matching_to_many_images.rb

@@ -0,0 +1,16 @@
+require 'opencv'
+require 'benchmark'
+include OpenCV
+
+data = File.join(File.dirname(__FILE__), 'matching_to_many_images')
+
+query = IplImage.load File.join(data, 'query.png'), CV_LOAD_IMAGE_GRAYSCALE
+image_files = ['1.png', '2.png', '3.png'].map{|f| File.join(data, 'train', f)}
+images = image_files.map{|f| IplImage.load f, CV_LOAD_IMAGE_GRAYSCALE}
+
+
+matchs = query.match_descriptors(images)
+
+match_index, count = matchs.max_by {|image_index, count| count}
+
+puts "max match: #{image_files[match_index]}"

data/examples/matching_to_many_images/train/trainImages.txt

@@ -0,0 +1,3 @@
+1.png
+2.png
+3.png

data/examples/paint.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+# paint.rb
+require "rubygems"
+require "opencv"
+
+include OpenCV
+
+window = GUI::Window.new("free canvas")
+canvas = CvMat.new(500, 500, CV_8U, 3).fill!(CvColor::White) # create white canvas
+window.show canvas
+
+colors = CvColor::constants.collect{ |i| i.to_s }
+
+usage =<<USAGE
+[mouse]
+drag            - draw
+right button    - fill by color
+[keyborad]
+1 to 9          - change thickness of line
+type color name - change color
+esc             - exit
+USAGE
+puts usage
+
+# drawing option
+opt = {
+  :color => CvColor::Black,
+  :tickness => 1
+}
+
+point = nil
+window.on_mouse{ |m|
+  case m.event
+  when :move
+    if m.left_button?
+      canvas.line!(point, m, opt) if point
+      point = m
+    end
+  when :left_button_down
+    canvas.line!(m, m, opt)
+    point = m
+  when :left_button_up
+    point = nil
+  when :right_button_down
+    mask = canvas.flood_fill!(m, opt[:color])    
+  end
+  window.show canvas
+}
+
+color_name = ''
+while key = GUI.wait_key
+  next if key < 0 or key > 255
+  case key.chr
+  when "\e" # [esc] - exit
+    exit
+  when '1'..'9'
+    puts "change thickness to #{key.chr.to_i}."
+    opt[:thickness] = key.chr.to_i
+  when /[A-Za-z]/
+    color_name << key.chr
+    choice = colors.find_all{ |i| i =~ /\A#{color_name}/i }
+    if choice.size == 1
+      color,= choice
+      puts "change color to #{color}."
+      opt[:color] = CvColor::const_get(color)
+    end
+    color_name = '' if choice.size < 2
+  end
+end
+

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

@@ -0,0 +1,112 @@
+/************************************************************
+
+   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;
+}
+
+void
+define_ruby_module()
+{
+  if (module)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   *
+   * note: this comment is used by rdoc.
+   */
+  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);
+}
+
+/*
+ * If curve is closed, return true. Otherwise return false.
+ */
+VALUE
+rb_closed_q(VALUE self)
+{
+  return CV_IS_SEQ_CLOSED(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * If curve is convex, return true. Otherwise return false.
+ */
+VALUE
+rb_convex_q(VALUE self)
+{
+  return CV_IS_SEQ_CONVEX(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * If curve is hole(inner contour), return true. Otherwise return false.
+ */
+VALUE
+rb_hole_q(VALUE self)
+{  
+  return CV_IS_SEQ_HOLE(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * no idia.
+ */
+VALUE
+rb_simple_q(VALUE self)
+{
+  return CV_IS_SEQ_SIMPLE(CVSEQ(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   arc_length(<i>[slice = nil][,is_closed = nil]</i>) -> float
+ *
+ * Calculates contour perimeter or curve length.
+ * <i>slice</i> is starting and ending points of the curve.
+ * <i>is_closed</i> is 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#close?
+ */
+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);
+}
+
+__NAMESPACE_END_CURVE
+__NAMESPACE_END_OPENCV
+

data/ext/opencv/curve.h

@@ -0,0 +1,34 @@
+/************************************************************
+
+   curve.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSEQ_CURVE_H
+#define RUBY_OPENCV_CVSEQ_CURVE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CURVE namespace mCurve {
+#define __NAMESPACE_END_CURVE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CURVE
+
+VALUE rb_module();
+
+void define_ruby_module();
+
+VALUE rb_closed_q(VALUE self);
+VALUE rb_convex_q(VALUE self);
+VALUE rb_hole_q(VALUE self);
+VALUE rb_simple_q(VALUE self);
+VALUE rb_arc_length(int argc, VALUE *argv, VALUE self);
+
+__NAMESPACE_END_CURVE
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSEQ_CURVE_H