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

change CvSeq's constructor parameter to Fixnum flags to allow CV_SEQ_KIND_* flags

Browse source
This commit is contained in:
ser1zw 2014-08-10 07:20:27 +09:00
parent 720c0072c1
commit 884da95685
8 changed files with 254 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
ext/opencv/cvcontour.cpp
View file

@ -42,31 +42,49 @@ rb_allocate(VALUE klass)
/*
* Constructor
* @overload new(storage = nil)
*
* @overload new(seq_flags = CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_GENERIC, storage = nil)
* @param [Fixnum] seq_flags Flags of the created sequence, which are combinations of
* the element types and sequence types.
* - Element type:
* - <tt>CV_SEQ_ELTYPE_POINT</tt>: {CvPoint}
* - <tt>CV_32FC2</tt>: {CvPoint2D32f}
* - <tt>CV_SEQ_ELTYPE_POINT3D</tt>: {CvPoint3D32f}
* - <tt>CV_SEQ_ELTYPE_INDEX</tt>: Fixnum
* - <tt>CV_SEQ_ELTYPE_CODE</tt>: Fixnum (Freeman code)
* - Sequence type:
* - <tt>CV_SEQ_KIND_GENERIC</tt>: Generic sequence
* - <tt>CV_SEQ_KIND_CURVE</tt>: Curve
* @param [CvMemStorage] storage Sequence location
* @return [CvContour] self
* @opencv_func cvCreateSeq
* @example
* seq = CvContour.new(CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_CURVE)
* seq << CvPoint.new(1, 2)
* seq << 3 #=> TypeError
*/
VALUE
rb_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE storage;
rb_scan_args(argc, argv, "01", &storage);
VALUE seq_flags_value, storage_value;
rb_scan_args(argc, argv, "02", &seq_flags_value, &storage_value);
if (NIL_P(storage))
storage = cCvMemStorage::new_object(0);
else
storage = CHECK_CVMEMSTORAGE(storage);
int seq_flags = 0;
if (NIL_P(seq_flags_value)) {
seq_flags = CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_GENERIC;
}
else {
Check_Type(seq_flags_value, T_FIXNUM);
seq_flags = FIX2INT(seq_flags_value);
}
storage_value = CHECK_CVMEMSTORAGE(storage_value);
try {
DATA_PTR(self) = (CvContour*)cvCreateSeq(CV_SEQ_ELTYPE_POINT, sizeof(CvContour),
sizeof(CvPoint), CVMEMSTORAGE(storage));
DATA_PTR(self) = (CvContour*)cCvSeq::create_seq(seq_flags, sizeof(CvContour), storage_value);
}
catch (cv::Exception& e) {
raise_cverror(e);
}
cCvSeq::register_elem_class(CVSEQ(self), cCvPoint::rb_class());
register_root_object(CVSEQ(self), storage);
return self;
}

7
ext/opencv/cvmemstorage.h
View file

