added error handling to some methods (2)

Added error handlings to the methods of following classes or modules
 -CvPoint2D32f
 -CvPoint3D32f
 -CvRect
 -CvScalar
 -CvSeq
 -CvSize
 -CvSize2D32f
 -CvSlice
 -CvSURFParams
 -CvSURFPoint
 -CvTermCriteria
 -CvTwoPoints
 -CvUtils
 -CvVideoWriter
 -GUI
 -IplConvKernel
 -IplImage
 -MouseEvent
 -OpenCV
 -Trackbar
 -Window

ext/opencv/cvpoint.cpp

@@ -120,8 +120,9 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
     break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    break;
   }
-  return Qnil;    
+  return self;
 }
 
 /*

ext/opencv/cvpoint2d32f.cpp

@@ -104,29 +104,25 @@ rb_allocate(VALUE klass)
 VALUE
 rb_initialize(int argc, VALUE *argv, VALUE self)
 {
-  VALUE obj, x, y;
+  CvPoint2D32f *self_ptr = CVPOINT2D32F(self);
   switch (argc) {
   case 0:
     break;
-  case 1:
+  case 1: {
-    obj = argv[0];
+    CvPoint2D32f point = VALUE_TO_CVPOINT2D32F(argv[0]);
-    if (rb_compatible_q(rb_klass, obj)) {
+    self_ptr->x = point.x;
-      CVPOINT2D32F(self)->x = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("x"), 0), rb_intern("to_f"), 0));
+    self_ptr->y = point.y;
-      CVPOINT2D32F(self)->y = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("y"), 0), rb_intern("to_f"), 0));
-    }
-    else {
-      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
-    }
     break;
+  }
   case 2:
-    x = argv[0], y = argv[1];
+    self_ptr->x = NUM2DBL(argv[0]);
-    CVPOINT2D32F(self)->x = NUM2DBL(x);
+    self_ptr->y = NUM2DBL(argv[1]);
-    CVPOINT2D32F(self)->y = NUM2DBL(y);
     break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    break;
   }
-  return Qnil;
+  return self;
 }
 
 /*

ext/opencv/cvpoint3d32f.cpp

@@ -114,29 +114,27 @@ VALUE
 rb_initialize(int argc, VALUE *argv, VALUE self)
 {
   VALUE obj, x, y, z;
+  CvPoint3D32f *self_ptr = CVPOINT3D32F(self);
   switch (argc) {
   case 0:
     break;
-  case 1:
+  case 1: {
-    obj = argv[0];
+    CvPoint3D32f point = VALUE_TO_CVPOINT3D32F(argv[0]);
-    if(rb_compatible_q(rb_klass, obj)) {
+    self_ptr->x = point.x;
-      CVPOINT3D32F(self)->x = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("x"), 0), rb_intern("to_f"), 0));
+    self_ptr->y = point.y;
-      CVPOINT3D32F(self)->y = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("y"), 0), rb_intern("to_f"), 0));
+    self_ptr->z = point.z;
-      CVPOINT3D32F(self)->z = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("z"), 0), rb_intern("to_f"), 0));
-    }else{
-      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
-    }
     break;
+  }
   case 3:
-    x = argv[0], y = argv[1], z = argv[2];
+    self_ptr->x = NUM2DBL(argv[0]);
-    CVPOINT3D32F(self)->x = NUM2DBL(x);
+    self_ptr->y = NUM2DBL(argv[1]);
-    CVPOINT3D32F(self)->y = NUM2DBL(y);
+    self_ptr->z = NUM2DBL(argv[2]);
-    CVPOINT3D32F(self)->z = NUM2DBL(z);
     break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    break;
   }
-  return Qnil;
+  return self;
 }
 
 /*

ext/opencv/cvrect.cpp

@@ -65,8 +65,6 @@ define_ruby_class()
   rb_define_method(rb_klass, "top_right", RUBY_METHOD_FUNC(rb_top_right), 0);
   rb_define_method(rb_klass, "bottom_left", RUBY_METHOD_FUNC(rb_bottom_left), 0);
   rb_define_method(rb_klass, "bottom_right", RUBY_METHOD_FUNC(rb_bottom_right), 0);
-  // rb_define_method(rb_klass, "or", RUBY_METHOD_FUNC(rb_or), 1);
-  // rb_define_alias(rb_klass, "|", "or");
 }
 
 /*
@@ -115,18 +113,6 @@ rb_max_rect(VALUE klass, VALUE rect1, VALUE rect2)
   return cCvRect::new_object(cvMaxRect(CVRECT(rect1), CVRECT(rect2)));
 }
 
-/*
- * call-seq:
- *   CvRect.bounding
- *
- */
-VALUE
-rb_bounding(VALUE klass, VALUE points)
-{
-  /* not yet */
-  return Qnil;
-}
-
 VALUE
 rb_allocate(VALUE klass)
 {
@@ -150,33 +136,29 @@ rb_allocate(VALUE klass)
 VALUE
 rb_initialize(int argc, VALUE *argv, VALUE self)
 {
-  VALUE object, x, y, width, height;
+  CvRect *self_ptr = CVRECT(self);
   switch (argc) {
   case 0:
     break;
-  case 1:
+  case 1: {
-    object = argv[0];
+    CvRect rect = VALUE_TO_CVRECT(argv[0]);
-    if (rb_compatible_q(rb_klass, object)) {
+    self_ptr->x = rect.x;
-      CVRECT(self)->x = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("x"), 0), rb_intern("to_i"), 0));
+    self_ptr->y = rect.y;
-      CVRECT(self)->y = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("y"), 0), rb_intern("to_i"), 0));
+    self_ptr->width = rect.width;
-      CVRECT(self)->width = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("width"), 0), rb_intern("to_i"), 0));
+    self_ptr->height = rect.height;
-      CVRECT(self)->height = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("height"), 0), rb_intern("to_i"), 0));
-    }
-    else{
-      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
-    }
     break;
+  }
   case 4:
-    x = argv[0], y = argv[1], width = argv[2], height = argv[3];
+    self_ptr->x = NUM2INT(argv[0]);
-    CVRECT(self)->x = NUM2INT(x);
+    self_ptr->y = NUM2INT(argv[1]);
-    CVRECT(self)->y = NUM2INT(y);
+    self_ptr->width = NUM2INT(argv[2]);
-    CVRECT(self)->width = NUM2INT(width);
+    self_ptr->height = NUM2INT(argv[3]);
-    CVRECT(self)->height = NUM2INT(height);
     break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    break;
   }
-  return Qnil;      
+  return self;
 }
 
 /*
@@ -303,7 +285,8 @@ rb_points(VALUE self)
 VALUE
 rb_top_left(VALUE self)
 {
-  return cCvPoint::new_object(cvPoint(CVRECT(self)->x, CVRECT(self)->y));
+  CvRect* rect = CVRECT(self);
+  return cCvPoint::new_object(cvPoint(rect->x, rect->y));
 }
 
 /*
@@ -312,7 +295,8 @@ rb_top_left(VALUE self)
 VALUE
 rb_top_right(VALUE self)
 {
-  return cCvPoint::new_object(cvPoint(CVRECT(self)->x + CVRECT(self)->width, CVRECT(self)->y));
+  CvRect* rect = CVRECT(self);
+  return cCvPoint::new_object(cvPoint(rect->x + rect->width, rect->y));
 }
 
 /*
@@ -321,7 +305,9 @@ rb_top_right(VALUE self)
 VALUE
 rb_bottom_left(VALUE self)
 {
-  return cCvPoint::new_object(cvPoint(CVRECT(self)->x, CVRECT(self)->y + CVRECT(self)->height));
+  CvRect* rect = CVRECT(self);
+  return cCvPoint::new_object(cvPoint(rect->x,
+				      rect->y + rect->height));
 }
 
 /*
@@ -330,7 +316,9 @@ rb_bottom_left(VALUE self)
 VALUE
 rb_bottom_right(VALUE self)
 {
-  return cCvPoint::new_object(cvPoint(CVRECT(self)->x + CVRECT(self)->width, CVRECT(self)->y + CVRECT(self)->height));
+  CvRect* rect = CVRECT(self);
+  return cCvPoint::new_object(cvPoint(rect->x + rect->width,
+				      rect->y + rect->height));
 }
 
 VALUE

ext/opencv/cvrect.h

@@ -24,7 +24,6 @@ void define_ruby_class();
 
 VALUE rb_compatible_q(VALUE klass, VALUE object);
 VALUE rb_max_rect(VALUE klass, VALUE rect1, VALUE rect2);
-VALUE rb_bounding(VALUE klass, VALUE points);
 
 VALUE rb_allocate(VALUE klass);
 VALUE rb_initialize(int argc, VALUE *argv, VALUE self);

ext/opencv/cvscalar.cpp

@@ -104,8 +104,9 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
 {
   VALUE val[4];
   rb_scan_args(argc, argv, "04", &val[0], &val[1], &val[2], &val[3]);
-  for (int i = 0; i < 4; i++) {
+  CvScalar* self_ptr = CVSCALAR(self);
-    CVSCALAR(self)->val[i] = NIL_P(val[i]) ? 0 : NUM2DBL(val[i]);
+  for (int i = 0; i < 4; ++i) {
+    self_ptr->val[i] = NIL_P(val[i]) ? 0 : NUM2DBL(val[i]);
   }
   return self;
 }
@@ -120,11 +121,10 @@ VALUE
 rb_aref(VALUE self, VALUE index)
 {
   int idx = NUM2INT(index);
-  if (!(idx < 0) && idx < 4) {
+  if (idx < 0 || idx >= 4) {
-    return rb_float_new(CVSCALAR(self)->val[idx]);
-  }else{
     rb_raise(rb_eIndexError, "scalar index should be 0...4");
   }
+  return rb_float_new(CVSCALAR(self)->val[idx]);
 }
 
 /*
@@ -137,12 +137,11 @@ VALUE
 rb_aset(VALUE self, VALUE index, VALUE value)
 {
   int idx = NUM2INT(index);
-  if (!(idx < 0) && idx < 4) {
+  if (idx < 0 || idx >= 4) {
-    CVSCALAR(self)->val[idx] = NUM2DBL(value);
-    return self;
-  }else{
     rb_raise(rb_eIndexError, "scalar index should be 0...4");
   }
+  CVSCALAR(self)->val[idx] = NUM2DBL(value);
+  return self;
 }
 
 /*
@@ -158,12 +157,21 @@ rb_sub(int argc, VALUE *argv, VALUE self)
 {
   VALUE val, mask;
   rb_scan_args(argc, argv, "11", &val, &mask);
-  if(rb_obj_is_kind_of(val, cCvMat::rb_class())){
+  if (rb_obj_is_kind_of(val, cCvMat::rb_class())) {
-    VALUE dest = cCvMat::new_object(cvGetSize(CVARR(val)), cvGetElemType(CVARR(val)));
+    CvArr *val_ptr = CVARR(val);
-    cvSubRS(CVARR(val), *CVSCALAR(self), CVARR(dest), MASK(mask));
+    VALUE dest = Qnil;
+    try {
+      dest = cCvMat::new_object(cvGetSize(val_ptr), cvGetElemType(val_ptr));
+      cvSubRS(val_ptr, *CVSCALAR(self), CVARR(dest), MASK(mask));
+    }
+    catch (cv::Exception& e) {
+      raise_cverror(e);
+    }
     return dest;
-  }else{
+  }
-    CvScalar *src = CVSCALAR(self), scl = VALUE_TO_CVSCALAR(val);
+  else {
+    CvScalar *src = CVSCALAR(self);
+    CvScalar scl = VALUE_TO_CVSCALAR(val);
     return new_object(cvScalar(src->val[0] - scl.val[0],
                                src->val[1] - scl.val[1],
                                src->val[2] - scl.val[2],

ext/opencv/cvseq.cpp

@@ -148,7 +148,7 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
     storage = rb_cvCreateMemStorage(0);
   
   if(!rb_obj_is_kind_of(klass, rb_cClass))
-    rb_raise(rb_eTypeError, "argument 1 (sequence-block class) should be %s.", rb_class2name(rb_cClass));
+    raise_typeerror(klass, rb_cClass);
 
   int type = 0, size = 0;
   if (klass == rb_cFixnum) {
@@ -168,9 +168,15 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
     size = sizeof(CvPoint3D32f);
   }
   else
-    rb_raise(rb_eTypeError, "unsupport %s class for sequence-block.", rb_class2name(klass));
+    rb_raise(rb_eArgError, "unsupport %s class for sequence-block.", rb_class2name(klass));
   
-  CvSeq* seq = cvCreateSeq(type, sizeof(CvSeq), size, storage);
+  CvSeq* seq = NULL;
+  try {
+    seq = cvCreateSeq(type, sizeof(CvSeq), size, storage);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   DATA_PTR(self) = seq;
   resist_class_information_of_sequence(seq, klass);
   
@@ -186,7 +192,7 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
 VALUE
 rb_total(VALUE self)
 {
-  return INT2FIX(CVSEQ(self)->total);
+  return INT2NUM(CVSEQ(self)->total);
 }
 
 /*
@@ -217,10 +223,17 @@ rb_aref(VALUE self, VALUE index)
   if (idx >= seq->total)
     rb_raise(rb_eIndexError, "index %d out of sequence", idx);
 
+  VALUE result = Qnil;
+  try {
     if (seqblock_class(seq) == rb_cFixnum)
-    return INT2FIX(*CV_GET_SEQ_ELEM(int, seq, idx));
+      result = INT2NUM(*CV_GET_SEQ_ELEM(int, seq, idx));
     else
-    return REFER_OBJECT(seqblock_class(seq), cvGetSeqElem(seq, idx), self);
+      result = REFER_OBJECT(seqblock_class(seq), cvGetSeqElem(seq, idx), self);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return result;
 }
 
 /*
@@ -320,7 +333,6 @@ rb_seq_push(VALUE self, VALUE args, int flag)
 {
   CvSeq *seq = CVSEQ(self);
   VALUE klass = seqblock_class(seq), object;
-  void *buffer = NULL;
   void *elem = NULL;
   int len = RARRAY_LEN(args);
   for (int i = 0; i < len; ++i) {
@@ -333,16 +345,29 @@ rb_seq_push(VALUE self, VALUE args, int flag)
       else {
 	elem = (void*)DATA_PTR(object);
       }
+      try {
 	if (flag == CV_FRONT)
 	  cvSeqPushFront(seq, elem);
 	else
 	  cvSeqPush(seq, elem);
       }
+      catch (cv::Exception& e) {
+	raise_cverror(e);
+      }
+    }
     else if (rb_obj_is_kind_of(object, rb_klass) && CLASS_OF(rb_first(object)) == klass) { // object is CvSeq
+      void *buffer = NULL;
+      try {
 	buffer = cvCvtSeqToArray(CVSEQ(object), rb_cvAlloc(CVSEQ(object)->total * CVSEQ(object)->elem_size));
 	cvSeqPushMulti(seq, buffer, CVSEQ(object)->total, flag);
 	cvFree(&buffer);
       }
+      catch (cv::Exception& e) {
+	if (buffer != NULL)
+	  cvFree(&buffer);
+	raise_cverror(e);
+      }
+    }
     else {
       rb_raise(rb_eTypeError, "arguments should be %s or %s which includes %s.",
 	       rb_class2name(klass), rb_class2name(rb_klass), rb_class2name(klass));
@@ -381,6 +406,7 @@ rb_pop(VALUE self)
   
   VALUE object;
   VALUE klass = seqblock_class(seq);
+  try {
     if (klass == rb_cFixnum) {
       int n = 0;
       cvSeqPop(seq, &n);
@@ -390,6 +416,10 @@ rb_pop(VALUE self)
       object = GENERIC_OBJECT(klass, malloc(seq->elem_size));
       cvSeqPop(seq, DATA_PTR(object));
     }
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return object;
 }
 
@@ -402,7 +432,12 @@ rb_pop(VALUE self)
 VALUE
 rb_clear(VALUE self)
 {
+  try {
     cvClearSeq(CVSEQ(self));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return self;
 }
 
@@ -415,7 +450,14 @@ rb_clear(VALUE self)
 VALUE
 rb_unshift(VALUE self, VALUE args)
 {
-  return rb_seq_push(self, args, CV_FRONT);
+  VALUE result = Qnil;
+  try {
+    result = rb_seq_push(self, args, CV_FRONT);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return result;
 }
 
 /*
@@ -431,16 +473,21 @@ rb_shift(VALUE self)
   if(seq->total == 0)
     return Qnil;
 
-  VALUE object;
+  VALUE object = Qnil;
+  try {
     if (seqblock_class(seq) == rb_cFixnum) {
       int n = 0;
       cvSeqPopFront(seq, &n);
-    object = INT2FIX(n);
+      object = INT2NUM(n);
     }
     else {
       object = GENERIC_OBJECT(seqblock_class(seq), malloc(seq->elem_size));
       cvSeqPopFront(seq, DATA_PTR(object));
     }
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
 
   return object;
 }
@@ -463,13 +510,18 @@ rb_each(VALUE self)
   CvSeq *seq = CVSEQ(self);
   if (seq->total > 0) {
     VALUE klass = seqblock_class(seq);
+    try {
       if (klass == rb_cFixnum)
 	for (int i = 0; i < seq->total; ++i)
-      	rb_yield(INT2FIX(*CV_GET_SEQ_ELEM(int, seq, i)));
+	  rb_yield(INT2NUM(*CV_GET_SEQ_ELEM(int, seq, i)));
       else
 	for (int i = 0; i < seq->total; ++i)
 	  rb_yield(REFER_OBJECT(klass, cvGetSeqElem(seq, i), self));
     }
+    catch (cv::Exception& e) {
+      raise_cverror(e);
+    }
+  }
   return self;
 }
 
@@ -484,7 +536,7 @@ rb_each_index(VALUE self)
 {
   CvSeq *seq = CVSEQ(self);
   for(int i = 0; i < seq->total; ++i)
-    rb_yield(INT2FIX(i));
+    rb_yield(INT2NUM(i));
   return self;
 }
 
@@ -503,12 +555,17 @@ rb_insert(VALUE self, VALUE index, VALUE object)
   VALUE klass = seqblock_class(seq);
   if (CLASS_OF(object) != klass)
     rb_raise(rb_eTypeError, "arguments should be %s.", rb_class2name(klass));
+  try {
     if (klass == rb_cFixnum) {
       int n = NUM2INT(object);
-    cvSeqInsert(seq, FIX2INT(index), &n);
+      cvSeqInsert(seq, NUM2INT(index), &n);
     }
     else
-    cvSeqInsert(seq, FIX2INT(index), DATA_PTR(object));
+      cvSeqInsert(seq, NUM2INT(index), DATA_PTR(object));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return self;
 }
 
@@ -521,7 +578,12 @@ rb_insert(VALUE self, VALUE index, VALUE object)
 VALUE
 rb_remove(VALUE self, VALUE index)
 {
-  cvSeqRemove(CVSEQ(self), FIX2INT(index));
+  try {
+    cvSeqRemove(CVSEQ(self), NUM2INT(index));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return self;
 }
 

ext/opencv/cvsize.cpp

@@ -7,7 +7,7 @@
    Copyright (C) 2005 Masakazu Yonekura
 
 ************************************************************/
