ruby-opencv 0.0.10-i386-mingw32

data/examples/face_detect.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# face_detect.rb
+require "rubygems"
+require "opencv"
+
+include OpenCV
+
+window = GUI::Window.new("face detect")
+capture = CvCapture.open
+detector = CvHaarClassifierCascade::load("./data/haarcascades/haarcascade_frontalface_alt.xml")
+
+loop {
+  image = capture.query
+  detector.detect_objects(image).each { |rect|
+    image.rectangle! rect.top_left, rect.bottom_right, :color => CvColor::Red
+  }
+  window.show image
+  break if GUI::wait_key(100)
+}
+

data/examples/find_obj.rb

@@ -0,0 +1,169 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+
+# A Demo Ruby/OpenCV Implementation of SURF
+# See https://code.ros.org/trac/opencv/browser/tags/2.3.1/opencv/samples/c/find_obj.cpp
+require 'opencv'
+require 'benchmark'
+include OpenCV
+
+def compare_surf_descriptors(d1, d2, best, length)
+  raise ArgumentError unless (length % 4) == 0
+  total_cost = 0
+  0.step(length - 1, 4) { |i|
+    t0 = d1[i] - d2[i]
+    t1 = d1[i + 1] - d2[i + 1]
+    t2 = d1[i + 2] - d2[i + 2]
+    t3 = d1[i + 3] - d2[i + 3]
+    total_cost += t0 * t0 + t1 * t1 + t2 * t2 + t3 * t3
+    break if total_cost > best
+  }
+  total_cost
+end
+
+def naive_nearest_neighbor(vec, laplacian, model_keypoints, model_descriptors)
+  length = model_descriptors[0].size
+  neighbor = nil
+  dist1 = 1e6
+  dist2 = 1e6
+
+  model_descriptors.size.times { |i|
+    kp = model_keypoints[i]
+    mvec = model_descriptors[i]
+    next if laplacian != kp.laplacian
+    
+    d = compare_surf_descriptors(vec, mvec, dist2, length)
+    if d < dist1
+      dist2 = dist1
+      dist1 = d
+      neighbor = i
+    elsif d < dist2
+      dist2 = d
+    end
+  }
+
+  return (dist1 < 0.6 * dist2) ? neighbor : nil
+end
+
+def find_pairs(object_keypoints, object_descriptors,
+               image_keypoints, image_descriptors)
+  ptpairs = []
+  object_descriptors.size.times { |i|
+    kp = object_keypoints[i]
+    descriptor = object_descriptors[i]
+    nearest_neighbor = naive_nearest_neighbor(descriptor, kp.laplacian, image_keypoints, image_descriptors)
+    unless nearest_neighbor.nil?
+      ptpairs << i
+      ptpairs << nearest_neighbor
+    end
+  }
+  ptpairs
+end
+
+def locate_planar_object(object_keypoints, object_descriptors,
+                         image_keypoints, image_descriptors, src_corners)
+  ptpairs = find_pairs(object_keypoints, object_descriptors, image_keypoints, image_descriptors)
+  n = ptpairs.size / 2
+  return nil if n < 4
+
+  pt1 = []
+  pt2 = []
+  n.times { |i|
+    pt1 << object_keypoints[ptpairs[i * 2]].pt
+    pt2 << image_keypoints[ptpairs[i * 2 + 1]].pt
+  }
+
+  _pt1 = CvMat.new(1, n, CV_32F, 2)
+  _pt2 = CvMat.new(1, n, CV_32F, 2)
+  _pt1.set_data(pt1)
+  _pt2.set_data(pt2)
+  h = CvMat.find_homography(_pt1, _pt2, :ransac, 5)
+
+  dst_corners = []
+  4.times { |i|
+    x = src_corners[i].x
+    y = src_corners[i].y
+    z = 1.0 / (h[6][0] * x + h[7][0] * y + h[8][0])
+    x = (h[0][0] * x + h[1][0] * y + h[2][0]) * z
+    y = (h[3][0] * x + h[4][0] * y + h[5][0]) * z
+    dst_corners << CvPoint.new(x.to_i, y.to_i)
+  }
+
+  dst_corners
+end
+
+
+##### Main #####
+puts 'This program demonstrated the use of the SURF Detector and Descriptor using'
+puts 'brute force matching on planar objects.'
+puts 'Usage:'
+puts "ruby #{__FILE__} <object_filename> <scene_filename>, default is box.png and box_in_scene.png"
+puts
+
+object_filename = (ARGV.size == 2) ? ARGV[0] : 'box.png'
+scene_filename = (ARGV.size == 2) ? ARGV[1] : 'box_in_scene.png'
+
+object, image = nil, nil
+begin
+  object = IplImage.load(object_filename, CV_LOAD_IMAGE_GRAYSCALE)
+  image = IplImage.load(scene_filename, CV_LOAD_IMAGE_GRAYSCALE)
+rescue
+  puts "Can not load #{object_filename} and/or #{scene_filename}"
+  puts "Usage: ruby #{__FILE__} [<object_filename> <scene_filename>]"
+  exit
+end
+object_color = object.GRAY2BGR
+
+param = CvSURFParams.new(1500)
+
+object_keypoints, object_descriptors = nil, nil
+image_keypoints, image_descriptors = nil, nil
+tms = Benchmark.measure {
+  object_keypoints, object_descriptors = object.extract_surf(param)
+  puts "Object Descriptors: #{object_descriptors.size}"
+
+  image_keypoints, image_descriptors = image.extract_surf(param)
+  puts "Image Descriptors: #{image_descriptors.size}"
+}
+puts "Extraction time = #{tms.real * 1000} ms"
+
+correspond = IplImage.new(image.width, object.height + image.height, CV_8U, 1);
+correspond.set_roi(CvRect.new(0, 0, object.width, object.height))
+object.copy(correspond)
+correspond.set_roi(CvRect.new(0, object.height, image.width, image.height))
+image.copy(correspond)
+correspond.reset_roi
+
+src_corners = [CvPoint.new(0, 0), CvPoint.new(object.width, 0),
+               CvPoint.new(object.width, object.height), CvPoint.new(0, object.height)]
+dst_corners = locate_planar_object(object_keypoints, object_descriptors,
+                                   image_keypoints, image_descriptors, src_corners)
+
+correspond = correspond.GRAY2BGR
+if dst_corners
+  4.times { |i|
+    r1 = dst_corners[i % 4]
+    r2 = dst_corners[(i + 1) % 4]
+    correspond.line!(CvPoint.new(r1.x, r1.y + object.height), CvPoint.new(r2.x, r2.y + object.height),
+                     :color => CvColor::Red, :thickness => 2, :line_type => :aa)
+  }
+end
+
+ptpairs = find_pairs(object_keypoints, object_descriptors, image_keypoints, image_descriptors)
+
+0.step(ptpairs.size - 1, 2) { |i|
+  r1 = object_keypoints[ptpairs[i]]
+  r2 = image_keypoints[ptpairs[i + 1]]
+  correspond.line!(r1.pt, CvPoint.new(r2.pt.x, r2.pt.y + object.height),
+                   :color => CvColor::Red, :line_type => :aa)
+}
+
+object_keypoints.each { |r|
+  radius = (r.size * 1.2 / 9.0 * 2).to_i
+  object_color.circle!(r.pt, radius, :color => CvColor::Red, :line_type => :aa)
+}
+
+GUI::Window.new('Object Correspond').show correspond
+GUI::Window.new('Object').show object_color
+GUI::wait_key
+

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 -*-
+
+# 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
+