@ -39,13 +39,10 @@ CVMEMSTORAGE(VALUE object)
inline VALUE
CHECK_CVMEMSTORAGE(VALUE object)
{
if (rb_obj_is_kind_of(object, cCvMemStorage::rb_class()))
if (rb_obj_is_kind_of(object, cCvMemStorage::rb_class())) {
return object;
else {
if (!NIL_P(object))
rb_warn("invalid CvMemStorage object given. allocate new memory storage automatically.");
return cCvMemStorage::new_object();
}
return cCvMemStorage::new_object();
}
__NAMESPACE_END_OPENCV

197
ext/opencv/cvseq.cpp
View file

@ -10,27 +10,6 @@
#include "cvseq.h"
/*
* Document-class: OpenCV::CvSeq
*
* Generic Sequence class. CvSeq has the method like Array (push, pop, select, etc...).
* But, CvSeq cannot store the object of a different class.
* When storing object in CvSeq, conversion is automatically tried,
* and the object occurs the error if it cannot be done.
*
* e.g.
* seq = CvSeq.new(CvPoint) # Argument mean "this sequence contain only this class's object"
* seq.push(CvPoint.new(0, 0)) # => it's ok
* seq.push("hello") # => try convert "hello" to CvPoint. but can't do it. raise error.
*
* If the sequecne contain object of class A.
* When storing object(named "obj") of class B to the sequence.
* Try automatically : A.from_B(obj) => object of class A.
*
* The sequence might have another sequence outside. see below.
* Each sequece has h_prev, h_next, v_prev, v_next method.
* If the adjoining sequence exists, each method return the adjoining sequence.
* Otherwise return nil.
*
* link:../images/CvSeq_relationmap.png
*/
__NAMESPACE_BEGIN_OPENCV
__NAMESPACE_BEGIN_CVSEQ
@ -80,62 +59,116 @@ rb_allocate(VALUE klass)
return Data_Wrap_Struct(klass, 0, unregister_elem_class, ptr);
}
/*
* call-seq:
* CvSeq.new(type[,storage])
*
* Return a new CvSeq. <i>type</i> should be following classes.
*
* * CvIndex
* * CvPoint
*/
VALUE
rb_initialize(int argc, VALUE *argv, VALUE self)
CvSeq*
create_seq(int seq_flags, size_t header_size, VALUE storage_value)
{
VALUE klass, storage_value;
VALUE klass = Qnil;
int eltype = seq_flags & CV_SEQ_ELTYPE_MASK;
storage_value = CHECK_CVMEMSTORAGE(storage_value);
rb_scan_args(argc, argv, "11", &klass, &storage_value);
if (!rb_obj_is_kind_of(klass, rb_cClass))
raise_typeerror(klass, rb_cClass);
switch (eltype) {
case CV_SEQ_ELTYPE_POINT:
klass = cCvPoint::rb_class();
break;
case CV_32FC2:
klass = cCvPoint2D32f::rb_class();
break;
case CV_SEQ_ELTYPE_POINT3D:
klass = cCvPoint3D32f::rb_class();
break;
case CV_SEQ_ELTYPE_CODE:
case CV_SEQ_ELTYPE_INDEX:
klass = rb_cFixnum;
break;
case CV_SEQ_ELTYPE_PPOINT: // or CV_SEQ_ELTYPE_PTR:
// Not supported
rb_raise(rb_eArgError, "seq_flags %d is not supported.", eltype);
break;
default:
seq_flags = CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_GENERIC;
klass = cCvPoint::rb_class();
break;
}
int type = 0, size = 0;
if (klass == rb_cFixnum) {
type = CV_SEQ_ELTYPE_INDEX;
size = sizeof(int);
}
else if (klass == cCvPoint::rb_class()) {
type = CV_SEQ_ELTYPE_POINT;
size = sizeof(CvPoint);
}
else if (klass == cCvPoint2D32f::rb_class()) {
type = CV_SEQ_ELTYPE_POINT;
size = sizeof(CvPoint2D32f);
}
else if (klass == cCvPoint3D32f::rb_class()) {
type = CV_SEQ_ELTYPE_POINT3D;
size = sizeof(CvPoint3D32f);
}
else
rb_raise(rb_eArgError, "unsupport %s class for sequence-block.", rb_class2name(klass));
int mat_type = CV_MAT_TYPE(seq_flags);
size_t elem_size = (size_t)(CV_ELEM_SIZE(mat_type));
CvSeq* seq = NULL;
if (NIL_P(storage_value)) {
storage_value = cCvMemStorage::new_object(0);
}
else {
storage_value = CHECK_CVMEMSTORAGE(storage_value);
}
try {
seq = cvCreateSeq(type, sizeof(CvSeq), size, CVMEMSTORAGE(storage_value));
seq = cvCreateSeq(seq_flags, header_size, elem_size, CVMEMSTORAGE(storage_value));
}
catch (cv::Exception& e) {
raise_cverror(e);
}
DATA_PTR(self) = seq;
register_elem_class(seq, klass);
register_root_object(seq, storage_value);
return seq;
}
VALUE
class2seq_flags_value(VALUE klass) {
int seq_flags;
if (klass == cCvPoint::rb_class()) {
seq_flags = CV_SEQ_ELTYPE_POINT;
}
else if (klass == cCvPoint2D32f::rb_class()) {
seq_flags = CV_32FC2;
}
else if (klass == cCvPoint3D32f::rb_class()) {
seq_flags = CV_SEQ_ELTYPE_POINT3D;
}
else if (klass == rb_cFixnum) {
seq_flags = CV_SEQ_ELTYPE_INDEX;
}
else {
rb_raise(rb_eTypeError, "unexpected type: %s", rb_class2name(klass));
}
return INT2NUM(seq_flags | CV_SEQ_KIND_GENERIC);
}
/*
* Constructor
*
* @overload new(seq_flags, storage = nil)
* @param [Fixnum] seq_flags Flags of the created sequence, which are combinations of
* the element types and sequence types.
* - Element type:
* - <tt>CV_SEQ_ELTYPE_POINT</tt>: {CvPoint}
* - <tt>CV_32FC2</tt>: {CvPoint2D32f}
* - <tt>CV_SEQ_ELTYPE_POINT3D</tt>: {CvPoint3D32f}
* - <tt>CV_SEQ_ELTYPE_INDEX</tt>: Fixnum
* - <tt>CV_SEQ_ELTYPE_CODE</tt>: Fixnum (Freeman code)
* - Sequence type:
* - <tt>CV_SEQ_KIND_GENERIC</tt>: Generic sequence
* - <tt>CV_SEQ_KIND_CURVE</tt>: Curve
* @param [CvMemStorage] storage Sequence location
* @return [CvSeq] self
* @opencv_func cvCreateSeq
* @example
* seq1 = CvSeq.new(CV_SEQ_ELTYPE_INDEX)
* seq1 << 1
* seq1 << CvPoint.new(1, 2) #=> TypeError
*
* seq2 = CvSeq.new(CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_CURVE)
* seq2 << CvPoint.new(1, 2)
* seq2 << 3 #=> TypeError
*/
VALUE
rb_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE seq_flags_value, storage_value;
rb_scan_args(argc, argv, "11", &seq_flags_value, &storage_value);
int seq_flags = 0;
if (TYPE(seq_flags_value) == T_CLASS) { // To maintain backward compatibility
seq_flags_value = class2seq_flags_value(seq_flags_value);
}
Check_Type(seq_flags_value, T_FIXNUM);
seq_flags = FIX2INT(seq_flags_value);
DATA_PTR(self) = create_seq(seq_flags, sizeof(CvSeq), storage_value);
return self;
}
@ -174,17 +207,22 @@ rb_aref(VALUE self, VALUE index)
{
CvSeq *seq = CVSEQ(self);
int idx = NUM2INT(index);
if (seq->total == 0)
if (seq->total == 0) {
return Qnil;
if (idx >= seq->total)
}
if (idx >= seq->total) {
rb_raise(rb_eIndexError, "index %d out of sequence", idx);
}
VALUE result = Qnil;
try {
if (seqblock_class(seq) == rb_cFixnum)
VALUE klass = seqblock_class(seq);
if (RTEST(rb_class_inherited_p(klass, rb_cInteger))) {
result = INT2NUM(*CV_GET_SEQ_ELEM(int, seq, idx));
else
result = REFER_OBJECT(seqblock_class(seq), cvGetSeqElem(seq, idx), self);
}
else {
result = REFER_OBJECT(klass, cvGetSeqElem(seq, idx), self);
}
}
catch (cv::Exception& e) {
raise_cverror(e);
@ -288,16 +326,20 @@ VALUE
rb_seq_push(VALUE self, VALUE args, int flag)
{
CvSeq *seq = CVSEQ(self);
VALUE klass = seqblock_class(seq), object;
VALUE klass = seqblock_class(seq);
volatile void *elem = NULL;
int len = RARRAY_LEN(args);
for (int i = 0; i < len; ++i) {
object = RARRAY_PTR(args)[i];
if (CLASS_OF(object) == klass) {
if (TYPE(object) == T_FIXNUM) {
volatile int int_elem = FIX2INT(object);
for (int i = 0; i < len; i++) {
VALUE object = RARRAY_PTR(args)[i];
if (rb_obj_is_kind_of(object, klass)) {
if (rb_obj_is_kind_of(object, rb_cInteger)) {
volatile int int_elem = NUM2INT(object);
elem = &int_elem;
}
else if (rb_obj_is_kind_of(object, rb_cNumeric)) {
volatile double double_elem = NUM2DBL(object);
elem = &double_elem;
}
else {
elem = (void*)DATA_PTR(object);
}
@ -311,7 +353,8 @@ rb_seq_push(VALUE self, VALUE args, int flag)
raise_cverror(e);
}
}
else if (rb_obj_is_kind_of(object, rb_klass) && CLASS_OF(rb_first(object)) == klass) { // object is CvSeq
else if ((rb_obj_is_kind_of(object, rb_klass) == Qtrue) &&
RTEST(rb_class_inherited_p(seqblock_class(CVSEQ(object)), klass))) { // object is CvSeq
void *buffer = NULL;
try {
buffer = cvCvtSeqToArray(CVSEQ(object), rb_cvAlloc(CVSEQ(object)->total * CVSEQ(object)->elem_size));

1
ext/opencv/cvseq.h
View file

@ -24,6 +24,7 @@ void init_ruby_class();
VALUE seqblock_class(void *ptr);
void register_elem_class(CvSeq *seq, VALUE klass);
void unregister_elem_class(void *ptr);
CvSeq* create_seq(int seq_flags, size_t header_size, VALUE storage_value);
VALUE rb_allocate(VALUE klass);

41
ext/opencv/opencv.cpp
View file

@ -388,6 +388,47 @@ init_ruby_module()
rb_define_const(rb_module, "COLORMAP_PINK", INT2FIX(cv::COLORMAP_PINK));
rb_define_const(rb_module, "COLORMAP_HOT", INT2FIX(cv::COLORMAP_HOT));
/* Sequence types */
rb_define_const(rb_module, "CV_SEQ_ELTYPE_BITS", INT2FIX(CV_SEQ_ELTYPE_BITS));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_MASK", INT2FIX(CV_SEQ_ELTYPE_MASK));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_POINT", INT2FIX(CV_SEQ_ELTYPE_POINT));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_CODE", INT2FIX(CV_SEQ_ELTYPE_CODE));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_GENERIC", INT2FIX(CV_SEQ_ELTYPE_GENERIC));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_PTR", INT2FIX(CV_SEQ_ELTYPE_PTR));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_PPOINT", INT2FIX(CV_SEQ_ELTYPE_PPOINT));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_INDEX", INT2FIX(CV_SEQ_ELTYPE_INDEX));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_GRAPH_EDGE", INT2FIX(CV_SEQ_ELTYPE_GRAPH_EDGE));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_GRAPH_VERTEX", INT2FIX(CV_SEQ_ELTYPE_GRAPH_VERTEX));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_TRIAN_ATR", INT2FIX(CV_SEQ_ELTYPE_TRIAN_ATR));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_CONNECTED_COMP", INT2FIX(CV_SEQ_ELTYPE_CONNECTED_COMP));
rb_define_const(rb_module, "CV_SEQ_ELTYPE_POINT3D", INT2FIX(CV_SEQ_ELTYPE_POINT3D));
rb_define_const(rb_module, "CV_SEQ_KIND_BITS", INT2FIX(CV_SEQ_KIND_BITS));
rb_define_const(rb_module, "CV_SEQ_KIND_MASK", INT2FIX(CV_SEQ_KIND_MASK));
rb_define_const(rb_module, "CV_SEQ_KIND_GENERIC", INT2FIX(CV_SEQ_KIND_GENERIC));
rb_define_const(rb_module, "CV_SEQ_KIND_CURVE", INT2FIX(CV_SEQ_KIND_CURVE));
rb_define_const(rb_module, "CV_SEQ_KIND_BIN_TREE", INT2FIX(CV_SEQ_KIND_BIN_TREE));
rb_define_const(rb_module, "CV_SEQ_KIND_GRAPH", INT2FIX(CV_SEQ_KIND_GRAPH));
rb_define_const(rb_module, "CV_SEQ_KIND_SUBDIV2D", INT2FIX(CV_SEQ_KIND_SUBDIV2D));
rb_define_const(rb_module, "CV_SEQ_FLAG_SHIFT", INT2FIX(CV_SEQ_FLAG_SHIFT));
rb_define_const(rb_module, "CV_SEQ_FLAG_CLOSED", INT2FIX(CV_SEQ_FLAG_CLOSED));
rb_define_const(rb_module, "CV_SEQ_FLAG_SIMPLE", INT2FIX(CV_SEQ_FLAG_SIMPLE));
rb_define_const(rb_module, "CV_SEQ_FLAG_CONVEX", INT2FIX(CV_SEQ_FLAG_CONVEX));
rb_define_const(rb_module, "CV_SEQ_FLAG_HOLE", INT2FIX(CV_SEQ_FLAG_HOLE));
rb_define_const(rb_module, "CV_GRAPH_FLAG_ORIENTED", INT2FIX(CV_GRAPH_FLAG_ORIENTED));
rb_define_const(rb_module, "CV_GRAPH", INT2FIX(CV_GRAPH));
rb_define_const(rb_module, "CV_ORIENTED_GRAPH", INT2FIX(CV_ORIENTED_GRAPH));
rb_define_const(rb_module, "CV_SEQ_POINT_SET", INT2FIX(CV_SEQ_POINT_SET));
rb_define_const(rb_module, "CV_SEQ_POINT3D_SET", INT2FIX(CV_SEQ_POINT3D_SET));
rb_define_const(rb_module, "CV_SEQ_POLYLINE", INT2FIX(CV_SEQ_POLYLINE));
rb_define_const(rb_module, "CV_SEQ_POLYGON", INT2FIX(CV_SEQ_POLYGON));
rb_define_const(rb_module, "CV_SEQ_CONTOUR", INT2FIX(CV_SEQ_CONTOUR));
rb_define_const(rb_module, "CV_SEQ_SIMPLE_POLYGON", INT2FIX(CV_SEQ_SIMPLE_POLYGON));
rb_define_const(rb_module, "CV_SEQ_CHAIN", INT2FIX(CV_SEQ_CHAIN));
rb_define_const(rb_module, "CV_SEQ_CHAIN_CONTOUR", INT2FIX(CV_SEQ_CHAIN_CONTOUR));
rb_define_const(rb_module, "CV_SEQ_POLYGON_TREE", INT2FIX(CV_SEQ_POLYGON_TREE));
rb_define_const(rb_module, "CV_SEQ_CONNECTED_COMP", INT2FIX(CV_SEQ_CONNECTED_COMP));
rb_define_const(rb_module, "CV_SEQ_INDEX", INT2FIX(CV_SEQ_INDEX));
VALUE inversion_method = rb_hash_new();
/* {:lu, :svd, :svd_sym(:svd_symmetric)}: Inversion method */
rb_define_const(rb_module, "INVERSION_METHOD", inversion_method);

4
test/test_cvconnectedcomp.rb
View file

@ -10,7 +10,7 @@ include OpenCV
class TestCvConnectedComp < OpenCVTestCase
def setup
@connected_comp = CvConnectedComp.new(9216, CvScalar.new(1, 2, 3, 4),
CvRect.new(1, 2, 3, 4), CvSeq.new(CvPoint))
CvRect.new(1, 2, 3, 4), CvSeq.new(CV_SEQ_ELTYPE_INDEX))
end
def test_initialize
@ -22,7 +22,7 @@ class TestCvConnectedComp < OpenCVTestCase
assert_not_nil(connected_comp.contour)
connected_comp = CvConnectedComp.new(100, CvScalar.new(1, 2, 3, 4),
CvRect.new(1, 2, 3, 4), CvSeq.new(CvPoint))
CvRect.new(1, 2, 3, 4), CvSeq.new(CV_SEQ_ELTYPE_POINT))
assert_equal(CvConnectedComp, connected_comp.class)
assert_not_nil(connected_comp.area)
assert_not_nil(connected_comp.value)

4
test/test_cvcontourtree.rb
View file

@ -9,11 +9,11 @@ include OpenCV
# Tests for OpenCV::CvContourTree
class TestCvContourTree < OpenCVTestCase
def setup
@tree = CvContourTree.new(CvPoint)
@tree = CvContourTree.new(CV_SEQ_ELTYPE_POINT)
end
def test_initialize
tree = CvContourTree.new(CvPoint)
tree = CvContourTree.new(CV_SEQ_ELTYPE_POINT)
assert_equal(CvContourTree, tree.class)
assert(tree.is_a? CvSeq)
end

98
test/test_cvseq.rb
View file

@ -9,17 +9,34 @@ include OpenCV
# Tests for OpenCV::CvSeq
class TestCvSeq < OpenCVTestCase
def test_initialize
# assert_not_nil(CvSeq.new(CvIndex))
assert_not_nil(CvSeq.new(Fixnum))
assert_not_nil(CvSeq.new(CvPoint))
assert_not_nil(CvSeq.new(CvPoint2D32f))
assert_not_nil(CvSeq.new(CvPoint3D32f))
types = [CV_SEQ_ELTYPE_POINT, CV_SEQ_ELTYPE_POINT3D, CV_SEQ_ELTYPE_CODE, CV_SEQ_ELTYPE_INDEX]
kinds = [CV_SEQ_KIND_GENERIC, CV_SEQ_KIND_CURVE, CV_SEQ_KIND_BIN_TREE, CV_SEQ_KIND_GRAPH, CV_SEQ_KIND_SUBDIV2D]
flags = [CV_SEQ_FLAG_CLOSED, CV_SEQ_FLAG_SIMPLE, CV_SEQ_FLAG_CONVEX, CV_SEQ_FLAG_HOLE]
types.each { |type|
kinds.each { |kind|
flags.each { |flag|
seq_flag = type | kind | flag
assert_equal(CvSeq, CvSeq.new(seq_flag).class)
}
}
}
assert(CvSeq.new(CvPoint).is_a? Enumerable)
[CV_SEQ_POINT_SET, CV_SEQ_POINT3D_SET, CV_SEQ_POLYLINE, CV_SEQ_POLYGON,
CV_SEQ_CONTOUR, CV_SEQ_SIMPLE_POLYGON, CV_SEQ_CHAIN, CV_SEQ_CHAIN_CONTOUR,
CV_SEQ_INDEX ].each { |seq_flag|
assert_equal(CvSeq, CvSeq.new(seq_flag).class)
}
# Unsupported types
[CV_SEQ_ELTYPE_PTR, CV_SEQ_ELTYPE_PPOINT].each { |type|
assert_raise(ArgumentError) {
CvSeq.new(type)
}
}
end
def test_total
seq1 = CvSeq.new(CvPoint)
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT)
assert_equal(0, seq1.total)
seq1.push(CvPoint.new(1, 2))
@ -33,13 +50,12 @@ class TestCvSeq < OpenCVTestCase
end
def test_empty
assert(CvSeq.new(CvPoint).empty?)
assert(CvSeq.new(CvPoint2D32f).empty?)
assert(CvSeq.new(CvPoint3D32f).empty?)
assert(CvSeq.new(CV_SEQ_ELTYPE_POINT).empty?)
end
def test_aref
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT)
seq1.push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
assert_equal(CvPoint, seq1[0].class)
assert_equal(10, seq1[0].x)
@ -49,8 +65,8 @@ class TestCvSeq < OpenCVTestCase
assert_equal(50, seq1[2].x)
assert_equal(60, seq1[2].y)
seq2 = CvSeq.new(Fixnum).push(10, 20, 30)
seq2 = CvSeq.new(CV_SEQ_ELTYPE_INDEX)
seq2.push(10, 20, 30)
assert_equal(Fixnum, seq2[0].class)
assert_equal(10, seq2[0])
assert_equal(20, seq2[1])
@ -58,7 +74,7 @@ class TestCvSeq < OpenCVTestCase
end
def test_push
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(10, 20), CvPoint.new(30, 40))
assert_equal(2, seq1.total)
assert_equal(CvPoint, seq1[0].class)
@ -68,7 +84,7 @@ class TestCvSeq < OpenCVTestCase
assert_equal(30, seq1[1].x)
assert_equal(40, seq1[1].y)
seq2 = CvSeq.new(CvPoint).push(CvPoint.new(50, 60))
seq2 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(50, 60))
seq2.push(seq1)
assert_equal(3, seq2.total)
assert_equal(CvPoint, seq2[0].class)
@ -81,8 +97,8 @@ class TestCvSeq < OpenCVTestCase
assert_equal(30, seq2[2].x)
assert_equal(40, seq2[2].y)
seq3 = CvSeq.new(Fixnum).push(10)
seq4 = CvSeq.new(Fixnum).push(20, 30)
seq3 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).push(10)
seq4 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).push(20, 30)
seq3.push(seq4)
assert_equal(3, seq3.total)
assert_equal(Fixnum, seq3[0].class)
@ -91,17 +107,17 @@ class TestCvSeq < OpenCVTestCase
assert_equal(30, seq3[2])
assert_raise(TypeError) {
seq1.push(CvPoint2D32f.new(55.5, 66.6))
seq1.push(55.5, 66.6)
}
assert_raise(TypeError) {
seq3 = CvSeq.new(CvPoint2D32f).push(CvPoint2D32f.new(55.5, 66.6))
seq3 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).push(55, 66)
seq1.push(seq3)
}
end
def test_pop
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(10, 20), CvPoint.new(30, 40))
point1 = seq1.pop
assert_equal(CvPoint, point1.class)
assert_equal(30, point1.x)
@ -112,23 +128,23 @@ class TestCvSeq < OpenCVTestCase
assert_equal(10, seq1[0].x)
assert_equal(20, seq1[0].y)
assert_nil(CvSeq.new(CvPoint).pop)
assert_nil(CvSeq.new(CV_SEQ_ELTYPE_POINT).pop)
seq2 = CvSeq.new(Fixnum).push(10, 20, 30)
seq2 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).push(10, 20, 30)
assert_equal(30, seq2.pop)
assert_equal(20, seq2.pop)
assert_equal(10, seq2.pop)
end
def test_clear
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(10, 20), CvPoint.new(30, 40))
seq1.clear
assert_not_nil(seq1)
assert_equal(0, seq1.total)
end
def test_unshift
seq1 = CvSeq.new(CvPoint).unshift(CvPoint.new(10, 20), CvPoint.new(30, 40))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).unshift(CvPoint.new(10, 20), CvPoint.new(30, 40))
assert_equal(2, seq1.total)
assert_equal(CvPoint, seq1[0].class)
@ -138,7 +154,7 @@ class TestCvSeq < OpenCVTestCase
assert_equal(10, seq1[1].x)
assert_equal(20, seq1[1].y)
seq2 = CvSeq.new(CvPoint).unshift(CvPoint.new(50, 60))
seq2 = CvSeq.new(CV_SEQ_ELTYPE_POINT).unshift(CvPoint.new(50, 60))
seq2.unshift(seq1)
assert_equal(3, seq2.total)
assert_equal(CvPoint, seq1[0].class)
@ -151,24 +167,24 @@ class TestCvSeq < OpenCVTestCase
assert_equal(50, seq2[2].x)
assert_equal(60, seq2[2].y)
seq3 = CvSeq.new(Fixnum).unshift(10, 20, 30)
seq3 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).unshift(10, 20, 30)
assert_equal(3, seq3.total)
assert_equal(30, seq3[0])
assert_equal(20, seq3[1])
assert_equal(10, seq3[2])
assert_raise(TypeError) {
seq1.unshift(CvPoint2D32f.new(55.5, 66.6))
seq1.unshift(10)
}
assert_raise(TypeError) {
seq3 = CvSeq.new(CvPoint2D32f).push(CvPoint2D32f.new(55.5, 66.6))
seq3 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).push(10, 20, 30)
seq1.unshift(seq3)
}
end
def test_shift
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(10, 20), CvPoint.new(30, 40))
point1 = seq1.shift
assert_equal(CvPoint, point1.class)
assert_equal(10, point1.x)
@ -179,38 +195,38 @@ class TestCvSeq < OpenCVTestCase
assert_equal(30, seq1[0].x)
assert_equal(40, seq1[0].y)
seq2 = CvSeq.new(Fixnum).push(10, 20, 30)
seq2 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).push(10, 20, 30)
assert_equal(10, seq2.shift)
assert_equal(20, seq2.shift)
assert_equal(30, seq2.shift)
assert_nil(CvSeq.new(CvPoint).shift)
assert_nil(CvSeq.new(CV_SEQ_ELTYPE_POINT).shift)
end
def test_first
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
point1 = seq1.first
assert_equal(CvPoint, point1.class)
assert_equal(10, point1.x)
assert_equal(20, point1.y)
seq2 = CvSeq.new(Fixnum).push(10, 20, 30)
seq2 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).push(10, 20, 30)
assert_equal(10, seq2.first)
end
def test_last
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
point1 = seq1.last
assert_equal(CvPoint, point1.class)
assert_equal(50, point1.x)
assert_equal(60, point1.y)
seq2 = CvSeq.new(Fixnum).push(10, 20, 30)
seq2 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).push(10, 20, 30)
assert_equal(30, seq2.last)
end
def test_each
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
i = 0
seq1.each { |s|
assert_equal(CvPoint, s.class)
@ -220,7 +236,7 @@ class TestCvSeq < OpenCVTestCase
}
assert_equal(3, i)
seq2 = CvSeq.new(Fixnum).push(10, 20, 30)
seq2 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).push(10, 20, 30)
i = 0
seq2.each { |s|
assert_equal(seq2[i], s)
@ -230,7 +246,7 @@ class TestCvSeq < OpenCVTestCase
end
def test_each_index
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
n = 0
seq1.each_index { |i|
assert_equal(n, i)
@ -240,7 +256,7 @@ class TestCvSeq < OpenCVTestCase
end
def test_insert
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(10, 20), CvPoint.new(30, 40))
seq1.insert(1, CvPoint.new(50, 60))
assert_equal(3, seq1.total)
assert_equal(CvPoint, seq1[0].class)
@ -253,7 +269,7 @@ class TestCvSeq < OpenCVTestCase
assert_equal(30, seq1[2].x)
assert_equal(40, seq1[2].y)
seq2 = CvSeq.new(Fixnum).push(10, 20)
seq2 = CvSeq.new(CV_SEQ_ELTYPE_INDEX).push(10, 20)
seq2.insert(1, 15)
assert_equal(3, seq2.total)
assert_equal(10, seq2[0])
@ -262,7 +278,7 @@ class TestCvSeq < OpenCVTestCase
end
def test_remove
seq1 = CvSeq.new(CvPoint).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
seq1 = CvSeq.new(CV_SEQ_ELTYPE_POINT).push(CvPoint.new(10, 20), CvPoint.new(30, 40), CvPoint.new(50, 60))
seq1.remove(1)
assert_equal(2, seq1.total)