ruby-opencv 0.0.8-x86-mingw32 → 0.0.9.pre2-x86-mingw32

data/examples/match_kdtree.rb

@@ -1,88 +1,88 @@
-#!/usr/bin/env ruby
-# -*- mode: ruby; coding: utf-8-unix -*- 
-
-# A sample of matching SURF feature points using kd-tree
-# See http://tech.groups.yahoo.com/group/OpenCV/message/62318
-
-require 'opencv'
-include OpenCV
-
-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)
-
-puts 'Extracting features from img1 using SURF...'
-param = CvSURFParams.new(THRESHOLD, USE_EXTENDED_DESCRIPTOR)
-kp1, desc1 = img1.extract_surf(param)
-puts "found #{kp1.size} keypoints from img1"
-
-puts 'Extracting features from img2 using SURF...'
-kp2, desc2 = img2.extract_surf(param)
-puts "found #{kp2.size} keypoints from img2"
-
-puts 'Matching keypoints...'
-desc1mat = CvMat.new(kp1.size, DESCRIPTOR_SIZE, :cv32f, 1)
-desc2mat = CvMat.new(kp2.size, DESCRIPTOR_SIZE, :cv32f, 1)
-desc1.each_with_index { |desc, i|
-  desc.each_with_index { |d, j|
-    desc1mat[i, j] = CvScalar.new(d)
-  }
-}
-desc2.each_with_index { |desc, i|
-  desc.each_with_index { |d, j|
-    desc2mat[i, j] = CvScalar.new(d)
-  }
-}
-
-feature_tree = CvFeatureTree.new(desc1mat)
-results, distances = feature_tree.find_features(desc2mat, 1, 250)
-
-reverse_lookup = []
-reverse_lookup_dist = []
-kp1.size.times { |i|
-  reverse_lookup << -1
-  reverse_lookup_dist << Float::MAX
-}
-
-match_count = 0
-kp2.size.times { |j|
-  i = results[j][0].to_i
-  d = distances[j][0]
-  if (d < reverse_lookup_dist[i])
-    match_count += 1 if reverse_lookup_dist[i] == Float::MAX
-    reverse_lookup[i] = j
-    reverse_lookup_dist[i] = d
-  end
-}
-puts "found #{match_count} putative correspondences"
-
-points1 = []
-points2 = []
-kp2.size.times { |j|
-  i = results[j][0].to_i
-  if (j == reverse_lookup[i])
-    points1 << kp1[i].pt
-    points2 << kp2[j].pt
-  end
-}
-
-width = img1.cols + img2.cols
-height = (img1.rows > img2.rows) ? img1.rows : img2.rows
-correspond = IplImage.new(width, height, :cv8u, 1);
-correspond.set_roi(CvRect.new(0, 0, img1.cols, img1.rows))
-img1.copy(correspond)
-correspond.set_roi(CvRect.new(img1.cols, 0, img1.cols + img2.cols, img2.rows))
-img2.copy(correspond)
-correspond.reset_roi
-
-points1.zip(points2) { |pt1, pt2|
-  pt2.x += img1.cols
-  correspond.line!(pt1, pt2, :color => CvColor::White)
-}
-
-GUI::Window.new('Object Correspond').show correspond
-GUI::wait_key
-
+#!/usr/bin/env ruby
+# -*- mode: ruby; coding: utf-8 -*-
+
+# A sample of matching SURF feature points using kd-tree
+# See http://tech.groups.yahoo.com/group/OpenCV/message/62318
+
+require 'opencv'
+include OpenCV
+
+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)
+
+puts 'Extracting features from img1 using SURF...'
+param = CvSURFParams.new(THRESHOLD, USE_EXTENDED_DESCRIPTOR)
+kp1, desc1 = img1.extract_surf(param)
+puts "found #{kp1.size} keypoints from img1"
+
+puts 'Extracting features from img2 using SURF...'
+kp2, desc2 = img2.extract_surf(param)
+puts "found #{kp2.size} keypoints from img2"
+
+puts 'Matching keypoints...'
+desc1mat = CvMat.new(kp1.size, DESCRIPTOR_SIZE, :cv32f, 1)
+desc2mat = CvMat.new(kp2.size, DESCRIPTOR_SIZE, :cv32f, 1)
+desc1.each_with_index { |desc, i|
+  desc.each_with_index { |d, j|
+    desc1mat[i, j] = CvScalar.new(d)
+  }
+}
+desc2.each_with_index { |desc, i|
+  desc.each_with_index { |d, j|
+    desc2mat[i, j] = CvScalar.new(d)
+  }
+}
+
+feature_tree = CvFeatureTree.new(desc1mat)
+results, distances = feature_tree.find_features(desc2mat, 1, 250)
+
+reverse_lookup = []
+reverse_lookup_dist = []
+kp1.size.times { |i|
+  reverse_lookup << -1
+  reverse_lookup_dist << Float::MAX
+}
+
+match_count = 0
+kp2.size.times { |j|
+  i = results[j][0].to_i
+  d = distances[j][0]
+  if (d < reverse_lookup_dist[i])
+    match_count += 1 if reverse_lookup_dist[i] == Float::MAX
+    reverse_lookup[i] = j
+    reverse_lookup_dist[i] = d
+  end
+}
+puts "found #{match_count} putative correspondences"
+
+points1 = []
+points2 = []
+kp2.size.times { |j|
+  i = results[j][0].to_i
+  if (j == reverse_lookup[i])
+    points1 << kp1[i].pt
+    points2 << kp2[j].pt
+  end
+}
+
+width = img1.cols + img2.cols
+height = (img1.rows > img2.rows) ? img1.rows : img2.rows
+correspond = IplImage.new(width, height, :cv8u, 1);
+correspond.set_roi(CvRect.new(0, 0, img1.cols, img1.rows))
+img1.copy(correspond)
+correspond.set_roi(CvRect.new(img1.cols, 0, img1.cols + img2.cols, img2.rows))
+img2.copy(correspond)
+correspond.reset_roi
+
+points1.zip(points2) { |pt1, pt2|
+  pt2.x += img1.cols
+  correspond.line!(pt1, pt2, :color => CvColor::White)
+}
+
+GUI::Window.new('Object Correspond').show correspond
+GUI::wait_key
+

