jf-ruby-opencv 0.0.18

data/ext/opencv/cvvideowriter.cpp

@@ -0,0 +1,142 @@
+/************************************************************
+
+   cvvideowriter.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvvideowriter.h"
+/*
+ * Document-class: OpenCV::CvVideoWriter
+ *
+ * Create video stream from images.
+ *
+ * C structure is "black box".
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVVIDEOWRITER
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+/*
+ * call-seq:
+ *   CvVideoWriter.new(filname, fourcc, fps, size[, is_color]) -> cvvideowriter
+ *   CvVideoWriter.new(filname, fourcc, fps, size[, is_color]){|vw| ... } -> nil
+ *
+ * Open new video writer. If block given, writer is closed automatically when end of block.
+ * 
+ * note: if <i>fourcc</i> is nil, popup codec select dialog (Windows only).
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE filename, fourcc, fps, size, is_color_val;
+  rb_scan_args(argc, argv, "41", &filename, &fourcc, &fps, &size, &is_color_val);
+  char codec[4] = {' ', ' ', ' ', ' '};
+  int codec_number;
+  Check_Type(filename, T_STRING);
+  if (RSTRING_LEN(filename) == 0)
+    rb_raise(rb_eArgError, "argument 1 (file name) dose not given");
+  if (NIL_P(fourcc))
+    codec_number = -1;
+  else {
+    Check_Type(fourcc, T_STRING);
+    if (RSTRING_LEN(fourcc) > 4)
+      rb_raise(rb_eStandardError, "argument 2 (fourcc) should be specific 4-character. (i.e \"PIM1\",\"MJPG\")");
+    else {
+      int len = RSTRING_LEN(fourcc);
+      for (int i = 0; i < len; ++i)
+        codec[i] = RSTRING_PTR(fourcc)[i];
+      codec_number = CV_FOURCC(codec[0], codec[1], codec[2], codec[3]);
+    }
+  }
+  int is_color;
+  if (NIL_P(is_color_val))
+    is_color = 1;
+  else
+    is_color = (is_color_val == Qtrue) ? 1 : 0;
+  try {
+    DATA_PTR(self) = cvCreateVideoWriter(StringValueCStr(filename), codec_number,
+					 NUM2DBL(fps), VALUE_TO_CVSIZE(size), is_color);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  if (rb_block_given_p()) {
+    rb_yield(self);
+    rb_close(self);
+    return Qnil;
+  }
+  else
+    return self;
+}
+
+/*
+ * call-seq:
+ *   write(frame)
+ *
+ * Write image as frame of video stream.
+ * <i>frame</i> should be IplImage
+ */
+VALUE
+rb_write(VALUE self, VALUE frame)
+{
+  try {
+    cvWriteFrame(CVVIDEOWRITER(self), IPLIMAGE_WITH_CHECK(frame));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return self;
+}
+
+/*
+ * Close vidoe writer.
+ */
+VALUE
+rb_close(VALUE self)
+{
+  CvVideoWriter *writer = CVVIDEOWRITER(self);
+  try {
+    if (writer)
+      cvReleaseVideoWriter(&writer);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return Qnil;
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+#endif
+
+  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, "CvVideoWriter", rb_cObject);
+  rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "write", RUBY_METHOD_FUNC(rb_write), 1);
+  rb_define_method(rb_klass, "close", RUBY_METHOD_FUNC(rb_close), 0);
+}
+
+__NAMESPACE_END_CVVIDEOWRITER
+__NAMESPACE_END_OPENCV
+

data/ext/opencv/cvvideowriter.h

