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

fixed double free bug of sequences

Browse source
This commit is contained in:
ser1zw 2011-08-04 03:09:30 +09:00
parent 37109f225d
commit 43c67a60cc
8 changed files with 56 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

14
ext/opencv/cvchain.cpp
View file

@ -67,18 +67,8 @@ define_ruby_class()
VALUE
rb_allocate(VALUE klass)
{
CvChain *ptr = ALLOC(CvChain);
return Data_Wrap_Struct(klass, 0, cvchain_free, ptr);
}
void
cvchain_free(void *ptr)
{
if (ptr) {
CvChain *chain = (CvChain*)ptr;
if (chain->storage)
cvReleaseMemStorage(&(chain->storage));
}
CvChain *ptr;
return Data_Make_Struct(klass, CvChain, 0, 0, ptr);
}
VALUE

3
ext/opencv/cvchain.h
View file

@ -11,7 +11,7 @@
#define RUBY_OPENCV_CVCHAIN_H
#include "opencv.h"
#define __NAMESPACE_BEGIN_CVCHAIN namespace cCvChain{
#define __NAMESPACE_BEGIN_CVCHAIN namespace cCvChain {
#define __NAMESPACE_END_CVCHAIN }
__NAMESPACE_BEGIN_OPENCV
@ -22,7 +22,6 @@ VALUE rb_class();
void define_ruby_class();
VALUE rb_allocate(VALUE klass);
void cvchain_free(void *ptr);
VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
VALUE rb_origin(VALUE self);

16
ext/opencv/cvconnectedcomp.cpp
View file

@ -55,25 +55,11 @@ define_ruby_class()
rb_define_method(rb_klass, "contour", RUBY_METHOD_FUNC(rb_contour), 0);
}
void
cvconnectedcomp_free(void *ptr)
{
if (ptr) {
CvConnectedComp* connected_comp = (CvConnectedComp*)ptr;
if (connected_comp->contour) {
CvContour *contour = (CvContour*)connected_comp->contour;
if (contour->storage)
cvReleaseMemStorage(&(contour->storage));
}
free(ptr);
}
}
VALUE
rb_allocate(VALUE klass)
{
CvConnectedComp *ptr;
return Data_Make_Struct(klass, CvConnectedComp, 0, cvconnectedcomp_free, ptr);
return Data_Make_Struct(klass, CvConnectedComp, 0, -1, ptr);
}
VALUE

38
ext/opencv/cvcontour.cpp
View file

@ -80,39 +80,31 @@ define_ruby_class()
VALUE
rb_allocate(VALUE klass)
{
CvContour *ptr = ALLOC(CvContour);
return Data_Wrap_Struct(klass, 0, cvcontour_free, ptr);
}
void
cvcontour_free(void *ptr)
{
if (ptr) {
CvContour *contour = (CvContour*)ptr;
if (contour->storage)
cvReleaseMemStorage(&(contour->storage));
}
CvContour *ptr;
return Data_Make_Struct(klass, CvContour, mark_root_object, unresist_object, ptr);
}
VALUE
rb_initialize(int argc, VALUE *argv, VALUE self)
{
CvMemStorage *storage;
VALUE storage_value;
if (rb_scan_args(argc, argv, "01", &storage_value) > 0) {
storage_value = CHECK_CVMEMSTORAGE(storage_value);
storage = CVMEMSTORAGE(storage_value);
}
else
storage = rb_cvCreateMemStorage(0);
VALUE storage;
rb_scan_args(argc, argv, "01", &storage);
if (NIL_P(storage))
storage = cCvMemStorage::new_object(0);
else
storage = CHECK_CVMEMSTORAGE(storage);
CvContour* contour = (CvContour*)DATA_PTR(self);
try {
DATA_PTR(self) = (CvContour*)cvCreateSeq(CV_SEQ_ELTYPE_POINT, sizeof(CvContour),
sizeof(CvPoint), storage);
contour = (CvContour*)cvCreateSeq(CV_SEQ_ELTYPE_POINT, sizeof(CvContour),
sizeof(CvPoint), CVMEMSTORAGE(storage));
}
catch (cv::Exception& e) {
raise_cverror(e);
}
resist_root_object((CvSeq*)contour, storage);
return self;
}
@ -270,7 +262,6 @@ VALUE
rb_point_polygon_test(VALUE self, VALUE point, VALUE measure_dist)
{
int measure_dist_flag;
double dist;
if (measure_dist == Qtrue)
measure_dist_flag = 1;
@ -279,6 +270,7 @@ rb_point_polygon_test(VALUE self, VALUE point, VALUE measure_dist)
else
measure_dist_flag = NUM2INT(measure_dist);
double dist = Qnil;
try {
dist = cvPointPolygonTest(CVARR(self), VALUE_TO_CVPOINT2D32F(point), measure_dist_flag);
}

2
ext/opencv/cvcontour.h
View file

@ -11,7 +11,7 @@
#define RUBY_OPENCV_CVCONTOUR_H
#include "opencv.h"
#define __NAMESPACE_BEGIN_CVCONTOUR namespace cCvContour{
#define __NAMESPACE_BEGIN_CVCONTOUR namespace cCvContour {
#define __NAMESPACE_END_CVCONTOUR }
__NAMESPACE_BEGIN_OPENCV

6
ext/opencv/cvmemstorage.h
View file

@ -39,10 +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))
else {
if (!NIL_P(object))
rb_warn("invalid CvMemStorage object given. allocate new memory storage automatically.");
return cCvMemStorage::new_object();
}

