mirror of
https://github.com/ruby-opencv/ruby-opencv
synced 2023-03-27 23:22:12 -04:00
change utility functions' name
REGISTER_CVMETHOD -> REGISTER_HASH LOOKUP_CVMETHOD -> LOOKUP_HASH
This commit is contained in:
ser1zw
parent
c0bff63c92
commit
79f0bef6b3
8 changed files with 115 additions and 115 deletions
|
|
@ -18,10 +18,10 @@ __NAMESPACE_BEGIN_OPENCV
|
|||
__NAMESPACE_BEGIN_CVCHAIN
|
||||
|
||||
#define APPROX_CHAIN_OPTION(op) rb_get_option_table(rb_klass, "APPROX_CHAIN_OPTION", op)
|
||||
#define APPROX_CHAIN_METHOD(op) CVMETHOD("APPROX_CHAIN_METHOD", LOOKUP_CVMETHOD(op, "method"), CV_CHAIN_APPROX_SIMPLE)
|
||||
#define APPROX_CHAIN_PARAMETER(op) NUM2INT(LOOKUP_CVMETHOD(op, "parameter"))
|
||||
#define APPROX_CHAIN_MINIMAL_PERIMETER(op) NUM2INT(LOOKUP_CVMETHOD(op, "minimal_perimeter"))
|
||||
#define APPROX_CHAIN_RECURSIVE(op) TRUE_OR_FALSE(LOOKUP_CVMETHOD(op, "recursive"))
|
||||
#define APPROX_CHAIN_METHOD(op) CVMETHOD("APPROX_CHAIN_METHOD", LOOKUP_HASH(op, "method"), CV_CHAIN_APPROX_SIMPLE)
|
||||
#define APPROX_CHAIN_PARAMETER(op) NUM2INT(LOOKUP_HASH(op, "parameter"))
|
||||
#define APPROX_CHAIN_MINIMAL_PERIMETER(op) NUM2INT(LOOKUP_HASH(op, "minimal_perimeter"))
|
||||
#define APPROX_CHAIN_RECURSIVE(op) TRUE_OR_FALSE(LOOKUP_HASH(op, "recursive"))
|
||||
|
||||
VALUE rb_klass;
|
||||
|
||||
|
|
|
|||
|
|
@ -18,9 +18,9 @@ __NAMESPACE_BEGIN_OPENCV
|
|||
__NAMESPACE_BEGIN_CVCONTOUR
|
||||
|
||||
#define APPROX_POLY_OPTION(op) rb_get_option_table(rb_klass, "APPROX_OPTION", op)
|
||||
#define APPROX_POLY_METHOD(op) CVMETHOD("APPROX_POLY_METHOD", LOOKUP_CVMETHOD(op, "method"), CV_POLY_APPROX_DP)
|
||||
#define APPROX_POLY_ACCURACY(op) NUM2DBL(LOOKUP_CVMETHOD(op, "accuracy"))
|
||||
#define APPROX_POLY_RECURSIVE(op) TRUE_OR_FALSE(LOOKUP_CVMETHOD(op, "recursive"))
|
||||
#define APPROX_POLY_METHOD(op) CVMETHOD("APPROX_POLY_METHOD", LOOKUP_HASH(op, "method"), CV_POLY_APPROX_DP)
|
||||
#define APPROX_POLY_ACCURACY(op) NUM2DBL(LOOKUP_HASH(op, "accuracy"))
|
||||
#define APPROX_POLY_RECURSIVE(op) TRUE_OR_FALSE(LOOKUP_HASH(op, "recursive"))
|
||||
|
||||
VALUE rb_allocate(VALUE klass);
|
||||
void cvcontour_free(void *ptr);
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ VALUE rb_klass;
|
|||
int
|
||||
rb_font_option_line_type(VALUE font_option)
|
||||
{
|
||||
VALUE line_type = LOOKUP_CVMETHOD(font_option, "line_type");
|
||||
VALUE line_type = LOOKUP_HASH(font_option, "line_type");
|
||||
if (FIXNUM_P(line_type)) {
|
||||
return FIX2INT(line_type);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,11 +19,11 @@ __NAMESPACE_BEGIN_OPENCV
|
|||
__NAMESPACE_BEGIN_CVFONT
|
||||
|
||||
#define FONT_OPTION(op) rb_get_option_table(rb_klass, "FONT_OPTION", op)
|
||||
#define FO_ITALIC(op) TRUE_OR_FALSE(LOOKUP_CVMETHOD(op, "italic"))
|
||||
#define FO_HSCALE(op) NUM2DBL(LOOKUP_CVMETHOD(op, "hscale"))
|
||||
#define FO_VSCALE(op) NUM2DBL(LOOKUP_CVMETHOD(op, "vscale"))
|
||||
#define FO_SHEAR(op) NUM2DBL(LOOKUP_CVMETHOD(op, "shear"))
|
||||
#define FO_THICKNESS(op) NUM2INT(LOOKUP_CVMETHOD(op, "thickness"))
|
||||
#define FO_ITALIC(op) TRUE_OR_FALSE(LOOKUP_HASH(op, "italic"))
|
||||
#define FO_HSCALE(op) NUM2DBL(LOOKUP_HASH(op, "hscale"))
|
||||
#define FO_VSCALE(op) NUM2DBL(LOOKUP_HASH(op, "vscale"))
|
||||
#define FO_SHEAR(op) NUM2DBL(LOOKUP_HASH(op, "shear"))
|
||||
#define FO_THICKNESS(op) NUM2INT(LOOKUP_HASH(op, "thickness"))
|
||||
#define FO_LINE_TYPE(op) rb_font_option_line_type(op)
|
||||
|
||||
VALUE rb_class();
|
||||
|
|
|
|||
|
|
@ -138,14 +138,14 @@ rb_detect_objects(int argc, VALUE *argv, VALUE self)
|
|||
storage_val = cCvMemStorage::new_object();
|
||||
}
|
||||
else {
|
||||
scale_factor = IF_DBL(LOOKUP_CVMETHOD(options, "scale_factor"), 1.1);
|
||||
flags = IF_INT(LOOKUP_CVMETHOD(options, "flags"), 0);
|
||||
min_neighbors = IF_INT(LOOKUP_CVMETHOD(options, "min_neighbors"), 3);
|
||||
VALUE min_size_val = LOOKUP_CVMETHOD(options, "min_size");
|
||||
scale_factor = IF_DBL(LOOKUP_HASH(options, "scale_factor"), 1.1);
|
||||
flags = IF_INT(LOOKUP_HASH(options, "flags"), 0);
|
||||
min_neighbors = IF_INT(LOOKUP_HASH(options, "min_neighbors"), 3);
|
||||
VALUE min_size_val = LOOKUP_HASH(options, "min_size");
|
||||
min_size = NIL_P(min_size_val) ? cvSize(0, 0) : VALUE_TO_CVSIZE(min_size_val);
|
||||
VALUE max_size_val = LOOKUP_CVMETHOD(options, "max_size");
|
||||
VALUE max_size_val = LOOKUP_HASH(options, "max_size");
|
||||
max_size = NIL_P(max_size_val) ? cvSize(0, 0) : VALUE_TO_CVSIZE(max_size_val);
|
||||
storage_val = CHECK_CVMEMSTORAGE(LOOKUP_CVMETHOD(options, "storage"));
|
||||
storage_val = CHECK_CVMEMSTORAGE(LOOKUP_HASH(options, "storage"));
|
||||
}
|
||||
|
||||
VALUE result = Qnil;
|
||||
|
|
|
|||
|
|
@ -46,49 +46,49 @@ __NAMESPACE_BEGIN_OPENCV
|
|||
__NAMESPACE_BEGIN_CVMAT
|
||||
|
||||
#define DRAWING_OPTION(opt) rb_get_option_table(rb_klass, "DRAWING_OPTION", opt)
|
||||
#define DO_COLOR(opt) VALUE_TO_CVSCALAR(LOOKUP_CVMETHOD(opt, "color"))
|
||||
#define DO_THICKNESS(opt) NUM2INT(LOOKUP_CVMETHOD(opt, "thickness"))
|
||||
#define DO_COLOR(opt) VALUE_TO_CVSCALAR(LOOKUP_HASH(opt, "color"))
|
||||
#define DO_THICKNESS(opt) NUM2INT(LOOKUP_HASH(opt, "thickness"))
|
||||
#define DO_LINE_TYPE(opt) rb_drawing_option_line_type(opt)
|
||||
#define DO_SHIFT(opt) NUM2INT(LOOKUP_CVMETHOD(opt, "shift"))
|
||||
#define DO_IS_CLOSED(opt) TRUE_OR_FALSE(LOOKUP_CVMETHOD(opt, "is_closed"))
|
||||
#define DO_SHIFT(opt) NUM2INT(LOOKUP_HASH(opt, "shift"))
|
||||
#define DO_IS_CLOSED(opt) TRUE_OR_FALSE(LOOKUP_HASH(opt, "is_closed"))
|
||||
|
||||
#define GOOD_FEATURES_TO_TRACK_OPTION(opt) rb_get_option_table(rb_klass, "GOOD_FEATURES_TO_TRACK_OPTION", opt)
|
||||
#define GF_MAX(opt) NUM2INT(LOOKUP_CVMETHOD(opt, "max"))
|
||||
#define GF_MASK(opt) MASK(LOOKUP_CVMETHOD(opt, "mask"))
|
||||
#define GF_BLOCK_SIZE(opt) NUM2INT(LOOKUP_CVMETHOD(opt, "block_size"))
|
||||
#define GF_USE_HARRIS(opt) TRUE_OR_FALSE(LOOKUP_CVMETHOD(opt, "use_harris"))
|
||||
#define GF_K(opt) NUM2DBL(LOOKUP_CVMETHOD(opt, "k"))
|
||||
#define GF_MAX(opt) NUM2INT(LOOKUP_HASH(opt, "max"))
|
||||
#define GF_MASK(opt) MASK(LOOKUP_HASH(opt, "mask"))
|
||||
#define GF_BLOCK_SIZE(opt) NUM2INT(LOOKUP_HASH(opt, "block_size"))
|
||||
#define GF_USE_HARRIS(opt) TRUE_OR_FALSE(LOOKUP_HASH(opt, "use_harris"))
|
||||
#define GF_K(opt) NUM2DBL(LOOKUP_HASH(opt, "k"))
|
||||
|
||||
#define FLOOD_FILL_OPTION(opt) rb_get_option_table(rb_klass, "FLOOD_FILL_OPTION", opt)
|
||||
#define FF_CONNECTIVITY(opt) NUM2INT(LOOKUP_CVMETHOD(opt, "connectivity"))
|
||||
#define FF_FIXED_RANGE(opt) TRUE_OR_FALSE(LOOKUP_CVMETHOD(opt, "fixed_range"))
|
||||
#define FF_MASK_ONLY(opt) TRUE_OR_FALSE(LOOKUP_CVMETHOD(opt, "mask_only"))
|
||||
#define FF_CONNECTIVITY(opt) NUM2INT(LOOKUP_HASH(opt, "connectivity"))
|
||||
#define FF_FIXED_RANGE(opt) TRUE_OR_FALSE(LOOKUP_HASH(opt, "fixed_range"))
|
||||
#define FF_MASK_ONLY(opt) TRUE_OR_FALSE(LOOKUP_HASH(opt, "mask_only"))
|
||||
|
||||
#define FIND_CONTOURS_OPTION(opt) rb_get_option_table(rb_klass, "FIND_CONTOURS_OPTION", opt)
|
||||
#define FC_MODE(opt) NUM2INT(LOOKUP_CVMETHOD(opt, "mode"))
|
||||
#define FC_METHOD(opt) NUM2INT(LOOKUP_CVMETHOD(opt, "method"))
|
||||
#define FC_OFFSET(opt) VALUE_TO_CVPOINT(LOOKUP_CVMETHOD(opt, "offset"))
|
||||
#define FC_MODE(opt) NUM2INT(LOOKUP_HASH(opt, "mode"))
|
||||
#define FC_METHOD(opt) NUM2INT(LOOKUP_HASH(opt, "method"))
|
||||
#define FC_OFFSET(opt) VALUE_TO_CVPOINT(LOOKUP_HASH(opt, "offset"))
|
||||
|
||||
#define OPTICAL_FLOW_HS_OPTION(opt) rb_get_option_table(rb_klass, "OPTICAL_FLOW_HS_OPTION", opt)
|
||||
#define HS_LAMBDA(opt) NUM2DBL(LOOKUP_CVMETHOD(opt, "lambda"))
|
||||
#define HS_CRITERIA(opt) VALUE_TO_CVTERMCRITERIA(LOOKUP_CVMETHOD(opt, "criteria"))
|
||||
#define HS_LAMBDA(opt) NUM2DBL(LOOKUP_HASH(opt, "lambda"))
|
||||
#define HS_CRITERIA(opt) VALUE_TO_CVTERMCRITERIA(LOOKUP_HASH(opt, "criteria"))
|
||||
|
||||
#define OPTICAL_FLOW_BM_OPTION(opt) rb_get_option_table(rb_klass, "OPTICAL_FLOW_BM_OPTION", opt)
|
||||
#define BM_BLOCK_SIZE(opt) VALUE_TO_CVSIZE(LOOKUP_CVMETHOD(opt, "block_size"))
|
||||
#define BM_SHIFT_SIZE(opt) VALUE_TO_CVSIZE(LOOKUP_CVMETHOD(opt, "shift_size"))
|
||||
#define BM_MAX_RANGE(opt) VALUE_TO_CVSIZE(LOOKUP_CVMETHOD(opt, "max_range"))
|
||||
#define BM_BLOCK_SIZE(opt) VALUE_TO_CVSIZE(LOOKUP_HASH(opt, "block_size"))
|
||||
#define BM_SHIFT_SIZE(opt) VALUE_TO_CVSIZE(LOOKUP_HASH(opt, "shift_size"))
|
||||
#define BM_MAX_RANGE(opt) VALUE_TO_CVSIZE(LOOKUP_HASH(opt, "max_range"))
|
||||
|
||||
#define FIND_FUNDAMENTAL_MAT_OPTION(opt) rb_get_option_table(rb_klass, "FIND_FUNDAMENTAL_MAT_OPTION", opt)
|
||||
#define FFM_WITH_STATUS(opt) TRUE_OR_FALSE(LOOKUP_CVMETHOD(opt, "with_status"))
|
||||
#define FFM_MAXIMUM_DISTANCE(opt) NUM2DBL(LOOKUP_CVMETHOD(opt, "maximum_distance"))
|
||||
#define FFM_DESIRABLE_LEVEL(opt) NUM2DBL(LOOKUP_CVMETHOD(opt, "desirable_level"))
|
||||
#define FFM_WITH_STATUS(opt) TRUE_OR_FALSE(LOOKUP_HASH(opt, "with_status"))
|
||||
#define FFM_MAXIMUM_DISTANCE(opt) NUM2DBL(LOOKUP_HASH(opt, "maximum_distance"))
|
||||
#define FFM_DESIRABLE_LEVEL(opt) NUM2DBL(LOOKUP_HASH(opt, "desirable_level"))
|
||||
|
||||
VALUE rb_klass;
|
||||
|
||||
int
|
||||
rb_drawing_option_line_type(VALUE drawing_option)
|
||||
{
|
||||
VALUE line_type = LOOKUP_CVMETHOD(drawing_option, "line_type");
|
||||
VALUE line_type = LOOKUP_HASH(drawing_option, "line_type");
|
||||
if (FIXNUM_P(line_type)) {
|
||||
return FIX2INT(line_type);
|
||||
}
|
||||
|
|
@ -2676,9 +2676,9 @@ rb_mul_transposed(int argc, VALUE *argv, VALUE self)
|
|||
|
||||
if (rb_scan_args(argc, argv, "01", &options) > 0) {
|
||||
Check_Type(options, T_HASH);
|
||||
_delta = LOOKUP_CVMETHOD(options, "delta");
|
||||
_scale = LOOKUP_CVMETHOD(options, "scale");
|
||||
_order = LOOKUP_CVMETHOD(options, "order");
|
||||
_delta = LOOKUP_HASH(options, "delta");
|
||||
_scale = LOOKUP_HASH(options, "scale");
|
||||
_order = LOOKUP_HASH(options, "order");
|
||||
}
|
||||
|
||||
CvArr* delta = NIL_P(_delta) ? NULL : CVARR_WITH_CHECK(_delta);
|
||||
|
|
@ -4582,15 +4582,15 @@ rb_adaptive_threshold(int argc, VALUE *argv, VALUE self)
|
|||
double param1 = 5;
|
||||
if (!NIL_P(options)) {
|
||||
Check_Type(options, T_HASH);
|
||||
threshold_type = CVMETHOD("THRESHOLD_TYPE", LOOKUP_CVMETHOD(options, "threshold_type"),
|
||||
threshold_type = CVMETHOD("THRESHOLD_TYPE", LOOKUP_HASH(options, "threshold_type"),
|
||||
CV_THRESH_BINARY);
|
||||
adaptive_method = CVMETHOD("ADAPTIVE_METHOD", LOOKUP_CVMETHOD(options, "adaptive_method"),
|
||||
adaptive_method = CVMETHOD("ADAPTIVE_METHOD", LOOKUP_HASH(options, "adaptive_method"),
|
||||
CV_ADAPTIVE_THRESH_MEAN_C);
|
||||
VALUE _block_size = LOOKUP_CVMETHOD(options, "block_size");
|
||||
VALUE _block_size = LOOKUP_HASH(options, "block_size");
|
||||
if (!NIL_P(_block_size)) {
|
||||
block_size = NUM2INT(_block_size);
|
||||
}
|
||||
VALUE _param1 = LOOKUP_CVMETHOD(options, "param1");
|
||||
VALUE _param1 = LOOKUP_HASH(options, "param1");
|
||||
if (!NIL_P(_param1)) {
|
||||
param1 = NUM2INT(_param1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -341,129 +341,129 @@ define_ruby_module()
|
|||
VALUE inversion_method = rb_hash_new();
|
||||
/* {:lu, :svd, :svd_sym(:svd_symmetric)}: Inversion method */
|
||||
rb_define_const(rb_module, "INVERSION_METHOD", inversion_method);
|
||||
REGISTER_CVMETHOD(inversion_method, "lu", CV_LU);
|
||||
REGISTER_CVMETHOD(inversion_method, "svd", CV_SVD);
|
||||
REGISTER_CVMETHOD(inversion_method, "svd_sym", CV_SVD_SYM);
|
||||
REGISTER_CVMETHOD(inversion_method, "svd_symmetric", CV_SVD_SYM);
|
||||
REGISTER_HASH(inversion_method, "lu", CV_LU);
|
||||
REGISTER_HASH(inversion_method, "svd", CV_SVD);
|
||||
REGISTER_HASH(inversion_method, "svd_sym", CV_SVD_SYM);
|
||||
REGISTER_HASH(inversion_method, "svd_symmetric", CV_SVD_SYM);
|
||||
|
||||
VALUE homography_calc_method = rb_hash_new();
|
||||
/* {:all, :ransac, :lmeds}: Methods used to computed homography matrix */
|
||||
rb_define_const(rb_module, "HOMOGRAPHY_CALC_METHOD", homography_calc_method);
|
||||
REGISTER_CVMETHOD(homography_calc_method, "all", 0);
|
||||
REGISTER_CVMETHOD(homography_calc_method, "ransac", CV_RANSAC);
|
||||
REGISTER_CVMETHOD(homography_calc_method, "lmeds", CV_LMEDS);
|
||||
REGISTER_HASH(homography_calc_method, "all", 0);
|
||||
REGISTER_HASH(homography_calc_method, "ransac", CV_RANSAC);
|
||||
REGISTER_HASH(homography_calc_method, "lmeds", CV_LMEDS);
|
||||
|
||||
VALUE depth = rb_hash_new();
|
||||
/* {:cv8u, :cv8s, :cv16u, :cv16s, :cv32s, :cv32f, :cv64f}: Depth of each pixel. */
|
||||
rb_define_const(rb_module, "DEPTH", depth);
|
||||
REGISTER_CVMETHOD(depth, "cv8u", CV_8U);
|
||||
REGISTER_CVMETHOD(depth, "cv8s", CV_8S);
|
||||
REGISTER_CVMETHOD(depth, "cv16u", CV_16U);
|
||||
REGISTER_CVMETHOD(depth, "cv16s", CV_16S);
|
||||
REGISTER_CVMETHOD(depth, "cv32s", CV_32S);
|
||||
REGISTER_CVMETHOD(depth, "cv32f", CV_32F);
|
||||
REGISTER_CVMETHOD(depth, "cv64f", CV_64F);
|
||||
REGISTER_HASH(depth, "cv8u", CV_8U);
|
||||
REGISTER_HASH(depth, "cv8s", CV_8S);
|
||||
REGISTER_HASH(depth, "cv16u", CV_16U);
|
||||
REGISTER_HASH(depth, "cv16s", CV_16S);
|
||||
REGISTER_HASH(depth, "cv32s", CV_32S);
|
||||
REGISTER_HASH(depth, "cv32f", CV_32F);
|
||||
REGISTER_HASH(depth, "cv64f", CV_64F);
|
||||
|
||||
VALUE connectivity = rb_hash_new();
|
||||
/* {:aa(:anti_alias)}: Determined by the closeness of pixel values */
|
||||
rb_define_const(rb_module, "CONNECTIVITY", connectivity);
|
||||
REGISTER_CVMETHOD(connectivity, "aa", CV_AA);
|
||||
REGISTER_CVMETHOD(connectivity, "anti_alias", CV_AA);
|
||||
REGISTER_HASH(connectivity, "aa", CV_AA);
|
||||
REGISTER_HASH(connectivity, "anti_alias", CV_AA);
|
||||
|
||||
VALUE structuring_element_shape = rb_hash_new();
|
||||
/* {:rect, :cross, :ellipse, :custom}: Shape of the structuring elements */
|
||||
rb_define_const(rb_module, "STRUCTURING_ELEMENT_SHAPE", structuring_element_shape);
|
||||
REGISTER_CVMETHOD(structuring_element_shape, "rect", CV_SHAPE_RECT);
|
||||
REGISTER_CVMETHOD(structuring_element_shape, "cross", CV_SHAPE_CROSS);
|
||||
REGISTER_CVMETHOD(structuring_element_shape, "ellipse", CV_SHAPE_ELLIPSE);
|
||||
REGISTER_CVMETHOD(structuring_element_shape, "custom", CV_SHAPE_CUSTOM);
|
||||
REGISTER_HASH(structuring_element_shape, "rect", CV_SHAPE_RECT);
|
||||
REGISTER_HASH(structuring_element_shape, "cross", CV_SHAPE_CROSS);
|
||||
REGISTER_HASH(structuring_element_shape, "ellipse", CV_SHAPE_ELLIPSE);
|
||||
REGISTER_HASH(structuring_element_shape, "custom", CV_SHAPE_CUSTOM);
|
||||
|
||||
VALUE retrieval_mode = rb_hash_new();
|
||||
/* {:external, :list, :ccomp, :tree}: Retrieval mode */
|
||||
rb_define_const(rb_module, "RETRIEVAL_MODE", retrieval_mode);
|
||||
REGISTER_CVMETHOD(retrieval_mode, "external", CV_RETR_EXTERNAL);
|
||||
REGISTER_CVMETHOD(retrieval_mode, "list", CV_RETR_LIST);
|
||||
REGISTER_CVMETHOD(retrieval_mode, "ccomp", CV_RETR_CCOMP);
|
||||
REGISTER_CVMETHOD(retrieval_mode, "tree", CV_RETR_TREE);
|
||||
REGISTER_HASH(retrieval_mode, "external", CV_RETR_EXTERNAL);
|
||||
REGISTER_HASH(retrieval_mode, "list", CV_RETR_LIST);
|
||||
REGISTER_HASH(retrieval_mode, "ccomp", CV_RETR_CCOMP);
|
||||
REGISTER_HASH(retrieval_mode, "tree", CV_RETR_TREE);
|
||||
|
||||
VALUE approx_chain_method = rb_hash_new();
|
||||
/* {:code, :approx_none, :approx_simple, :apporx_tc89_11, :approx_tc89_kcos}: Approximation method */
|
||||
rb_define_const(rb_module, "APPROX_CHAIN_METHOD", approx_chain_method);
|
||||
REGISTER_CVMETHOD(approx_chain_method, "code", CV_CHAIN_CODE);
|
||||
REGISTER_CVMETHOD(approx_chain_method, "approx_none", CV_CHAIN_APPROX_NONE);
|
||||
REGISTER_CVMETHOD(approx_chain_method, "approx_simple", CV_CHAIN_APPROX_SIMPLE);
|
||||
REGISTER_CVMETHOD(approx_chain_method, "approx_tc89_l1", CV_CHAIN_APPROX_TC89_L1);
|
||||
REGISTER_CVMETHOD(approx_chain_method, "approx_tc89_kcos", CV_CHAIN_APPROX_TC89_KCOS);
|
||||
REGISTER_HASH(approx_chain_method, "code", CV_CHAIN_CODE);
|
||||
REGISTER_HASH(approx_chain_method, "approx_none", CV_CHAIN_APPROX_NONE);
|
||||
REGISTER_HASH(approx_chain_method, "approx_simple", CV_CHAIN_APPROX_SIMPLE);
|
||||
REGISTER_HASH(approx_chain_method, "approx_tc89_l1", CV_CHAIN_APPROX_TC89_L1);
|
||||
REGISTER_HASH(approx_chain_method, "approx_tc89_kcos", CV_CHAIN_APPROX_TC89_KCOS);
|
||||
|
||||
VALUE approx_poly_method = rb_hash_new();
|
||||
/* {:dp}: Approximation method (polygon) */
|
||||
rb_define_const(rb_module, "APPROX_POLY_METHOD", approx_poly_method);
|
||||
REGISTER_CVMETHOD(approx_poly_method, "dp", CV_POLY_APPROX_DP);
|
||||
REGISTER_HASH(approx_poly_method, "dp", CV_POLY_APPROX_DP);
|
||||
|
||||
VALUE match_template_method = rb_hash_new();
|
||||
/* {:sqdiff, :sqdiff_normed, :ccorr, :ccorr_normed, :ccoeff, :ccoeff_normed}: Match template method */
|
||||
rb_define_const(rb_module, "MATCH_TEMPLATE_METHOD", match_template_method);
|
||||
REGISTER_CVMETHOD(match_template_method, "sqdiff", CV_TM_SQDIFF);
|
||||
REGISTER_CVMETHOD(match_template_method, "sqdiff_normed", CV_TM_SQDIFF_NORMED);
|
||||
REGISTER_CVMETHOD(match_template_method, "ccorr", CV_TM_CCORR);
|
||||
REGISTER_CVMETHOD(match_template_method, "ccorr_normed", CV_TM_CCORR_NORMED);
|
||||
REGISTER_CVMETHOD(match_template_method, "ccoeff", CV_TM_CCOEFF);
|
||||
REGISTER_CVMETHOD(match_template_method, "ccoeff_normed", CV_TM_CCOEFF_NORMED);
|
||||
REGISTER_HASH(match_template_method, "sqdiff", CV_TM_SQDIFF);
|
||||
REGISTER_HASH(match_template_method, "sqdiff_normed", CV_TM_SQDIFF_NORMED);
|
||||
REGISTER_HASH(match_template_method, "ccorr", CV_TM_CCORR);
|
||||
REGISTER_HASH(match_template_method, "ccorr_normed", CV_TM_CCORR_NORMED);
|
||||
REGISTER_HASH(match_template_method, "ccoeff", CV_TM_CCOEFF);
|
||||
REGISTER_HASH(match_template_method, "ccoeff_normed", CV_TM_CCOEFF_NORMED);
|
||||
|
||||
VALUE morphological_operation = rb_hash_new();
|
||||
/* {:open, :close, :gradient, :tophat, :blackhat}: Types of morphological operations */
|
||||
rb_define_const(rb_module, "MORPHOLOGICAL_OPERATION", morphological_operation);
|
||||
REGISTER_CVMETHOD(morphological_operation, "open", CV_MOP_OPEN);
|
||||
REGISTER_CVMETHOD(morphological_operation, "close", CV_MOP_CLOSE);
|
||||
REGISTER_CVMETHOD(morphological_operation, "gradient", CV_MOP_GRADIENT);
|
||||
REGISTER_CVMETHOD(morphological_operation, "tophat", CV_MOP_TOPHAT);
|
||||
REGISTER_CVMETHOD(morphological_operation, "blackhat", CV_MOP_BLACKHAT);
|
||||
REGISTER_HASH(morphological_operation, "open", CV_MOP_OPEN);
|
||||
REGISTER_HASH(morphological_operation, "close", CV_MOP_CLOSE);
|
||||
REGISTER_HASH(morphological_operation, "gradient", CV_MOP_GRADIENT);
|
||||
REGISTER_HASH(morphological_operation, "tophat", CV_MOP_TOPHAT);
|
||||
REGISTER_HASH(morphological_operation, "blackhat", CV_MOP_BLACKHAT);
|
||||
|
||||
VALUE smoothing_type = rb_hash_new();
|
||||
/* {:blur_no_scale, :blur, :gaussian, :median, :bilateral}: Types of smoothing */
|
||||
rb_define_const(rb_module, "SMOOTHING_TYPE", smoothing_type);
|
||||
REGISTER_CVMETHOD(smoothing_type, "blur_no_scale", CV_BLUR_NO_SCALE);
|
||||
REGISTER_CVMETHOD(smoothing_type, "blur", CV_BLUR);
|
||||
REGISTER_CVMETHOD(smoothing_type, "gaussian", CV_GAUSSIAN);
|
||||
REGISTER_CVMETHOD(smoothing_type, "median", CV_MEDIAN);
|
||||
REGISTER_CVMETHOD(smoothing_type, "bilateral", CV_BILATERAL);
|
||||
REGISTER_HASH(smoothing_type, "blur_no_scale", CV_BLUR_NO_SCALE);
|
||||
REGISTER_HASH(smoothing_type, "blur", CV_BLUR);
|
||||
REGISTER_HASH(smoothing_type, "gaussian", CV_GAUSSIAN);
|
||||
REGISTER_HASH(smoothing_type, "median", CV_MEDIAN);
|
||||
REGISTER_HASH(smoothing_type, "bilateral", CV_BILATERAL);
|
||||
|
||||
VALUE adaptive_method = rb_hash_new();
|
||||
/* {:mean_c, :gaussian_c}: Adaptive thresholding algorithm */
|
||||
rb_define_const(rb_module, "ADAPTIVE_METHOD", adaptive_method);
|
||||
REGISTER_CVMETHOD(adaptive_method, "mean_c", CV_ADAPTIVE_THRESH_MEAN_C);
|
||||
REGISTER_CVMETHOD(adaptive_method, "gaussian_c", CV_ADAPTIVE_THRESH_GAUSSIAN_C);
|
||||
REGISTER_HASH(adaptive_method, "mean_c", CV_ADAPTIVE_THRESH_MEAN_C);
|
||||
REGISTER_HASH(adaptive_method, "gaussian_c", CV_ADAPTIVE_THRESH_GAUSSIAN_C);
|
||||
|
||||
VALUE threshold_type = rb_hash_new();
|
||||
/* {:binary, :binary_inv, :trunc, :tozero, :tozero_inv, :otsu} : Thresholding types */
|
||||
rb_define_const(rb_module, "THRESHOLD_TYPE", threshold_type);
|
||||
REGISTER_CVMETHOD(threshold_type, "binary", CV_THRESH_BINARY);
|
||||
REGISTER_CVMETHOD(threshold_type, "binary_inv", CV_THRESH_BINARY_INV);
|
||||
REGISTER_CVMETHOD(threshold_type, "trunc", CV_THRESH_TRUNC);
|
||||
REGISTER_CVMETHOD(threshold_type, "tozero", CV_THRESH_TOZERO);
|
||||
REGISTER_CVMETHOD(threshold_type, "tozero_inv", CV_THRESH_TOZERO_INV);
|
||||
REGISTER_CVMETHOD(threshold_type, "otsu", CV_THRESH_OTSU);
|
||||
REGISTER_HASH(threshold_type, "binary", CV_THRESH_BINARY);
|
||||
REGISTER_HASH(threshold_type, "binary_inv", CV_THRESH_BINARY_INV);
|
||||
REGISTER_HASH(threshold_type, "trunc", CV_THRESH_TRUNC);
|
||||
REGISTER_HASH(threshold_type, "tozero", CV_THRESH_TOZERO);
|
||||
REGISTER_HASH(threshold_type, "tozero_inv", CV_THRESH_TOZERO_INV);
|
||||
REGISTER_HASH(threshold_type, "otsu", CV_THRESH_OTSU);
|
||||
|
||||
VALUE hough_transform_method = rb_hash_new();
|
||||
/* {:standard, :probabilistic, :multi_scale} : Hough transform method */
|
||||
rb_define_const(rb_module, "HOUGH_TRANSFORM_METHOD", hough_transform_method);
|
||||
REGISTER_CVMETHOD(hough_transform_method, "standard", CV_HOUGH_STANDARD);
|
||||
REGISTER_CVMETHOD(hough_transform_method, "probabilistic", CV_HOUGH_PROBABILISTIC);
|
||||
REGISTER_CVMETHOD(hough_transform_method, "multi_scale", CV_HOUGH_MULTI_SCALE);
|
||||
REGISTER_CVMETHOD(hough_transform_method, "gradient", CV_HOUGH_GRADIENT);
|
||||
REGISTER_HASH(hough_transform_method, "standard", CV_HOUGH_STANDARD);
|
||||
REGISTER_HASH(hough_transform_method, "probabilistic", CV_HOUGH_PROBABILISTIC);
|
||||
REGISTER_HASH(hough_transform_method, "multi_scale", CV_HOUGH_MULTI_SCALE);
|
||||
REGISTER_HASH(hough_transform_method, "gradient", CV_HOUGH_GRADIENT);
|
||||
|
||||
VALUE inpaint_method = rb_hash_new();
|
||||
/* {:ns, :telea} : Inpaint method */
|
||||
rb_define_const(rb_module, "INPAINT_METHOD", inpaint_method);
|
||||
REGISTER_CVMETHOD(inpaint_method, "ns", CV_INPAINT_NS);
|
||||
REGISTER_CVMETHOD(inpaint_method, "telea", CV_INPAINT_TELEA);
|
||||
REGISTER_HASH(inpaint_method, "ns", CV_INPAINT_NS);
|
||||
REGISTER_HASH(inpaint_method, "telea", CV_INPAINT_TELEA);
|
||||
|
||||
VALUE comparison_method = rb_hash_new();
|
||||
/* Comparison method */
|
||||
rb_define_const(rb_module, "COMPARISON_METHOD", comparison_method);
|
||||
REGISTER_CVMETHOD(comparison_method, "i1", CV_CONTOURS_MATCH_I1);
|
||||
REGISTER_CVMETHOD(comparison_method, "i2", CV_CONTOURS_MATCH_I2);
|
||||
REGISTER_CVMETHOD(comparison_method, "i3", CV_CONTOURS_MATCH_I3);
|
||||
REGISTER_HASH(comparison_method, "i1", CV_CONTOURS_MATCH_I1);
|
||||
REGISTER_HASH(comparison_method, "i2", CV_CONTOURS_MATCH_I2);
|
||||
REGISTER_HASH(comparison_method, "i3", CV_CONTOURS_MATCH_I3);
|
||||
|
||||
/* color convert methods */
|
||||
rb_define_module_function(rb_module, "BGR2BGRA", RUBY_METHOD_FUNC(rb_BGR2BGRA), 1);
|
||||
|
|
|
|||
|
|
@ -147,8 +147,8 @@ extern "C" {
|
|||
|
||||
#define IF_DEPTH(val, ifnone) NIL_P(val) ? ifnone : NUM2INT(val)
|
||||
|
||||
#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 REGISTER_HASH(hash, str, value) rb_hash_aset(hash, ID2SYM(rb_intern(str)), INT2FIX(value))
|
||||
#define LOOKUP_HASH(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; })
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue