jf-ruby-opencv 0.0.18

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/facerec/create_csv.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+
+# This is a tiny script to help you creating a CSV file from a face
+# database with a similar hierarchie:
+# 
+#  philipp@mango:~/facerec/data/at$ tree
+#  .
+#  |-- README
+#  |-- s1
+#  |   |-- 1.pgm
+#  |   |-- ...
+#  |   |-- 10.pgm
+#  |-- s2
+#  |   |-- 1.pgm
+#  |   |-- ...
+#  |   |-- 10.pgm
+#  ...
+#  |-- s40
+#  |   |-- 1.pgm
+#  |   |-- ...
+#  |   |-- 10.pgm
+#
+# See http://docs.opencv.org/trunk/modules/contrib/doc/facerec/facerec_tutorial.html
+#
+if ARGV.size != 1
+  puts "usage: ruby #{__FILE__} <base_path>"
+  exit
+end
+
+BASE_PATH = ARGV[0]
+SEPARATOR = ';'
+
+label = 0
+Dir.glob("#{BASE_PATH}/*").each { |dir|
+  if FileTest::directory? dir
+    Dir.glob("#{dir}/*") { |filename|
+      puts "#{filename}#{SEPARATOR}#{label}"
+    }
+    label += 1
+  end
+}
+

data/examples/facerec/facerec_eigenfaces.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+
+# Eigenfaces sample in ruby-opencv, equivalent to http://docs.opencv.org/trunk/_downloads/facerec_eigenfaces.cpp
+# See http://docs.opencv.org/trunk/modules/contrib/doc/facerec/facerec_tutorial.html
+require 'opencv'
+include OpenCV
+
+def norm_0_255(src)
+  dst = nil
+  case src.channel
+  when 1
+    dst = src.normalize(0, 255, CV_NORM_MINMAX, CV_8UC1)
+  when 2
+    dst = src.normalize(0, 255, CV_NORM_MINMAX, CV_8UC3)
+  else
+    dst = src.copy
+  end
+
+  dst
+end
+
+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
+
+if ARGV.size < 1
+  puts "usage: ruby #{__FILE__} <csv.ext> <output_folder>"
+  exit 1
+end
+fn_csv = ARGV.shift
+output_folder = ARGV.shift
+
+images, labels = read_csv(fn_csv);
+
+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 Eigenfaces model for
+# face recognition and train it with the images and
+# labels read from the given CSV file.
+# This here is a full PCA, if you just want to keep
+# 10 principal components (read Eigenfaces), then call
+# the factory method like this:
+#
+#      EigenFaces.new(10)
+#
+# If you want to create a FaceRecognizer with a
+# confidence threshold (e.g. 123.0), call it with:
+#
+#      EigenFaces.new(10, 123.0)
+#
+# If you want to use _all_ Eigenfaces and have a threshold,
+# then call the method like this:
+#
+#      EigenFaces.new(0, 123.0)
+#
+model = EigenFaces.new
+model.train(images, labels)
+
+# The following line predicts the label of a given test image:
+predicted_label, predicted_confidence = model.predict(test_sample)
+
+puts "Predicted class: #{predicted_label} / Actual class: #{test_label}"
+
+eigenvalues = model.get_mat('eigenvalues')
+w = model.get_mat('eigenvectors');
+mean = model.get_mat('mean')
+
+if output_folder
+  norm_0_255(mean.reshape(1, images[0].rows)).save("#{output_folder}/mean.png")
+else
+  w1 = GUI::Window.new('Predicted')
+  w2 = GUI::Window.new('Actual')
+  w3 = GUI::Window.new('mean')
+
+  w1.show images[predicted_label]
+  w2.show images[test_label]
+  w3.show norm_0_255(mean.reshape(1, images[0].rows))
+end
+
+# Display or save the Eigenfaces:
+[w.cols, 10].min.times { |i|
+  puts "Eigenvalue ##{i} = #{eigenvalues[i][0]}"
+  ev = w.get_cols(i).clone()
+  grayscale = norm_0_255(ev.reshape(1, height))
+
+  # Show the image & apply a Jet colormap for better sensing.
+  cgrayscale = grayscale.apply_color_map(COLORMAP_JET)
+  if output_folder
+    norm_0_255(cgrayscale).save("#{output_folder}/eigenface_#{i}.png")
+  else
+    w4 = GUI::Window.new("eigenface_#{i}")
+    w4.show norm_0_255(cgrayscale)
+  end
+}
+
+[w.cols, 10].min.step([w.cols, 300].min, 15) { |num_components|
+  # slice the eigenvectors from the model
+  evs = w.get_cols(0..num_components)
+  projection = images[0].reshape(1, 1).subspace_project(evs, mean)
+  reconstruction = projection.subspace_reconstruct(evs, mean)
+
+  # Normalize the result:
+  reconstruction = norm_0_255(reconstruction.reshape(1, images[0].rows))
+
+  # Display or save:
+  if output_folder
+    norm_0_255(reconstruction).save("#{output_folder}/eigenface_reconstruction_#{num_components}.png")
+  else
+    w5 = GUI::Window.new("eigenface_reconstruction_#{num_components}")
+    w5.show norm_0_255(reconstruction)
+  end
+}
+
+GUI::wait_key unless output_folder
+

