ruby-opencv 0.0.10 → 0.0.11.pre

data/examples/facerec/facerec_lbph.rb

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+
+# LBPH sample in ruby-opencv, equivalent to http://docs.opencv.org/trunk/_downloads/facerec_lbph.cpp
+# See http://docs.opencv.org/trunk/modules/contrib/doc/facerec/facerec_tutorial.html
+require 'opencv'
+include OpenCV
+
+def read_csv(filename, sepalator = ';')
+  images = []
+  labels = []
+  open(filename, 'r') { |f|
+    f.each { |line|
+      path, label = line.chomp.split(sepalator)
+      images << CvMat.load(path, CV_LOAD_IMAGE_GRAYSCALE)
+      labels << label.to_i
+    }
+  }
+
+  [images, labels]
+end
+
+# Check for valid command line arguments, print usage
+# if no arguments were given.
+if ARGV.size < 1
+  puts "usage: ruby #{__FILE__} <csv.ext>"
+  exit 1
+end
+
+# Get the path to your CSV.
+fn_csv = ARGV.shift
+
+# Read in the data. This can fail if no valid
+# input filename is given.
+images, labels = read_csv(fn_csv);
+
+# Quit if there are not enough images for this demo.
+raise 'This demo needs at least 2 images to work. Please add more images to your data set!' if images.size <= 1
+
+# Get the height from the first image. We'll need this
+# later in code to reshape the images to their original size:
+height = images[0].rows;
+
+# The following lines simply get the last images from
+# your dataset and remove it from the vector. This is
+# done, so that the training data (which we learn the
+# cv::FaceRecognizer on) and the test data we test
+# the model with, do not overlap.
+test_sample = images.pop
+test_label = labels.pop
+
+# The following lines create an LBPH model for
+# face recognition and train it with the images and
+# labels read from the given CSV file.
+# 
+# The LBPHFaceRecognizer uses Extended Local Binary Patterns
+# (it's probably configurable with other operators at a later
+# point), and has the following default values
+# 
+#      radius = 1
+#      neighbors = 8
+#      grid_x = 8
+#      grid_y = 8
+# 
+# So if you want a LBPH FaceRecognizer using a radius of
+# 2 and 16 neighbors, call the factory method with:
+# 
+#      LBPH.new(2, 16);
+# 
+# And if you want a threshold (e.g. 123.0) call it with its default values:
+# 
+#      LBPH.new(1,8,8,8,123.0)
+# 
+model = LBPH.new
+model.train(images, labels)
+
+# The following line predicts the label of a given test image:
+predicted_label, predicted_confidence = model.predict(test_sample)
+
+# To get the confidence of a prediction call the model with:
+# 
+#      predicted_label = -1;
+#      confidence = 0.0;
+#      model.predict(test_sample, predicted_label, confidence)
+# 
+puts "Predicted class: #{predicted_label} / Actual class: #{test_label}"
+
+# Sometimes you'll need to get/set internal model data,
+# which isn't exposed by the public FaceRecognizer.
+# Since each FaceRecognizer is derived from a Algorithm,
+# you can query the data.
+#
+# First we'll use it to set the threshold of the FaceRecognizer
+# to 0.0 without retraining the model. This can be useful if
+# you are evaluating the model:
+model.set_double('threshold', 0.0);
+
+# Now the threshold of this model is set to 0.0. A prediction
+# now returns -1, as it's impossible to have a distance below it
+predicted_label = model.predict(test_sample)
+puts "Predicted class = #{predicted_label}"
+
+# Show some informations about the model, as there's no cool
+# Model data to display as in Eigenfaces/Fisherfaces.
+# Due to efficiency reasons the LBP images are not stored
+# within the model:
+puts 'Model Information:'
+model_info = "\tLBPH(radius=#{model.get_int('radius')}, neighbors=#{model.get_int('neighbors')}, grid_x=#{model.get_int('grid_x')}, grid_y=#{model.get_int('grid_y')}, threshold=#{model.get_double('threshold')})"
+puts model_info
+
+# We could get the histograms for example:
+histgrams = model.get_matvector('histograms');
+
+# But should I really visualize it? Probably the length is interesting:
+puts "Size of the histograms: #{histgrams[0].dims.reduce(&:*)}"
+