-#include"cvsize.h"
+#include "cvsize.h"
 /*
  * Document-class: OpenCV::CvSize
  *
@@ -104,28 +104,25 @@ rb_allocate(VALUE klass)
 VALUE
 rb_initialize(int argc, VALUE *argv, VALUE self)
 {
-  VALUE obj, x, y;
+  CvSize *self_ptr = CVSIZE(self);
   switch (argc) {
   case 0:
     break;
-  case 1:
+  case 1: {
-    obj = argv[0];
+    CvSize size = VALUE_TO_CVSIZE(argv[0]);
-    if(rb_compatible_q(rb_klass, obj)) {
+    self_ptr->width = size.width;
-      CVSIZE(self)->width = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("width"), 0), rb_intern("to_i"), 0));
+    self_ptr->height = size.height;
-      CVSIZE(self)->height = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("height"), 0), rb_intern("to_i"), 0));
-    }else{
-      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
-    }
     break;
+  }
   case 2:
-    x = argv[0], y = argv[1];
+    self_ptr->width = NUM2INT(argv[0]);
-    CVSIZE(self)->width = NUM2INT(x);
+    self_ptr->height = NUM2INT(argv[1]);
-    CVSIZE(self)->height = NUM2INT(y);
     break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    break;
   }
-  return Qnil;      
+  return self;
 }
 
 /*

ext/opencv/cvsize2d32f.cpp

@@ -103,23 +103,19 @@ rb_allocate(VALUE klass)
 VALUE
 rb_initialize(int argc, VALUE *argv, VALUE self)
 {
-  VALUE obj, x, y;
+  CvSize2D32f *self_ptr = CVSIZE2D32F(self);
   switch(argc){
   case 0:
     break;
-  case 1:
+  case 1: {
-    obj = argv[0];
+    CvSize2D32f size = VALUE_TO_CVSIZE2D32F(argv[0]);
-    if(rb_compatible_q(rb_klass, obj)){
+    self_ptr->width = size.width;
-      CVSIZE2D32F(self)->width = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("width"), 0), rb_intern("to_f"), 0));
+    self_ptr->height = size.height;
-      CVSIZE2D32F(self)->height = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("height"), 0), rb_intern("to_f"), 0));
-    }else{
-      rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(rb_klass));
-    }
     break;
+  }
   case 2:
-    x = argv[0], y = argv[1];
+    self_ptr->width = NUM2DBL(argv[0]);
-    CVSIZE2D32F(self)->width = NUM2DBL(x);
+    self_ptr->height = NUM2DBL(argv[1]);
-    CVSIZE2D32F(self)->height = NUM2DBL(y);
     break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);

ext/opencv/cvslice.cpp

@@ -64,8 +64,9 @@ rb_allocate(VALUE klass)
 VALUE
 rb_initialize(VALUE self, VALUE start, VALUE end)
 {
-  CVSLICE(self)->start_index = NUM2INT(start);
+  CvSlice *self_ptr = CVSLICE(self);
-  CVSLICE(self)->end_index = NUM2INT(end);
+  self_ptr->start_index = NUM2INT(start);
+  self_ptr->end_index = NUM2INT(end);
   return self;
 }
 
@@ -99,7 +100,7 @@ rb_end_index_aref(VALUE self)
 VALUE
 rb_start_index_aset(VALUE self, VALUE index)
 {
-  CVSLICE(self)->start_index = FIX2INT(index);
+  CVSLICE(self)->start_index = NUM2INT(index);
   return self;
 }
 
@@ -111,7 +112,7 @@ rb_start_index_aset(VALUE self, VALUE index)
 VALUE
 rb_end_index_aset(VALUE self, VALUE index)
 {
-  CVSLICE(self)->end_index = FIX2INT(index);
+  CVSLICE(self)->end_index = NUM2INT(index);
   return self;
 }
 

ext/opencv/cvsurfparams.cpp

@@ -76,8 +76,8 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
 
   self_ptr->hessianThreshold = NUM2DBL(h_thresh);
   self_ptr->extended = NIL_P(ext) ? 0 : BOOL2INT(ext);
-  self_ptr->nOctaves = NIL_P(noct) ? 3 : FIX2INT(noct);
+  self_ptr->nOctaves = NIL_P(noct) ? 3 : NUM2INT(noct);
-  self_ptr->nOctaveLayers = NIL_P(noctl) ? 4 : FIX2INT(noctl);
+  self_ptr->nOctaveLayers = NIL_P(noctl) ? 4 : NUM2INT(noctl);
     
   return self;
 }
@@ -141,7 +141,7 @@ rb_set_extended(VALUE self, VALUE value)
 VALUE
 rb_get_n_octaves(VALUE self)
 {
-  return INT2FIX(CVSURFPARAMS(self)->nOctaves);
+  return INT2NUM(CVSURFPARAMS(self)->nOctaves);
 }
 
 /*
@@ -152,7 +152,7 @@ rb_get_n_octaves(VALUE self)
 VALUE
 rb_set_n_octaves(VALUE self, VALUE value)
 {
-  CVSURFPARAMS(self)->nOctaves = FIX2INT(value);
+  CVSURFPARAMS(self)->nOctaves = NUM2INT(value);
   return self;
 }
 
@@ -164,7 +164,7 @@ rb_set_n_octaves(VALUE self, VALUE value)
 VALUE
 rb_get_n_octave_layers(VALUE self)
 {
-  return INT2FIX(CVSURFPARAMS(self)->nOctaveLayers);
+  return INT2NUM(CVSURFPARAMS(self)->nOctaveLayers);
 }
 
 /*
@@ -175,7 +175,7 @@ rb_get_n_octave_layers(VALUE self)
 VALUE
 rb_set_n_octave_layers(VALUE self, VALUE value)
 {
-  CVSURFPARAMS(self)->nOctaveLayers = FIX2INT(value);
+  CVSURFPARAMS(self)->nOctaveLayers = NUM2INT(value);
   return self;
 }
 

ext/opencv/cvsurfpoint.cpp

@@ -79,8 +79,8 @@ rb_initialize(VALUE self, VALUE pt, VALUE laplacian, VALUE size, VALUE dir, VALU
 {
   CvSURFPoint *self_ptr = CVSURFPOINT(self);
   self_ptr->pt = VALUE_TO_CVPOINT2D32F(pt);
-  self_ptr->laplacian = FIX2INT(laplacian);
+  self_ptr->laplacian = NUM2INT(laplacian);
-  self_ptr->size = FIX2INT(size);
+  self_ptr->size = NUM2INT(size);
   self_ptr->dir = (float)NUM2DBL(dir);
   self_ptr->hessian = (float)NUM2DBL(hessian);
 
@@ -107,21 +107,19 @@ rb_get_pt(VALUE self)
 VALUE
 rb_set_pt(VALUE self, VALUE value)
 {
-  if (!cCvPoint2D32f::rb_compatible_q(rb_klass, value))
-    rb_raise(rb_eArgError, "object is not compatible %s.", rb_class2name(cCvPoint2D32f::rb_class()));
   CVSURFPOINT(self)->pt = VALUE_TO_CVPOINT2D32F(value);
   return self;
 }
 
 /*
  * call-seq:
- *   laplacian -> fixnum
+ *   laplacian -> number
  * Return sign of the laplacian at the point (-1, 0 or +1)
  */
 VALUE
 rb_get_laplacian(VALUE self)
 {
-  return INT2FIX(CVSURFPOINT(self)->laplacian);
+  return INT2NUM(CVSURFPOINT(self)->laplacian);
 }
 
 /*
@@ -132,20 +130,20 @@ rb_get_laplacian(VALUE self)
 VALUE
 rb_set_laplacian(VALUE self, VALUE value)
 {
-  int val = FIX2INT(value);
+  int val = NUM2INT(value);
   CVSURFPOINT(self)->laplacian = (val > 0) ? 1 : (val < 0) ? -1 : 0;
   return self;
 }
 
 /*
  * call-seq:
- *   size -> fixnum
+ *   size -> number
  * Return size of feature
  */
 VALUE
 rb_get_size(VALUE self)
 {
-  return INT2FIX(CVSURFPOINT(self)->size);
+  return INT2NUM(CVSURFPOINT(self)->size);
 }
 
 /*
@@ -156,7 +154,7 @@ rb_get_size(VALUE self)
 VALUE
 rb_set_size(VALUE self, VALUE value)
 {
-  CVSURFPOINT(self)->size = FIX2INT(value);
+  CVSURFPOINT(self)->size = NUM2INT(value);
   return self;
 }
 

ext/opencv/cvtermcriteria.cpp

@@ -80,7 +80,12 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
     type |= CV_TERMCRIT_ITER;
   if (!NIL_P(eps))
     type |= CV_TERMCRIT_EPS;
+  try {
     *CVTERMCRITERIA(self) = cvTermCriteria(type, IF_INT(max, 0), IF_DBL(eps, 0.0));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return self;
 }
 
@@ -127,7 +132,8 @@ rb_set_max(VALUE self, VALUE max_value)
   if (max > 0) {
     ptr->type |= CV_TERMCRIT_ITER;
     ptr->max_iter = max;
-  } else {
+  }
+  else {
     ptr->type ^= CV_TERMCRIT_ITER;
     ptr->max_iter = 0;
   }
@@ -166,7 +172,8 @@ rb_set_eps(VALUE self, VALUE eps_value)
   if (eps > 0) {
     ptr->type = ptr->type | CV_TERMCRIT_EPS;
     ptr->epsilon = eps;
-  } else {
+  }
+  else {
     ptr->type = ptr->type ^ CV_TERMCRIT_EPS;
     ptr->epsilon = 0;
   }

ext/opencv/cvtwopoints.cpp

@@ -59,13 +59,6 @@ rb_allocate(VALUE klass)
   return Data_Make_Struct(klass, CvTwoPoints, 0, -1, ptr);
 }
 
-VALUE
-rb_cvseqblock(VALUE self)
-{
-  return Qnil;
-}
-
-
 /*
  * Return point 1.
  */