@@ -0,0 +1,43 @@
+/************************************************************
+
+   cvvideowriter.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVVIDEOWRITER_H
+#define RUBY_OPENCV_CVVIDEOWRITER_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVVIDEOWRITER namespace cCvVideoWriter {
+#define __NAMESPACE_END_CVVIDEOWRITER }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVVIDEOWRITER
+
+VALUE rb_class();
+
+void init_ruby_class();
+
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_write(VALUE self, VALUE frame);
+VALUE rb_close(VALUE self);
+
+__NAMESPACE_END_CVVIDEOWRITER
+
+inline CvVideoWriter*
+CVVIDEOWRITER(VALUE object)
+{
+  // CvVideoWriter is 
+  // CvVideoWriter *ptr;
+  // Data_Get_Struct(object, CvVideoWriter, ptr);
+  // return ptr;
+  return (CvVideoWriter*)DATA_PTR(object);
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVVIDEOWRITER_H

data/ext/opencv/eigenfaces.cpp

@@ -0,0 +1,75 @@
+/************************************************************
+
+   eigenfaces.cpp -
+
+   $Author: ser1zw $
+
+   Copyright (C) 2013 ser1zw
+
+************************************************************/
+#include <stdio.h>
+#include "eigenfaces.h"
+/*
+ * Document-class: OpenCV::EigenFaces
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_EIGENFACES
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+/* 
+ * call-seq:
+ *   EigenFaces.new(num_components=0, threshold=DBL_MAX)
+ */
+VALUE
+rb_initialize(int argc, VALUE argv[], VALUE self)
+{
+  VALUE num_components_val, threshold_val;
+  rb_scan_args(argc, argv, "02", &num_components_val, &threshold_val);
+
+  int num_components = NIL_P(num_components_val) ? 0 : NUM2INT(num_components_val);
+  double threshold = NIL_P(threshold_val) ? DBL_MAX : NUM2DBL(threshold_val);
+
+  free(DATA_PTR(self));
+  cv::Ptr<cv::FaceRecognizer> ptr = cv::createEigenFaceRecognizer(num_components, threshold);
+  DATA_PTR(self) = ptr;
+
+  cFaceRecognizer::guard_facerecognizer(DATA_PTR(self), ptr);
+
+  return self;
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+  VALUE alghorithm = rb_define_class_under(opencv, "Algorithm", rb_cObject);
+  VALUE face_recognizer = rb_define_class_under(opencv, "FaceRecognizer", alghorithm);
+#endif
+
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  VALUE face_recognizer = cFaceRecognizer::rb_class();
+  rb_klass = rb_define_class_under(opencv, "EigenFaces", face_recognizer);
+  rb_define_alloc_func(rb_klass, cFaceRecognizer::allocate_facerecognizer);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+}
+
+__NAMESPACE_END_EIGENFACES
+__NAMESPACE_END_OPENCV
+

data/ext/opencv/eigenfaces.h

@@ -0,0 +1,30 @@
+/************************************************************
+
+   eigenfaces.h
+
+   $Author: ser1zw $
+
+   Copyright (C) 2013 ser1zw
+
+************************************************************/
+#ifndef RUBY_OPENCV_EIGENFACES_H
+#define RUBY_OPENCV_EIGENFACES_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_EIGENFACES namespace cEigenFaces {
+#define __NAMESPACE_END_EIGENFACES }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_EIGENFACES
+
+VALUE rb_class();
+
+void init_ruby_class();
+VALUE rb_initialize(int argc, VALUE argv[], VALUE self);
+
+__NAMESPACE_END_EIGENFACES
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_EIGENFACES_H
+