data/examples/facerec/facerec_fisherfaces.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+
+# Fisherfaces sample in ruby-opencv, equivalent to http://docs.opencv.org/trunk/_downloads/facerec_fisherfaces.cpp
+# See http://docs.opencv.org/trunk/modules/contrib/doc/facerec/facerec_tutorial.html
+require 'opencv'
+include OpenCV
+
+def norm_0_255(src)
+  dst = nil
+  case src.channel
+  when 1
+    dst = src.normalize(0, 255, CV_NORM_MINMAX, CV_8UC1)
+  when 2
+    dst = src.normalize(0, 255, CV_NORM_MINMAX, CV_8UC3)
+  else
+    dst = src.copy
+  end
+
+  dst
+end
+
+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
+
+if ARGV.size < 1
+  puts "usage: ruby #{__FILE__} <csv.ext> <output_folder>"
+  exit 1
+end
+fn_csv = ARGV.shift
+output_folder = ARGV.shift
+
+images, labels = read_csv(fn_csv);
+
+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 Fisherfaces model for
+# face recognition and train it with the images and
+# labels read from the given CSV file.
+# If you just want to keep 10 Fisherfaces, then call
+# the factory method like this:
+# 
+#      FisherFaces.new(10)
+# 
+# However it is not useful to discard Fisherfaces! Please
+# always try to use _all_ available Fisherfaces for
+# classification.
+# 
+# If you want to create a FaceRecognizer with a
+# confidence threshold (e.g. 123.0) and use _all_
+# Fisherfaces, then call it with:
+# 
+#      FisherFaces.new(0, 123.0);
+#
+model = FisherFaces.new
+model.train(images, labels)
+
+# The following line predicts the label of a given test image:
+predicted_label, predicted_confidence = model.predict(test_sample)
+
+puts "Predicted class: #{predicted_label} / Actual class: #{test_label}"
+
+eigenvalues = model.get_mat('eigenvalues')
+w = model.get_mat('eigenvectors');
+mean = model.get_mat('mean')
+
+if output_folder
+  norm_0_255(mean.reshape(1, images[0].rows)).save("#{output_folder}/mean.png")
+else
+  w1 = GUI::Window.new('Predicted')
+  w2 = GUI::Window.new('Actual')
+  w3 = GUI::Window.new('mean')
+
+  w1.show images[predicted_label]
+  w2.show images[test_label]
+  w3.show norm_0_255(mean.reshape(1, images[0].rows))
+end
+
+# Display or save the first, at most 16 Fisherfaces
+[w.cols, 16].min.times { |i|
+  puts "Eigenvalue ##{i} = #{eigenvalues[i][0]}"
+  ev = w.get_cols(i).clone()
+  grayscale = norm_0_255(ev.reshape(1, height))
+
+  # Show the image & apply a Bone colormap for better sensing.
+  cgrayscale = grayscale.apply_color_map(COLORMAP_BONE)
+  if output_folder
+    norm_0_255(cgrayscale).save("#{output_folder}/fisherface_#{i}.png")
+  else
+    w4 = GUI::Window.new("fisherface_#{i}")
+    w4.show norm_0_255(cgrayscale)
+  end
+}
+
+[w.cols, 16].min.times { |num_component|
+  # Slice the Fisherface from the model
+  ev = w.get_cols(num_component)
+  projection = images[0].reshape(1, 1).subspace_project(ev, mean)
+  reconstruction = projection.subspace_reconstruct(ev, mean)
+
+  # Normalize the result:
+  reconstruction = norm_0_255(reconstruction.reshape(1, images[0].rows))
+
+  # Display or save:
+  if output_folder
+    norm_0_255(reconstruction).save("#{output_folder}/fisherface_reconstruction_#{num_component}.png")
+  else
+    w5 = GUI::Window.new("fisherface_reconstruction_#{num_component}")
+    w5.show norm_0_255(reconstruction)
+  end
+}
+
+GUI::wait_key unless output_folder
+

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, predicted_confidence = 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.
+