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

changed some functions' name

Browse source
This commit is contained in:
ser1zw 2011-08-12 00:53:48 +09:00
parent 383eaa89bf
commit d72fbd7c2c
4 changed files with 90 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ext/opencv/cvcontour.cpp
View file

@ -81,7 +81,7 @@ VALUE
rb_allocate(VALUE klass) rb_allocate(VALUE klass)
{ {
CvContour *ptr; CvContour *ptr;
return Data_Make_Struct(klass, CvContour, mark_root_object, unresist_object, ptr); return Data_Make_Struct(klass, CvContour, mark_root_object, unregister_object, ptr);
} }
VALUE VALUE
@ -103,7 +103,7 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
catch (cv::Exception& e) { catch (cv::Exception& e) {
raise_cverror(e); raise_cverror(e);
} }
resist_root_object((CvSeq*)contour, storage); register_root_object((CvSeq*)contour, storage);
return self; return self;
} }

6
ext/opencv/cvseq.cpp
View file

@ -69,7 +69,7 @@ unregister_elem_class(void *ptr)
{ {
if (ptr) { if (ptr) {
st_delete(seqblock_klass_table, (st_data_t*)&ptr, NULL); st_delete(seqblock_klass_table, (st_data_t*)&ptr, NULL);
unresist_object(ptr); unregister_object(ptr);
} }
} }
@ -177,7 +177,7 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
} }
DATA_PTR(self) = seq; DATA_PTR(self) = seq;
register_elem_class(seq, klass); register_elem_class(seq, klass);
resist_root_object(seq, storage_value); register_root_object(seq, storage_value);
return self; return self;
} }
@ -589,7 +589,7 @@ rb_remove(VALUE self, VALUE index)
VALUE VALUE
new_sequence(VALUE klass, CvSeq *seq, VALUE element_klass, VALUE storage) new_sequence(VALUE klass, CvSeq *seq, VALUE element_klass, VALUE storage)
{ {
resist_root_object(seq, storage); register_root_object(seq, storage);
if (!NIL_P(element_klass)) if (!NIL_P(element_klass))
register_elem_class(seq, element_klass); register_elem_class(seq, element_klass);
return Data_Wrap_Struct(klass, mark_root_object, unregister_elem_class, seq); return Data_Wrap_Struct(klass, mark_root_object, unregister_elem_class, seq);

154
ext/opencv/opencv.cpp
View file

@ -76,10 +76,10 @@ lookup_root_object(void *ptr)
} }
/* /*
* Resist root object. * Register root object.
*/ */
void void
resist_root_object(void *ptr, VALUE root) register_root_object(void *ptr, VALUE root)
{ {
st_insert(root_table, (st_data_t)ptr, (st_data_t)root); st_insert(root_table, (st_data_t)ptr, (st_data_t)root);
} }
@ -88,7 +88,7 @@ resist_root_object(void *ptr, VALUE root)
* Delete mark symbol from hashtable only, not free memory. * Delete mark symbol from hashtable only, not free memory.
*/ */
void void
unresist_object(void *ptr) unregister_object(void *ptr)
{ {
st_delete(root_table, (st_data_t*)&ptr, 0); st_delete(root_table, (st_data_t*)&ptr, 0);
} }
@ -100,7 +100,7 @@ void
free_object(void *ptr) free_object(void *ptr)
{ {
if (ptr) { if (ptr) {
unresist_object(ptr); unregister_object(ptr);
cvFree(&ptr); cvFree(&ptr);
} }
} }
@ -112,7 +112,7 @@ void
release_object(void *ptr) release_object(void *ptr)
{ {
if (ptr) { if (ptr) {
unresist_object(ptr); unregister_object(ptr);
cvRelease(&ptr); cvRelease(&ptr);
} }
} }
@ -124,7 +124,7 @@ void
release_iplconvkernel_object(void *ptr) release_iplconvkernel_object(void *ptr)
{ {
if (ptr) { if (ptr) {
unresist_object(ptr); unregister_object(ptr);
cvReleaseStructuringElement((IplConvKernel**)(&ptr)); cvReleaseStructuringElement((IplConvKernel**)(&ptr));
} }
} }
@ -256,145 +256,145 @@ define_ruby_module()
VALUE inversion_method = rb_hash_new(); VALUE inversion_method = rb_hash_new();
/* {:lu, :svd, :svd_sym(:svd_symmetric)}: Inversion method */ /* {:lu, :svd, :svd_sym(:svd_symmetric)}: Inversion method */
rb_define_const(rb_module, "INVERSION_METHOD", inversion_method); rb_define_const(rb_module, "INVERSION_METHOD", inversion_method);
RESIST_CVMETHOD(inversion_method, "lu", CV_LU); REGISTER_CVMETHOD(inversion_method, "lu", CV_LU);
RESIST_CVMETHOD(inversion_method, "svd", CV_SVD); REGISTER_CVMETHOD(inversion_method, "svd", CV_SVD);
RESIST_CVMETHOD(inversion_method, "svd_sym", CV_SVD_SYM); REGISTER_CVMETHOD(inversion_method, "svd_sym", CV_SVD_SYM);
RESIST_CVMETHOD(inversion_method, "svd_symmetric", CV_SVD_SYM); REGISTER_CVMETHOD(inversion_method, "svd_symmetric", CV_SVD_SYM);
VALUE dxt_flag = rb_hash_new(); VALUE dxt_flag = rb_hash_new();
/* {:forward, :inverse, :scale, :rows}: DFT and DCT flags */ /* {:forward, :inverse, :scale, :rows}: DFT and DCT flags */
rb_define_const(rb_module, "DXT_FLAG", dxt_flag); rb_define_const(rb_module, "DXT_FLAG", dxt_flag);
RESIST_CVMETHOD(dxt_flag, "forward", CV_DXT_FORWARD); REGISTER_CVMETHOD(dxt_flag, "forward", CV_DXT_FORWARD);
RESIST_CVMETHOD(dxt_flag, "inverse", CV_DXT_INVERSE); REGISTER_CVMETHOD(dxt_flag, "inverse", CV_DXT_INVERSE);
RESIST_CVMETHOD(dxt_flag, "scale", CV_DXT_SCALE); REGISTER_CVMETHOD(dxt_flag, "scale", CV_DXT_SCALE);
RESIST_CVMETHOD(dxt_flag, "rows", CV_DXT_ROWS); REGISTER_CVMETHOD(dxt_flag, "rows", CV_DXT_ROWS);
VALUE interpolation_method = rb_hash_new(); VALUE interpolation_method = rb_hash_new();
/* {:nn, :linear, :area, :cubic}: Interpolation method */ /* {:nn, :linear, :area, :cubic}: Interpolation method */
rb_define_const(rb_module, "INTERPOLATION_METHOD", interpolation_method); rb_define_const(rb_module, "INTERPOLATION_METHOD", interpolation_method);
RESIST_CVMETHOD(interpolation_method, "nn", CV_INTER_NN); REGISTER_CVMETHOD(interpolation_method, "nn", CV_INTER_NN);
RESIST_CVMETHOD(interpolation_method, "linear", CV_INTER_LINEAR); REGISTER_CVMETHOD(interpolation_method, "linear", CV_INTER_LINEAR);
RESIST_CVMETHOD(interpolation_method, "area", CV_INTER_AREA); REGISTER_CVMETHOD(interpolation_method, "area", CV_INTER_AREA);
RESIST_CVMETHOD(interpolation_method, "cubic", CV_INTER_CUBIC); REGISTER_CVMETHOD(interpolation_method, "cubic", CV_INTER_CUBIC);
VALUE warp_flag = rb_hash_new(); VALUE warp_flag = rb_hash_new();
/* {:fill_outliers, :inverse_map}: Warp affine optional flags */ /* {:fill_outliers, :inverse_map}: Warp affine optional flags */
rb_define_const(rb_module, "WARP_FLAG", warp_flag); rb_define_const(rb_module, "WARP_FLAG", warp_flag);
RESIST_CVMETHOD(warp_flag, "fill_outliers", CV_WARP_FILL_OUTLIERS); REGISTER_CVMETHOD(warp_flag, "fill_outliers", CV_WARP_FILL_OUTLIERS);
RESIST_CVMETHOD(warp_flag, "inverse_map", CV_WARP_INVERSE_MAP); REGISTER_CVMETHOD(warp_flag, "inverse_map", CV_WARP_INVERSE_MAP);
VALUE homography_calc_method = rb_hash_new(); VALUE homography_calc_method = rb_hash_new();
/* {:all, :ransac, :lmeds}: Methods used to computed homography matrix */ /* {:all, :ransac, :lmeds}: Methods used to computed homography matrix */
rb_define_const(rb_module, "HOMOGRAPHY_CALC_METHOD", homography_calc_method); rb_define_const(rb_module, "HOMOGRAPHY_CALC_METHOD", homography_calc_method);
RESIST_CVMETHOD(homography_calc_method, "all", 0); REGISTER_CVMETHOD(homography_calc_method, "all", 0);
RESIST_CVMETHOD(homography_calc_method, "ransac", CV_RANSAC); REGISTER_CVMETHOD(homography_calc_method, "ransac", CV_RANSAC);
RESIST_CVMETHOD(homography_calc_method, "lmeds", CV_LMEDS); REGISTER_CVMETHOD(homography_calc_method, "lmeds", CV_LMEDS);
VALUE depth = rb_hash_new(); VALUE depth = rb_hash_new();
/* {:cv8u, :cv8s, :cv16u, :cv16s, :cv32s, :cv32f, :cv64f}: Depth of each pixel. */ /* {:cv8u, :cv8s, :cv16u, :cv16s, :cv32s, :cv32f, :cv64f}: Depth of each pixel. */
rb_define_const(rb_module, "DEPTH", depth); rb_define_const(rb_module, "DEPTH", depth);
RESIST_CVMETHOD(depth, "cv8u", CV_8U); REGISTER_CVMETHOD(depth, "cv8u", CV_8U);
RESIST_CVMETHOD(depth, "cv8s", CV_8S); REGISTER_CVMETHOD(depth, "cv8s", CV_8S);
RESIST_CVMETHOD(depth, "cv16u", CV_16U); REGISTER_CVMETHOD(depth, "cv16u", CV_16U);
RESIST_CVMETHOD(depth, "cv16s", CV_16S); REGISTER_CVMETHOD(depth, "cv16s", CV_16S);
RESIST_CVMETHOD(depth, "cv32s", CV_32S); REGISTER_CVMETHOD(depth, "cv32s", CV_32S);
RESIST_CVMETHOD(depth, "cv32f", CV_32F); REGISTER_CVMETHOD(depth, "cv32f", CV_32F);
RESIST_CVMETHOD(depth, "cv64f", CV_64F); REGISTER_CVMETHOD(depth, "cv64f", CV_64F);
VALUE connectivity = rb_hash_new(); VALUE connectivity = rb_hash_new();
/* {:aa(:anti_alias)}: Determined by the closeness of pixel values */ /* {:aa(:anti_alias)}: Determined by the closeness of pixel values */
rb_define_const(rb_module, "CONNECTIVITY", connectivity); rb_define_const(rb_module, "CONNECTIVITY", connectivity);
RESIST_CVMETHOD(connectivity, "aa", CV_AA); REGISTER_CVMETHOD(connectivity, "aa", CV_AA);
RESIST_CVMETHOD(connectivity, "anti_alias", CV_AA); REGISTER_CVMETHOD(connectivity, "anti_alias", CV_AA);
VALUE structuring_element_shape = rb_hash_new(); VALUE structuring_element_shape = rb_hash_new();
/* {:rect, :cross, :ellipse, :custom}: Shape of the structuring elements */ /* {:rect, :cross, :ellipse, :custom}: Shape of the structuring elements */
rb_define_const(rb_module, "STRUCTURING_ELEMENT_SHAPE", structuring_element_shape); rb_define_const(rb_module, "STRUCTURING_ELEMENT_SHAPE", structuring_element_shape);
RESIST_CVMETHOD(structuring_element_shape, "rect", CV_SHAPE_RECT); REGISTER_CVMETHOD(structuring_element_shape, "rect", CV_SHAPE_RECT);
RESIST_CVMETHOD(structuring_element_shape, "cross", CV_SHAPE_CROSS); REGISTER_CVMETHOD(structuring_element_shape, "cross", CV_SHAPE_CROSS);
RESIST_CVMETHOD(structuring_element_shape, "ellipse", CV_SHAPE_ELLIPSE); REGISTER_CVMETHOD(structuring_element_shape, "ellipse", CV_SHAPE_ELLIPSE);
RESIST_CVMETHOD(structuring_element_shape, "custom", CV_SHAPE_CUSTOM); REGISTER_CVMETHOD(structuring_element_shape, "custom", CV_SHAPE_CUSTOM);
VALUE retrieval_mode = rb_hash_new(); VALUE retrieval_mode = rb_hash_new();
/* {:external, :list, :ccomp, :tree}: Retrieval mode */ /* {:external, :list, :ccomp, :tree}: Retrieval mode */
rb_define_const(rb_module, "RETRIEVAL_MODE", retrieval_mode); rb_define_const(rb_module, "RETRIEVAL_MODE", retrieval_mode);
RESIST_CVMETHOD(retrieval_mode, "external", CV_RETR_EXTERNAL); REGISTER_CVMETHOD(retrieval_mode, "external", CV_RETR_EXTERNAL);
RESIST_CVMETHOD(retrieval_mode, "list", CV_RETR_LIST); REGISTER_CVMETHOD(retrieval_mode, "list", CV_RETR_LIST);
RESIST_CVMETHOD(retrieval_mode, "ccomp", CV_RETR_CCOMP); REGISTER_CVMETHOD(retrieval_mode, "ccomp", CV_RETR_CCOMP);
RESIST_CVMETHOD(retrieval_mode, "tree", CV_RETR_TREE); REGISTER_CVMETHOD(retrieval_mode, "tree", CV_RETR_TREE);
VALUE approx_chain_method = rb_hash_new(); VALUE approx_chain_method = rb_hash_new();
/* {:code, :approx_none, :approx_simple, :apporx_tc89_11, :approx_tc89_kcos}: Approximation method */ /* {:code, :approx_none, :approx_simple, :apporx_tc89_11, :approx_tc89_kcos}: Approximation method */
rb_define_const(rb_module, "APPROX_CHAIN_METHOD", approx_chain_method); rb_define_const(rb_module, "APPROX_CHAIN_METHOD", approx_chain_method);
RESIST_CVMETHOD(approx_chain_method, "code", CV_CHAIN_CODE); REGISTER_CVMETHOD(approx_chain_method, "code", CV_CHAIN_CODE);
RESIST_CVMETHOD(approx_chain_method, "approx_none", CV_CHAIN_APPROX_NONE); REGISTER_CVMETHOD(approx_chain_method, "approx_none", CV_CHAIN_APPROX_NONE);
RESIST_CVMETHOD(approx_chain_method, "approx_simple", CV_CHAIN_APPROX_SIMPLE); REGISTER_CVMETHOD(approx_chain_method, "approx_simple", CV_CHAIN_APPROX_SIMPLE);
RESIST_CVMETHOD(approx_chain_method, "approx_tc89_l1", CV_CHAIN_APPROX_TC89_L1); REGISTER_CVMETHOD(approx_chain_method, "approx_tc89_l1", CV_CHAIN_APPROX_TC89_L1);
RESIST_CVMETHOD(approx_chain_method, "approx_tc89_kcos", CV_CHAIN_APPROX_TC89_KCOS); REGISTER_CVMETHOD(approx_chain_method, "approx_tc89_kcos", CV_CHAIN_APPROX_TC89_KCOS);
VALUE approx_poly_method = rb_hash_new(); VALUE approx_poly_method = rb_hash_new();
/* {:dp}: Approximation method (polygon) */ /* {:dp}: Approximation method (polygon) */
rb_define_const(rb_module, "APPROX_POLY_METHOD", approx_poly_method); rb_define_const(rb_module, "APPROX_POLY_METHOD", approx_poly_method);
RESIST_CVMETHOD(approx_poly_method, "dp", CV_POLY_APPROX_DP); REGISTER_CVMETHOD(approx_poly_method, "dp", CV_POLY_APPROX_DP);
VALUE match_template_method = rb_hash_new(); VALUE match_template_method = rb_hash_new();
/* {:sqdiff, :sqdiff_normed, :ccorr, :ccorr_normed, :ccoeff, :ccoeff_normed}: Match template method */ /* {:sqdiff, :sqdiff_normed, :ccorr, :ccorr_normed, :ccoeff, :ccoeff_normed}: Match template method */
rb_define_const(rb_module, "MATCH_TEMPLATE_METHOD", match_template_method); rb_define_const(rb_module, "MATCH_TEMPLATE_METHOD", match_template_method);
RESIST_CVMETHOD(match_template_method, "sqdiff", CV_TM_SQDIFF); REGISTER_CVMETHOD(match_template_method, "sqdiff", CV_TM_SQDIFF);
RESIST_CVMETHOD(match_template_method, "sqdiff_normed", CV_TM_SQDIFF_NORMED); REGISTER_CVMETHOD(match_template_method, "sqdiff_normed", CV_TM_SQDIFF_NORMED);
RESIST_CVMETHOD(match_template_method, "ccorr", CV_TM_CCORR); REGISTER_CVMETHOD(match_template_method, "ccorr", CV_TM_CCORR);
RESIST_CVMETHOD(match_template_method, "ccorr_normed", CV_TM_CCORR_NORMED); REGISTER_CVMETHOD(match_template_method, "ccorr_normed", CV_TM_CCORR_NORMED);
RESIST_CVMETHOD(match_template_method, "ccoeff", CV_TM_CCOEFF); REGISTER_CVMETHOD(match_template_method, "ccoeff", CV_TM_CCOEFF);
RESIST_CVMETHOD(match_template_method, "ccoeff_normed", CV_TM_CCOEFF_NORMED); REGISTER_CVMETHOD(match_template_method, "ccoeff_normed", CV_TM_CCOEFF_NORMED);
VALUE morphological_operation = rb_hash_new(); VALUE morphological_operation = rb_hash_new();
/* {:open, :close, :gradient, :tophat, :blackhat}: Types of morphological operations */ /* {:open, :close, :gradient, :tophat, :blackhat}: Types of morphological operations */
rb_define_const(rb_module, "MORPHOLOGICAL_OPERATION", morphological_operation); rb_define_const(rb_module, "MORPHOLOGICAL_OPERATION", morphological_operation);
RESIST_CVMETHOD(morphological_operation, "open", CV_MOP_OPEN); REGISTER_CVMETHOD(morphological_operation, "open", CV_MOP_OPEN);
RESIST_CVMETHOD(morphological_operation, "close", CV_MOP_CLOSE); REGISTER_CVMETHOD(morphological_operation, "close", CV_MOP_CLOSE);
RESIST_CVMETHOD(morphological_operation, "gradient", CV_MOP_GRADIENT); REGISTER_CVMETHOD(morphological_operation, "gradient", CV_MOP_GRADIENT);
RESIST_CVMETHOD(morphological_operation, "tophat", CV_MOP_TOPHAT); REGISTER_CVMETHOD(morphological_operation, "tophat", CV_MOP_TOPHAT);
RESIST_CVMETHOD(morphological_operation, "blackhat", CV_MOP_BLACKHAT); REGISTER_CVMETHOD(morphological_operation, "blackhat", CV_MOP_BLACKHAT);
VALUE smoothing_type = rb_hash_new(); VALUE smoothing_type = rb_hash_new();
/* {:blur_no_scale, :blur, :gaussian, :median, :bilateral}: Types of smoothing */ /* {:blur_no_scale, :blur, :gaussian, :median, :bilateral}: Types of smoothing */
rb_define_const(rb_module, "SMOOTHING_TYPE", smoothing_type); rb_define_const(rb_module, "SMOOTHING_TYPE", smoothing_type);
RESIST_CVMETHOD(smoothing_type, "blur_no_scale", CV_BLUR_NO_SCALE); REGISTER_CVMETHOD(smoothing_type, "blur_no_scale", CV_BLUR_NO_SCALE);
RESIST_CVMETHOD(smoothing_type, "blur", CV_BLUR); REGISTER_CVMETHOD(smoothing_type, "blur", CV_BLUR);
RESIST_CVMETHOD(smoothing_type, "gaussian", CV_GAUSSIAN); REGISTER_CVMETHOD(smoothing_type, "gaussian", CV_GAUSSIAN);
RESIST_CVMETHOD(smoothing_type, "median", CV_MEDIAN); REGISTER_CVMETHOD(smoothing_type, "median", CV_MEDIAN);
RESIST_CVMETHOD(smoothing_type, "bilateral", CV_BILATERAL); REGISTER_CVMETHOD(smoothing_type, "bilateral", CV_BILATERAL);
VALUE threshold_type = rb_hash_new(); VALUE threshold_type = rb_hash_new();
/* {:binary, :binary_inv, :trunc, :tozero, :tozero_inv, :otsu} : Thresholding types */ /* {:binary, :binary_inv, :trunc, :tozero, :tozero_inv, :otsu} : Thresholding types */
rb_define_const(rb_module, "THRESHOLD_TYPE", threshold_type); rb_define_const(rb_module, "THRESHOLD_TYPE", threshold_type);
RESIST_CVMETHOD(threshold_type, "binary", CV_THRESH_BINARY); REGISTER_CVMETHOD(threshold_type, "binary", CV_THRESH_BINARY);
RESIST_CVMETHOD(threshold_type, "binary_inv", CV_THRESH_BINARY_INV); REGISTER_CVMETHOD(threshold_type, "binary_inv", CV_THRESH_BINARY_INV);
RESIST_CVMETHOD(threshold_type, "trunc", CV_THRESH_TRUNC); REGISTER_CVMETHOD(threshold_type, "trunc", CV_THRESH_TRUNC);
RESIST_CVMETHOD(threshold_type, "tozero", CV_THRESH_TOZERO); REGISTER_CVMETHOD(threshold_type, "tozero", CV_THRESH_TOZERO);
RESIST_CVMETHOD(threshold_type, "tozero_inv", CV_THRESH_TOZERO_INV); REGISTER_CVMETHOD(threshold_type, "tozero_inv", CV_THRESH_TOZERO_INV);
RESIST_CVMETHOD(threshold_type, "otsu", CV_THRESH_OTSU); REGISTER_CVMETHOD(threshold_type, "otsu", CV_THRESH_OTSU);
VALUE hough_transform_method = rb_hash_new(); VALUE hough_transform_method = rb_hash_new();
/* {:standard, :probabilistic, :multi_scale} : Hough transform method */ /* {:standard, :probabilistic, :multi_scale} : Hough transform method */
rb_define_const(rb_module, "HOUGH_TRANSFORM_METHOD", hough_transform_method); rb_define_const(rb_module, "HOUGH_TRANSFORM_METHOD", hough_transform_method);
RESIST_CVMETHOD(hough_transform_method, "standard", CV_HOUGH_STANDARD); REGISTER_CVMETHOD(hough_transform_method, "standard", CV_HOUGH_STANDARD);
RESIST_CVMETHOD(hough_transform_method, "probabilistic", CV_HOUGH_PROBABILISTIC); REGISTER_CVMETHOD(hough_transform_method, "probabilistic", CV_HOUGH_PROBABILISTIC);
RESIST_CVMETHOD(hough_transform_method, "multi_scale", CV_HOUGH_MULTI_SCALE); REGISTER_CVMETHOD(hough_transform_method, "multi_scale", CV_HOUGH_MULTI_SCALE);
RESIST_CVMETHOD(hough_transform_method, "gradient", CV_HOUGH_GRADIENT); REGISTER_CVMETHOD(hough_transform_method, "gradient", CV_HOUGH_GRADIENT);
VALUE inpaint_method = rb_hash_new(); VALUE inpaint_method = rb_hash_new();
/* {:ns, :telea} : Inpaint method */ /* {:ns, :telea} : Inpaint method */
rb_define_const(rb_module, "INPAINT_METHOD", inpaint_method); rb_define_const(rb_module, "INPAINT_METHOD", inpaint_method);
RESIST_CVMETHOD(inpaint_method, "ns", CV_INPAINT_NS); REGISTER_CVMETHOD(inpaint_method, "ns", CV_INPAINT_NS);
RESIST_CVMETHOD(inpaint_method, "telea", CV_INPAINT_TELEA); REGISTER_CVMETHOD(inpaint_method, "telea", CV_INPAINT_TELEA);
VALUE comparison_method = rb_hash_new(); VALUE comparison_method = rb_hash_new();
/* Comparison method */ /* Comparison method */
rb_define_const(rb_module, "COMPARISON_METHOD", comparison_method); rb_define_const(rb_module, "COMPARISON_METHOD", comparison_method);
RESIST_CVMETHOD(comparison_method, "i1", CV_CONTOURS_MATCH_I1); REGISTER_CVMETHOD(comparison_method, "i1", CV_CONTOURS_MATCH_I1);
RESIST_CVMETHOD(comparison_method, "i2", CV_CONTOURS_MATCH_I2); REGISTER_CVMETHOD(comparison_method, "i2", CV_CONTOURS_MATCH_I2);
RESIST_CVMETHOD(comparison_method, "i3", CV_CONTOURS_MATCH_I3); REGISTER_CVMETHOD(comparison_method, "i3", CV_CONTOURS_MATCH_I3);
/* color convert methods */ /* color convert methods */
rb_define_module_function(rb_module, "BGR2BGRA", RUBY_METHOD_FUNC(rb_BGR2BGRA), 1); rb_define_module_function(rb_module, "BGR2BGRA", RUBY_METHOD_FUNC(rb_BGR2BGRA), 1);

