ruby-opencv 0.0.8.pre-x86-mingw32

data/Rakefile

@@ -0,0 +1,32 @@
+# -*- mode: ruby; coding: utf-8-unix -*-
+require 'rubygems'
+require './ext/opencv/lib/opencv/psyched_yaml'
+require 'hoe'
+require 'rake/extensiontask'
+
+Hoe.plugin :gemspec
+
+hoespec = Hoe.spec 'ruby-opencv' do |s|
+  s.summary = 'OpenCV wrapper for Ruby'
+  s.developer('lsxi', 'masakazu.yonekura@gmail.com')
+  s.developer('ser1zw', 'azariahsawtikes@gmail.com')
+  s.developer('pcting', 'pcting@gmail.com')
+
+  s.readme_file  = 'README.rdoc'
+  s.history_file = 'History.txt'
+  s.spec_extras = { :extensions => ['extconf.rb'] }
+  s.test_globs = ['test/test_*.rb']
+  s.urls = ['https://github.com/ruby-opencv/ruby-opencv/']
+
+  s.extra_dev_deps << ['rake-compiler', '>= 0'] << ['hoe-gemspec']
+
+  Rake::ExtensionTask.new('opencv', spec) do |ext|
+    ext.lib_dir = File.join('lib', 'opencv')
+  end
+end
+
+hoespec.spec.files.delete('.gemtest')
+
+Rake::Task[:test].prerequisites << :compile
+
+# vim: syntax=ruby

data/examples/alpha_blend.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8-unix -*-
+
+# Alpha blending sample with GUI
+
+require 'opencv'
+include OpenCV
+
+img1 = IplImage.load('lenna.jpg', CV_LOAD_IMAGE_ANYCOLOR | CV_LOAD_IMAGE_ANYDEPTH)
+img2 = IplImage.load('tiffany.jpg', CV_LOAD_IMAGE_ANYCOLOR | CV_LOAD_IMAGE_ANYDEPTH)
+
+window = GUI::Window.new('Alpha blend')
+max = 100.0
+val = max / 2.0
+window.set_trackbar("Alpha", max, val) { |v|
+  a = v.to_f / max
+  window.show CvMat.add_weighted(img1, a, img2, 1.0 - a, 0)
+}
+window.show CvMat.add_weighted(img1, val / max, img2, 1.0 - val / max, 0)
+GUI::wait_key
+

data/examples/contours/bounding-box-detect-canny.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+#
+# Detects contours in an image and
+# their boundingboxes
+#
+require "opencv"
+
+# Load image
+cvmat = OpenCV::CvMat.load("rotated-boxes.jpg")
+
+# The "canny" edge-detector does only work with grayscale images
+# so to be sure, convert the image
+# otherwise you will get an OpenCV::CvStsAssert exception.
+cvmat = cvmat.BGR2GRAY
+
+# Use the "canny" edge detection algorithm (http://en.wikipedia.org/wiki/Canny_edge_detector)
+# Parameters are two colors that are then used to determine possible corners
+canny = cvmat.canny(50, 150)
+
+# Look for contours
+# We want them to be returned as a flat list (CV_RETR_LIST) and simplified (CV_CHAIN_APPROX_SIMPLE)
+# Both are the defaults but included here for clarity
+contour = canny.find_contours(:mode => OpenCV::CV_RETR_LIST, :method => OpenCV::CV_CHAIN_APPROX_SIMPLE)
+
+# The Canny Algorithm returns two matches for every contour (see O'Reilly: Learning OpenCV Page 235)
+# We need only the external edges so we ignore holes.
+# When there are no more contours, contours.h_next will return nil
+while contour
+  # No "holes" please (aka. internal contours)
+  unless contour.hole?
+
+    puts '-' * 80
+    puts "BOUNDING RECT FOUND"
+    puts '-' * 80
+
+    # You can detect the "bounding rectangle" which is always oriented horizontally and vertically
+    box = contour.bounding_rect
+    puts "found external contour with bounding rectangle from #{box.top_left.x},#{box.top_left.y} to #{box.bottom_right.x},#{box.bottom_right.y}"
+
+    # The contour area can be computed:
+    puts "that contour encloses an area of #{contour.contour_area} square pixels"
+
+    # .. as can be the length of the contour
+    puts "that contour is #{contour.arc_length} pixels long "
+
+    # Draw that bounding rectangle
+    cvmat.rectangle! box.top_left, box.bottom_right, :color => OpenCV::CvColor::Black
+
+    # You can also detect the "minimal rectangle" which has an angle, width, height and center coordinates
+    # and is not neccessarily horizonally or vertically aligned.
+    # The corner of the rectangle with the lowest y and x position is the anchor (see image here: http://bit.ly/lT1XvB)
+    # The zero angle position is always straight up. 
+    # Positive angle values are clockwise and negative values counter clockwise (so -60 means 60 degree counter clockwise)
+    box = contour.min_area_rect2
+    puts "found minimal rectangle with its center at (#{box.center.x.round},#{box.center.y.round}), width of #{box.size.width.round}px, height of #{box.size.height.round} and an angle of #{box.angle.round} degree"
+  end
+  contour = contour.h_next
+end 
+
+# And save the image
+puts "\nSaving image with bounding rectangles"
+cvmat.save_image("rotated-boxes-with-detected-bounding-rectangles.jpg")