data/examples/facerec/readme.md

@@ -0,0 +1,111 @@
+# Face recognition with ruby-opencv
+
+This is a face recognition sample with ruby-opencv, which equivalent to the following OpenCV's tutorial.
+
+[Face Recognition with OpenCV](http://docs.opencv.org/trunk/modules/contrib/doc/facerec/facerec_tutorial.html)
+
+
+## Running samples
+
+### 1. Get AT&T Facedatabase
+
+Get AT&T Facedatabase from http://www.cl.cam.ac.uk/research/dtg/attarchive/facedatabase.html and unzip it.
+
+```sh
+$ wget http://www.cl.cam.ac.uk/Research/DTG/attarchive/pub/data/att_faces.zip
+$ unzip att_faces.zip
+```
+
+### 2. Prepare the data
+
+Create a CSV file to run samples.
+
+```sh
+$ ruby create_csv.rb att_faces > at.txt
+```
+
+You will get a CSV file which contains lines composed of a filename followed by a ; followed by the label (as integer number).
+
+```sh
+$ cat at.txt
+att_faces/s34/2.pgm;0
+att_faces/s34/3.pgm;0
+att_faces/s34/8.pgm;0
+att_faces/s34/4.pgm;0
+att_faces/s34/5.pgm;0
+att_faces/s34/10.pgm;0
+att_faces/s34/9.pgm;0
+att_faces/s34/7.pgm;0
+att_faces/s34/6.pgm;0
+att_faces/s34/1.pgm;0
+...
+```
+
+### 3. Run sample codes
+
+#### Eigenfaces
+
+```sh
+$ mkdir output-eigenfaces
+$ ruby facerec_eigenfaces.rb at.txt output-eigenfaces
+```
+
+You will get the predicted class, actual class and eignvalues shown in console.
+
+```sh
+Predicted class: 39 / Actual class: 39
+Eigenvalue #0 = 2823424.500638128
+Eigenvalue #1 = 2062015.3818895558
+Eigenvalue #2 = 1090171.0771557507
+Eigenvalue #3 = 892019.3644237233
+Eigenvalue #4 = 818537.7917991373
+Eigenvalue #5 = 539058.2364753223
+Eigenvalue #6 = 390359.3231975121
+Eigenvalue #7 = 373809.5486713626
+Eigenvalue #8 = 314658.94374918053
+Eigenvalue #9 = 288764.63018440653
+```
+
+The result images will be stored in **output-eigenfaces** .
+
+
+#### Fisherfaces
+
+```sh
+$ mkdir output-fisherfaces
+$ ruby facerec_fisherfaces.rb at.txt output-fisherfaces
+```
+
+You will get the predicted class, actual class and eignvalues like Eigenfaces sample.
+
+The result images will be stored in **output-fisherfaces** .
+
+
+#### Local Binary Patterns Histograms
+
+```sh
+$ ruby facerec_lbph.rb at.txt
+```
+
+You will get the predicted class, actual class, model information and size of the histgrams.
+
+```
+Predicted class: 39 / Actual class: 39
+Predicted class = -1
+Model Information:
+        LBPH(radius=1, neighbors=8, grid_x=8, grid_y=8, threshold=0.0)
+Size of the histograms: 16384
+```
+
+## Credits
+
+### The Database of Faces
+
+The Database of Faces, formerly The ORL Database of Faces, contains a set of face images taken between April 1992 and April 1994. The database was used in the context of a face recognition project carried out in collaboration with the Speech, Vision and Robotics Group of the Cambridge University Engineering Department.
+
+There are ten different images of each of 40 distinct subjects. For some subjects, the images were taken at different times, varying the lighting, facial expressions (open / closed eyes, smiling / not smiling) and facial details (glasses / no glasses). All the images were taken against a dark homogeneous background with the subjects in an upright, frontal position (with tolerance for some side movement).
+
+The files are in PGM format. The size of each image is 92x112 pixels, with 256 grey levels per pixel. The images are organised in 40 directories (one for each subject), which have names of the form sX, where X indicates the subject number (between 1 and 40). In each of these directories, there are ten different images of that subject, which have names of the form Y.pgm, where Y is the image number for that subject (between 1 and 10).
+
+A copy of the database can be retrieved from: http://www.cl.cam.ac.uk/research/dtg/attarchive/pub/data/att_faces.zip.
+

data/examples/find_obj.rb

@@ -100,8 +100,8 @@ 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_filename = (ARGV.size == 2) ? ARGV[0] : 'images/box.png'
+scene_filename = (ARGV.size == 2) ? ARGV[1] : 'images/box_in_scene.png'
 
 object, image = nil, nil
 begin

data/examples/houghcircle.rb

@@ -7,7 +7,7 @@ include OpenCV
 original_window = GUI::Window.new "original"
 hough_window = GUI::Window.new "hough circles"
 
-image = IplImage::load "stuff.jpg"
+image = IplImage::load "images/stuff.jpg"
 gray = image.BGR2GRAY
 
 result = image.clone

data/examples/inpaint.rb

@@ -20,7 +20,7 @@ owindow = GUI::Window.new('original')
 mwindow = GUI::Window.new('mask')
 iwindow = GUI::Window.new('inpaint')
 
-image = IplImage::load('inpaint.png')
+image = IplImage::load('images/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)

data/examples/match_kdtree.rb

@@ -11,8 +11,8 @@ 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)
+img1 = CvMat.load('images/lenna.jpg', CV_LOAD_IMAGE_GRAYSCALE)
+img2 = CvMat.load('images/lenna-rotated.jpg', CV_LOAD_IMAGE_GRAYSCALE)
 
 puts 'Extracting features from img1 using SURF...'
 param = CvSURFParams.new(THRESHOLD, USE_EXTENDED_DESCRIPTOR)

data/examples/match_template.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+# A demo of Ruby/OpenCV's match_template function
+
+require 'opencv'
+include OpenCV
+
+puts 'This program demonstrates the match_template function'
+puts 'Usage:'
+puts "ruby #{__FILE__} <template_filename> <match_filename>"
+puts
+
+template_filename = (ARGV.size == 2) ? ARGV[0] : File.expand_path(File.dirname(__FILE__) + '/images/lena-eyes.jpg')
+match_image_filename = (ARGV.size == 2) ? ARGV[1] : File.expand_path(File.dirname(__FILE__) + '/images/lena-256x256.jpg')
+
+template = CvMat.load(template_filename)
+match_image = CvMat.load(match_image_filename)
+result = match_image.match_template(template, :sqdiff_normed)
+
+pt1 = result.min_max_loc[2] # minimum location
+pt2 = CvPoint.new(pt1.x + template.width, pt1.y + template.height)
+match_image.rectangle!(pt1, pt2, :color => CvColor::Black, :thickness => 3)
+
+window = GUI::Window.new('Display window') # Create a window for display.
+window.show(match_image) # Show our image inside it.
+GUI::wait_key # Wait for a keystroke in the window.

data/examples/{matching_to_many_images.rb → matching_to_many_images/matching_to_many_images.rb}

@@ -2,11 +2,11 @@ require 'opencv'
 require 'benchmark'
 include OpenCV
 
-data = File.join(File.dirname(__FILE__), 'matching_to_many_images')
+data = File.dirname(__FILE__)
 
-query = IplImage.load File.join(data, 'query.png'), CV_LOAD_IMAGE_GRAYSCALE
+query = CvMat.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}
+images = image_files.map{|f| CvMat.load f, CV_LOAD_IMAGE_GRAYSCALE}
 
 
 matchs = query.match_descriptors(images)

data/ext/opencv/algorithm.cpp

@@ -0,0 +1,286 @@
+/************************************************************
+
+   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
+define_ruby_class()
+{
+  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
+