data/ext/opencv/cvcapture.cpp

@@ -187,21 +187,25 @@ VALUE
 rb_retrieve(VALUE self)
 {
   VALUE image = Qnil;
+  IplImage *frame = NULL;
   try {
-    IplImage *frame = cvRetrieveFrame(CVCAPTURE(self));
-    if (!frame)
+    if (!(frame = cvRetrieveFrame(CVCAPTURE(self)))) {
       return Qnil;
-    image = cIplImage::new_object(cvSize(frame->width, frame->height),
-				  CV_MAKETYPE(CV_8U, frame->nChannels));
-    if (frame->origin == IPL_ORIGIN_TL)
+    }
+    image = cIplImage::new_object(frame->width, frame->height,
+				  CV_MAKETYPE(IPL2CV_DEPTH(frame->depth), frame->nChannels));
+    if (frame->origin == IPL_ORIGIN_TL) {
       cvCopy(frame, CVARR(image));
-    else
+    }
+    else {
       cvFlip(frame, CVARR(image));
+    }
   }
   catch (cv::Exception& e) {
     raise_cverror(e);
   }
   return image;
+
 }
 
 /*
@@ -214,16 +218,19 @@ VALUE
 rb_query(VALUE self)
 {
   VALUE image = Qnil;
+  IplImage *frame = NULL;
   try {
-    IplImage *frame = cvQueryFrame(CVCAPTURE(self));
-    if (!frame)
+    if (!(frame = cvQueryFrame(CVCAPTURE(self)))) {
       return Qnil;
-    image = cIplImage::new_object(cvSize(frame->width, frame->height),
-				  CV_MAKETYPE(CV_8U, frame->nChannels));
-    if (frame->origin == IPL_ORIGIN_TL)
+    }
+    image = cIplImage::new_object(frame->width, frame->height,
+				  CV_MAKETYPE(IPL2CV_DEPTH(frame->depth), frame->nChannels));
+    if (frame->origin == IPL_ORIGIN_TL) {
       cvCopy(frame, CVARR(image));
-    else
+    }
+    else {
       cvFlip(frame, CVARR(image));
+    }
   }
   catch (cv::Exception& e) {
     raise_cverror(e);

data/ext/opencv/cvutils.cpp

@@ -1,194 +1,192 @@
-/************************************************************
-
-  cvutils.cpp -
-
-  $Author: ser1zw $
-
-  Copyright (C) 2011 ser1zw
-
-************************************************************/
-#include "cvutils.h"
-
-void
-raise_typeerror(VALUE object, VALUE expected_class)
-{
-  raise_typeerror(object, rb_class2name(expected_class));
-}
-
-void
-raise_typeerror(VALUE object, const char* expected_class_name)
-{
-  rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
-  	   rb_obj_classname(object), expected_class_name);
-}
-
-void
-raise_compatible_typeerror(VALUE object, VALUE expected_class)
-{
-  raise_compatible_typeerror(object, rb_class2name(expected_class));
-}
-
-void
-raise_compatible_typeerror(VALUE object, const char* expected_class_name)
-{
-  rb_raise(rb_eTypeError, "wrong argument type %s (expected %s or compatible object)",
-  	   rb_obj_classname(object), expected_class_name);
-}
-
-/*
- * Allocates a memory buffer
- * When memory allocation is failed, run GC and retry it
- */
-void*
-rb_cvAlloc(size_t size)
-{
-  void* ptr = NULL;
-  try {
-    ptr = cvAlloc(size);
-  }
-  catch(cv::Exception& e) {
-    if (e.code != CV_StsNoMem)
-      rb_raise(rb_eRuntimeError, "%s", e.what());
-
-    rb_gc_start();
-    try {
-      ptr = cvAlloc(size);
-    }
-    catch (cv::Exception& e) {
-      if (e.code == CV_StsNoMem)
-	rb_raise(rb_eNoMemError, "%s", e.what());
-      else
-	rb_raise(rb_eRuntimeError, "%s", e.what());
-    }
-  }
-  return ptr;
-}
-
-/*
- * Creates CvMat and underlying data
- * When memory allocation is failed, run GC and retry it
- */
-CvMat*
-rb_cvCreateMat(int height, int width, int type)
-{
-  CvMat* ptr = NULL;
-  try {
-    ptr = cvCreateMat(height, width, type);
-  }
-  catch(cv::Exception& e) {
-    if (e.code != CV_StsNoMem)
-      rb_raise(rb_eRuntimeError, "%s", e.what());
-
-    rb_gc_start();
-    try {
-      ptr = cvCreateMat(height, width, type);
-    }
-    catch (cv::Exception& e) {
-      if (e.code == CV_StsNoMem)
-	rb_raise(rb_eNoMemError, "%s", e.what());
-      else
-	rb_raise(rb_eRuntimeError, "%s", e.what());
-    }
-  }
-  return ptr;
-}
-
-/*
- * Create IplImage header and allocate underlying data
- * When memory allocation is failed, run GC and retry it
- */
-IplImage*
-rb_cvCreateImage(CvSize size, int depth, int channels)
-{
-  IplImage* ptr = NULL;
-  try {
-    ptr = cvCreateImage(size, depth, channels);
-  }
-  catch(cv::Exception& e) {
-    if (e.code != CV_StsNoMem)
-      rb_raise(rb_eRuntimeError, "%s", e.what());
-
-    rb_gc_start();
-    try {
-      ptr = cvCreateImage(size, depth, channels);
-    }
-    catch (cv::Exception& e) {
-      if (e.code == CV_StsNoMem)
-	rb_raise(rb_eNoMemError, "%s", e.what());
-      else
-	rb_raise(rb_eRuntimeError, "%s", e.what());
-    }
-  }
-  return ptr;
-}
-
-/*
- * Creates a structuring element
- * When memory allocation is failed, run GC and retry it
- */
-IplConvKernel*
-rb_cvCreateStructuringElementEx(int cols, int rows,
-				int anchorX, int anchorY,
-				int shape, int *values)
-{
-  IplConvKernel* ptr = NULL;
-  try {
-    ptr = cvCreateStructuringElementEx(cols, rows, anchorX, anchorY, shape, values);
-  }
-  catch(cv::Exception& e) {
-    if (e.code != CV_StsNoMem)
-      rb_raise(rb_eRuntimeError, "%s", e.what());
-
-    rb_gc_start();
-    try {
-      ptr = cvCreateStructuringElementEx(cols, rows, anchorX, anchorY, shape, values);
-    }
-    catch (cv::Exception& e) {
-      if (e.code == CV_StsNoMem)
-	rb_raise(rb_eNoMemError, "%s", e.what());
-      else
-	rb_raise(rb_eRuntimeError, "%s", e.what());
-    }
-  }
-  return ptr;
-}
-
-/*
- * Creates memory storage
- * When memory allocation is failed, run GC and retry it
- */
-CvMemStorage*
-rb_cvCreateMemStorage(int block_size)
-{
-  CvMemStorage* ptr = NULL;
-  try {
-    ptr = cvCreateMemStorage(block_size);
-  }
-  catch(cv::Exception& e) {
-    if (e.code != CV_StsNoMem)
-      rb_raise(rb_eRuntimeError, "%s", e.what());
-
-    rb_gc_start();
-    try {
-      ptr = cvCreateMemStorage(block_size);
-    }
-    catch (cv::Exception& e) {
-      if (e.code == CV_StsNoMem)
-	rb_raise(rb_eNoMemError, "%s", e.what());
-      else
-	rb_raise(rb_eRuntimeError, "%s", e.what());
-    }
-  }
-  return ptr;
-}
-
-VALUE
-rb_get_option_table(VALUE klass, const char* table_name, VALUE option)
-{
-  VALUE table = rb_const_get(klass, rb_intern(table_name));
-  if (NIL_P(option))
-    return table;
-  else
-    return rb_funcall(table, rb_intern("merge"), 1, option);
-}
-
+/************************************************************
+
+  cvutils.cpp -
+
+  $Author: ser1zw $
+
+  Copyright (C) 2011 ser1zw
+
+************************************************************/
+#include "cvutils.h"
+
+void
+raise_typeerror(VALUE object, VALUE expected_class)
+{
+  raise_typeerror(object, rb_class2name(expected_class));
+}
+
+void
+raise_typeerror(VALUE object, const char* expected_class_name)
+{
+  rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
+  	   rb_obj_classname(object), expected_class_name);
+}
+
+void
+raise_compatible_typeerror(VALUE object, VALUE expected_class)
+{
+  raise_compatible_typeerror(object, rb_class2name(expected_class));
+}
+
+void
+raise_compatible_typeerror(VALUE object, const char* expected_class_name)
+{
+  rb_raise(rb_eTypeError, "wrong argument type %s (expected %s or compatible object)",
+  	   rb_obj_classname(object), expected_class_name);
+}
+
+/*
+ * Allocates a memory buffer
+ * see cv::fastMalloc()
+ */
+void*
+rbFastMalloc(size_t size)
+{
+  uchar* udata = (uchar*)xmalloc(size + sizeof(void*) + CV_MALLOC_ALIGN);
+  if(!udata) {
+    rb_raise(rb_eNoMemError, "Failed to allocate memory");
+  }
+  uchar** adata = cv::alignPtr((uchar**)udata + 1, CV_MALLOC_ALIGN);
+  adata[-1] = udata;
+  return adata;
+}
+
+/*
+ * Allocates a memory buffer
+ * When memory allocation is failed, run GC and retry it
+ */
+void*
+rb_cvAlloc(size_t size)
+{
+  return rbFastMalloc(size);
+}
+
+/*
+ * Creates CvMat and underlying data
+ * When memory allocation is failed, run GC and retry it
+ */
+CvMat*
+rb_cvCreateMat(int rows, int cols, int type)
+{
+  CvMat* mat = NULL;
+  try {
+    mat = cvCreateMatHeader(rows, cols, type);
+    if (mat) {
+      // see OpenCV's cvCreateData()
+      size_t step = mat->step;
+      size_t total_size = step * mat->rows + sizeof(int) + CV_MALLOC_ALIGN;
+
+      mat->refcount = (int*)rbFastMalloc(total_size);
+      mat->data.ptr = (uchar*)cvAlignPtr(mat->refcount + 1, CV_MALLOC_ALIGN);
+      *mat->refcount = 1;
+    }
+    else {
+      rb_raise(rb_eRuntimeError, "Failed to create mat header");
+    }
+  }
+  catch(cv::Exception& e) {
+    if (mat) {
+      cvReleaseMat(&mat);
+    }
+    rb_raise(rb_eRuntimeError, "%s", e.what());
+  }
+  return mat;
+}
+
+/*
+ * Create IplImage header and allocate underlying data
+ * When memory allocation is failed, run GC and retry it
+ */
+IplImage*
+rb_cvCreateImage(CvSize size, int depth, int channels)
+{
+  IplImage* ptr = NULL;
+  try {
+    ptr = cvCreateImageHeader(size, depth, channels);
+    if (ptr) {
+      // see OpenCV's cvCreateData()
+      ptr->imageData = ptr->imageDataOrigin = (char*)rbFastMalloc((size_t)ptr->imageSize);
+    }
+    else {
+      rb_raise(rb_eRuntimeError, "Failed to create image header");
+    }
+  }
+  catch(cv::Exception& e) {
+    if (ptr) {
+      cvReleaseImage(&ptr);
+    }
+    rb_raise(rb_eRuntimeError, "%s", e.what());
+  }
+  return ptr;
+}
+
+/*
+ * Creates a structuring element
+ * When memory allocation is failed, run GC and retry it
+ */
+IplConvKernel*
+rb_cvCreateStructuringElementEx(int cols, int rows,
+				int anchorX, int anchorY,
+				int shape, int *values)
+{
+  IplConvKernel* ptr = NULL;
+  try {
+    ptr = cvCreateStructuringElementEx(cols, rows, anchorX, anchorY, shape, values);
+  }
+  catch(cv::Exception& e) {
+    if (e.code != CV_StsNoMem)
+      rb_raise(rb_eRuntimeError, "%s", e.what());
+
+    rb_gc_start();
+    try {
+      ptr = cvCreateStructuringElementEx(cols, rows, anchorX, anchorY, shape, values);
+    }
+    catch (cv::Exception& e) {
+      if (e.code == CV_StsNoMem)
+	rb_raise(rb_eNoMemError, "%s", e.what());
+      else
+	rb_raise(rb_eRuntimeError, "%s", e.what());
+    }
+  }
+  return ptr;
+}
+
+/*
+ * Creates memory storage
+ * When memory allocation is failed, run GC and retry it
+ */
+CvMemStorage*
+rb_cvCreateMemStorage(int block_size)
+{
+  CvMemStorage* ptr = NULL;
+  try {
+    ptr = cvCreateMemStorage(block_size);
+  }
+  catch(cv::Exception& e) {
+    if (e.code != CV_StsNoMem)
+      rb_raise(rb_eRuntimeError, "%s", e.what());
+
+    rb_gc_start();
+    try {
+      ptr = cvCreateMemStorage(block_size);
+    }
+    catch (cv::Exception& e) {
+      if (e.code == CV_StsNoMem)
+	rb_raise(rb_eNoMemError, "%s", e.what());
+      else
+	rb_raise(rb_eRuntimeError, "%s", e.what());
+    }
+  }
+  return ptr;
+}
+
+VALUE
+rb_get_option_table(VALUE klass, const char* table_name, VALUE option)
+{
+  VALUE table = rb_const_get(klass, rb_intern(table_name));
+  if (NIL_P(option))
+    return table;
+  else
+    return rb_funcall(table, rb_intern("merge"), 1, option);
+}
+