79
ext/opencv/cvseq.cpp
View file

@ -59,15 +59,24 @@ seqblock_class(void *ptr)
}
void
resist_class_information_of_sequence(CvSeq *seq, VALUE klass)
register_elem_class(CvSeq *seq, VALUE klass)
{
st_insert(seqblock_klass_table, (st_data_t)seq, (st_data_t)klass);
}
void
unregister_elem_class(void *ptr)
{
if (ptr) {
st_delete(seqblock_klass_table, (st_data_t*)&ptr, NULL);
unresist_object(ptr);
}
}
void
define_ruby_class()
{
if(rb_klass)
if (rb_klass)
return;
/*
* opencv = rb_define_module("OpenCV");
@ -111,18 +120,7 @@ VALUE
rb_allocate(VALUE klass)
{
CvSeq *ptr = ALLOC(CvSeq);
return Data_Wrap_Struct(klass, 0, cvseq_free, ptr);
}
void
cvseq_free(void *ptr)
{
if (ptr) {
CvSeq *seq = (CvSeq*)ptr;
st_delete(seqblock_klass_table, (st_data_t*)&ptr, NULL);
if (seq->storage)
cvReleaseMemStorage(&(seq->storage));
}
return Data_Wrap_Struct(klass, 0, unregister_elem_class, ptr);
}
/*
@ -138,15 +136,8 @@ VALUE
rb_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE klass, storage_value;
CvMemStorage *storage;
if (rb_scan_args(argc, argv, "11", &klass, &storage_value) > 1) {
storage_value = CHECK_CVMEMSTORAGE(storage_value);
storage = CVMEMSTORAGE(storage_value);
}
else
storage = rb_cvCreateMemStorage(0);
rb_scan_args(argc, argv, "11", &klass, &storage_value);
if (!rb_obj_is_kind_of(klass, rb_cClass))
raise_typeerror(klass, rb_cClass);
@ -171,14 +162,22 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
rb_raise(rb_eArgError, "unsupport %s class for sequence-block.", rb_class2name(klass));
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, storage);
seq = cvCreateSeq(type, sizeof(CvSeq), size, CVMEMSTORAGE(storage_value));
}
catch (cv::Exception& e) {
raise_cverror(e);
}
DATA_PTR(self) = seq;
resist_class_information_of_sequence(seq, klass);
register_elem_class(seq, klass);
resist_root_object(seq, storage_value);
return self;
}
@ -587,46 +586,20 @@ rb_remove(VALUE self, VALUE index)
return self;
}
/*
VALUE
new_object(CvSeq *seq, VALUE klass)
{
VALUE storage = cCvMemStorage::new_object();
VALUE object = REFER_OBJECT(rb_klass, seq, storage);
st_insert(seqblock_klass, (st_data_t)seq, (st_data_t)klass);
return object;
}
VALUE
new_object(CvSeq *seq, VALUE klass, VALUE storage)
{
VALUE object = REFER_OBJECT(rb_klass, seq, storage);
st_insert(seqblock_klass, (st_data_t)seq, (st_data_t)klass);
return object;
}
*/
void
unresist_cvseq(void *ptr)
{
if (ptr)
st_delete(seqblock_klass_table, (st_data_t*)&ptr, NULL);
}
VALUE
new_sequence(VALUE klass, CvSeq *seq, VALUE element_klass, VALUE storage)
{
resist_root_object(seq, storage);
if (!NIL_P(element_klass))
resist_class_information_of_sequence(seq, element_klass);
return Data_Wrap_Struct(klass, mark_root_object, unresist_cvseq, seq);
register_elem_class(seq, element_klass);
return Data_Wrap_Struct(klass, mark_root_object, unregister_elem_class, seq);
}
VALUE
auto_extend(VALUE object)
{
CvSeq *seq = CVSEQ(object);
if(CV_IS_SEQ_POINT_SET(seq)){
if (CV_IS_SEQ_POINT_SET(seq)) {
rb_extend_object(object, mPointSet::rb_module());
}
return object;

4
ext/opencv/cvseq.h
View file

@ -12,7 +12,7 @@
#include "opencv.h"
#define __NAMESPACE_BEGIN_CVSEQ namespace cCvSeq{
#define __NAMESPACE_BEGIN_CVSEQ namespace cCvSeq {
#define __NAMESPACE_END_CVSEQ }
__NAMESPACE_BEGIN_OPENCV
@ -24,8 +24,6 @@ void define_ruby_class();
VALUE seqblock_class(void *ptr);
VALUE rb_allocate(VALUE klass);
void free(void *ptr);
void resist_class_information_of_sequence(CvSeq *seq, VALUE klass);
VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
VALUE rb_total(VALUE self);