ruby-opencv 0.0.8.pre-mswin32 → 0.0.9.pre2-mswin32

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);
+}
+

data/ext/opencv/cvutils.h

@@ -1,29 +1,30 @@
-/************************************************************
-
-    cvutils.h -
-
-    $Author: ser1zw $
-
-    Copyright (C) 2011 ser1zw
-
-************************************************************/
-
-#include <ruby.h>
-#include "opencv2/core/core_c.h"
-#include "opencv2/core/core.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
-#include "opencv2/imgproc/imgproc.hpp"
-
-#define raise_cverror(e) cCvError::raise(e)
-
-void raise_typeerror(VALUE object, VALUE expected_class);
-void raise_typeerror(VALUE object, const char* expected_class_name);
-void raise_compatible_typeerror(VALUE object, VALUE expected_class);
-void raise_compatible_typeerror(VALUE object, const char* expected_class_name);
-void* rb_cvAlloc(size_t size);
-CvMat* rb_cvCreateMat(int height, int width, int type);
-IplImage* rb_cvCreateImage(CvSize size, int depth, int channels);
-IplConvKernel* rb_cvCreateStructuringElementEx(int cols, int rows, int anchorX, int anchorY, int shape, int *values);
-CvMemStorage* rb_cvCreateMemStorage(int block_size);
-VALUE rb_get_option_table(VALUE klass, const char* table_name, VALUE option);
-
+/************************************************************
+
+    cvutils.h -
+
+    $Author: ser1zw $
+
+    Copyright (C) 2011 ser1zw
+
+************************************************************/
+
+#include <ruby.h>
+#include "opencv2/core/core_c.h"
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/internal.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/imgproc/imgproc.hpp"
+
+#define raise_cverror(e) cCvError::raise(e)
+
+void raise_typeerror(VALUE object, VALUE expected_class);
+void raise_typeerror(VALUE object, const char* expected_class_name);
+void raise_compatible_typeerror(VALUE object, VALUE expected_class);
+void raise_compatible_typeerror(VALUE object, const char* expected_class_name);
+void* rb_cvAlloc(size_t size);
+CvMat* rb_cvCreateMat(int height, int width, int type);
+IplImage* rb_cvCreateImage(CvSize size, int depth, int channels);
+IplConvKernel* rb_cvCreateStructuringElementEx(int cols, int rows, int anchorX, int anchorY, int shape, int *values);
+CvMemStorage* rb_cvCreateMemStorage(int block_size);
+VALUE rb_get_option_table(VALUE klass, const char* table_name, VALUE option);
+