ext/opencv/cvtwopoints.h

@@ -12,12 +12,12 @@
 
 #include "opencv.h"
 
-#define __NAMESPACE_BEGIN_CVTWOPOINTS namespace cCvTwoPoints{
+#define __NAMESPACE_BEGIN_CVTWOPOINTS namespace cCvTwoPoints {
 #define __NAMESPACE_END_CVTWOPOINTS }
 
 __NAMESPACE_BEGIN_OPENCV
 
-typedef struct CvTwoPoints{
+typedef struct CvTwoPoints {
   CvPoint p1;
   CvPoint p2;
 } CvTwoPoints;
@@ -40,7 +40,7 @@ VALUE new_object(CvTwoPoints twopoints);
 __NAMESPACE_END_CVTWOPOINTS
 
 inline CvTwoPoints*
-CVTWOPOINTS(VALUE object){
+CVTWOPOINTS(VALUE object) {
   CvTwoPoints *ptr;
   Data_Get_Struct(object, CvTwoPoints, ptr);
   return ptr;

ext/opencv/cvvideowriter.cpp

@@ -80,9 +80,13 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
     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);
@@ -97,14 +101,17 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
  *   write(<i>frame</i>)
  *
  * Write image as frame of video stream.
- * <i>frame</i> should be CvMat or subclass.
+ * <i>frame</i> should be IplImage
  */
 VALUE
 rb_write(VALUE self, VALUE frame)
 {
-  if (!rb_obj_is_kind_of(frame, cCvMat::rb_class()))
+  try {
-    rb_raise(rb_eTypeError, "argument 1 (frame) should be %s or subclass", rb_class2name(cCvMat::rb_class()));
+    cvWriteFrame(CVVIDEOWRITER(self), IPLIMAGE_WITH_CHECK(frame));
-  cvWriteFrame(CVVIDEOWRITER(self), IPLIMAGE(frame));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return self;
 }
 
@@ -115,8 +122,13 @@ VALUE
 rb_close(VALUE self)
 {
   CvVideoWriter *writer = CVVIDEOWRITER(self);
+  try {
     if (writer)
       cvReleaseVideoWriter(&writer);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return Qnil;
 }
 

ext/opencv/gui.cpp

@@ -54,7 +54,13 @@ rb_wait_key(int argc, VALUE *argv, VALUE self)
   VALUE delay;
   rb_scan_args(argc, argv, "01", &delay);
   int keycode = 0;
-  return ((keycode = cvWaitKey(IF_INT(delay, 0))) < 0) ? Qnil : INT2FIX(keycode);
+  try {
+    keycode = cvWaitKey(IF_INT(delay, 0));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return (keycode < 0) ? Qnil : INT2NUM(keycode);
 }
 
 __NAMESPACE_END_GUI

ext/opencv/iplconvkernel.cpp

@@ -7,7 +7,7 @@
    Copyright (C) 2005-2006 Masakazu Yonekura
 
 ************************************************************/
-#include"iplconvkernel.h"
+#include "iplconvkernel.h"
 /*
  * Document-class: OpenCV::IplConvKernel
  *
@@ -101,11 +101,16 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
     num_values = RARRAY_LEN(values);
     _values = ALLOCA_N(int, num_values);
     VALUE *values_ptr = RARRAY_PTR(values);
-    for (int i = 0; i < num_values; i++)
+    for (int i = 0; i < num_values; ++i)
       _values[i] = NUM2INT(values_ptr[i]);
   }
+  try {
     DATA_PTR(self) = rb_cvCreateStructuringElementEx(_cols, _rows, NUM2INT(anchor_x), NUM2INT(anchor_y),
 						     shape_type, _values);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return self;
 }
 

ext/opencv/iplimage.h

@@ -57,6 +57,14 @@ IPLIMAGE(VALUE object)
   return cvGetImage(ptr, &stub);
 }
 
+inline IplImage*
+IPLIMAGE_WITH_CHECK(VALUE object)
+{
+  if (!rb_obj_is_kind_of(object, cIplImage::rb_class()))
+    raise_typeerror(object, cIplImage::rb_class());
+  return IPLIMAGE(object);
+}
+
 __NAMESPACE_END_OPENCV
 
 #endif // RUBY_OPENCV_IPLIMAGE_H

ext/opencv/opencv.cpp

@@ -474,14 +474,18 @@ define_ruby_module()
 #define CREATE_CVTCOLOR_FUNC(rb_func_name, c_const_name, src_cn, dest_cn) \
   VALUE rb_func_name(VALUE klass, VALUE image)				\
   {									\
-    VALUE dest;								\
+    VALUE dest = Qnil;							\
-    if (!rb_obj_is_kind_of(image, cCvMat::rb_class()))			\
+    CvArr* img_ptr = CVMAT_WITH_CHECK(image);				\
-      rb_raise(rb_eTypeError, "argument 1 should be %s.", rb_class2name(cCvMat::rb_class())); \
+    try {								\
-    int type = cvGetElemType(CVARR(image));				\
+      int type = cvGetElemType(img_ptr);				\
       if (CV_MAT_CN(type) != src_cn)					\
-      rb_raise(rb_eTypeError, "argument 1 should be %d-channel.", src_cn); \
+	rb_raise(rb_eArgError, "argument 1 should be %d-channel.", src_cn); \
-    dest = cIplImage::new_object(cvGetSize(CVARR(image)), CV_MAKETYPE(CV_MAT_DEPTH(type), dest_cn)); \
+      dest = cCvMat::new_mat_kind_object(cvGetSize(img_ptr), image, CV_MAT_DEPTH(type), dest_cn); \
-    cvCvtColor(CVARR(image), CVARR(dest), c_const_name);		\
+      cvCvtColor(img_ptr, CVARR(dest), c_const_name);			\
+    }									\
+    catch (cv::Exception& e) {						\
+      raise_cverror(e);							\
+    }									\
     return dest;							\
   }
 

ext/opencv/trackbar.cpp

@@ -88,14 +88,14 @@ VALUE rb_name(VALUE self) {
  * Return the maximum value that can be taken this trackbar.
  */
 VALUE rb_max(VALUE self) {
-  return INT2FIX(TRACKBAR(self)->maxval);
+  return INT2NUM(TRACKBAR(self)->maxval);
 }
 
 /*
  * Return the value of this trackbar.
  */
 VALUE rb_value(VALUE self) {
-  return INT2FIX(TRACKBAR(self)->val);
+  return INT2NUM(TRACKBAR(self)->val);
 }
 
 /*

ext/opencv/window.cpp

@@ -28,7 +28,14 @@ GET_WINDOW_NAME(VALUE object)
   void *handle = DATA_PTR(object);
   if (!handle)
     rb_raise(rb_eStandardError, "window handle error");
-  return (const char*)cvGetWindowName(handle);
+  char* window_name = NULL;
+  try {
+    window_name = (char*)cvGetWindowName(handle);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return (const char*)window_name;
 }
 
 st_table *windows = st_init_numtable();
@@ -107,7 +114,13 @@ rb_aref(VALUE klass, VALUE name)
 {
   VALUE window;
   Check_Type(name, T_STRING);
-  void *handle = cvGetWindowHandle(StringValueCStr(name));
+  void *handle = NULL;
+  try {
+    handle = cvGetWindowHandle(StringValueCStr(name));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   st_table *holder;
   if (st_lookup(windows, (st_data_t)handle, (st_data_t*)&holder) && 
       st_lookup(holder, 0, (st_data_t*)&window)) {
@@ -136,8 +149,14 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
   }
 
   char* name_str = StringValueCStr(name);
+  void *handle = NULL;
+  try {
     cvNamedWindow(name_str, mode);
-  void *handle = cvGetWindowHandle(name_str);
+    handle = cvGetWindowHandle(name_str);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   if (st_lookup(windows, (st_data_t)handle, 0)) {
     rb_raise(rb_eStandardError, "window name should be unique.");
   }
@@ -171,7 +190,12 @@ rb_destroy(VALUE self)
   if (st_delete(windows, (st_data_t*)&handle, (st_data_t*)&holder)) {
     st_free_table(holder);
   }
+  try {
     cvDestroyWindow(GET_WINDOW_NAME(self));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return self;
 }
 
@@ -183,7 +207,12 @@ rb_destroy_all(VALUE klass)
 {
   st_free_table(windows);
   windows = st_init_numtable();
+  try {
     cvDestroyAllWindows();
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return Qnil;
 }
 
@@ -203,13 +232,18 @@ rb_resize(int argc, VALUE *argv, VALUE self)
     size = VALUE_TO_CVSIZE(argv[0]);
     break;
   case 2:
-    size = cvSize(FIX2INT(argv[0]), FIX2INT(argv[1]));
+    size = cvSize(NUM2INT(argv[0]), NUM2INT(argv[1]));
     break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (1 or 2)");
     break;
   }
+  try {
     cvResizeWindow(GET_WINDOW_NAME(self), size.width, size.height);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return self;
 }
 
@@ -235,7 +269,12 @@ rb_move(int argc, VALUE *argv, VALUE self)
     rb_raise(rb_eArgError, "wrong number of arguments (1 or 2)");
     break;
   }
+  try {
     cvMoveWindow(GET_WINDOW_NAME(self), point.x, point.y);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return self;
 }
       
@@ -251,19 +290,19 @@ rb_show_image(int argc, VALUE *argv, VALUE self)
 {
   CvArr* image = NULL;
   if (argc > 0) {
-    if (!rb_obj_is_kind_of(argv[0], cCvMat::rb_class()))
+    image = CVMAT_WITH_CHECK(argv[0]);
-      rb_raise(rb_eTypeError, "argument should be %s.", rb_class2name(cCvMat::rb_class()));
-    else
-      image = CVARR(argv[0]);
-
     st_table *holder;
-    if (st_lookup(windows, (st_data_t)DATA_PTR(self), (st_data_t*)&holder)) {
+    if (st_lookup(windows, (st_data_t)DATA_PTR(self), (st_data_t*)&holder))
       st_insert(holder, cCvMat::rb_class(), argv[0]);
-    }else
+    else
       rb_raise(rb_eFatal, "invalid window operation.");
   }
+  try {
     cvShowImage(GET_WINDOW_NAME(self), image);
-  
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   return self;
 }
 
@@ -291,13 +330,19 @@ rb_set_trackbar(int argc, VALUE *argv, VALUE self)
   VALUE instance;
   if (argc == 1 && rb_obj_is_kind_of(argv[0], cTrackbar::rb_class())) {
     instance = argv[0];
-  }else{
+  }
+  else {
     instance = cTrackbar::rb_initialize(argc, argv, cTrackbar::rb_allocate(cTrackbar::rb_class()));
   }
   Trackbar *trackbar = TRACKBAR(instance);
   void *callback = (void *)alloc_callback(&trackbar_callback, trackbar->block);
+  try {
     cvCreateTrackbar(trackbar->name, GET_WINDOW_NAME(self), &(trackbar->val), trackbar->maxval,
 		     (CvTrackbarCallback)callback);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   st_table *holder;
   if (st_lookup(windows, (st_data_t)DATA_PTR(self), (st_data_t*)&holder)) {
     st_insert(holder, (st_data_t)&trackbar->name, (st_data_t)instance);
@@ -354,7 +399,12 @@ rb_set_mouse_callback(int argc, VALUE* argv, VALUE self)
 
   VALUE block = Qnil;
   rb_scan_args(argc, argv, "0&", &block);
+  try {
     cvSetMouseCallback(GET_WINDOW_NAME(self), on_mouse, (void*)block);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
   st_table *holder;
   if (st_lookup(windows, (st_data_t)DATA_PTR(self), (st_data_t*)&holder)) {
     st_insert(holder, rb_cProc, block);

test/test_cvpoint2d32f.rb

@@ -47,8 +47,8 @@ class TestCvPoint2D32f < OpenCVTestCase
     assert_in_delta(1.1, point.x, 0.001)
     assert_in_delta(2.2, point.y, 0.001)
 
-    assert_raise(ArgumentError) {
+    assert_raise(TypeError) {
-      CvPoint2D32f.new('string')
+      CvPoint2D32f.new(DUMMY_OBJ)
     }
     assert_raise(ArgumentError) {
       CvPoint2D32f.new(1, 2, 3)

test/test_cvpoint3d32f.rb

@@ -60,12 +60,15 @@ class TestCvPoint3D32f < OpenCVTestCase
     assert_in_delta(2.2, point.y, 0.001)
     assert_in_delta(3.3, point.z, 0.001)
 
-    assert_raise(ArgumentError) {
+    assert_raise(TypeError) {
-      CvPoint3D32f.new('string')
+      CvPoint3D32f.new(DUMMY_OBJ)
     }
     assert_raise(ArgumentError) {
       CvPoint3D32f.new(1, 2)
     }
+    assert_raise(ArgumentError) {
+      CvPoint3D32f.new(1, 2, 3, 4)
+    }
   end
 
   def test_to_s

test/test_cvrect.rb

@@ -74,12 +74,18 @@ class TestCvRect < OpenCVTestCase
     assert_equal(30, rect.width)
     assert_equal(40, rect.height)
 
+    assert_raise(TypeError) {
+      CvRect.new(DUMMY_OBJ)
+    }
     assert_raise(ArgumentError) {
-      CvRect.new('string')
+      CvRect.new(1, 2)
     }
     assert_raise(ArgumentError) {
       CvRect.new(1, 2, 3)
     }
+    assert_raise(ArgumentError) {
+      CvRect.new(1, 2, 3, 4, 5)
+    }
   end
 
   def test_center

test/test_cvsize.rb

@@ -48,8 +48,8 @@ class TestCvSize < OpenCVTestCase
     assert_equal(10, size.width)
     assert_equal(20, size.height)
 
-    assert_raise(ArgumentError) {
+    assert_raise(TypeError) {
-      CvSize.new('string')
+      CvSize.new(DUMMY_OBJ)
     }
     assert_raise(ArgumentError) {
       CvSize.new(1, 2, 3)

test/test_cvsize2d32f.rb

@@ -48,8 +48,8 @@ class TestCvSize2D32f < OpenCVTestCase
     assert_in_delta(1.1, size.width, 0.001)
     assert_in_delta(2.2, size.height, 0.001)
 
-    assert_raise(ArgumentError) {
+    assert_raise(TypeError) {
-      CvSize2D32f.new('string')
+      CvSize2D32f.new(DUMMY_OBJ)
     }
     assert_raise(ArgumentError) {
       CvSize2D32f.new(1, 2, 3)

test/test_cvsurfpoint.rb

@@ -29,6 +29,10 @@ class TestCvSURFPoint < OpenCVTestCase
     @surf_point1.pt = CvPoint2D32f.new(12.3, 45.6)
     assert_in_delta(12.3, @surf_point1.pt.x, 0.001)
     assert_in_delta(45.6, @surf_point1.pt.y, 0.001)
+
+    assert_raise(TypeError) {
+      @surf_point1.pt = DUMMY_OBJ
+    }
   end
 
   def test_laplacian

test/test_cvvideowriter.rb

@@ -32,12 +32,19 @@ class TestCvVideoWriter < OpenCVTestCase
   end
 
   def test_write
+    img = IplImage.load(FILENAME_LENA256x256)
     vw = CvVideoWriter.new('foo.avi', 'MJPG', 15, CvSize.new(256, 256))
-    vw.write CvMat.load(FILENAME_LENA256x256)
+    vw.write img
     vw.close
 
     CvVideoWriter.new('foo.avi', 'MJPG', 15, CvSize.new(256, 256)) { |vw|
-      vw.write CvMat.load(FILENAME_LENA256x256)
+      vw.write img
+    }
+    
+    assert_raise(TypeError) {
+      CvVideoWriter.new('foo.avi', 'MJPG', 15, CvSize.new(256, 256)) { |vw|
+        vw.write DUMMY_OBJ
+      }
     }
   end
 

test/test_opencv.rb

@@ -235,48 +235,61 @@ class TestOpenCV < OpenCVTestCase
 
     # RGB(A) <=> RGB(A)
     [mat_3ch.BGR2BGRA, mat_3ch.RGB2RGBA].each { |m|
+      assert_equal(CvMat, m.class)
       assert_equal(4, m.channel)
       assert_cvscalar_equal(CvScalar.new(10, 20, 30, 255), m[0])
     }
     [mat_3ch.BGR2RGBA, mat_3ch.RGB2BGRA].each { |m|
+      assert_equal(CvMat, m.class)
       assert_equal(4, m.channel)
       assert_cvscalar_equal(CvScalar.new(30, 20, 10, 255), m[0])
     }
     [mat_4ch.BGRA2BGR, mat_4ch.RGBA2RGB].each { |m|
+      assert_equal(CvMat, m.class)
       assert_equal(3, m.channel)
       assert_cvscalar_equal(CvScalar.new(10, 20, 30, 0), m[0])
     }
     [mat_4ch.RGBA2BGR, mat_4ch.BGRA2RGB].each { |m|
+      assert_equal(CvMat, m.class)
       assert_equal(3, m.channel)
       assert_cvscalar_equal(CvScalar.new(30, 20, 10, 0), m[0])
     }
     [mat_3ch.BGR2RGB, mat_3ch.RGB2BGR].each { |m|
+      assert_equal(CvMat, m.class)
       assert_equal(3, m.channel)
       assert_cvscalar_equal(CvScalar.new(30, 20, 10, 0), m[0])
     }
     [mat_4ch.BGRA2RGBA, mat_4ch.RGBA2BGRA].each { |m|
+      assert_equal(CvMat, m.class)
       assert_equal(4, m.channel)
       assert_cvscalar_equal(CvScalar.new(30, 20, 10, 40), m[0])
     }
 
     # RGB <=> GRAY
     [mat_3ch.BGR2GRAY, mat_4ch.BGRA2GRAY].each { |m|
+      assert_equal(CvMat, m.class)
       assert_equal(1, m.channel)
       assert_cvscalar_equal(CvScalar.new(gray_bgr, 0, 0, 0), m[0])
     }
     [mat_3ch.RGB2GRAY, mat_4ch.RGBA2GRAY].each { |m|
+      assert_equal(CvMat, m.class)
       assert_equal(1, m.channel)
       assert_cvscalar_equal(CvScalar.new(gray_rgb, 0, 0, 0), m[0])
     }
     [mat_1ch.GRAY2BGR, mat_1ch.GRAY2RGB].each { |m|
+      assert_equal(CvMat, m.class)
       assert_equal(3, m.channel)
       assert_cvscalar_equal(CvScalar.new(10, 10, 10, 0), m[0])
     }
     [mat_1ch.GRAY2BGRA, mat_1ch.GRAY2RGBA].each { |m|
+      assert_equal(CvMat, m.class)
       assert_equal(4, m.channel)
       assert_cvscalar_equal(CvScalar.new(10, 10, 10, 255), m[0])
     }
 
+    img_3ch = IplImage.new(1, 1, :cv8u, 3)
+    assert_equal(IplImage, img_3ch.BGR2GRAY.class)
+
     flunk('FIXME: Most cvtColor functions are not tested yet.')
   end
 end

test/test_window.rb

@@ -62,7 +62,7 @@ class TestWindow < OpenCVTestCase
 
     # Uncomment the following lines to show the results
     # @window1.show(CvMat.new(10, 20))
-    # @window2.show(CvMat.new(100, 200))
+    # @window1.resize(100, 200)
     # GUI::wait_key
   end