kotovalexarian-likes-github/ruby-opencv
1
0
Fork 0
mirror of https://github.com/ruby-opencv/ruby-opencv synced 2023-03-27 23:22:12 -04:00
Code Releases Activity

added error handling to some methods (2)

Browse source 
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
This commit is contained in:
ser1zw 2011-07-23 19:51:58 +09:00
parent ea55e0d42e
commit b3016fc68c
31 changed files with 407 additions and 245 deletions
Download patch file Download diff file Expand all files Collapse all files

3
ext/opencv/cvpoint.cpp
View file

@ -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;
}
/*

24
ext/opencv/cvpoint2d32f.cpp
View file

@ -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:
obj = argv[0];
if (rb_compatible_q(rb_klass, obj)) {
CVPOINT2D32F(self)->x = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("x"), 0), rb_intern("to_f"), 0));
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));
}
case 1: {
CvPoint2D32f point = VALUE_TO_CVPOINT2D32F(argv[0]);
self_ptr->x = point.x;
self_ptr->y = point.y;
break;
}
case 2:
x = argv[0], y = argv[1];
CVPOINT2D32F(self)->x = NUM2DBL(x);
CVPOINT2D32F(self)->y = NUM2DBL(y);
self_ptr->x = NUM2DBL(argv[0]);
self_ptr->y = NUM2DBL(argv[1]);
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
break;
}
return Qnil;
return self;
}
/*

26
ext/opencv/cvpoint3d32f.cpp
View file

@ -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:
obj = argv[0];
if(rb_compatible_q(rb_klass, obj)) {
CVPOINT3D32F(self)->x = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("x"), 0), rb_intern("to_f"), 0));
CVPOINT3D32F(self)->y = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("y"), 0), rb_intern("to_f"), 0));
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));
}
case 1: {
CvPoint3D32f point = VALUE_TO_CVPOINT3D32F(argv[0]);
self_ptr->x = point.x;
self_ptr->y = point.y;
self_ptr->z = point.z;
break;
}
case 3:
x = argv[0], y = argv[1], z = argv[2];
CVPOINT3D32F(self)->x = NUM2DBL(x);
CVPOINT3D32F(self)->y = NUM2DBL(y);
CVPOINT3D32F(self)->z = NUM2DBL(z);
self_ptr->x = NUM2DBL(argv[0]);
self_ptr->y = NUM2DBL(argv[1]);
self_ptr->z = NUM2DBL(argv[2]);
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
break;
}
return Qnil;
return self;
}
/*

60
ext/opencv/cvrect.cpp
View file

@ -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:
object = argv[0];
if (rb_compatible_q(rb_klass, object)) {
CVRECT(self)->x = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("x"), 0), rb_intern("to_i"), 0));
CVRECT(self)->y = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("y"), 0), rb_intern("to_i"), 0));
CVRECT(self)->width = NUM2INT(rb_funcall(rb_funcall(object, rb_intern("width"), 0), rb_intern("to_i"), 0));
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));
}
case 1: {
CvRect rect = VALUE_TO_CVRECT(argv[0]);
self_ptr->x = rect.x;
self_ptr->y = rect.y;
self_ptr->width = rect.width;
self_ptr->height = rect.height;
break;
}
case 4:
x = argv[0], y = argv[1], width = argv[2], height = argv[3];
CVRECT(self)->x = NUM2INT(x);
CVRECT(self)->y = NUM2INT(y);
CVRECT(self)->width = NUM2INT(width);
CVRECT(self)->height = NUM2INT(height);
self_ptr->x = NUM2INT(argv[0]);
self_ptr->y = NUM2INT(argv[1]);
self_ptr->width = NUM2INT(argv[2]);
self_ptr->height = NUM2INT(argv[3]);
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

1
ext/opencv/cvrect.h
View file

@ -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);

36
ext/opencv/cvscalar.cpp
View file

@ -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)->val[i] = NIL_P(val[i]) ? 0 : NUM2DBL(val[i]);
CvScalar* self_ptr = CVSCALAR(self);
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) {
return rb_float_new(CVSCALAR(self)->val[idx]);
}else{
if (idx < 0 || idx >= 4) {
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) {
CVSCALAR(self)->val[idx] = NUM2DBL(value);
return self;
}else{
if (idx < 0 || idx >= 4) {
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())){
VALUE dest = cCvMat::new_object(cvGetSize(CVARR(val)), cvGetElemType(CVARR(val)));
cvSubRS(CVARR(val), *CVSCALAR(self), CVARR(dest), MASK(mask));
if (rb_obj_is_kind_of(val, cCvMat::rb_class())) {
CvArr *val_ptr = CVARR(val);
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],

92
ext/opencv/cvseq.cpp
View file

@ -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;
}

25
ext/opencv/cvsize.cpp
View file

@ -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:
obj = argv[0];
if(rb_compatible_q(rb_klass, obj)) {
CVSIZE(self)->width = NUM2INT(rb_funcall(rb_funcall(obj, rb_intern("width"), 0), rb_intern("to_i"), 0));
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));
}
case 1: {
CvSize size = VALUE_TO_CVSIZE(argv[0]);
self_ptr->width = size.width;
self_ptr->height = size.height;
break;
}
case 2:
x = argv[0], y = argv[1];
CVSIZE(self)->width = NUM2INT(x);
CVSIZE(self)->height = NUM2INT(y);
self_ptr->width = NUM2INT(argv[0]);
self_ptr->height = NUM2INT(argv[1]);
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
break;
}
return Qnil;
return self;
}
/*

20
ext/opencv/cvsize2d32f.cpp
View file

@ -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:
obj = argv[0];
if(rb_compatible_q(rb_klass, obj)){
CVSIZE2D32F(self)->width = NUM2DBL(rb_funcall(rb_funcall(obj, rb_intern("width"), 0), rb_intern("to_f"), 0));
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));
}
case 1: {
CvSize2D32f size = VALUE_TO_CVSIZE2D32F(argv[0]);
self_ptr->width = size.width;
self_ptr->height = size.height;
break;
}
case 2:
x = argv[0], y = argv[1];
CVSIZE2D32F(self)->width = NUM2DBL(x);
CVSIZE2D32F(self)->height = NUM2DBL(y);
self_ptr->width = NUM2DBL(argv[0]);
self_ptr->height = NUM2DBL(argv[1]);
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);

9
ext/opencv/cvslice.cpp
View file

@ -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)->end_index = NUM2INT(end);
CvSlice *self_ptr = CVSLICE(self);
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;
}

12
ext/opencv/cvsurfparams.cpp
View file

@ -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->nOctaveLayers = NIL_P(noctl) ? 4 : FIX2INT(noctl);
self_ptr->nOctaves = NIL_P(noct) ? 3 : NUM2INT(noct);
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;
}

18
ext/opencv/cvsurfpoint.cpp
View file

@ -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->size = FIX2INT(size);
self_ptr->laplacian = NUM2INT(laplacian);
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;
}

11
ext/opencv/cvtermcriteria.cpp
View file

@ -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;
}

7
ext/opencv/cvtwopoints.cpp
View file

@ -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.
*/