data/ext/opencv/extconf.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+CC = RbConfig::CONFIG['CC']
+if CC =~ /clang/
+  RbConfig::MAKEFILE_CONFIG['try_header'] = :try_cpp
+  RbConfig::CONFIG['CPP'] = "#{CC} -E"
+elsif RbConfig::CONFIG['arch'] =~ /mswin32/
+  RbConfig::MAKEFILE_CONFIG['try_header'] = :try_cpp
+  RbConfig::CONFIG['CPP'] = "#{CC} /P"
+end
+
+require "mkmf"
+
+def cv_version_suffix(incdir)
+  major, minor, subminor = nil, nil, nil
+  open("#{incdir}/opencv2/core/version.hpp", 'r') { |f|
+    f.read.lines.each { |line|
+      major = $1.to_s if line =~ /\A#define\s+(?:CV_VERSION_EPOCH|CV_MAJOR_VERSION)\s+(\d+)\s*\Z/
+      minor = $1.to_s if line =~ /\A#define\s+(?:CV_VERSION_MAJOR|CV_MINOR_VERSION)\s+(\d+)\s*\Z/
+      subminor = $1.to_s if line =~ /\A#define\s+(?:CV_VERSION_MINOR|CV_SUBMINOR_VERSION)\s+(\d+)\s*\Z/
+    }
+  }
+  major + minor + subminor
+end
+
+# Quick fix for 2.0.0
+# @libdir_basename is set to nil and dir_config() sets invalid libdir '${opencv-dir}/' when --with-opencv-dir option passed.
+@libdir_basename ||= 'lib'
+incdir, libdir = dir_config("opencv", "/usr/local/include", "/usr/local/lib")
+dir_config("libxml2", "/usr/include", "/usr/lib")
+
+opencv_headers = ["opencv2/core/core_c.h", "opencv2/core/core.hpp", "opencv2/imgproc/imgproc_c.h",
+                  "opencv2/imgproc/imgproc.hpp", "opencv2/video/tracking.hpp", "opencv2/features2d/features2d.hpp",
+                  "opencv2/flann/flann.hpp", "opencv2/calib3d/calib3d.hpp", "opencv2/objdetect/objdetect.hpp",
+                  "opencv2/legacy/compat.hpp", "opencv2/legacy/legacy.hpp", "opencv2/highgui/highgui_c.h",
+                  "opencv2/highgui/highgui.hpp", "opencv2/photo/photo.hpp"]
+opencv_headers_opt = ["opencv2/nonfree/nonfree.hpp"]
+
+opencv_libraries = ["opencv_calib3d", "opencv_contrib", "opencv_core", "opencv_features2d",
+                    "opencv_flann", "opencv_highgui", "opencv_imgproc", "opencv_legacy",
+                    "opencv_ml", "opencv_objdetect", "opencv_video", "opencv_photo"]
+opencv_libraries_opt = ["opencv_gpu", "opencv_nonfree"]
+
+puts ">> Check the required libraries..."
+if $mswin or $mingw
+  suffix = cv_version_suffix(incdir)
+  opencv_libraries.map! { |lib| lib + suffix }
+  opencv_libraries_opt.map! { |lib| lib + suffix }
+  have_library("msvcrt")
+  if $mswin
+    $CFLAGS << ' /EHsc'
+    CONFIG['CXXFLAGS'] << ' /EHsc'
+  end
+else
+  have_library("stdc++")
+end
+
+opencv_libraries.each { |lib| raise "#{lib} not found." unless have_library(lib) }
+opencv_libraries_opt.each { |lib| warn "#{lib} not found." unless have_library(lib) }
+
+# Check the required headers
+puts ">> Check the required headers..."
+opencv_headers.each { |header| raise "#{header} not found." unless have_header(header) }
+opencv_headers_opt.each { |header| warn "#{header} not found." unless have_header(header) }
+have_header("stdarg.h")
+
+if $warnflags
+  $warnflags.slice!('-Wdeclaration-after-statement')
+  $warnflags.slice!('-Wimplicit-function-declaration')
+end
+
+# Quick fix for 1.8.7
+$CFLAGS << " -I#{File.dirname(__FILE__)}/ext/opencv"
+
+# Create Makefile
+create_makefile('opencv')
+

data/ext/opencv/facerecognizer.cpp

