ruby-opencv 0.0.9-x86-mswin32

data/ext/opencv/cvfeaturetree.h

@@ -0,0 +1,55 @@
+/************************************************************
+
+   cvfeaturetree.h -
+
+   $Author: ser1zw $
+
+   Copyright (C) 2011 ser1zw
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVFEATURETREE_H
+#define RUBY_OPENCV_CVFEATURETREE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVFEATURETREE namespace cCvFeatureTree {
+#define __NAMESPACE_END_CVFEATURETREE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVFEATURETREE
+
+VALUE rb_class();
+void define_ruby_class();
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(VALUE self, VALUE desc);
+VALUE rb_find_features(VALUE self, VALUE desc, VALUE k, VALUE emax);
+
+__NAMESPACE_END_CVFEATURETREE
+
+typedef struct _CvFeatureTreeWrap {
+  CvFeatureTree* feature_tree;
+  VALUE desc;
+} CvFeatureTreeWrap;
+
+inline CvFeatureTree*
+CVFEATURETREE(VALUE object)
+{
+  CvFeatureTreeWrap* ptr;
+  Data_Get_Struct(object, CvFeatureTreeWrap, ptr);
+  return ptr->feature_tree;
+}
+
+inline CvFeatureTree*
+CVFEATURETREE_WITH_CHECK(VALUE object)
+{
+  if (!rb_obj_is_kind_of(object, cCvFeatureTree::rb_class()))
+    raise_typeerror(object, cCvFeatureTree::rb_class());
+  return CVFEATURETREE(object);
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVFEATURETREE
+
+
+

data/ext/opencv/cvfont.cpp

@@ -0,0 +1,208 @@
+/************************************************************
+
+   cvfont.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvfont.h"
+/*
+ * Document-class: OpenCV::CvFont
+ *
+ * Font structure that can be passed to text rendering functions. 
+ * see CvMat#put_text, CvMat#put_text!
+ */
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVFONT
+
+VALUE rb_klass;
+
+int
+rb_font_option_line_type(VALUE font_option)
+{
+  VALUE line_type = LOOKUP_HASH(font_option, "line_type");
+  if (FIXNUM_P(line_type)) {
+    return FIX2INT(line_type);
+  }
+  else if (line_type == ID2SYM(rb_intern("aa"))) {
+    return CV_AA;
+  }
+  return 0;
+}
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+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, "CvFont", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  VALUE face = rb_hash_new();
+  rb_define_const(rb_klass, "FACE", face);
+  rb_hash_aset(face, ID2SYM(rb_intern("simplex")), INT2FIX(CV_FONT_HERSHEY_SIMPLEX));
+  rb_hash_aset(face, ID2SYM(rb_intern("plain")), INT2FIX(CV_FONT_HERSHEY_PLAIN));
+  rb_hash_aset(face, ID2SYM(rb_intern("duplex")), INT2FIX(CV_FONT_HERSHEY_DUPLEX));
+  rb_hash_aset(face, ID2SYM(rb_intern("triplex")), INT2FIX(CV_FONT_HERSHEY_TRIPLEX));
+  rb_hash_aset(face, ID2SYM(rb_intern("complex_small")), INT2FIX(CV_FONT_HERSHEY_COMPLEX_SMALL));
+  rb_hash_aset(face, ID2SYM(rb_intern("script_simplex")), INT2FIX(CV_FONT_HERSHEY_SCRIPT_SIMPLEX));
+  rb_hash_aset(face, ID2SYM(rb_intern("script_complex")), INT2FIX(CV_FONT_HERSHEY_SCRIPT_COMPLEX));
+
+  VALUE default_option = rb_hash_new();
+  rb_define_const(rb_klass, "FONT_OPTION", default_option);
+  rb_hash_aset(default_option, ID2SYM(rb_intern("hscale")), rb_float_new(1.0));
+  rb_hash_aset(default_option, ID2SYM(rb_intern("vscale")), rb_float_new(1.0));
+  rb_hash_aset(default_option, ID2SYM(rb_intern("shear")), INT2FIX(0));
+  rb_hash_aset(default_option, ID2SYM(rb_intern("thickness")), INT2FIX(1));
+  rb_hash_aset(default_option, ID2SYM(rb_intern("line_type")), INT2FIX(8));
+  
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "face", RUBY_METHOD_FUNC(rb_face), 0);
+  rb_define_method(rb_klass, "hscale", RUBY_METHOD_FUNC(rb_hscale), 0);
+  rb_define_method(rb_klass, "vscale", RUBY_METHOD_FUNC(rb_vscale), 0);
+  rb_define_method(rb_klass, "shear", RUBY_METHOD_FUNC(rb_shear), 0);
+  rb_define_method(rb_klass, "thickness", RUBY_METHOD_FUNC(rb_thickness), 0);
+  rb_define_method(rb_klass, "line_type", RUBY_METHOD_FUNC(rb_line_type), 0);
+  rb_define_method(rb_klass, "italic", RUBY_METHOD_FUNC(rb_italic), 0);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvFont *ptr;
+  return Data_Make_Struct(klass, CvFont, 0, -1, ptr);
+}
+
+
+/*
+ * call-seq:
+ *   CvFont.new(<i>face[,font_option]</i>) -> font
+ *
+ * Create font object.
+ * <i>face</i> is font name identifier. 
+ * 
+ * Only a subset of Hershey fonts (http://sources.isc.org/utils/misc/hershey-font.txt) are supported now:
+ * * :simplex - normal size sans-serif font
+ * * :plain - small size sans-serif font
+ * * :duplex - normal size sans-serif font (more complex than :simplex)
+ * * :complex - normal size serif font
+ * * :triplex - normal size serif font (more complex than :complex)
+ * * :complex_small - smaller version of :complex
+ * * :script_simplex - hand-writing style font
+ * * :script_complex - more complex variant of :script_simplex
+ *
+ * <i>font_option</i> should be Hash include these keys.
+ *   :hscale
+ *     Horizontal scale. If equal to 1.0, the characters have the original width depending on the font type.
+ *     If equal to 0.5, the characters are of half the original width.
+ *   :vscale
+ *     Vertical scale. If equal to 1.0, the characters have the original height depending on the font type.
+ *     If equal to 0.5, the characters are of half the original height.
+ *   :shear
+ *     Approximate tangent of the character slope relative to the vertical line.
+ *     Zero value means a non-italic font, 1.0f means ~45degree slope, etc.
+ *   :thickness
+ *     Thickness of the text strokes.
+ *   :line_type
+ *     Type of the strokes, see CvMat#Line description.
+ *   :italic
+ *     If value is not nil or false that means italic or oblique font.
+ *
+ * note: <i>font_option</i>'s default value is CvFont::FONT_OPTION.
+ *
+ * e.g. Create Font
+ *   OpenCV::CvFont.new(:simplex, :hscale => 2, :vslace => 2, :italic => true)
+ *   # create 2x bigger than normal, italic type font.
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE face, font_option;
+  rb_scan_args(argc, argv, "11", &face, &font_option);
+  Check_Type(face, T_SYMBOL);
+  face = rb_hash_lookup(rb_const_get(cCvFont::rb_class(), rb_intern("FACE")), face);
+  if (NIL_P(face)) {
+    rb_raise(rb_eArgError, "undefined face.");
+  }
+  font_option = FONT_OPTION(font_option);
+
+  int font_face = NUM2INT(face);
+  if (FO_ITALIC(font_option)) {
+    font_face |= CV_FONT_ITALIC;
+  }
+  try {
+    cvInitFont(CVFONT(self),
+	       font_face,
+	       FO_HSCALE(font_option),
+	       FO_VSCALE(font_option),
+	       FO_SHEAR(font_option),
+	       FO_THICKNESS(font_option),
+	       FO_LINE_TYPE(font_option));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+
+  return self;
+}
+
+
+VALUE
+rb_face(VALUE self)
+{
+  return INT2FIX(CVFONT(self)->font_face);
+}
+
+VALUE
+rb_hscale(VALUE self)
+{
+  return rb_float_new(CVFONT(self)->hscale);
+}
+
+VALUE
+rb_vscale(VALUE self)
+{
+  return rb_float_new(CVFONT(self)->vscale);
+}
+
+VALUE
+rb_shear(VALUE self)
+{
+  return rb_float_new(CVFONT(self)->shear);
+}
+
+VALUE
+rb_thickness(VALUE self)
+{
+  return INT2FIX(CVFONT(self)->thickness);
+}
+
+VALUE
+rb_line_type(VALUE self)
+{
+  return INT2FIX(CVFONT(self)->line_type);
+}
+
+VALUE
+rb_italic(VALUE self)
+{
+  return ((CVFONT(self)->font_face & CV_FONT_ITALIC) > 0) ? Qtrue : Qfalse;
+}
+
+__NAMESPACE_END_CVFONT
+__NAMESPACE_END_OPENCV

data/ext/opencv/cvfont.h

@@ -0,0 +1,64 @@
+/************************************************************
+
+   cvfont.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVFONT_H
+#define RUBY_OPENCV_CVFONT_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVFONT namespace cCvFont {
+#define __NAMESPACE_END_CVFONT }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVFONT
+
+#define FONT_OPTION(op) rb_get_option_table(rb_klass, "FONT_OPTION", op)
+#define FO_ITALIC(op) TRUE_OR_FALSE(LOOKUP_HASH(op, "italic"))
+#define FO_HSCALE(op) NUM2DBL(LOOKUP_HASH(op, "hscale"))
+#define FO_VSCALE(op) NUM2DBL(LOOKUP_HASH(op, "vscale"))
+#define FO_SHEAR(op) NUM2DBL(LOOKUP_HASH(op, "shear"))
+#define FO_THICKNESS(op) NUM2INT(LOOKUP_HASH(op, "thickness"))
+#define FO_LINE_TYPE(op) rb_font_option_line_type(op)
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE rb_face(VALUE self);
+VALUE rb_hscale(VALUE self);
+VALUE rb_vscale(VALUE self);
+VALUE rb_shear(VALUE self);
+VALUE rb_thickness(VALUE self);
+VALUE rb_line_type(VALUE self);
+VALUE rb_italic(VALUE self);
+
+__NAMESPACE_END_CVFONT
+
+inline CvFont*
+CVFONT(VALUE object)
+{
+  CvFont *ptr;
+  Data_Get_Struct(object, CvFont, ptr);
+  return ptr;
+}
+
+inline CvFont*
+CVFONT_WITH_CHECK(VALUE object)
+{
+  if (!rb_obj_is_kind_of(object, cCvFont::rb_class()))
+    raise_typeerror(object, cCvFont::rb_class());
+  return CVFONT(object);
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVFONT_H

data/ext/opencv/cvhaarclassifiercascade.cpp

@@ -0,0 +1,168 @@
+/************************************************************
+
+  cvhaarclassifercascade.cpp -
+
+  $Author: lsxi $
+
+  Copyright (C) 2005-2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvhaarclassifiercascade.h"
+/*
+ * Document-class: OpenCV::CvHaarClassifierCascade
+ *
+ * CvHaarClassifierCascade object is "fast-object-detector".
+ * This detector can discover object (e.g. human's face) from image.
+ *
+ * Find face-area from picture "lena"...
+ * link:../images/face_detect_from_lena.jpg
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVHAARCLASSIFERCASCADE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+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, "CvHaarClassifierCascade", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_singleton_method(rb_klass, "load", RUBY_METHOD_FUNC(rb_load), 1);
+  rb_define_method(rb_klass, "detect_objects", RUBY_METHOD_FUNC(rb_detect_objects), -1);
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  return OPENCV_OBJECT(klass, 0);
+}
+
+void
+cvhaarclassifiercascade_free(void* ptr)
+{
+  if (ptr) {
+    CvHaarClassifierCascade* cascade = (CvHaarClassifierCascade*)ptr;
+    cvReleaseHaarClassifierCascade(&cascade);
+  }
+}
+
+/*
+ * call-seq:
+ *   CvHaarClassiferCascade.load(<i>path</i>) -> object-detector
+ * 
+ * Load trained cascade of haar classifers from file.
+ * Object detection classifiers are stored in XML or YAML files.
+ * sample of object detection classifier files is included by OpenCV.
+ *
+ * You can found these at
+ *    C:\Program Files\OpenCV\data\haarcascades\*.xml (Windows, default install path)
+ *
+ * e.g. you want to try to detect human's face.
+ *    detector = CvHaarClassiferCascade.load("haarcascade_frontalface_alt.xml")
+ */
+VALUE
+rb_load(VALUE klass, VALUE path)
+{
+  CvHaarClassifierCascade *cascade = NULL;
+  try {
+    cascade = (CvHaarClassifierCascade*)cvLoad(StringValueCStr(path), 0, 0, 0);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  if (!CV_IS_HAAR_CLASSIFIER(cascade))
+    rb_raise(rb_eArgError, "invalid format haar classifier cascade file.");
+  return Data_Wrap_Struct(klass, 0, cvhaarclassifiercascade_free, cascade);
+}
+
+/*
+ * call-seq:
+ *   detect_objects(image[, options]) -> cvseq(include CvAvgComp object)
+ *   detect_objects(image[, options]){|cmp| ... } -> cvseq(include CvAvgComp object)
+ *
+ * Detects objects in the image. This method finds rectangular regions in the
+ * given image that are likely to contain objects the cascade has been trained
+ * for and return those regions as a sequence of rectangles.
+ *
+ * * <i>option</i> should be Hash include these keys.
+ *   :scale_factor (should be > 1.0)
+ *      The factor by which the search window is scaled between the subsequent scans,
+ *      1.1 mean increasing window by 10%.
+ *   :storage
+ *      Memory storage to store the resultant sequence of the object candidate rectangles
+ *   :flags
+ *      Mode of operation. Currently the only flag that may be specified is CV_HAAR_DO_CANNY_PRUNING .
+ *      If it is set, the function uses Canny edge detector to reject some image regions that contain
+ *      too few or too much edges and thus can not contain the searched object. The particular threshold
+ *      values are tuned for face detection and in this case the pruning speeds up the processing
+ *   :min_neighbors
+ *      Minimum number (minus 1) of neighbor rectangles that makes up an object.
+ *      All the groups of a smaller number of rectangles than min_neighbors - 1 are rejected.
+ *      If min_neighbors is 0, the function does not any grouping at all and returns all the detected
+ *      candidate rectangles, whitch many be useful if the user wants to apply a customized grouping procedure.
+ *   :min_size
+ *      Minimum window size. By default, it is set to size of samples the classifier has been
+ *      trained on (~20x20 for face detection).
+ *   :max_size
+ *      aximum window size to use. By default, it is set to the size of the image.
+ */
+VALUE
+rb_detect_objects(int argc, VALUE *argv, VALUE self)
+{ 
+  VALUE image, options;
+  rb_scan_args(argc, argv, "11", &image, &options);
+
+  double scale_factor;
+  int flags, min_neighbors;
+  CvSize min_size, max_size;
+  VALUE storage_val;
+  if (NIL_P(options)) {
+    scale_factor = 1.1;
+    flags = 0;
+    min_neighbors = 3;
+    min_size = max_size = cvSize(0, 0);
+    storage_val = cCvMemStorage::new_object();
+  }
+  else {
+    scale_factor = IF_DBL(LOOKUP_HASH(options, "scale_factor"), 1.1);
+    flags = IF_INT(LOOKUP_HASH(options, "flags"), 0);
+    min_neighbors = IF_INT(LOOKUP_HASH(options, "min_neighbors"), 3);
+    VALUE min_size_val = LOOKUP_HASH(options, "min_size");
+    min_size = NIL_P(min_size_val) ? cvSize(0, 0) : VALUE_TO_CVSIZE(min_size_val);
+    VALUE max_size_val = LOOKUP_HASH(options, "max_size");
+    max_size = NIL_P(max_size_val) ? cvSize(0, 0) : VALUE_TO_CVSIZE(max_size_val);
+    storage_val = CHECK_CVMEMSTORAGE(LOOKUP_HASH(options, "storage"));
+  }
+
+  VALUE result = Qnil;
+  try {
+    CvSeq *seq = cvHaarDetectObjects(CVARR_WITH_CHECK(image), CVHAARCLASSIFIERCASCADE(self), CVMEMSTORAGE(storage_val),
+			      scale_factor, min_neighbors, flags, min_size, max_size);
+    result = cCvSeq::new_sequence(cCvSeq::rb_class(), seq, cCvAvgComp::rb_class(), storage_val);
+    if (rb_block_given_p()) {
+      for(int i = 0; i < seq->total; ++i)
+	rb_yield(REFER_OBJECT(cCvAvgComp::rb_class(), cvGetSeqElem(seq, i), storage_val));
+    }
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return result;
+}
+
+__NAMESPACE_END_CVHAARCLASSIFERCASCADE
+__NAMESPACE_END_OPENCV