6
ext/opencv/cvtwopoints.h
View file

@ -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;

22
ext/opencv/cvvideowriter.cpp
View file

@ -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()))
rb_raise(rb_eTypeError, "argument 1 (frame) should be %s or subclass", rb_class2name(cCvMat::rb_class()));
cvWriteFrame(CVVIDEOWRITER(self), IPLIMAGE(frame));
try {
cvWriteFrame(CVVIDEOWRITER(self), IPLIMAGE_WITH_CHECK(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;
}

8
ext/opencv/gui.cpp
View file

@ -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

9
ext/opencv/iplconvkernel.cpp
View file

@ -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;
}

8
ext/opencv/iplimage.h
View file

@ -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

18
ext/opencv/opencv.cpp
View file

@ -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; \
if (!rb_obj_is_kind_of(image, cCvMat::rb_class())) \
rb_raise(rb_eTypeError, "argument 1 should be %s.", rb_class2name(cCvMat::rb_class())); \
int type = cvGetElemType(CVARR(image)); \
VALUE dest = Qnil; \
CvArr* img_ptr = CVMAT_WITH_CHECK(image); \
try { \
int type = cvGetElemType(img_ptr); \
if (CV_MAT_CN(type) != src_cn) \
rb_raise(rb_eTypeError, "argument 1 should be %d-channel.", src_cn); \
dest = cIplImage::new_object(cvGetSize(CVARR(image)), CV_MAKETYPE(CV_MAT_DEPTH(type), dest_cn)); \
cvCvtColor(CVARR(image), CVARR(dest), c_const_name); \
rb_raise(rb_eArgError, "argument 1 should be %d-channel.", src_cn); \
dest = cCvMat::new_mat_kind_object(cvGetSize(img_ptr), image, CV_MAT_DEPTH(type), dest_cn); \
cvCvtColor(img_ptr, CVARR(dest), c_const_name); \
} \
catch (cv::Exception& e) { \
raise_cverror(e); \
} \
return dest; \
}

4
ext/opencv/trackbar.cpp
View file

@ -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);
}
/*

76
ext/opencv/window.cpp
View file

@ -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()))
rb_raise(rb_eTypeError, "argument should be %s.", rb_class2name(cCvMat::rb_class()));
else
image = CVARR(argv[0]);
image = CVMAT_WITH_CHECK(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);

4
test/test_cvpoint2d32f.rb
View file

@ -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) {
CvPoint2D32f.new('string')
assert_raise(TypeError) {
CvPoint2D32f.new(DUMMY_OBJ)
}
assert_raise(ArgumentError) {
CvPoint2D32f.new(1, 2, 3)

7
test/test_cvpoint3d32f.rb
View file

@ -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) {
CvPoint3D32f.new('string')
assert_raise(TypeError) {
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

8
test/test_cvrect.rb
View file

@ -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

4
test/test_cvsize.rb
View file

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

4
test/test_cvsize2d32f.rb
View file

@ -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) {
CvSize2D32f.new('string')
assert_raise(TypeError) {
CvSize2D32f.new(DUMMY_OBJ)
}
assert_raise(ArgumentError) {
CvSize2D32f.new(1, 2, 3)

4
test/test_cvsurfpoint.rb
View file

@ -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

11
test/test_cvvideowriter.rb
View file

@ -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

13
test/test_opencv.rb
View file

@ -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

2
test/test_window.rb
View file

@ -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