@@ -0,0 +1,219 @@
+/************************************************************
+
+   facerecognizer.cpp -
+
+   $Author: ser1zw $
+
+   Copyright (C) 2013 ser1zw
+
+************************************************************/
+#include <stdio.h>
+#include "facerecognizer.h"
+/*
+ * Document-class: OpenCV::FaceRecognizer
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_FACERECOGNIZER
+
+VALUE rb_klass;
+
+std::map<void*, cv::Ptr<cv::FaceRecognizer> > ptr_guard_map;
+
+void
+guard_facerecognizer(void* data_ptr, cv::Ptr<cv::FaceRecognizer> ptr)
+{
+  ptr_guard_map[data_ptr] = ptr;
+}
+
+void
+release_facerecognizer(void *data_ptr)
+{
+  ptr_guard_map[data_ptr].release();
+  ptr_guard_map.erase(data_ptr);
+}
+
+VALUE
+allocate_facerecognizer(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, 0, release_facerecognizer, NULL);
+}
+
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+/*
+ * call-seq:
+ *   train(src, labels)
+ *
+ * Trains a FaceRecognizer with given data and associated labels.
+ */
+VALUE
+rb_train(VALUE self, VALUE src, VALUE labels)
+{
+  Check_Type(src, T_ARRAY);
+  Check_Type(labels, T_ARRAY);
+
+  VALUE *src_ptr = RARRAY_PTR(src);
+  int src_size = RARRAY_LEN(src);
+  std::vector<cv::Mat> images;
+  for (int i = 0; i < src_size; i++) {
+    images.push_back(cv::Mat(CVMAT_WITH_CHECK(src_ptr[i])));
+  }
+
+  VALUE *labels_ptr = RARRAY_PTR(labels);
+  int labels_size = RARRAY_LEN(labels);
+  std::vector<int> local_labels;
+  for (int i = 0; i < labels_size; i++) {
+    local_labels.push_back(NUM2INT(labels_ptr[i]));
+  }
+
+  cv::FaceRecognizer *self_ptr = FACERECOGNIZER(self);
+  try {
+    self_ptr->train(images, local_labels);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   udpate(src, labels)
+ *
+ * Updates a FaceRecognizer with given data and associated labels. Only valid on LBPH models.
+ */
+VALUE
+rb_update(VALUE self, VALUE src, VALUE labels)
+{
+  Check_Type(src, T_ARRAY);
+  Check_Type(labels, T_ARRAY);
+
+  VALUE *src_ptr = RARRAY_PTR(src);
+  int src_size = RARRAY_LEN(src);
+  std::vector<cv::Mat> images;
+  for (int i = 0; i < src_size; i++) {
+    images.push_back(cv::Mat(CVMAT_WITH_CHECK(src_ptr[i])));
+  }
+
+  VALUE *labels_ptr = RARRAY_PTR(labels);
+  int labels_size = RARRAY_LEN(labels);
+  std::vector<int> local_labels;
+  for (int i = 0; i < labels_size; i++) {
+    local_labels.push_back(NUM2INT(labels_ptr[i]));
+  }
+
+  cv::FaceRecognizer *self_ptr = FACERECOGNIZER(self);
+  try {
+    self_ptr->update(images, local_labels);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   predict(src)
+ * 
+ * Predicts a label and associated confidence (e.g. distance) for a given input image.
+ */
+VALUE
+rb_predict(VALUE self, VALUE src)
+{
+  cv::Mat mat = cv::Mat(CVMAT_WITH_CHECK(src));
+  cv::FaceRecognizer *self_ptr = FACERECOGNIZER(self);
+  int label;
+  double confidence;
+  try {
+    self_ptr->predict(mat, label, confidence);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return rb_ary_new3(2, INT2NUM(label), DBL2NUM(confidence));
+}
+
+
+/*
+ * call-seq:
+ *   save(filename)
+ *
+ * Saves this model to a given filename, either as XML or YAML.
+ */
+VALUE
+rb_save(VALUE self, VALUE filename)
+{
+  Check_Type(filename, T_STRING);
+  cv::FaceRecognizer *self_ptr = FACERECOGNIZER(self);
+  try {
+    char* s = StringValueCStr(filename);
+    self_ptr->save(std::string(s));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   load(filename)
+ *
+ * Loads a FaceRecognizer and its model state.
+ */
+VALUE
+rb_load(VALUE self, VALUE filename)
+{
+  Check_Type(filename, T_STRING);
+  cv::FaceRecognizer *self_ptr = FACERECOGNIZER(self);
+  try {
+    char* s = StringValueCStr(filename);
+    self_ptr->load(std::string(s));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return Qnil;
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+  VALUE alghorithm = rb_define_class_under(opencv, "Algorithm", rb_cObject);
+#endif
+
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  VALUE alghorithm = cAlgorithm::rb_class();
+  rb_klass = rb_define_class_under(opencv, "FaceRecognizer", alghorithm);
+  rb_define_method(rb_klass, "train", RUBY_METHOD_FUNC(rb_train), 2);
+  rb_define_method(rb_klass, "update", RUBY_METHOD_FUNC(rb_update), 2);
+  rb_define_method(rb_klass, "predict", RUBY_METHOD_FUNC(rb_predict), 1);
+  rb_define_method(rb_klass, "save", RUBY_METHOD_FUNC(rb_save), 1);
+  rb_define_method(rb_klass, "load", RUBY_METHOD_FUNC(rb_load), 1);
+}
+
+__NAMESPACE_END_FACERECOGNIZER
+__NAMESPACE_END_OPENCV
+