data/examples/contours/contour_retrieval_modes.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+#
+# This file shows the different retrieval modes for contour detection
+#
+require "opencv"
+
+# Load image
+# The structure of the image is "explained" in bitmap-contours-with-labels.png
+cvmat = OpenCV::CvMat.load("bitmap-contours.png")
+
+# "find_contours" does only operate on bitmap images (black/white)
+mat = OpenCV::CvMat.new(cvmat.rows, cvmat.cols, :cv8u, 1)
+(cvmat.rows * cvmat.cols).times do |i|
+  mat[i] = (cvmat[i][0] <= 128) ? OpenCV::CvScalar.new(0) : OpenCV::CvScalar.new(255)
+end
+
+# find_contours takes two parameters:
+# 1. Retrieval mode (:mode, defines the structure of the contour sequence returned)
+#    - CV_RETR_LIST (default)
+#    - CV_RETR_EXTERNAL
+#    - CV_RETR_CCOMP
+#    - CV_RETR_TREE
+# 2. Retrieval Method (:method, how the contours are approximated)
+#    - CV_CHAIN_CODE
+#    - CV_CHAIN_APPROX_NONE
+#    - CV_CHAIN_APPROX_SIMPLE (default)
+#    - CV_CHAIN_APPROX_TC89_L1
+#    - CV_CHAIN_APPROX_T89_KCOS
+#    - CV_LINK_RUNS
+
+#
+# The default: CV_RETR_LIST and CV_CHAIN_APPROX_SIMPLE
+# This produces a flat list of contours that can be traversed with .h_next and .h_prev
+#
+puts "Detecting using CV_RETR_LIST and CV_CHAIN_APPROX_SIMPLE"
+contour = mat.find_contours(:mode => OpenCV::CV_RETR_LIST, :method => OpenCV::CV_CHAIN_APPROX_SIMPLE)
+cindex=1
+
+while contour
+  puts "Contour ##{cindex} is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+  contour = contour.h_next
+  cindex+=1
+end 
+
+#
+# CV_RETR_EXTERNAL retrieves only the outer most non "hole" contour
+#
+puts '-'*80
+puts "Detecting using CV_RETR_EXTERNAL and CV_CHAIN_APPROX_SIMPLE"
+contour = mat.find_contours(:mode => OpenCV::CV_RETR_EXTERNAL, :method => OpenCV::CV_CHAIN_APPROX_SIMPLE)
+cindex=1
+
+while contour
+  puts "Contour ##{cindex} is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+  contour = contour.h_next
+  cindex+=1
+end 
+
+#
+# CV_RETR_CCOMP organizes the contours in a two level deep stack
+# The first level holds the contours
+# The second level contains the holes of the contours in level 1
+#
+# C00001 <-> C00000 <-> C000 <-> C0
+#                         |     |
+#                         V     V
+#                       H0000   H00
+#
+puts '-'*80
+puts "Detecting using CV_RETR_CCOMP and CV_CHAIN_APPROX_SIMPLE"
+contour = mat.find_contours(:mode => OpenCV::CV_RETR_CCOMP, :method => OpenCV::CV_CHAIN_APPROX_SIMPLE)
+
+# C00001
+puts "Contour #1 is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+contour = contour.h_next
+
+# C00000
+puts "Contour #2 is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+contour = contour.h_next
+
+# C000
+puts "Contour #3 is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+contour_down = contour.v_next
+
+# H0000
+puts "Contour #4 is #{contour_down.contour_area} px^2 (width: #{contour_down.bounding_rect.width}, height: #{contour_down.bounding_rect.height}, type: #{(contour_down.hole?)?"hole":"contour"})"
+contour = contour.h_next
+
+# C0
+puts "Contour #5 is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+contour_down = contour.v_next
+
+# H00
+puts "Contour #6 is #{contour_down.contour_area} px^2 (width: #{contour_down.bounding_rect.width}, height: #{contour_down.bounding_rect.height}, type: #{(contour_down.hole?)?"hole":"contour"})"
+
+#
+# CV_RETR_TREE manages the contours in a tree structure
+# This reconstructs the complete hierarchy of contours and holes that the image displayed
+#
+# C0
+#  |
+#  V
+# H00
+#  |
+#  V
+# C000
+#  |
+#  V
+# H0000-------+
+#  |          |
+#  V          V
+# C00000   C00001
+#
+puts '-'*80
+puts "Detecting using CV_RETR_TREE and CV_CHAIN_APPROX_SIMPLE"
+contour = mat.find_contours(:mode => OpenCV::CV_RETR_TREE, :method => OpenCV::CV_CHAIN_APPROX_SIMPLE)
+
+# C0
+puts "Contour #1 is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+contour = contour.v_next
+
+# H00
+puts "Contour #2 is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+contour = contour.v_next
+
+# C000
+puts "Contour #3 is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+contour = contour.v_next
+
+# H0000
+puts "Contour #4 is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+contour = contour.v_next
+
+# C00000
+puts "Contour #5 is #{contour.contour_area} px^2 (width: #{contour.bounding_rect.width}, height: #{contour.bounding_rect.height}, type: #{(contour.hole?)?"hole":"contour"})"
+contour_right = contour.h_next
+
+# C00001
+puts "Contour #6 is #{contour_right.contour_area} px^2 (width: #{contour_right.bounding_rect.width}, height: #{contour_right.bounding_rect.height}, type: #{(contour_right.hole?)?"hole":"contour"})"