12
ext/opencv/opencv.h
View file

@ -148,7 +148,7 @@ extern "C"{
#define IF_DEPTH(val, ifnone) NIL_P(val) ? ifnone : NUM2INT(val) #define IF_DEPTH(val, ifnone) NIL_P(val) ? ifnone : NUM2INT(val)
#define RESIST_CVMETHOD(hash, str, value) rb_hash_aset(hash, ID2SYM(rb_intern(str)), INT2FIX(value)) #define REGISTER_CVMETHOD(hash, str, value) rb_hash_aset(hash, ID2SYM(rb_intern(str)), INT2FIX(value))
#define LOOKUP_CVMETHOD(hash, key_as_cstr) (rb_hash_lookup(hash, ID2SYM(rb_intern(key_as_cstr)))) #define LOOKUP_CVMETHOD(hash, key_as_cstr) (rb_hash_lookup(hash, ID2SYM(rb_intern(key_as_cstr))))
#define maxint(a,b) ({int _a = (a), _b = (b); _a > _b ? _a : _b; }) #define maxint(a,b) ({int _a = (a), _b = (b); _a > _b ? _a : _b; })
@ -188,8 +188,8 @@ __NAMESPACE_BEGIN_OPENCV
void mark_root_object(void *ptr); void mark_root_object(void *ptr);
VALUE lookup_root_object(void *ptr); VALUE lookup_root_object(void *ptr);
void resist_root_object(void *ptr, VALUE root); void register_root_object(void *ptr, VALUE root);
void unresist_object(void *ptr); void unregister_object(void *ptr);
void free_object(void *ptr); void free_object(void *ptr);
void release_object(void *ptr); void release_object(void *ptr);
void release_iplconvkernel_object(void *ptr); void release_iplconvkernel_object(void *ptr);
@ -227,15 +227,15 @@ GENERIC_OBJECT(VALUE klass, void *ptr)
inline VALUE inline VALUE
DEPEND_OBJECT(VALUE klass, void *ptr, VALUE root) DEPEND_OBJECT(VALUE klass, void *ptr, VALUE root)
{ {
resist_root_object(ptr, root); register_root_object(ptr, root);
return Data_Wrap_Struct(klass, mark_root_object, free_object, ptr); return Data_Wrap_Struct(klass, mark_root_object, free_object, ptr);
} }
inline VALUE inline VALUE
REFER_OBJECT(VALUE klass, void *ptr, VALUE root) REFER_OBJECT(VALUE klass, void *ptr, VALUE root)
{ {
resist_root_object(ptr, root); register_root_object(ptr, root);
return Data_Wrap_Struct(klass, mark_root_object, unresist_object, ptr); return Data_Wrap_Struct(klass, mark_root_object, unregister_object, ptr);
} }
inline VALUE inline VALUE