data/examples/convexhull.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# convexhull.rb
+# Draw contours and convexity defect points to captured image
+require "rubygems"
+require "opencv"
+include OpenCV
+
+window = GUI::Window.new("convexhull")
+capture = CvCapture::open
+
+accuracy = 1
+t = window.set_trackbar("accuracy", 10, 1) { |v|
+  accuracy = v
+}
+
+circle_options = { :color => CvColor::Blue, :line_type => :aa, :thickness => -1 }
+
+loop do
+  image = capture.query
+
+  # Calculate contours from a binary image
+  gray = image.BGR2GRAY
+  bin = gray.threshold(0x44, 0xFF, :binary)
+  contours = bin.find_contours
+
+  while contours
+    # Draw contours
+    poly = contours.approx(:accuracy => accuracy)
+    begin
+      image.draw_contours!(poly, CvColor::Red, CvColor::Black, 2,
+                           :thickness => 2, :line_type => :aa)
+    end while (poly = poly.h_next)
+
+    # Draw convexity defects
+    hull = contours.convex_hull2(true, false)
+    contours.convexity_defects(hull).each { |cd|
+      image.circle!(cd.start, 3, circle_options)
+      image.circle!(cd.depth_point, 3, circle_options)
+      image.circle!(cd.end, 3, circle_options)
+    }
+    contours = contours.h_next
+  end
+
+  window.show image
+  exit if GUI::wait_key(1)
+end
+

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