Module: OpenCV::Cv

Defined in:
lib/ruby/ropencv/ropencv_types.rb,
lib/ruby/ropencv/ropencv_ruby.rb

Overview

wrapper for cv

Defined Under Namespace

Modules: DrawMatchesFlags, FREAK, FeatureEvaluator, Flann, Hamming, InputArray, Param, SVD, SelfSimDescriptor, SparseMat Classes: Algorithm, AlgorithmStruct, BFMatcher, BFMatcherStruct, BRISK, BRISKStruct, CascadeClassifier, CascadeClassifierStruct, DMatch, DMatchStruct, DescriptorExtractor, DescriptorExtractorStruct, DescriptorMatcher, DescriptorMatcherStruct, EM, EMStruct, FaceRecognizer, FaceRecognizerStruct, FastFeatureDetector, FastFeatureDetectorStruct, Feature2D, Feature2DStruct, FeatureDetector, FeatureDetectorStruct, FileNode, FileNodeStruct, FileStorage, FileStorageStruct, FlannBasedMatcher, FlannBasedMatcherStruct, GridAdaptedFeatureDetector, GridAdaptedFeatureDetectorStruct, HOGDescriptor, HOGDescriptorStruct, KDTree, KDTreeStruct, KeyPoint, KeyPointStruct, MSER, MSERStruct, Mat, MatStruct, Moments, MomentsStruct, ORB, ORBStruct, Point, Point2d, Point2dStruct, Point2f, Point2fStruct, Point3d, Point3dStruct, Point3f, Point3fStruct, PointStruct, PyramidAdaptedFeatureDetector, PyramidAdaptedFeatureDetectorStruct, RNG, RNGStruct, Range, RangeStruct, Rect, RectStruct, RotatedRect, RotatedRectStruct, SIFT, SIFTStruct, SURF, SURFStruct, Scalar, ScalarStruct, SimpleBlobDetector, SimpleBlobDetectorStruct, Size, Size2f, Size2fStruct, SizeStruct, StarDetector, StarDetectorStruct, StereoBM, StereoBMStruct, StereoSGBM, StereoSGBMStruct, StereoVar, StereoVarStruct, String, StringStruct, Subdiv2D, Subdiv2DStruct, TermCriteria, TermCriteriaStruct, Vec2d, Vec2dStruct, Vec3d, Vec3dStruct, Vec4d, Vec4dStruct, Vec4f, Vec4fStruct, Vec6f, Vec6fStruct, VideoCapture, VideoCaptureStruct, VideoWriter, VideoWriterStruct

Constants collapse

CV_MAX_DIM = 
32
IPL_BORDER_CONSTANT = 
0
IPL_BORDER_REPLICATE = 
1
IPL_BORDER_REFLECT = 
2
IPL_BORDER_WRAP = 
3
IPL_BORDER_REFLECT_101 = 
4
IPL_BORDER_TRANSPARENT = 
5
CV_LMEDS = 
4
CV_RANSAC = 
8
CV_ITERATIVE = 
0
CV_EPNP = 
1
CV_P3P = 
2
CV_CALIB_USE_INTRINSIC_GUESS = 
0x00001
CV_CALIB_FIX_ASPECT_RATIO = 
0x00002
CV_CALIB_FIX_PRINCIPAL_POINT = 
0x00004
CV_CALIB_ZERO_TANGENT_DIST = 
0x00008
CV_CALIB_FIX_FOCAL_LENGTH = 
0x00010
CV_CALIB_FIX_K1 = 
0x00020
CV_CALIB_FIX_K2 = 
0x00040
CV_CALIB_FIX_K3 = 
0x00080
CV_CALIB_FIX_K4 = 
0x00800
CV_CALIB_FIX_K5 = 
0x01000
CV_CALIB_FIX_K6 = 
0x02000
CV_CALIB_RATIONAL_MODEL = 
0x04000
CV_CALIB_THIN_PRISM_MODEL = 
0x08000
CV_CALIB_FIX_S1_S2_S3_S4 = 
0x10000
CV_CALIB_FIX_INTRINSIC = 
0x00100
CV_CALIB_SAME_FOCAL_LENGTH = 
0x00200
CV_CALIB_ZERO_DISPARITY = 
0x00400
CV_FM_7POINT = 
1
CV_FM_8POINT = 
2
CV_FM_LMEDS = 
4
CV_FM_RANSAC = 
8
CV_AFM_4POINT = 
16
CV_AFM_LMEDS = 
32
CV_AFM_RANSAC = 
64
CV_WINDOW_NORMAL = 
0x00000000
CV_WINDOW_AUTOSIZE = 
0x00000001
CV_WINDOW_OPENGL = 
0x00001000
CV_WINDOW_FULLSCREEN = 
1
CV_WINDOW_FREERATIO = 
0x00000100
CV_WINDOW_KEEPRATIO = 
0x00000000
CV_WND_PROP_FULLSCREEN = 
0
CV_WND_PROP_AUTOSIZE = 
1
CV_WND_PROP_ASPECT_RATIO = 
2
CV_WND_PROP_OPENGL = 
3
CV_8U = 
0
CV_8S = 
1
CV_16U = 
2
CV_16S = 
3
CV_32S = 
4
CV_32F = 
5
CV_64F = 
6
CV_8UC1 = 
(1-1)*8 + CV_8U
CV_8UC2 = 
(2-1)*8 + CV_8U
CV_8UC3 = 
(3-1)*8 + CV_8U
CV_8UC4 = 
(4-1)*8 + CV_8U
CV_8SC1 = 
(1-1)*8 + CV_8S
CV_8SC2 = 
(2-1)*8 + CV_8S
CV_8SC3 = 
(3-1)*8 + CV_8S
CV_8SC4 = 
(4-1)*8 + CV_8S
CV_16UC1 = 
(1-1)*8 + CV_16U
CV_16UC2 = 
(2-1)*8 + CV_16U
CV_16UC3 = 
(3-1)*8 + CV_16U
CV_16UC4 = 
(4-1)*8 + CV_16U
CV_16SC1 = 
(1-1)*8 + CV_16S
CV_16SC2 = 
(2-1)*8 + CV_16S
CV_16SC3 = 
(3-1)*8 + CV_16S
CV_16SC4 = 
(4-1)*8 + CV_16S
CV_32SC1 = 
(1-1)*8 + CV_32S
CV_32SC2 = 
(2-1)*8 + CV_32S
CV_32SC3 = 
(3-1)*8 + CV_32S
CV_32SC4 = 
(4-1)*8 + CV_32S
CV_32FC1 = 
(1-1)*8 + CV_32F
CV_32FC2 = 
(2-1)*8 + CV_32F
CV_32FC3 = 
(3-1)*8 + CV_32F
CV_32FC4 = 
(4-1)*8 + CV_32F
CV_64FC1 = 
(1-1)*8 + CV_64F
CV_64FC2 = 
(2-1)*8 + CV_64F
CV_64FC3 = 
(3-1)*8 + CV_64F
CV_64FC4 = 
(4-1)*8 + CV_64F
CV_CN_MAX = 
512
CV_CN_SHIFT = 
3
CV_DEPTH_MAX = 
(1 << CV_CN_SHIFT)
CV_MAT_CN_MASK = 
((CV_CN_MAX - 1) << CV_CN_SHIFT)
CV_MAT_TYPE_MASK = 
(CV_DEPTH_MAX*CV_CN_MAX - 1)
CV_MAT_CONT_FLAG_SHIFT = 
14
CV_MAT_CONT_FLAG = 
(1 << CV_MAT_CONT_FLAG_SHIFT)
CV_SUBMAT_FLAG_SHIFT = 
15
CV_SUBMAT_FLAG = 
(1 << CV_SUBMAT_FLAG_SHIFT)
DECOMP_LU = 
0
DECOMP_SVD = 
1
DECOMP_EIG = 
2
DECOMP_CHOLESKY = 
3
DECOMP_QR = 
4
DECOMP_NORMAL = 
16
NORM_INF = 
1
NORM_L1 = 
2
NORM_L2 = 
4
NORM_L2SQR = 
5
NORM_HAMMING = 
6
NORM_HAMMING2 = 
7
NORM_TYPE_MASK = 
7
NORM_RELATIVE = 
8
NORM_MINMAX = 
32
CMP_EQ = 
0
CMP_GT = 
1
CMP_GE = 
2
CMP_LT = 
3
CMP_LE = 
4
CMP_NE = 
5
GEMM_1_T = 
1
GEMM_2_T = 
2
GEMM_3_T = 
4
DFT_INVERSE = 
1
DFT_SCALE = 
2
DFT_ROWS = 
4
DFT_COMPLEX_OUTPUT = 
16
DFT_REAL_OUTPUT = 
32
DCT_INVERSE = 
DFT_INVERSE
DCT_ROWS = 
DFT_ROWS
DEPTH_MASK_8U = 
1 << CV_8U
DEPTH_MASK_8S = 
1 << CV_8S
DEPTH_MASK_16U = 
1 << CV_16U
DEPTH_MASK_16S = 
1 << CV_16S
DEPTH_MASK_32S = 
1 << CV_32S
DEPTH_MASK_32F = 
1 << CV_32F
DEPTH_MASK_64F = 
1 << CV_64F
DEPTH_MASK_ALL = 
(DEPTH_MASK_64F<<1)-1
DEPTH_MASK_ALL_BUT_8S = 
DEPTH_MASK_ALL & ~DEPTH_MASK_8S
DEPTH_MASK_FLT = 
DEPTH_MASK_32F + DEPTH_MASK_64F
MAGIC_MASK = 
0xFFFF0000
TYPE_MASK = 
0x00000FFF
DEPTH_MASK = 
7
SORT_EVERY_ROW = 
0
SORT_EVERY_COLUMN = 
1
SORT_ASCENDING = 
0
SORT_DESCENDING = 
16
COVAR_SCRAMBLED = 
0
COVAR_NORMAL = 
1
COVAR_USE_AVG = 
2
COVAR_SCALE = 
4
COVAR_ROWS = 
8
COVAR_COLS = 
16
KMEANS_RANDOM_CENTERS = 
0
KMEANS_PP_CENTERS = 
2
KMEANS_USE_INITIAL_LABELS = 
1
FONT_HERSHEY_SIMPLEX = 
0
FONT_HERSHEY_PLAIN = 
1
FONT_HERSHEY_DUPLEX = 
2
FONT_HERSHEY_COMPLEX = 
3
FONT_HERSHEY_TRIPLEX = 
4
FONT_HERSHEY_COMPLEX_SMALL = 
5
FONT_HERSHEY_SCRIPT_SIMPLEX = 
6
FONT_HERSHEY_SCRIPT_COMPLEX = 
7
FONT_ITALIC = 
16
BORDER_REPLICATE = 
IPL_BORDER_REPLICATE
BORDER_CONSTANT = 
IPL_BORDER_CONSTANT
BORDER_REFLECT = 
IPL_BORDER_REFLECT
BORDER_WRAP = 
IPL_BORDER_WRAP
BORDER_REFLECT_101 = 
IPL_BORDER_REFLECT_101
BORDER_REFLECT101 = 
BORDER_REFLECT_101
BORDER_TRANSPARENT = 
IPL_BORDER_TRANSPARENT
BORDER_DEFAULT = 
BORDER_REFLECT_101
BORDER_ISOLATED = 
16
KERNEL_GENERAL = 
0
KERNEL_SYMMETRICAL = 
1
KERNEL_ASYMMETRICAL = 
2
KERNEL_SMOOTH = 
4
KERNEL_INTEGER = 
8
MORPH_ERODE = 
CV_MOP_ERODE
MORPH_DILATE = 
CV_MOP_DILATE
MORPH_OPEN = 
CV_MOP_OPEN
MORPH_CLOSE = 
CV_MOP_CLOSE
MORPH_GRADIENT = 
CV_MOP_GRADIENT
MORPH_TOPHAT = 
CV_MOP_TOPHAT
MORPH_BLACKHAT = 
CV_MOP_BLACKHAT
MORPH_RECT = 
0
MORPH_CROSS = 
1
MORPH_ELLIPSE = 
2
GHT_POSITION = 
0
GHT_SCALE = 
1
GHT_ROTATION = 
2
INTER_NEAREST = 
CV_INTER_NN
INTER_LINEAR = 
CV_INTER_LINEAR
INTER_CUBIC = 
CV_INTER_CUBIC
INTER_AREA = 
CV_INTER_AREA
INTER_LANCZOS4 = 
CV_INTER_LANCZOS4
INTER_MAX = 
7
WARP_INVERSE_MAP = 
CV_WARP_INVERSE_MAP
INTER_BITS = 
5
INTER_BITS2 = 
INTER_BITS*2
INTER_TAB_SIZE = 
(1<<INTER_BITS)
INTER_TAB_SIZE2 = 
INTER_TAB_SIZE*INTER_TAB_SIZE
THRESH_BINARY = 
CV_THRESH_BINARY
THRESH_BINARY_INV = 
CV_THRESH_BINARY_INV
THRESH_TRUNC = 
CV_THRESH_TRUNC
THRESH_TOZERO = 
CV_THRESH_TOZERO
THRESH_TOZERO_INV = 
CV_THRESH_TOZERO_INV
THRESH_MASK = 
CV_THRESH_MASK
THRESH_OTSU = 
CV_THRESH_OTSU
ADAPTIVE_THRESH_MEAN_C = 
0
ADAPTIVE_THRESH_GAUSSIAN_C = 
1
PROJ_SPHERICAL_ORTHO = 
0
PROJ_SPHERICAL_EQRECT = 
1
GC_BGD = 
0
GC_FGD = 
1
GC_PR_BGD = 
2
GC_PR_FGD = 
3
GC_INIT_WITH_RECT = 
0
GC_INIT_WITH_MASK = 
1
GC_EVAL = 
2
DIST_LABEL_CCOMP = 
0
DIST_LABEL_PIXEL = 
1
FLOODFILL_FIXED_RANGE = 
1 << 16
FLOODFILL_MASK_ONLY = 
1 << 17
COLOR_BGR2BGRA = 
0
COLOR_RGB2RGBA = 
COLOR_BGR2BGRA
COLOR_BGRA2BGR = 
1
COLOR_RGBA2RGB = 
COLOR_BGRA2BGR
COLOR_BGR2RGBA = 
2
COLOR_RGB2BGRA = 
COLOR_BGR2RGBA
COLOR_RGBA2BGR = 
3
COLOR_BGRA2RGB = 
COLOR_RGBA2BGR
COLOR_BGR2RGB = 
4
COLOR_RGB2BGR = 
COLOR_BGR2RGB
COLOR_BGRA2RGBA = 
5
COLOR_RGBA2BGRA = 
COLOR_BGRA2RGBA
COLOR_BGR2GRAY = 
6
COLOR_RGB2GRAY = 
7
COLOR_GRAY2BGR = 
8
COLOR_GRAY2RGB = 
COLOR_GRAY2BGR
COLOR_GRAY2BGRA = 
9
COLOR_GRAY2RGBA = 
COLOR_GRAY2BGRA
COLOR_BGRA2GRAY = 
10
COLOR_RGBA2GRAY = 
11
COLOR_BGR2BGR565 = 
12
COLOR_RGB2BGR565 = 
13
COLOR_BGR5652BGR = 
14
COLOR_BGR5652RGB = 
15
COLOR_BGRA2BGR565 = 
16
COLOR_RGBA2BGR565 = 
17
COLOR_BGR5652BGRA = 
18
COLOR_BGR5652RGBA = 
19
COLOR_GRAY2BGR565 = 
20
COLOR_BGR5652GRAY = 
21
COLOR_BGR2BGR555 = 
22
COLOR_RGB2BGR555 = 
23
COLOR_BGR5552BGR = 
24
COLOR_BGR5552RGB = 
25
COLOR_BGRA2BGR555 = 
26
COLOR_RGBA2BGR555 = 
27
COLOR_BGR5552BGRA = 
28
COLOR_BGR5552RGBA = 
29
COLOR_GRAY2BGR555 = 
30
COLOR_BGR5552GRAY = 
31
COLOR_BGR2XYZ = 
32
COLOR_RGB2XYZ = 
33
COLOR_XYZ2BGR = 
34
COLOR_XYZ2RGB = 
35
COLOR_BGR2YCrCb = 
36
COLOR_RGB2YCrCb = 
37
COLOR_YCrCb2BGR = 
38
COLOR_YCrCb2RGB = 
39
COLOR_BGR2HSV = 
40
COLOR_RGB2HSV = 
41
COLOR_BGR2Lab = 
44
COLOR_RGB2Lab = 
45
COLOR_BayerBG2BGR = 
46
COLOR_BayerGB2BGR = 
47
COLOR_BayerRG2BGR = 
48
COLOR_BayerGR2BGR = 
49
COLOR_BayerBG2RGB = 
COLOR_BayerRG2BGR
COLOR_BayerGB2RGB = 
COLOR_BayerGR2BGR
COLOR_BayerRG2RGB = 
COLOR_BayerBG2BGR
COLOR_BayerGR2RGB = 
COLOR_BayerGB2BGR
COLOR_BGR2Luv = 
50
COLOR_RGB2Luv = 
51
COLOR_BGR2HLS = 
52
COLOR_RGB2HLS = 
53
COLOR_HSV2BGR = 
54
COLOR_HSV2RGB = 
55
COLOR_Lab2BGR = 
56
COLOR_Lab2RGB = 
57
COLOR_Luv2BGR = 
58
COLOR_Luv2RGB = 
59
COLOR_HLS2BGR = 
60
COLOR_HLS2RGB = 
61
COLOR_BayerBG2BGR_VNG = 
62
COLOR_BayerGB2BGR_VNG = 
63
COLOR_BayerRG2BGR_VNG = 
64
COLOR_BayerGR2BGR_VNG = 
65
COLOR_BayerBG2RGB_VNG = 
COLOR_BayerRG2BGR_VNG
COLOR_BayerGB2RGB_VNG = 
COLOR_BayerGR2BGR_VNG
COLOR_BayerRG2RGB_VNG = 
COLOR_BayerBG2BGR_VNG
COLOR_BayerGR2RGB_VNG = 
COLOR_BayerGB2BGR_VNG
COLOR_BGR2HSV_FULL = 
66
COLOR_RGB2HSV_FULL = 
67
COLOR_BGR2HLS_FULL = 
68
COLOR_RGB2HLS_FULL = 
69
COLOR_HSV2BGR_FULL = 
70
COLOR_HSV2RGB_FULL = 
71
COLOR_HLS2BGR_FULL = 
72
COLOR_HLS2RGB_FULL = 
73
COLOR_LBGR2Lab = 
74
COLOR_LRGB2Lab = 
75
COLOR_LBGR2Luv = 
76
COLOR_LRGB2Luv = 
77
COLOR_Lab2LBGR = 
78
COLOR_Lab2LRGB = 
79
COLOR_Luv2LBGR = 
80
COLOR_Luv2LRGB = 
81
COLOR_BGR2YUV = 
82
COLOR_RGB2YUV = 
83
COLOR_YUV2BGR = 
84
COLOR_YUV2RGB = 
85
COLOR_BayerBG2GRAY = 
86
COLOR_BayerGB2GRAY = 
87
COLOR_BayerRG2GRAY = 
88
COLOR_BayerGR2GRAY = 
89
COLOR_YUV2RGB_NV12 = 
90
COLOR_YUV2BGR_NV12 = 
91
COLOR_YUV2RGB_NV21 = 
92
COLOR_YUV2BGR_NV21 = 
93
COLOR_YUV420sp2RGB = 
COLOR_YUV2RGB_NV21
COLOR_YUV420sp2BGR = 
COLOR_YUV2BGR_NV21
COLOR_YUV2RGBA_NV12 = 
94
COLOR_YUV2BGRA_NV12 = 
95
COLOR_YUV2RGBA_NV21 = 
96
COLOR_YUV2BGRA_NV21 = 
97
COLOR_YUV420sp2RGBA = 
COLOR_YUV2RGBA_NV21
COLOR_YUV420sp2BGRA = 
COLOR_YUV2BGRA_NV21
COLOR_YUV2RGB_YV12 = 
98
COLOR_YUV2BGR_YV12 = 
99
COLOR_YUV2RGB_IYUV = 
100
COLOR_YUV2BGR_IYUV = 
101
COLOR_YUV2RGB_I420 = 
COLOR_YUV2RGB_IYUV
COLOR_YUV2BGR_I420 = 
COLOR_YUV2BGR_IYUV
COLOR_YUV420p2RGB = 
COLOR_YUV2RGB_YV12
COLOR_YUV420p2BGR = 
COLOR_YUV2BGR_YV12
COLOR_YUV2RGBA_YV12 = 
102
COLOR_YUV2BGRA_YV12 = 
103
COLOR_YUV2RGBA_IYUV = 
104
COLOR_YUV2BGRA_IYUV = 
105
COLOR_YUV2RGBA_I420 = 
COLOR_YUV2RGBA_IYUV
COLOR_YUV2BGRA_I420 = 
COLOR_YUV2BGRA_IYUV
COLOR_YUV420p2RGBA = 
COLOR_YUV2RGBA_YV12
COLOR_YUV420p2BGRA = 
COLOR_YUV2BGRA_YV12
COLOR_YUV2GRAY_420 = 
106
COLOR_YUV2GRAY_NV21 = 
COLOR_YUV2GRAY_420
COLOR_YUV2GRAY_NV12 = 
COLOR_YUV2GRAY_420
COLOR_YUV2GRAY_YV12 = 
COLOR_YUV2GRAY_420
COLOR_YUV2GRAY_IYUV = 
COLOR_YUV2GRAY_420
COLOR_YUV2GRAY_I420 = 
COLOR_YUV2GRAY_420
COLOR_YUV420sp2GRAY = 
COLOR_YUV2GRAY_420
COLOR_YUV420p2GRAY = 
COLOR_YUV2GRAY_420
COLOR_YUV2RGB_UYVY = 
107
COLOR_YUV2BGR_UYVY = 
108
COLOR_YUV2RGB_Y422 = 
COLOR_YUV2RGB_UYVY
COLOR_YUV2BGR_Y422 = 
COLOR_YUV2BGR_UYVY
COLOR_YUV2RGB_UYNV = 
COLOR_YUV2RGB_UYVY
COLOR_YUV2BGR_UYNV = 
COLOR_YUV2BGR_UYVY
COLOR_YUV2RGBA_UYVY = 
111
COLOR_YUV2BGRA_UYVY = 
112
COLOR_YUV2RGBA_Y422 = 
COLOR_YUV2RGBA_UYVY
COLOR_YUV2BGRA_Y422 = 
COLOR_YUV2BGRA_UYVY
COLOR_YUV2RGBA_UYNV = 
COLOR_YUV2RGBA_UYVY
COLOR_YUV2BGRA_UYNV = 
COLOR_YUV2BGRA_UYVY
COLOR_YUV2RGB_YUY2 = 
115
COLOR_YUV2BGR_YUY2 = 
116
COLOR_YUV2RGB_YVYU = 
117
COLOR_YUV2BGR_YVYU = 
118
COLOR_YUV2RGB_YUYV = 
COLOR_YUV2RGB_YUY2
COLOR_YUV2BGR_YUYV = 
COLOR_YUV2BGR_YUY2
COLOR_YUV2RGB_YUNV = 
COLOR_YUV2RGB_YUY2
COLOR_YUV2BGR_YUNV = 
COLOR_YUV2BGR_YUY2
COLOR_YUV2RGBA_YUY2 = 
119
COLOR_YUV2BGRA_YUY2 = 
120
COLOR_YUV2RGBA_YVYU = 
121
COLOR_YUV2BGRA_YVYU = 
122
COLOR_YUV2RGBA_YUYV = 
COLOR_YUV2RGBA_YUY2
COLOR_YUV2BGRA_YUYV = 
COLOR_YUV2BGRA_YUY2
COLOR_YUV2RGBA_YUNV = 
COLOR_YUV2RGBA_YUY2
COLOR_YUV2BGRA_YUNV = 
COLOR_YUV2BGRA_YUY2
COLOR_YUV2GRAY_UYVY = 
123
COLOR_YUV2GRAY_YUY2 = 
124
COLOR_YUV2GRAY_Y422 = 
COLOR_YUV2GRAY_UYVY
COLOR_YUV2GRAY_UYNV = 
COLOR_YUV2GRAY_UYVY
COLOR_YUV2GRAY_YVYU = 
COLOR_YUV2GRAY_YUY2
COLOR_YUV2GRAY_YUYV = 
COLOR_YUV2GRAY_YUY2
COLOR_YUV2GRAY_YUNV = 
COLOR_YUV2GRAY_YUY2
COLOR_RGBA2mRGBA = 
125
COLOR_mRGBA2RGBA = 
126
COLOR_COLORCVT_MAX = 
127
TM_SQDIFF = 
0
TM_SQDIFF_NORMED = 
1
TM_CCORR = 
2
TM_CCORR_NORMED = 
3
TM_CCOEFF = 
4
TM_CCOEFF_NORMED = 
5
RETR_EXTERNAL = 
CV_RETR_EXTERNAL
RETR_LIST = 
CV_RETR_LIST
RETR_CCOMP = 
CV_RETR_CCOMP
RETR_TREE = 
CV_RETR_TREE
RETR_FLOODFILL = 
CV_RETR_FLOODFILL
CHAIN_APPROX_NONE = 
CV_CHAIN_APPROX_NONE
CHAIN_APPROX_SIMPLE = 
CV_CHAIN_APPROX_SIMPLE
CHAIN_APPROX_TC89_L1 = 
CV_CHAIN_APPROX_TC89_L1
CHAIN_APPROX_TC89_KCOS = 
CV_CHAIN_APPROX_TC89_KCOS
INPAINT_NS = 
CV_INPAINT_NS
INPAINT_TELEA = 
CV_INPAINT_TELEA
CASCADE_DO_CANNY_PRUNING = 
1
CASCADE_SCALE_IMAGE = 
2
CASCADE_FIND_BIGGEST_OBJECT = 
4
CASCADE_DO_ROUGH_SEARCH = 
8
LMEDS = 
CV_LMEDS
RANSAC = 
CV_RANSAC
ITERATIVE = 
CV_ITERATIVE
EPNP = 
CV_EPNP
P3P = 
CV_P3P
CALIB_CB_ADAPTIVE_THRESH = 
1
CALIB_CB_NORMALIZE_IMAGE = 
2
CALIB_CB_FILTER_QUADS = 
4
CALIB_CB_FAST_CHECK = 
8
CALIB_CB_SYMMETRIC_GRID = 
1
CALIB_CB_ASYMMETRIC_GRID = 
2
CALIB_CB_CLUSTERING = 
4
CALIB_USE_INTRINSIC_GUESS = 
CV_CALIB_USE_INTRINSIC_GUESS
CALIB_FIX_ASPECT_RATIO = 
CV_CALIB_FIX_ASPECT_RATIO
CALIB_FIX_PRINCIPAL_POINT = 
CV_CALIB_FIX_PRINCIPAL_POINT
CALIB_ZERO_TANGENT_DIST = 
CV_CALIB_ZERO_TANGENT_DIST
CALIB_FIX_FOCAL_LENGTH = 
CV_CALIB_FIX_FOCAL_LENGTH
CALIB_FIX_K1 = 
CV_CALIB_FIX_K1
CALIB_FIX_K2 = 
CV_CALIB_FIX_K2
CALIB_FIX_K3 = 
CV_CALIB_FIX_K3
CALIB_FIX_K4 = 
CV_CALIB_FIX_K4
CALIB_FIX_K5 = 
CV_CALIB_FIX_K5
CALIB_FIX_K6 = 
CV_CALIB_FIX_K6
CALIB_RATIONAL_MODEL = 
CV_CALIB_RATIONAL_MODEL
CALIB_FIX_INTRINSIC = 
CV_CALIB_FIX_INTRINSIC
CALIB_SAME_FOCAL_LENGTH = 
CV_CALIB_SAME_FOCAL_LENGTH
CALIB_ZERO_DISPARITY = 
CV_CALIB_ZERO_DISPARITY
FM_7POINT = 
CV_FM_7POINT
FM_8POINT = 
CV_FM_8POINT
FM_LMEDS = 
CV_FM_LMEDS
FM_RANSAC = 
CV_FM_RANSAC
WINDOW_NORMAL = 
CV_WINDOW_NORMAL
WINDOW_AUTOSIZE = 
CV_WINDOW_AUTOSIZE
WINDOW_OPENGL = 
CV_WINDOW_OPENGL
WND_PROP_FULLSCREEN = 
CV_WND_PROP_FULLSCREEN
WND_PROP_AUTOSIZE = 
CV_WND_PROP_AUTOSIZE
WND_PROP_ASPECT_RATIO = 
CV_WND_PROP_ASPECTRATIO
WND_PROP_OPENGL = 
CV_WND_PROP_OPENGL
EVENT_MOUSEMOVE = 
0
EVENT_LBUTTONDOWN = 
1
EVENT_RBUTTONDOWN = 
2
EVENT_MBUTTONDOWN = 
3
EVENT_LBUTTONUP = 
4
EVENT_RBUTTONUP = 
5
EVENT_MBUTTONUP = 
6
EVENT_LBUTTONDBLCLK = 
7
EVENT_RBUTTONDBLCLK = 
8
EVENT_MBUTTONDBLCLK = 
9
EVENT_FLAG_LBUTTON = 
1
EVENT_FLAG_RBUTTON = 
2
EVENT_FLAG_MBUTTON = 
4
EVENT_FLAG_CTRLKEY = 
8
EVENT_FLAG_SHIFTKEY = 
16
EVENT_FLAG_ALTKEY = 
32
IMREAD_UNCHANGED = 
-1
IMREAD_GRAYSCALE = 
0
IMREAD_COLOR = 
1
IMREAD_ANYDEPTH = 
2
IMREAD_ANYCOLOR = 
4
IMWRITE_JPEG_QUALITY = 
1
IMWRITE_PNG_COMPRESSION = 
16
IMWRITE_PNG_STRATEGY = 
17
IMWRITE_PNG_BILEVEL = 
18
IMWRITE_PNG_STRATEGY_DEFAULT = 
0
IMWRITE_PNG_STRATEGY_FILTERED = 
1
IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 
2
IMWRITE_PNG_STRATEGY_RLE = 
3
IMWRITE_PNG_STRATEGY_FIXED = 
4
IMWRITE_PXM_BINARY = 
32
ROTATION = 
1
TRANSLATION = 
2
RIGID_BODY_MOTION = 
4
COLORMAP_AUTUMN = 
0
COLORMAP_BONE = 
1
COLORMAP_JET = 
2
COLORMAP_WINTER = 
3
COLORMAP_RAINBOW = 
4
COLORMAP_OCEAN = 
5
COLORMAP_SUMMER = 
6
COLORMAP_SPRING = 
7
COLORMAP_COOL = 
8
COLORMAP_HSV = 
9
COLORMAP_PINK = 
10
COLORMAP_HOT = 
11

Class Method Summary collapse

Class Method Details

.absdiff(_src1, _src2, dst) ⇒ Object

wrapper for void cv::absdiff(const cv::Mat src1, const cv::Mat src2, cv::Mat dst)



1308
1309
1310
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1308

def self.absdiff(_src1, _src2, dst)
    Rbind::cv_absdiff(_src1, _src2, dst)
end

.accumulate(src, dst, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::accumulate(const cv::Mat src, cv::Mat dst, const cv::Mat mask=Mat())



1854
1855
1856
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1854

def self.accumulate(src, dst, mask = Cv::Mat.new())
    Rbind::cv_accumulate(src, dst, mask)
end

.accumulate_product(_src1, _src2, dst, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::accumulateProduct(const cv::Mat src1, const cv::Mat src2, cv::Mat dst, const cv::Mat mask=Mat())



1864
1865
1866
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1864

def self.accumulate_product(_src1, _src2, dst, mask = Cv::Mat.new())
    Rbind::cv_accumulate_product(_src1, _src2, dst, mask)
end

.accumulate_square(src, dst, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::accumulateSquare(const cv::Mat src, cv::Mat dst, const cv::Mat mask=Mat())



1859
1860
1861
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1859

def self.accumulate_square(src, dst, mask = Cv::Mat.new())
    Rbind::cv_accumulate_square(src, dst, mask)
end

.accumulate_weighted(src, dst, alpha, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::accumulateWeighted(const cv::Mat src, cv::Mat dst, double alpha, const cv::Mat mask=Mat())



1869
1870
1871
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1869

def self.accumulate_weighted(src, dst, alpha, mask = Cv::Mat.new())
    Rbind::cv_accumulate_weighted(src, dst, alpha, mask)
end

.adaptive_threshold(src, dst, max_value, adaptive_method, threshold_type, block_size, c) ⇒ Object

wrapper for void cv::adaptiveThreshold(const cv::Mat src, cv::Mat dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)



1899
1900
1901
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1899

def self.adaptive_threshold(src, dst, max_value, adaptive_method, threshold_type, block_size, c)
    Rbind::cv_adaptive_threshold(src, dst, max_value, adaptive_method, threshold_type, block_size, c)
end

.add(_src1, _src2, dst, mask = Cv::Mat.new(), dtype = -1)) ⇒ Object

wrapper for void cv::add(const cv::Mat src1, const cv::Mat src2, cv::Mat dst, const cv::Mat mask=Mat(), int dtype=-1)



1101
1102
1103
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1101

def self.add(_src1, _src2, dst, mask = Cv::Mat.new(), dtype = -1)
    Rbind::cv_add(_src1, _src2, dst, mask, dtype)
end

.add_weighted(_src1, alpha, _src2, beta, gamma, dst, dtype = -1)) ⇒ Object

wrapper for void cv::addWeighted(const cv::Mat src1, double alpha, const cv::Mat src2, double beta, double gamma, cv::Mat dst, int dtype=-1)



1152
1153
1154
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1152

def self.add_weighted(_src1, alpha, _src2, beta, gamma, dst, dtype = -1)
    Rbind::cv_add_weighted(_src1, alpha, _src2, beta, gamma, dst, dtype)
end

.apply_color_map(src, dst, colormap) ⇒ Object

wrapper for void cv::applyColorMap(const cv::Mat src, cv::Mat dst, int colormap)



2389
2390
2391
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2389

def self.apply_color_map(src, dst, colormap)
    Rbind::cv_apply_color_map(src, dst, colormap)
end

.approx_polydp(curve, approx_curve, epsilon, closed) ⇒ Object

wrapper for void cv::approxPolyDP(const cv::Mat curve, cv::Mat approxCurve, double epsilon, bool closed)



2019
2020
2021
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2019

def self.approx_polydp(curve, approx_curve, epsilon, closed)
    Rbind::cv_approx_polydp(curve, approx_curve, epsilon, closed)
end

.arc_length(curve, closed) ⇒ Object

wrapper for double cv::arcLength(const cv::Mat curve, bool closed)



2024
2025
2026
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2024

def self.arc_length(curve, closed)
    Rbind::cv_arc_length(curve, closed)
end

.batch_distance(_src1, _src2, dist, dtype, nidx, norm_type = NORM_L2, k = 0, mask = Cv::Mat.new(), update = 0, crosscheck = false) ⇒ Object

wrapper for void cv::batchDistance(const cv::Mat src1, const cv::Mat src2, cv::Mat dist, int dtype, cv::Mat nidx, int normType=NORM_L2, int K=0, const cv::Mat mask=Mat(), int update=0, bool crosscheck=false)



1223
1224
1225
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1223

def self.batch_distance(_src1, _src2, dist, dtype, nidx, norm_type = NORM_L2, k = 0, mask = Cv::Mat.new(), update = 0, crosscheck = false)
    Rbind::cv_batch_distance(_src1, _src2, dist, dtype, nidx, norm_type, k, mask, update, crosscheck)
end

.bilateral_filter(src, dst, d, sigma_color, sigma_space, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::bilateralFilter(const cv::Mat src, cv::Mat dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)



1684
1685
1686
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1684

def self.bilateral_filter(src, dst, d, sigma_color, sigma_space, border_type = BORDER_DEFAULT)
    Rbind::cv_bilateral_filter(src, dst, d, sigma_color, sigma_space, border_type)
end

.bitwise_and(_src1, _src2, dst, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::bitwise_and(const cv::Mat src1, const cv::Mat src2, cv::Mat dst, const cv::Mat mask=Mat())



1288
1289
1290
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1288

def self.bitwise_and(_src1, _src2, dst, mask = Cv::Mat.new())
    Rbind::cv_bitwise_and(_src1, _src2, dst, mask)
end

.bitwise_not(src, dst, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::bitwise_not(const cv::Mat src, cv::Mat dst, const cv::Mat mask=Mat())



1303
1304
1305
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1303

def self.bitwise_not(src, dst, mask = Cv::Mat.new())
    Rbind::cv_bitwise_not(src, dst, mask)
end

.bitwise_or(_src1, _src2, dst, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::bitwise_or(const cv::Mat src1, const cv::Mat src2, cv::Mat dst, const cv::Mat mask=Mat())



1293
1294
1295
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1293

def self.bitwise_or(_src1, _src2, dst, mask = Cv::Mat.new())
    Rbind::cv_bitwise_or(_src1, _src2, dst, mask)
end

.bitwise_xor(_src1, _src2, dst, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::bitwise_xor(const cv::Mat src1, const cv::Mat src2, cv::Mat dst, const cv::Mat mask=Mat())



1298
1299
1300
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1298

def self.bitwise_xor(_src1, _src2, dst, mask = Cv::Mat.new())
    Rbind::cv_bitwise_xor(_src1, _src2, dst, mask)
end

.blur(src, dst, ksize, anchor = Cv::Point.new(-1,-1), border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::blur(const cv::Mat src, cv::Mat dst, const cv::Size ksize, const cv::Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)



1694
1695
1696
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1694

def self.blur(src, dst, ksize, anchor = Cv::Point.new(-1,-1), border_type = BORDER_DEFAULT)
    Rbind::cv_blur(src, dst, ksize, anchor, border_type)
end

.border_interpolate(p, len, border_type) ⇒ Object

wrapper for int cv::borderInterpolate(int p, int len, int borderType)



1644
1645
1646
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1644

def self.border_interpolate(p, len, border_type)
    Rbind::cv_border_interpolate(p, len, border_type)
end

.bounding_rect(points) ⇒ Object

wrapper for cv::Rect cv::boundingRect(const cv::Mat points)



2029
2030
2031
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2029

def self.bounding_rect(points)
    Rbind::cv_bounding_rect(points)
end

.box_filter(src, dst, ddepth, ksize, anchor = Cv::Point.new(-1,-1), normalize = true, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::boxFilter(const cv::Mat src, cv::Mat dst, int ddepth, const cv::Size ksize, const cv::Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)



1689
1690
1691
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1689

def self.box_filter(src, dst, ddepth, ksize, anchor = Cv::Point.new(-1,-1), normalize = true, border_type = BORDER_DEFAULT)
    Rbind::cv_box_filter(src, dst, ddepth, ksize, anchor, normalize, border_type)
end

.calc_back_project(images, channels, hist, dst, ranges, scale) ⇒ Object

wrapper for void cv::calcBackProject(const vector_Mat images, const vector_int channels, const cv::Mat hist, cv::Mat dst, const vector_float ranges, double scale)



1944
1945
1946
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1944

def self.calc_back_project(images, channels, hist, dst, ranges, scale)
    Rbind::cv_calc_back_project(images, channels, hist, dst, ranges, scale)
end

.calc_covar_matrix(samples, covar, mean, flags, ctype = CV_64F) ⇒ Object

wrapper for void cv::calcCovarMatrix(const cv::Mat samples, cv::Mat covar, cv::Mat mean, int flags, int ctype=CV_64F)



1473
1474
1475
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1473

def self.calc_covar_matrix(samples, covar, mean, flags, ctype = CV_64F)
    Rbind::cv_calc_covar_matrix(samples, covar, mean, flags, ctype)
end

.calc_hist(images, channels, mask, hist, hist_size, ranges, accumulate = false) ⇒ Object

wrapper for void cv::calcHist(const vector_Mat images, const vector_int channels, const cv::Mat mask, cv::Mat hist, const vector_int histSize, const vector_float ranges, bool accumulate=false)



1939
1940
1941
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1939

def self.calc_hist(images, channels, mask, hist, hist_size, ranges, accumulate = false)
    Rbind::cv_calc_hist(images, channels, mask, hist, hist_size, ranges, accumulate)
end

.calibrate_camera(object_points, image_points, image_size, camera_matrix, dist_coeffs, rvecs, tvecs, flags = 0, criteria = Cv::TermCriteria.new( TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON)) ⇒ Object

wrapper for double cv::calibrateCamera(const vector_Mat objectPoints, const vector_Mat imagePoints, const cv::Size imageSize, cv::Mat cameraMatrix, cv::Mat distCoeffs, vector_Mat rvecs, vector_Mat tvecs, int flags=0, const cv::TermCriteria criteria=TermCriteria( TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))



2204
2205
2206
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2204

def self.calibrate_camera(object_points, image_points, image_size, camera_matrix, dist_coeffs, rvecs, tvecs, flags = 0, criteria = Cv::TermCriteria.new( TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
    Rbind::cv_calibrate_camera(object_points, image_points, image_size, camera_matrix, dist_coeffs, rvecs, tvecs, flags, criteria)
end

.calibration_matrix_values(camera_matrix, image_size, aperture_width, aperture_height, fovx, fovy, focal_length, principal_point, aspect_ratio) ⇒ Object

wrapper for void cv::calibrationMatrixValues(const cv::Mat cameraMatrix, const cv::Size imageSize, double apertureWidth, double apertureHeight, double fovx, double fovy, double focalLength, cv::Point2d principalPoint, double aspectRatio)



2209
2210
2211
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2209

def self.calibration_matrix_values(camera_matrix, image_size, aperture_width, aperture_height, fovx, fovy, focal_length, principal_point, aspect_ratio)
    Rbind::cv_calibration_matrix_values(camera_matrix, image_size, aperture_width, aperture_height, fovx, fovy, focal_length, principal_point, aspect_ratio)
end

.canny(image, edges, _threshold1, _threshold2, aperture_size = 3, _l2gradient = false) ⇒ Object

wrapper for void cv::Canny(const cv::Mat image, cv::Mat edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)



1724
1725
1726
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1724

def self.canny(image, edges, _threshold1, _threshold2, aperture_size = 3, _l2gradient = false)
    Rbind::cv_canny(image, edges, _threshold1, _threshold2, aperture_size, _l2gradient)
end

.cart_to_polar(x, y, magnitude, angle, angle_in_degrees = false) ⇒ Object

wrapper for void cv::cartToPolar(const cv::Mat x, const cv::Mat y, cv::Mat magnitude, cv::Mat angle, bool angleInDegrees=false)



1368
1369
1370
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1368

def self.cart_to_polar(x, y, magnitude, angle, angle_in_degrees = false)
    Rbind::cv_cart_to_polar(x, y, magnitude, angle, angle_in_degrees)
end

.chamer_matching(img, templ, results, cost, templ_scale = 1, max_matches = 20, min_match_distance = 1.0, pad_x = 3, pad_y = 3, scales = 5, min_scale = 0.6, max_scale = 1.6, orientation_weight = 0.5, truncate = 20) ⇒ Object

wrapper for int cv::chamerMatching(cv::Mat img, cv::Mat templ, vector_vector_Point results, vector_float cost, double templScale=1, int maxMatches=20, double minMatchDistance=1.0, int padX=3, int padY=3, int scales=5, double minScale=0.6, double maxScale=1.6, double orientationWeight=0.5, double truncate=20)



2369
2370
2371
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2369

def self.chamer_matching(img, templ, results, cost, templ_scale = 1, max_matches = 20, min_match_distance = 1.0, pad_x = 3, pad_y = 3, scales = 5, min_scale = 0.6, max_scale = 1.6, orientation_weight = 0.5, truncate = 20)
    Rbind::cv_chamer_matching(img, templ, results, cost, templ_scale, max_matches, min_match_distance, pad_x, pad_y, scales, min_scale, max_scale, orientation_weight, truncate)
end

.check_hardware_support(feature) ⇒ Object

wrapper for bool cv::checkHardwareSupport(int feature)



1081
1082
1083
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1081

def self.check_hardware_support(feature)
    Rbind::cv_check_hardware_support(feature)
end

.check_range(a, quiet = true, pos = 0, min_val = -DBL_MAX,, max_val = DBL_MAX) ⇒ Object

wrapper for bool cv::checkRange(const cv::Mat a, bool quiet=true, cv::Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)



1383
1384
1385
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1383

def self.check_range(a, quiet = true, pos = 0, min_val = -DBL_MAX, max_val = DBL_MAX)
    Rbind::cv_check_range(a, quiet, pos, min_val, max_val)
end

.circle(img, center, radius, color, thickness = 1, line_type = 8, shift = 0) ⇒ Object

wrapper for void cv::circle(cv::Mat img, const cv::Point center, int radius, const cv::Scalar color, int thickness=1, int lineType=8, int shift=0)



1573
1574
1575
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1573

def self.circle(img, center, radius, color, thickness = 1, line_type = 8, shift = 0)
    Rbind::cv_circle(img, center, radius, color, thickness, line_type, shift)
end

.clip_line(img_rect, _pt1, _pt2) ⇒ Object

wrapper for bool cv::clipLine(const cv::Rect imgRect, cv::Point pt1, cv::Point pt2)



1624
1625
1626
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1624

def self.clip_line(img_rect, _pt1, _pt2)
    Rbind::cv_clip_line(img_rect, _pt1, _pt2)
end

.compare(_src1, _src2, dst, cmpop) ⇒ Object

wrapper for void cv::compare(const cv::Mat src1, const cv::Mat src2, cv::Mat dst, int cmpop)



1318
1319
1320
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1318

def self.compare(_src1, _src2, dst, cmpop)
    Rbind::cv_compare(_src1, _src2, dst, cmpop)
end

.compare_hist(_h1, _h2, method) ⇒ Object

wrapper for double cv::compareHist(const cv::Mat H1, const cv::Mat H2, int method)



1949
1950
1951
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1949

def self.compare_hist(_h1, _h2, method)
    Rbind::cv_compare_hist(_h1, _h2, method)
end

.complete_symm(mtx, lower_to_upper = false) ⇒ Object

wrapper for void cv::completeSymm(cv::Mat mtx, bool lowerToUpper=false)



1418
1419
1420
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1418

def self.complete_symm(mtx, lower_to_upper = false)
    Rbind::cv_complete_symm(mtx, lower_to_upper)
end

.composert(_rvec1, _tvec1, _rvec2, _tvec2, _rvec3, _tvec3, _dr3dr1 = Cv::Mat.new(), _dr3dt1 = Cv::Mat.new(), _dr3dr2 = Cv::Mat.new(), _dr3dt2 = Cv::Mat.new(), _dt3dr1 = Cv::Mat.new(), _dt3dt1 = Cv::Mat.new(), _dt3dr2 = Cv::Mat.new(), _dt3dt2 = Cv::Mat.new()) ⇒ Object

wrapper for void cv::composeRT(const cv::Mat rvec1, const cv::Mat tvec1, const cv::Mat rvec2, const cv::Mat tvec2, cv::Mat rvec3, cv::Mat tvec3, cv::Mat dr3dr1=Mat(), cv::Mat dr3dt1=Mat(), cv::Mat dr3dr2=Mat(), cv::Mat dr3dt2=Mat(), cv::Mat dt3dr1=Mat(), cv::Mat dt3dt1=Mat(), cv::Mat dt3dr2=Mat(), cv::Mat dt3dt2=Mat())



2159
2160
2161
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2159

def self.composert(_rvec1, _tvec1, _rvec2, _tvec2, _rvec3, _tvec3, _dr3dr1 = Cv::Mat.new(), _dr3dt1 = Cv::Mat.new(), _dr3dr2 = Cv::Mat.new(), _dr3dt2 = Cv::Mat.new(), _dt3dr1 = Cv::Mat.new(), _dt3dt1 = Cv::Mat.new(), _dt3dr2 = Cv::Mat.new(), _dt3dt2 = Cv::Mat.new())
    Rbind::cv_composert(_rvec1, _tvec1, _rvec2, _tvec2, _rvec3, _tvec3, _dr3dr1, _dr3dt1, _dr3dr2, _dr3dt2, _dt3dr1, _dt3dt1, _dt3dr2, _dt3dt2)
end

.contour_area(contour, oriented = false) ⇒ Object

wrapper for double cv::contourArea(const cv::Mat contour, bool oriented=false)



2034
2035
2036
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2034

def self.contour_area(contour, oriented = false)
    Rbind::cv_contour_area(contour, oriented)
end

.convert_maps(_map1, _map2, _dstmap1, _dstmap2, _dstmap1type, nninterpolation = false) ⇒ Object

wrapper for void cv::convertMaps(const cv::Mat map1, const cv::Mat map2, cv::Mat dstmap1, cv::Mat dstmap2, int dstmap1type, bool nninterpolation=false)



1809
1810
1811
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1809

def self.convert_maps(_map1, _map2, _dstmap1, _dstmap2, _dstmap1type, nninterpolation = false)
    Rbind::cv_convert_maps(_map1, _map2, _dstmap1, _dstmap2, _dstmap1type, nninterpolation)
end

.convert_points_from_homogeneous(src, dst) ⇒ Object

wrapper for void cv::convertPointsFromHomogeneous(const cv::Mat src, cv::Mat dst)



2244
2245
2246
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2244

def self.convert_points_from_homogeneous(src, dst)
    Rbind::cv_convert_points_from_homogeneous(src, dst)
end

.convert_points_to_homogeneous(src, dst) ⇒ Object

wrapper for void cv::convertPointsToHomogeneous(const cv::Mat src, cv::Mat dst)



2239
2240
2241
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2239

def self.convert_points_to_homogeneous(src, dst)
    Rbind::cv_convert_points_to_homogeneous(src, dst)
end

.convert_scale_abs(src, dst, alpha = 1, beta = 0) ⇒ Object

wrapper for void cv::convertScaleAbs(const cv::Mat src, cv::Mat dst, double alpha=1, double beta=0)



1157
1158
1159
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1157

def self.convert_scale_abs(src, dst, alpha = 1, beta = 0)
    Rbind::cv_convert_scale_abs(src, dst, alpha, beta)
end

.convex_hull(points, hull, clockwise = false, return_points = true) ⇒ Object

wrapper for void cv::convexHull(const cv::Mat points, cv::Mat hull, bool clockwise=false, bool returnPoints=true)



2054
2055
2056
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2054

def self.convex_hull(points, hull, clockwise = false, return_points = true)
    Rbind::cv_convex_hull(points, hull, clockwise, return_points)
end

.convexity_defects(contour, convexhull, convexity_defects) ⇒ Object

wrapper for void cv::convexityDefects(const cv::Mat contour, const cv::Mat convexhull, cv::Mat convexityDefects)



2059
2060
2061
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2059

def self.convexity_defects(contour, convexhull, convexity_defects)
    Rbind::cv_convexity_defects(contour, convexhull, convexity_defects)
end

.copy_make_border(src, dst, top, bottom, left, right, border_type, value = Cv::Scalar.new()) ⇒ Object

wrapper for void cv::copyMakeBorder(const cv::Mat src, cv::Mat dst, int top, int bottom, int left, int right, int borderType, const cv::Scalar value=Scalar())



1669
1670
1671
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1669

def self.copy_make_border(src, dst, top, bottom, left, right, border_type, value = Cv::Scalar.new())
    Rbind::cv_copy_make_border(src, dst, top, bottom, left, right, border_type, value)
end

.corner_eigen_vals_and_vecs(src, dst, block_size, ksize, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::cornerEigenValsAndVecs(const cv::Mat src, cv::Mat dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT)



1739
1740
1741
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1739

def self.corner_eigen_vals_and_vecs(src, dst, block_size, ksize, border_type = BORDER_DEFAULT)
    Rbind::cv_corner_eigen_vals_and_vecs(src, dst, block_size, ksize, border_type)
end

.corner_harris(src, dst, block_size, ksize, k, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::cornerHarris(const cv::Mat src, cv::Mat dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT)



1734
1735
1736
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1734

def self.corner_harris(src, dst, block_size, ksize, k, border_type = BORDER_DEFAULT)
    Rbind::cv_corner_harris(src, dst, block_size, ksize, k, border_type)
end

.corner_min_eigen_val(src, dst, block_size, ksize = 3, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::cornerMinEigenVal(const cv::Mat src, cv::Mat dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT)



1729
1730
1731
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1729

def self.corner_min_eigen_val(src, dst, block_size, ksize = 3, border_type = BORDER_DEFAULT)
    Rbind::cv_corner_min_eigen_val(src, dst, block_size, ksize, border_type)
end

.corner_sub_pix(image, corners, win_size, zero_zone, criteria) ⇒ Object

wrapper for void cv::cornerSubPix(const cv::Mat image, cv::Mat corners, const cv::Size winSize, const cv::Size zeroZone, const cv::TermCriteria criteria)



1749
1750
1751
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1749

def self.corner_sub_pix(image, corners, win_size, zero_zone, criteria)
    Rbind::cv_corner_sub_pix(image, corners, win_size, zero_zone, criteria)
end

.correct_matches(f, _points1, _points2, _new_points1, _new_points2) ⇒ Object

wrapper for void cv::correctMatches(const cv::Mat F, const cv::Mat points1, const cv::Mat points2, cv::Mat newPoints1, cv::Mat newPoints2)



2259
2260
2261
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2259

def self.correct_matches(f, _points1, _points2, _new_points1, _new_points2)
    Rbind::cv_correct_matches(f, _points1, _points2, _new_points1, _new_points2)
end

.count_non_zero(src) ⇒ Object

wrapper for int cv::countNonZero(const cv::Mat src)



1172
1173
1174
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1172

def self.count_non_zero(src)
    Rbind::cv_count_non_zero(src)
end

.create_eigen_face_recognizer(num_components = 0, threshold = DBL_MAX) ⇒ Object

wrapper for Ptr_FaceRecognizer cv::createEigenFaceRecognizer(int num_components=0, double threshold=DBL_MAX)



2374
2375
2376
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2374

def self.create_eigen_face_recognizer(num_components = 0, threshold = DBL_MAX)
    Rbind::cv_create_eigen_face_recognizer(num_components, threshold)
end

.create_fisher_face_recognizer(num_components = 0, threshold = DBL_MAX) ⇒ Object

wrapper for Ptr_FaceRecognizer cv::createFisherFaceRecognizer(int num_components=0, double threshold=DBL_MAX)



2379
2380
2381
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2379

def self.create_fisher_face_recognizer(num_components = 0, threshold = DBL_MAX)
    Rbind::cv_create_fisher_face_recognizer(num_components, threshold)
end

.create_hanning_window(dst, win_size, type) ⇒ Object

wrapper for void cv::createHanningWindow(cv::Mat dst, const cv::Size winSize, int type)



1889
1890
1891
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1889

def self.create_hanning_window(dst, win_size, type)
    Rbind::cv_create_hanning_window(dst, win_size, type)
end

.createlbph_face_recognizer(radius = 1, neighbors = 8, grid_x = 8, grid_y = 8, threshold = DBL_MAX) ⇒ Object

wrapper for Ptr_FaceRecognizer cv::createLBPHFaceRecognizer(int radius=1, int neighbors=8, int grid_x=8, int grid_y=8, double threshold=DBL_MAX)



2384
2385
2386
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2384

def self.createlbph_face_recognizer(radius = 1, neighbors = 8, grid_x = 8, grid_y = 8, threshold = DBL_MAX)
    Rbind::cv_createlbph_face_recognizer(radius, neighbors, grid_x, grid_y, threshold)
end

.cube_root(val) ⇒ Object

wrapper for float cv::cubeRoot(float val)



1353
1354
1355
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1353

def self.cube_root(val)
    Rbind::cv_cube_root(val)
end

.cvt_color(src, dst, code, dst_cn = 0) ⇒ Object

wrapper for void cv::cvtColor(const cv::Mat src, cv::Mat dst, int code, int dstCn=0)



1989
1990
1991
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1989

def self.cvt_color(src, dst, code, dst_cn = 0)
    Rbind::cv_cvt_color(src, dst, code, dst_cn)
end

.dct(src, dst, flags = 0) ⇒ Object

wrapper for void cv::dct(const cv::Mat src, cv::Mat dst, int flags=0)



1523
1524
1525
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1523

def self.dct(src, dst, flags = 0)
    Rbind::cv_dct(src, dst, flags)
end

.decompose_projection_matrix(proj_matrix, camera_matrix, rot_matrix, trans_vect, rot_matrix_x = Cv::Mat.new(), rot_matrix_y = Cv::Mat.new(), rot_matrix_z = Cv::Mat.new(), euler_angles = Cv::Mat.new()) ⇒ Object

wrapper for void cv::decomposeProjectionMatrix(const cv::Mat projMatrix, cv::Mat cameraMatrix, cv::Mat rotMatrix, cv::Mat transVect, cv::Mat rotMatrixX=Mat(), cv::Mat rotMatrixY=Mat(), cv::Mat rotMatrixZ=Mat(), cv::Mat eulerAngles=Mat())



2149
2150
2151
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2149

def self.decompose_projection_matrix(proj_matrix, camera_matrix, rot_matrix, trans_vect, rot_matrix_x = Cv::Mat.new(), rot_matrix_y = Cv::Mat.new(), rot_matrix_z = Cv::Mat.new(), euler_angles = Cv::Mat.new())
    Rbind::cv_decompose_projection_matrix(proj_matrix, camera_matrix, rot_matrix, trans_vect, rot_matrix_x, rot_matrix_y, rot_matrix_z, euler_angles)
end

.destroy_all_windows ⇒ Object

wrapper for void cv::destroyAllWindows()



2299
2300
2301
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2299

def self.destroy_all_windows()
    Rbind::cv_destroy_all_windows()
end

.destroy_window(winname) ⇒ Object

wrapper for void cv::destroyWindow(const cv::String winname)



2294
2295
2296
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2294

def self.destroy_window(winname)
    Rbind::cv_destroy_window(winname)
end

.determinant(mtx) ⇒ Object

wrapper for double cv::determinant(const cv::Mat mtx)



1428
1429
1430
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1428

def self.determinant(mtx)
    Rbind::cv_determinant(mtx)
end

.dft(src, dst, flags = 0, nonzero_rows = 0) ⇒ Object

wrapper for void cv::dft(const cv::Mat src, cv::Mat dst, int flags=0, int nonzeroRows=0)



1513
1514
1515
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1513

def self.dft(src, dst, flags = 0, nonzero_rows = 0)
    Rbind::cv_dft(src, dst, flags, nonzero_rows)
end

.dilate(src, dst, kernel, anchor = Cv::Point.new(-1,-1), iterations = 1, border_type = BORDER_CONSTANT, border_value = morphology_default_border_value()) ⇒ Object

wrapper for void cv::dilate(const cv::Mat src, cv::Mat dst, const cv::Mat kernel, const cv::Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const cv::Scalar borderValue=morphologyDefaultBorderValue())



1779
1780
1781
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1779

def self.dilate(src, dst, kernel, anchor = Cv::Point.new(-1,-1), iterations = 1, border_type = BORDER_CONSTANT, border_value = morphology_default_border_value())
    Rbind::cv_dilate(src, dst, kernel, anchor, iterations, border_type, border_value)
end

.distance_transform(src, dst, distance_type, mask_size) ⇒ Object

wrapper for void cv::distanceTransform(const cv::Mat src, cv::Mat dst, int distanceType, int maskSize)



1979
1980
1981
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1979

def self.distance_transform(src, dst, distance_type, mask_size)
    Rbind::cv_distance_transform(src, dst, distance_type, mask_size)
end

.distance_transform_with_labels(src, dst, labels, distance_type, mask_size, label_type = DIST_LABEL_CCOMP) ⇒ Object

wrapper for void cv::distanceTransform(const cv::Mat src, cv::Mat dst, cv::Mat labels, int distanceType, int maskSize, int labelType=DIST_LABEL_CCOMP)



1974
1975
1976
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1974

def self.distance_transform_with_labels(src, dst, labels, distance_type, mask_size, label_type = DIST_LABEL_CCOMP)
    Rbind::cv_distance_transform_with_labels(src, dst, labels, distance_type, mask_size, label_type)
end

.divide(*args) ⇒ Object

wrapper for overloaded method divide

Raises:

  • (ArgumentError) 


1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1116

def self.divide(*args)
    # wrapper for void cv::divide(const cv::Mat src1, const cv::Mat src2, cv::Mat dst, double scale=1, int dtype=-1)
    @@cv_divide_defaults0 ||= [nil, nil, nil, 1, -1]
    if(args.size >= 3 && args.size <= 5)
        args.size.upto(4) do |i|
            args[i] = @@cv_divide_defaults0[i]
        end
        begin
            return Rbind::cv_divide(*args)
        rescue TypeError => e
            @error = e
        end
    end

    # wrapper for void cv::divide(double scale, const cv::Mat src2, cv::Mat dst, int dtype=-1)
    @@cv_divide2_defaults1 ||= [nil, nil, nil, -1]
    if(args.size >= 3 && args.size <= 4)
        args.size.upto(3) do |i|
            args[i] = @@cv_divide2_defaults1[i]
        end
        begin
            return Rbind::cv_divide2(*args)
        rescue TypeError => e
            @error = e
        end
    end

    raise ArgumentError, "No overloaded signature fits to: #{args.map(&:class)}"
end

.draw_chessboard_corners(image, pattern_size, corners, pattern_was_found) ⇒ Object

wrapper for void cv::drawChessboardCorners(cv::Mat image, const cv::Size patternSize, const cv::Mat corners, bool patternWasFound)



2189
2190
2191
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2189

def self.draw_chessboard_corners(image, pattern_size, corners, pattern_was_found)
    Rbind::cv_draw_chessboard_corners(image, pattern_size, corners, pattern_was_found)
end

.draw_contours(image, contours, contour_idx, color, thickness = 1, line_type = 8, hierarchy = Cv::Mat.new(), max_level = INT_MAX, offset = Cv::Point.new()) ⇒ Object

wrapper for void cv::drawContours(cv::Mat image, const vector_Mat contours, int contourIdx, const cv::Scalar color, int thickness=1, int lineType=8, const cv::Mat hierarchy=Mat(), int maxLevel=INT_MAX, const cv::Point offset=Point())



2014
2015
2016
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2014

def self.draw_contours(image, contours, contour_idx, color, thickness = 1, line_type = 8, hierarchy = Cv::Mat.new(), max_level = INT_MAX, offset = Cv::Point.new())
    Rbind::cv_draw_contours(image, contours, contour_idx, color, thickness, line_type, hierarchy, max_level, offset)
end

.draw_data_matrix_codes(image, codes, corners) ⇒ Object

wrapper for void cv::drawDataMatrixCodes(cv::Mat image, const vector_string codes, const cv::Mat corners)



2129
2130
2131
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2129

def self.draw_data_matrix_codes(image, codes, corners)
    Rbind::cv_draw_data_matrix_codes(image, codes, corners)
end

.draw_keypoints(image, keypoints, out_image, color = Cv::Scalar::all(-1), flags = DrawMatchesFlags::DEFAULT) ⇒ Object

wrapper for void cv::drawKeypoints(const cv::Mat image, const vector_KeyPoint keypoints, cv::Mat outImage, const cv::Scalar color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT)



2114
2115
2116
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2114

def self.draw_keypoints(image, keypoints, out_image, color = Cv::Scalar::all(-1), flags = DrawMatchesFlags::DEFAULT)
    Rbind::cv_draw_keypoints(image, keypoints, out_image, color, flags)
end

.draw_matches(_img1, _keypoints1, _img2, _keypoints2, _matches1to2, out_img, match_color = Cv::Scalar::all(-1), single_point_color = Cv::Scalar::all(-1), matches_mask = VectorChar.new(), flags = DrawMatchesFlags::DEFAULT) ⇒ Object

wrapper for void cv::drawMatches(const cv::Mat img1, const vector_KeyPoint keypoints1, const cv::Mat img2, const vector_KeyPoint keypoints2, const vector_DMatch matches1to2, cv::Mat outImg, const cv::Scalar matchColor=Scalar::all(-1), const cv::Scalar singlePointColor=Scalar::all(-1), const vector_char matchesMask=vector_char(), int flags=DrawMatchesFlags::DEFAULT)



2399
2400
2401
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2399

def self.draw_matches(_img1, _keypoints1, _img2, _keypoints2, _matches1to2, out_img, match_color = Cv::Scalar::all(-1), single_point_color = Cv::Scalar::all(-1), matches_mask = VectorChar.new(), flags = DrawMatchesFlags::DEFAULT)
    Rbind::cv_draw_matches(_img1, _keypoints1, _img2, _keypoints2, _matches1to2, out_img, match_color, single_point_color, matches_mask, flags)
end

.eigen(src, compute_eigenvectors, eigenvalues, eigenvectors) ⇒ Object

wrapper for bool cv::eigen(const cv::Mat src, bool computeEigenvectors, cv::Mat eigenvalues, cv::Mat eigenvectors)



1468
1469
1470
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1468

def self.eigen(src, compute_eigenvectors, eigenvalues, eigenvectors)
    Rbind::cv_eigen(src, compute_eigenvectors, eigenvalues, eigenvectors)
end

.ellipse(*args) ⇒ Object

wrapper for overloaded method ellipse

Raises:

  • (ArgumentError) 


1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1578

def self.ellipse(*args)
    # wrapper for void cv::ellipse(cv::Mat img, const cv::Point center, const cv::Size axes, double angle, double startAngle, double endAngle, const cv::Scalar color, int thickness=1, int lineType=8, int shift=0)
    @@cv_ellipse_defaults0 ||= [nil, nil, nil, nil, nil, nil, nil, 1, 8, 0]
    if(args.size >= 7 && args.size <= 10)
        args.size.upto(9) do |i|
            args[i] = @@cv_ellipse_defaults0[i]
        end
        begin
            return Rbind::cv_ellipse(*args)
        rescue TypeError => e
            @error = e
        end
    end

    # wrapper for void cv::ellipse(cv::Mat img, const cv::RotatedRect box, const cv::Scalar color, int thickness=1, int lineType=8)
    @@cv_ellipse2_defaults1 ||= [nil, nil, nil, 1, 8]
    if(args.size >= 3 && args.size <= 5)
        args.size.upto(4) do |i|
            args[i] = @@cv_ellipse2_defaults1[i]
        end
        begin
            return Rbind::cv_ellipse2(*args)
        rescue TypeError => e
            @error = e
        end
    end

    raise ArgumentError, "No overloaded signature fits to: #{args.map(&:class)}"
end

.ellipse2_poly(center, axes, angle, arc_start, arc_end, delta, pts) ⇒ Object

wrapper for void cv::ellipse2Poly(const cv::Point center, const cv::Size axes, int angle, int arcStart, int arcEnd, int delta, vector_Point pts)



1629
1630
1631
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1629

def self.ellipse2_poly(center, axes, angle, arc_start, arc_end, delta, pts)
    Rbind::cv_ellipse2_poly(center, axes, angle, arc_start, arc_end, delta, pts)
end

.equalize_hist(src, dst) ⇒ Object

wrapper for void cv::equalizeHist(const cv::Mat src, cv::Mat dst)



1954
1955
1956
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1954

def self.equalize_hist(src, dst)
    Rbind::cv_equalize_hist(src, dst)
end

.erode(src, dst, kernel, anchor = Cv::Point.new(-1,-1), iterations = 1, border_type = BORDER_CONSTANT, border_value = morphology_default_border_value()) ⇒ Object

wrapper for void cv::erode(const cv::Mat src, cv::Mat dst, const cv::Mat kernel, const cv::Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const cv::Scalar borderValue=morphologyDefaultBorderValue())



1774
1775
1776
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1774

def self.erode(src, dst, kernel, anchor = Cv::Point.new(-1,-1), iterations = 1, border_type = BORDER_CONSTANT, border_value = morphology_default_border_value())
    Rbind::cv_erode(src, dst, kernel, anchor, iterations, border_type, border_value)
end

.estimate_affine3d(src, dst, out, inliers, ransac_threshold = 3, confidence = 0.99) ⇒ Object

wrapper for int cv::estimateAffine3D(const cv::Mat src, const cv::Mat dst, cv::Mat out, cv::Mat inliers, double ransacThreshold=3, double confidence=0.99)



2284
2285
2286
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2284

def self.estimate_affine3d(src, dst, out, inliers, ransac_threshold = 3, confidence = 0.99)
    Rbind::cv_estimate_affine3d(src, dst, out, inliers, ransac_threshold, confidence)
end

.exp(src, dst) ⇒ Object

wrapper for void cv::exp(const cv::Mat src, cv::Mat dst)



1343
1344
1345
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1343

def self.exp(src, dst)
    Rbind::cv_exp(src, dst)
end

.extract_channel(src, dst, coi) ⇒ Object

wrapper for void cv::extractChannel(const cv::Mat src, cv::Mat dst, int coi)



1258
1259
1260
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1258

def self.extract_channel(src, dst, coi)
    Rbind::cv_extract_channel(src, dst, coi)
end

.fast_atan2(y, x) ⇒ Object

wrapper for float cv::fastAtan2(float y, float x)



1358
1359
1360
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1358

def self.fast_atan2(y, x)
    Rbind::cv_fast_atan2(y, x)
end

.fast_nl_means_denoising(src, dst, h = 3, template_window_size = 7, search_window_size = 21) ⇒ Object

wrapper for void cv::fastNlMeansDenoising(const cv::Mat src, cv::Mat dst, float h=3, int templateWindowSize=7, int searchWindowSize=21)



2094
2095
2096
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2094

def self.fast_nl_means_denoising(src, dst, h = 3, template_window_size = 7, search_window_size = 21)
    Rbind::cv_fast_nl_means_denoising(src, dst, h, template_window_size, search_window_size)
end

.fast_nl_means_denoising_colored(src, dst, h = 3, h_color = 3, template_window_size = 7, search_window_size = 21) ⇒ Object

wrapper for void cv::fastNlMeansDenoisingColored(const cv::Mat src, cv::Mat dst, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21)



2099
2100
2101
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2099

def self.fast_nl_means_denoising_colored(src, dst, h = 3, h_color = 3, template_window_size = 7, search_window_size = 21)
    Rbind::cv_fast_nl_means_denoising_colored(src, dst, h, h_color, template_window_size, search_window_size)
end

.fast_nl_means_denoising_colored_multi(src_imgs, dst, img_to_denoise_index, temporal_window_size, h = 3, h_color = 3, template_window_size = 7, search_window_size = 21) ⇒ Object

wrapper for void cv::fastNlMeansDenoisingColoredMulti(const vector_Mat srcImgs, cv::Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21)



2109
2110
2111
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2109

def self.fast_nl_means_denoising_colored_multi(src_imgs, dst, img_to_denoise_index, temporal_window_size, h = 3, h_color = 3, template_window_size = 7, search_window_size = 21)
    Rbind::cv_fast_nl_means_denoising_colored_multi(src_imgs, dst, img_to_denoise_index, temporal_window_size, h, h_color, template_window_size, search_window_size)
end

.fast_nl_means_denoising_multi(src_imgs, dst, img_to_denoise_index, temporal_window_size, h = 3, template_window_size = 7, search_window_size = 21) ⇒ Object

wrapper for void cv::fastNlMeansDenoisingMulti(const vector_Mat srcImgs, cv::Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, int templateWindowSize=7, int searchWindowSize=21)



2104
2105
2106
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2104

def self.fast_nl_means_denoising_multi(src_imgs, dst, img_to_denoise_index, temporal_window_size, h = 3, template_window_size = 7, search_window_size = 21)
    Rbind::cv_fast_nl_means_denoising_multi(src_imgs, dst, img_to_denoise_index, temporal_window_size, h, template_window_size, search_window_size)
end

.fill_convex_poly(img, points, color, line_type = 8, shift = 0) ⇒ Object

wrapper for void cv::fillConvexPoly(cv::Mat img, const cv::Mat points, const cv::Scalar color, int lineType=8, int shift=0)



1609
1610
1611
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1609

def self.fill_convex_poly(img, points, color, line_type = 8, shift = 0)
    Rbind::cv_fill_convex_poly(img, points, color, line_type, shift)
end

.fill_poly(img, pts, color, line_type = 8, shift = 0, offset = Cv::Point.new()) ⇒ Object

wrapper for void cv::fillPoly(cv::Mat img, const vector_Mat pts, const cv::Scalar color, int lineType=8, int shift=0, const cv::Point offset=Point())



1614
1615
1616
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1614

def self.fill_poly(img, pts, color, line_type = 8, shift = 0, offset = Cv::Point.new())
    Rbind::cv_fill_poly(img, pts, color, line_type, shift, offset)
end

.filter2d(src, dst, ddepth, kernel, anchor = Cv::Point.new(-1,-1), delta = 0, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::filter2D(const cv::Mat src, cv::Mat dst, int ddepth, const cv::Mat kernel, const cv::Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)



1699
1700
1701
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1699

def self.filter2d(src, dst, ddepth, kernel, anchor = Cv::Point.new(-1,-1), delta = 0, border_type = BORDER_DEFAULT)
    Rbind::cv_filter2d(src, dst, ddepth, kernel, anchor, delta, border_type)
end

.filter_speckles(img, new_val, max_speckle_size, max_diff, buf = Cv::Mat.new()) ⇒ Object

wrapper for void cv::filterSpeckles(cv::Mat img, double newVal, int maxSpeckleSize, double maxDiff, cv::Mat buf=Mat())



2264
2265
2266
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2264

def self.filter_speckles(img, new_val, max_speckle_size, max_diff, buf = Cv::Mat.new())
    Rbind::cv_filter_speckles(img, new_val, max_speckle_size, max_diff, buf)
end

.find_chessboard_corners(image, pattern_size, corners, flags = CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE) ⇒ Object

wrapper for bool cv::findChessboardCorners(const cv::Mat image, const cv::Size patternSize, cv::Mat corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE)



2184
2185
2186
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2184

def self.find_chessboard_corners(image, pattern_size, corners, flags = CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE)
    Rbind::cv_find_chessboard_corners(image, pattern_size, corners, flags)
end

.find_circles_grid(image, pattern_size, centers, flags = CALIB_CB_SYMMETRIC_GRID, blob_detector = Cv::SimpleBlobDetector.new()) ⇒ Object

wrapper for bool cv::findCirclesGrid(const cv::Mat image, const cv::Size patternSize, cv::Mat centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr_FeatureDetector blobDetector=new SimpleBlobDetector())



2194
2195
2196
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2194

def self.find_circles_grid(image, pattern_size, centers, flags = CALIB_CB_SYMMETRIC_GRID, blob_detector = Cv::SimpleBlobDetector.new())
    Rbind::cv_find_circles_grid(image, pattern_size, centers, flags, blob_detector)
end

.find_circles_grid_default(image, pattern_size, centers, flags = CALIB_CB_SYMMETRIC_GRID) ⇒ Object

wrapper for bool cv::findCirclesGridDefault(const cv::Mat image, const cv::Size patternSize, cv::Mat centers, int flags=CALIB_CB_SYMMETRIC_GRID)



2199
2200
2201
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2199

def self.find_circles_grid_default(image, pattern_size, centers, flags = CALIB_CB_SYMMETRIC_GRID)
    Rbind::cv_find_circles_grid_default(image, pattern_size, centers, flags)
end

.find_contours(image, contours, hierarchy, mode, method, offset = Cv::Point.new()) ⇒ Object

wrapper for void cv::findContours(cv::Mat image, vector_Mat contours, cv::Mat hierarchy, int mode, int method, const cv::Point offset=Point())



2009
2010
2011
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2009

def self.find_contours(image, contours, hierarchy, mode, method, offset = Cv::Point.new())
    Rbind::cv_find_contours(image, contours, hierarchy, mode, method, offset)
end

.find_data_matrix(image, codes, corners = Cv::Mat.new(), dmtx = VectorMat.new()) ⇒ Object

wrapper for void cv::findDataMatrix(const cv::Mat image, vector_string codes, cv::Mat corners=Mat(), vector_Mat dmtx=vector_Mat())



2124
2125
2126
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2124

def self.find_data_matrix(image, codes, corners = Cv::Mat.new(), dmtx = VectorMat.new())
    Rbind::cv_find_data_matrix(image, codes, corners, dmtx)
end

.find_fundamental_mat(_points1, _points2, method = FM_RANSAC, _param1 = 3.0, _param2 = 0.99, mask = Cv::Mat.new()) ⇒ Object

wrapper for cv::Mat cv::findFundamentalMat(const cv::Mat points1, const cv::Mat points2, int method=FM_RANSAC, double param1=3., double param2=0.99, cv::Mat mask=Mat())



2249
2250
2251
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2249

def self.find_fundamental_mat(_points1, _points2, method = FM_RANSAC, _param1 = 3.0, _param2 = 0.99, mask = Cv::Mat.new())
    Rbind::cv_find_fundamental_mat(_points1, _points2, method, _param1, _param2, mask)
end

.find_homography(src_points, dst_points, method = 0, ransac_reproj_threshold = 3, mask = Cv::Mat.new()) ⇒ Object

wrapper for cv::Mat cv::findHomography(const cv::Mat srcPoints, const cv::Mat dstPoints, int method=0, double ransacReprojThreshold=3, cv::Mat mask=Mat())



2139
2140
2141
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2139

def self.find_homography(src_points, dst_points, method = 0, ransac_reproj_threshold = 3, mask = Cv::Mat.new())
    Rbind::cv_find_homography(src_points, dst_points, method, ransac_reproj_threshold, mask)
end

.find_non_zero(src, idx) ⇒ Object

wrapper for void cv::findNonZero(const cv::Mat src, cv::Mat idx)



1177
1178
1179
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1177

def self.find_non_zero(src, idx)
    Rbind::cv_find_non_zero(src, idx)
end

.fit_ellipse(points) ⇒ Object

wrapper for cv::RotatedRect cv::fitEllipse(const cv::Mat points)



2074
2075
2076
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2074

def self.fit_ellipse(points)
    Rbind::cv_fit_ellipse(points)
end

.fit_line(points, line, dist_type, param, reps, aeps) ⇒ Object

wrapper for void cv::fitLine(const cv::Mat points, cv::Mat line, int distType, double param, double reps, double aeps)



2079
2080
2081
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2079

def self.fit_line(points, line, dist_type, param, reps, aeps)
    Rbind::cv_fit_line(points, line, dist_type, param, reps, aeps)
end

.flip(src, dst, flip_code) ⇒ Object

wrapper for void cv::flip(const cv::Mat src, cv::Mat dst, int flipCode)



1268
1269
1270
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1268

def self.flip(src, dst, flip_code)
    Rbind::cv_flip(src, dst, flip_code)
end

.flood_fill(image, mask, seed_point, new_val, rect = 0, lo_diff = Cv::Scalar.new(), up_diff = Cv::Scalar.new(), flags = 4) ⇒ Object

wrapper for int cv::floodFill(cv::Mat image, cv::Mat mask, const cv::Point seedPoint, const cv::Scalar newVal, cv::Rect *rect=0, const cv::Scalar loDiff=Scalar(), const cv::Scalar upDiff=Scalar(), int flags=4)



1984
1985
1986
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1984

def self.flood_fill(image, mask, seed_point, new_val, rect = 0, lo_diff = Cv::Scalar.new(), up_diff = Cv::Scalar.new(), flags = 4)
    Rbind::cv_flood_fill(image, mask, seed_point, new_val, rect, lo_diff, up_diff, flags)
end

.gaussian_blur(src, dst, ksize, sigma_x, sigma_y = 0, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::GaussianBlur(const cv::Mat src, cv::Mat dst, const cv::Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT)



1679
1680
1681
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1679

def self.gaussian_blur(src, dst, ksize, sigma_x, sigma_y = 0, border_type = BORDER_DEFAULT)
    Rbind::cv_gaussian_blur(src, dst, ksize, sigma_x, sigma_y, border_type)
end

.gemm(_src1, _src2, alpha, _src3, gamma, dst, flags = 0) ⇒ Object

wrapper for void cv::gemm(const cv::Mat src1, const cv::Mat src2, double alpha, const cv::Mat src3, double gamma, cv::Mat dst, int flags=0)



1393
1394
1395
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1393

def self.gemm(_src1, _src2, alpha, _src3, gamma, dst, flags = 0)
    Rbind::cv_gemm(_src1, _src2, alpha, _src3, gamma, dst, flags)
end

.get_affine_transform(src, dst) ⇒ Object

wrapper for cv::Mat cv::getAffineTransform(const cv::Mat src, const cv::Mat dst)



1829
1830
1831
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1829

def self.get_affine_transform(src, dst)
    Rbind::cv_get_affine_transform(src, dst)
end

.get_build_information ⇒ Object

wrapper for cv::String cv::getBuildInformation()



1061
1062
1063
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1061

def self.get_build_information()
    Rbind::cv_get_build_information()
end

.get_default_new_camera_matrix(camera_matrix, imgsize = Cv::Size.new(), center_principal_point = false) ⇒ Object

wrapper for cv::Mat cv::getDefaultNewCameraMatrix(const cv::Mat cameraMatrix, const cv::Size imgsize=Size(), bool centerPrincipalPoint=false)



1929
1930
1931
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1929

def self.get_default_new_camera_matrix(camera_matrix, imgsize = Cv::Size.new(), center_principal_point = false)
    Rbind::cv_get_default_new_camera_matrix(camera_matrix, imgsize, center_principal_point)
end

.get_deriv_kernels(kx, ky, dx, dy, ksize, normalize = false, ktype = CV_32F) ⇒ Object

wrapper for void cv::getDerivKernels(cv::Mat kx, cv::Mat ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F)



1654
1655
1656
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1654

def self.get_deriv_kernels(kx, ky, dx, dy, ksize, normalize = false, ktype = CV_32F)
    Rbind::cv_get_deriv_kernels(kx, ky, dx, dy, ksize, normalize, ktype)
end

.get_gabor_kernel(ksize, sigma, theta, lambd, gamma, psi = CV_PI*0.5, ktype = CV_64F) ⇒ Object

wrapper for cv::Mat cv::getGaborKernel(const cv::Size ksize, double sigma, double theta, double lambd, double gamma, double psi=CV_PI*0.5, int ktype=CV_64F)



1659
1660
1661
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1659

def self.get_gabor_kernel(ksize, sigma, theta, lambd, gamma, psi = CV_PI*0.5, ktype = CV_64F)
    Rbind::cv_get_gabor_kernel(ksize, sigma, theta, lambd, gamma, psi, ktype)
end

.get_gaussian_kernel(ksize, sigma, ktype = CV_64F) ⇒ Object

wrapper for cv::Mat cv::getGaussianKernel(int ksize, double sigma, int ktype=CV_64F)



1649
1650
1651
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1649

def self.get_gaussian_kernel(ksize, sigma, ktype = CV_64F)
    Rbind::cv_get_gaussian_kernel(ksize, sigma, ktype)
end

.get_number_ofcp_us ⇒ Object

wrapper for int cv::getNumberOfCPUs()



1086
1087
1088
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1086

def self.get_number_ofcp_us()
    Rbind::cv_get_number_ofcp_us()
end

.get_optimal_new_camera_matrix(camera_matrix, dist_coeffs, image_size, alpha, new_img_size = Cv::Size.new(), valid_pix_r_o_i = 0, center_principal_point = false) ⇒ Object

wrapper for cv::Mat cv::getOptimalNewCameraMatrix(const cv::Mat cameraMatrix, const cv::Mat distCoeffs, const cv::Size imageSize, double alpha, const cv::Size newImgSize=Size(), cv::Rect *validPixROI=0, bool centerPrincipalPoint=false)



2234
2235
2236
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2234

def self.get_optimal_new_camera_matrix(camera_matrix, dist_coeffs, image_size, alpha, new_img_size = Cv::Size.new(), valid_pix_r_o_i = 0, center_principal_point = false)
    Rbind::cv_get_optimal_new_camera_matrix(camera_matrix, dist_coeffs, image_size, alpha, new_img_size, valid_pix_r_o_i, center_principal_point)
end

.get_optimaldft_size(vecsize) ⇒ Object

wrapper for int cv::getOptimalDFTSize(int vecsize)



1538
1539
1540
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1538

def self.get_optimaldft_size(vecsize)
    Rbind::cv_get_optimaldft_size(vecsize)
end

.get_perspective_transform(src, dst) ⇒ Object

wrapper for cv::Mat cv::getPerspectiveTransform(const cv::Mat src, const cv::Mat dst)



1824
1825
1826
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1824

def self.get_perspective_transform(src, dst)
    Rbind::cv_get_perspective_transform(src, dst)
end

.get_rect_sub_pix(image, patch_size, center, patch, patch_type = -1)) ⇒ Object

wrapper for void cv::getRectSubPix(const cv::Mat image, const cv::Size patchSize, const cv::Point2f center, cv::Mat patch, int patchType=-1)



1834
1835
1836
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1834

def self.get_rect_sub_pix(image, patch_size, center, patch, patch_type = -1)
    Rbind::cv_get_rect_sub_pix(image, patch_size, center, patch, patch_type)
end

.get_rotation_matrix2d(center, angle, scale) ⇒ Object

wrapper for cv::Mat cv::getRotationMatrix2D(const cv::Point2f center, double angle, double scale)



1814
1815
1816
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1814

def self.get_rotation_matrix2d(center, angle, scale)
    Rbind::cv_get_rotation_matrix2d(center, angle, scale)
end

.get_structuring_element(shape, ksize, anchor = Cv::Point.new(-1,-1)) ⇒ Object

wrapper for cv::Mat cv::getStructuringElement(int shape, const cv::Size ksize, const cv::Point anchor=Point(-1,-1))



1664
1665
1666
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1664

def self.get_structuring_element(shape, ksize, anchor = Cv::Point.new(-1,-1))
    Rbind::cv_get_structuring_element(shape, ksize, anchor)
end

.get_text_size(text, font_face, font_scale, thickness, base_line) ⇒ Object

wrapper for cv::Size cv::getTextSize(const cv::String text, int fontFace, double fontScale, int thickness, int *baseLine)



1639
1640
1641
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1639

def self.get_text_size(text, font_face, font_scale, thickness, base_line)
    Rbind::cv_get_text_size(text, font_face, font_scale, thickness, base_line)
end

.get_tick_count ⇒ Object

wrapper for int64 cv::getTickCount()



1066
1067
1068
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1066

def self.get_tick_count()
    Rbind::cv_get_tick_count()
end

.get_tick_frequency ⇒ Object

wrapper for double cv::getTickFrequency()



1071
1072
1073
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1071

def self.get_tick_frequency()
    Rbind::cv_get_tick_frequency()
end

.get_trackbar_pos(trackbarname, winname) ⇒ Object

wrapper for int cv::getTrackbarPos(const cv::String trackbarname, const cv::String winname)



2339
2340
2341
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2339

def self.get_trackbar_pos(trackbarname, winname)
    Rbind::cv_get_trackbar_pos(trackbarname, winname)
end

.get_valid_disparityroi(_roi1, _roi2, min_disparity, number_of_disparities, s_a_d_window_size) ⇒ Object

wrapper for cv::Rect cv::getValidDisparityROI(const cv::Rect roi1, const cv::Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)



2269
2270
2271
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2269

def self.get_valid_disparityroi(_roi1, _roi2, min_disparity, number_of_disparities, s_a_d_window_size)
    Rbind::cv_get_valid_disparityroi(_roi1, _roi2, min_disparity, number_of_disparities, s_a_d_window_size)
end

.get_window_property(winname, prop_id) ⇒ Object

wrapper for double cv::getWindowProperty(const cv::String winname, int prop_id)



2334
2335
2336
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2334

def self.get_window_property(winname, prop_id)
    Rbind::cv_get_window_property(winname, prop_id)
end

.getcpu_tick_count ⇒ Object

wrapper for int64 cv::getCPUTickCount()



1076
1077
1078
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1076

def self.getcpu_tick_count()
    Rbind::cv_getcpu_tick_count()
end

.good_features_to_track(image, corners, max_corners, quality_level, min_distance, mask = Cv::Mat.new(), block_size = 3, use_harris_detector = false, k = 0.04) ⇒ Object

wrapper for void cv::goodFeaturesToTrack(const cv::Mat image, cv::Mat corners, int maxCorners, double qualityLevel, double minDistance, const cv::Mat mask=Mat(), int blockSize=3, bool useHarrisDetector=false, double k=0.04)



1754
1755
1756
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1754

def self.good_features_to_track(image, corners, max_corners, quality_level, min_distance, mask = Cv::Mat.new(), block_size = 3, use_harris_detector = false, k = 0.04)
    Rbind::cv_good_features_to_track(image, corners, max_corners, quality_level, min_distance, mask, block_size, use_harris_detector, k)
end

.grab_cut(img, mask, rect, bgd_model, fgd_model, iter_count, mode = GC_EVAL) ⇒ Object

wrapper for void cv::grabCut(const cv::Mat img, cv::Mat mask, const cv::Rect rect, cv::Mat bgdModel, cv::Mat fgdModel, int iterCount, int mode=GC_EVAL)



1969
1970
1971
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1969

def self.grab_cut(img, mask, rect, bgd_model, fgd_model, iter_count, mode = GC_EVAL)
    Rbind::cv_grab_cut(img, mask, rect, bgd_model, fgd_model, iter_count, mode)
end

.group_rectangles(rect_list, weights, group_threshold, eps = 0.2) ⇒ Object

wrapper for void cv::groupRectangles(vector_Rect rectList, vector_int weights, int groupThreshold, double eps=0.2)



2119
2120
2121
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2119

def self.group_rectangles(rect_list, weights, group_threshold, eps = 0.2)
    Rbind::cv_group_rectangles(rect_list, weights, group_threshold, eps)
end

.hconcat(src, dst) ⇒ Object

wrapper for void cv::hconcat(const vector_Mat src, cv::Mat dst)



1278
1279
1280
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1278

def self.hconcat(src, dst)
    Rbind::cv_hconcat(src, dst)
end

.hough_circles(image, circles, method, dp, min_dist, _param1 = 100, _param2 = 100, min_radius = 0, max_radius = 0) ⇒ Object

wrapper for void cv::HoughCircles(const cv::Mat image, cv::Mat circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0)



1769
1770
1771
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1769

def self.hough_circles(image, circles, method, dp, min_dist, _param1 = 100, _param2 = 100, min_radius = 0, max_radius = 0)
    Rbind::cv_hough_circles(image, circles, method, dp, min_dist, _param1, _param2, min_radius, max_radius)
end

.hough_lines(image, lines, rho, theta, threshold, srn = 0, stn = 0) ⇒ Object

wrapper for void cv::HoughLines(const cv::Mat image, cv::Mat lines, double rho, double theta, int threshold, double srn=0, double stn=0)



1759
1760
1761
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1759

def self.hough_lines(image, lines, rho, theta, threshold, srn = 0, stn = 0)
    Rbind::cv_hough_lines(image, lines, rho, theta, threshold, srn, stn)
end

.hough_linesp(image, lines, rho, theta, threshold, min_line_length = 0, max_line_gap = 0) ⇒ Object

wrapper for void cv::HoughLinesP(const cv::Mat image, cv::Mat lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0)



1764
1765
1766
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1764

def self.hough_linesp(image, lines, rho, theta, threshold, min_line_length = 0, max_line_gap = 0)
    Rbind::cv_hough_linesp(image, lines, rho, theta, threshold, min_line_length, max_line_gap)
end

.hu_moments(m, hu) ⇒ Object

wrapper for void cv::HuMoments(const cv::Moments m, cv::Mat hu)



1999
2000
2001
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1999

def self.hu_moments(m, hu)
    Rbind::cv_hu_moments(m, hu)
end

.idct(src, dst, flags = 0) ⇒ Object

wrapper for void cv::idct(const cv::Mat src, cv::Mat dst, int flags=0)



1528
1529
1530
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1528

def self.idct(src, dst, flags = 0)
    Rbind::cv_idct(src, dst, flags)
end

.idft(src, dst, flags = 0, nonzero_rows = 0) ⇒ Object

wrapper for void cv::idft(const cv::Mat src, cv::Mat dst, int flags=0, int nonzeroRows=0)



1518
1519
1520
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1518

def self.idft(src, dst, flags = 0, nonzero_rows = 0)
    Rbind::cv_idft(src, dst, flags, nonzero_rows)
end

.imdecode(buf, flags) ⇒ Object

wrapper for cv::Mat cv::imdecode(const cv::Mat buf, int flags)



2359
2360
2361
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2359

def self.imdecode(buf, flags)
    Rbind::cv_imdecode(buf, flags)
end

.imencode(ext, img, buf, params = VectorInt.new()) ⇒ Object

wrapper for bool cv::imencode(const cv::String ext, const cv::Mat img, vector_uchar buf, const vector_int params=vector_int())



2364
2365
2366
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2364

def self.imencode(ext, img, buf, params = VectorInt.new())
    Rbind::cv_imencode(ext, img, buf, params)
end

.imread(filename, flags = 1) ⇒ Object

wrapper for cv::Mat cv::imread(const cv::String filename, int flags=1)



2349
2350
2351
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2349

def self.imread(filename, flags = 1)
    Rbind::cv_imread(filename, flags)
end

.imshow(winname, mat) ⇒ Object

wrapper for void cv::imshow(const cv::String winname, const cv::Mat mat)



2314
2315
2316
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2314

def self.imshow(winname, mat)
    Rbind::cv_imshow(winname, mat)
end

.imwrite(filename, img, params = VectorInt.new()) ⇒ Object

wrapper for bool cv::imwrite(const cv::String filename, const cv::Mat img, const vector_int params=vector_int())



2354
2355
2356
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2354

def self.imwrite(filename, img, params = VectorInt.new())
    Rbind::cv_imwrite(filename, img, params)
end

.in_range(src, lowerb, upperb, dst) ⇒ Object

wrapper for void cv::inRange(const cv::Mat src, const cv::Mat lowerb, const cv::Mat upperb, cv::Mat dst)



1313
1314
1315
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1313

def self.in_range(src, lowerb, upperb, dst)
    Rbind::cv_in_range(src, lowerb, upperb, dst)
end

.init_camera_matrix2d(object_points, image_points, image_size, aspect_ratio = 1.0) ⇒ Object

wrapper for cv::Mat cv::initCameraMatrix2D(const vector_Mat objectPoints, const vector_Mat imagePoints, const cv::Size imageSize, double aspectRatio=1.)



2179
2180
2181
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2179

def self.init_camera_matrix2d(object_points, image_points, image_size, aspect_ratio = 1.0)
    Rbind::cv_init_camera_matrix2d(object_points, image_points, image_size, aspect_ratio)
end

.init_module_nonfree ⇒ Object

wrapper for bool cv::initModule_nonfree()



2394
2395
2396
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2394

def self.init_module_nonfree()
    Rbind::cv_init_module_nonfree()
end

.init_undistort_rectify_map(camera_matrix, dist_coeffs, r, new_camera_matrix, size, _m1type, _map1, _map2) ⇒ Object

wrapper for void cv::initUndistortRectifyMap(const cv::Mat cameraMatrix, const cv::Mat distCoeffs, const cv::Mat R, const cv::Mat newCameraMatrix, const cv::Size size, int m1type, cv::Mat map1, cv::Mat map2)



1919
1920
1921
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1919

def self.init_undistort_rectify_map(camera_matrix, dist_coeffs, r, new_camera_matrix, size, _m1type, _map1, _map2)
    Rbind::cv_init_undistort_rectify_map(camera_matrix, dist_coeffs, r, new_camera_matrix, size, _m1type, _map1, _map2)
end

.init_wide_angle_proj_map(camera_matrix, dist_coeffs, image_size, dest_image_width, _m1type, _map1, _map2, proj_type = PROJ_SPHERICAL_EQRECT, alpha = 0) ⇒ Object

wrapper for float cv::initWideAngleProjMap(const cv::Mat cameraMatrix, const cv::Mat distCoeffs, const cv::Size imageSize, int destImageWidth, int m1type, cv::Mat map1, cv::Mat map2, int projType=PROJ_SPHERICAL_EQRECT, double alpha=0)



1924
1925
1926
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1924

def self.init_wide_angle_proj_map(camera_matrix, dist_coeffs, image_size, dest_image_width, _m1type, _map1, _map2, proj_type = PROJ_SPHERICAL_EQRECT, alpha = 0)
    Rbind::cv_init_wide_angle_proj_map(camera_matrix, dist_coeffs, image_size, dest_image_width, _m1type, _map1, _map2, proj_type, alpha)
end

.inpaint(src, inpaint_mask, dst, inpaint_radius, flags) ⇒ Object

wrapper for void cv::inpaint(const cv::Mat src, const cv::Mat inpaintMask, cv::Mat dst, double inpaintRadius, int flags)



2089
2090
2091
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2089

def self.inpaint(src, inpaint_mask, dst, inpaint_radius, flags)
    Rbind::cv_inpaint(src, inpaint_mask, dst, inpaint_radius, flags)
end

.insert_channel(src, dst, coi) ⇒ Object

wrapper for void cv::insertChannel(const cv::Mat src, cv::Mat dst, int coi)



1263
1264
1265
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1263

def self.insert_channel(src, dst, coi)
    Rbind::cv_insert_channel(src, dst, coi)
end

.integral(src, sum, sdepth = -1)) ⇒ Object

wrapper for void cv::integral(const cv::Mat src, cv::Mat sum, int sdepth=-1)



1839
1840
1841
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1839

def self.integral(src, sum, sdepth = -1)
    Rbind::cv_integral(src, sum, sdepth)
end

.integral2(src, sum, sqsum, sdepth = -1)) ⇒ Object

wrapper for void cv::integral(const cv::Mat src, cv::Mat sum, cv::Mat sqsum, int sdepth=-1)



1844
1845
1846
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1844

def self.integral2(src, sum, sqsum, sdepth = -1)
    Rbind::cv_integral2(src, sum, sqsum, sdepth)
end

.integral3(src, sum, sqsum, tilted, sdepth = -1)) ⇒ Object

wrapper for void cv::integral(const cv::Mat src, cv::Mat sum, cv::Mat sqsum, cv::Mat tilted, int sdepth=-1)



1849
1850
1851
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1849

def self.integral3(src, sum, sqsum, tilted, sdepth = -1)
    Rbind::cv_integral3(src, sum, sqsum, tilted, sdepth)
end

.intersect_convex_convex(__p1, __p2, __p12, handle_nested = true) ⇒ Object

wrapper for float cv::intersectConvexConvex(const cv::Mat _p1, const cv::Mat _p2, cv::Mat _p12, bool handleNested=true)



2069
2070
2071
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2069

def self.intersect_convex_convex(__p1, __p2, __p12, handle_nested = true)
    Rbind::cv_intersect_convex_convex(__p1, __p2, __p12, handle_nested)
end

.invert(src, dst, flags = DECOMP_LU) ⇒ Object

wrapper for double cv::invert(const cv::Mat src, cv::Mat dst, int flags=DECOMP_LU)



1438
1439
1440
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1438

def self.invert(src, dst, flags = DECOMP_LU)
    Rbind::cv_invert(src, dst, flags)
end

.invert_affine_transform(m, i_m) ⇒ Object

wrapper for void cv::invertAffineTransform(const cv::Mat M, cv::Mat iM)



1819
1820
1821
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1819

def self.invert_affine_transform(m, i_m)
    Rbind::cv_invert_affine_transform(m, i_m)
end

.is_contour_convex(contour) ⇒ Object

wrapper for bool cv::isContourConvex(const cv::Mat contour)



2064
2065
2066
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2064

def self.is_contour_convex(contour)
    Rbind::cv_is_contour_convex(contour)
end

.kmeans(data, k, best_labels, criteria, attempts, flags, centers = Cv::Mat.new()) ⇒ Object

wrapper for double cv::kmeans(const cv::Mat data, int K, cv::Mat bestLabels, const cv::TermCriteria criteria, int attempts, int flags, cv::Mat centers=Mat())



1543
1544
1545
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1543

def self.kmeans(data, k, best_labels, criteria, attempts, flags, centers = Cv::Mat.new())
    Rbind::cv_kmeans(data, k, best_labels, criteria, attempts, flags, centers)
end

.laplacian(src, dst, ddepth, ksize = 1, scale = 1, delta = 0, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::Laplacian(const cv::Mat src, cv::Mat dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)



1719
1720
1721
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1719

def self.laplacian(src, dst, ddepth, ksize = 1, scale = 1, delta = 0, border_type = BORDER_DEFAULT)
    Rbind::cv_laplacian(src, dst, ddepth, ksize, scale, delta, border_type)
end

.line(img, _pt1, _pt2, color, thickness = 1, line_type = 8, shift = 0) ⇒ Object

wrapper for void cv::line(cv::Mat img, const cv::Point pt1, const cv::Point pt2, const cv::Scalar color, int thickness=1, int lineType=8, int shift=0)



1563
1564
1565
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1563

def self.line(img, _pt1, _pt2, color, thickness = 1, line_type = 8, shift = 0)
    Rbind::cv_line(img, _pt1, _pt2, color, thickness, line_type, shift)
end

.log(src, dst) ⇒ Object

wrapper for void cv::log(const cv::Mat src, cv::Mat dst)



1348
1349
1350
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1348

def self.log(src, dst)
    Rbind::cv_log(src, dst)
end

.lut(src, lut, dst, interpolation = 0) ⇒ Object

wrapper for void cv::LUT(const cv::Mat src, const cv::Mat lut, cv::Mat dst, int interpolation=0)



1162
1163
1164
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1162

def self.lut(src, lut, dst, interpolation = 0)
    Rbind::cv_lut(src, lut, dst, interpolation)
end

.magnitude(x, y, magnitude) ⇒ Object

wrapper for void cv::magnitude(const cv::Mat x, const cv::Mat y, cv::Mat magnitude)



1378
1379
1380
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1378

def self.magnitude(x, y, magnitude)
    Rbind::cv_magnitude(x, y, magnitude)
end

.mahalanobis(_v1, _v2, icovar) ⇒ Object

wrapper for double cv::Mahalanobis(const cv::Mat v1, const cv::Mat v2, const cv::Mat icovar)



1508
1509
1510
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1508

def self.mahalanobis(_v1, _v2, icovar)
    Rbind::cv_mahalanobis(_v1, _v2, icovar)
end

.mat_mul_deriv(a, b, d_a_bd_a, d_a_bd_b) ⇒ Object

wrapper for void cv::matMulDeriv(const cv::Mat A, const cv::Mat B, cv::Mat dABdA, cv::Mat dABdB)



2154
2155
2156
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2154

def self.mat_mul_deriv(a, b, d_a_bd_a, d_a_bd_b)
    Rbind::cv_mat_mul_deriv(a, b, d_a_bd_a, d_a_bd_b)
end

.match_shapes(_contour1, _contour2, method, parameter) ⇒ Object

wrapper for double cv::matchShapes(const cv::Mat contour1, const cv::Mat contour2, int method, double parameter)



2049
2050
2051
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2049

def self.match_shapes(_contour1, _contour2, method, parameter)
    Rbind::cv_match_shapes(_contour1, _contour2, method, parameter)
end

.match_template(image, templ, result, method) ⇒ Object

wrapper for void cv::matchTemplate(const cv::Mat image, const cv::Mat templ, cv::Mat result, int method)



2004
2005
2006
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2004

def self.match_template(image, templ, result, method)
    Rbind::cv_match_template(image, templ, result, method)
end

.max(_src1, _src2, dst) ⇒ Object

wrapper for void cv::max(const cv::Mat src1, const cv::Mat src2, cv::Mat dst)



1328
1329
1330
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1328

def self.max(_src1, _src2, dst)
    Rbind::cv_max(_src1, _src2, dst)
end

.mean(src, mask = Cv::Mat.new()) ⇒ Object

wrapper for cv::Scalar cv::mean(const cv::Mat src, const cv::Mat mask=Mat())



1182
1183
1184
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1182

def self.mean(src, mask = Cv::Mat.new())
    Rbind::cv_mean(src, mask)
end

.mean_std_dev(src, mean, stddev, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::meanStdDev(const cv::Mat src, cv::Mat mean, cv::Mat stddev, const cv::Mat mask=Mat())



1187
1188
1189
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1187

def self.mean_std_dev(src, mean, stddev, mask = Cv::Mat.new())
    Rbind::cv_mean_std_dev(src, mean, stddev, mask)
end

.median_blur(src, dst, ksize) ⇒ Object

wrapper for void cv::medianBlur(const cv::Mat src, cv::Mat dst, int ksize)



1674
1675
1676
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1674

def self.median_blur(src, dst, ksize)
    Rbind::cv_median_blur(src, dst, ksize)
end

.merge(mv, dst) ⇒ Object

wrapper for void cv::merge(const vector_Mat mv, cv::Mat dst)



1243
1244
1245
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1243

def self.merge(mv, dst)
    Rbind::cv_merge(mv, dst)
end

.min(_src1, _src2, dst) ⇒ Object

wrapper for void cv::min(const cv::Mat src1, const cv::Mat src2, cv::Mat dst)



1323
1324
1325
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1323

def self.min(_src1, _src2, dst)
    Rbind::cv_min(_src1, _src2, dst)
end

.min_area_rect(points) ⇒ Object

wrapper for cv::RotatedRect cv::minAreaRect(const cv::Mat points)



2039
2040
2041
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2039

def self.min_area_rect(points)
    Rbind::cv_min_area_rect(points)
end

.min_enclosing_circle(points, center, radius) ⇒ Object

wrapper for void cv::minEnclosingCircle(const cv::Mat points, cv::Point2f center, float radius)



2044
2045
2046
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2044

def self.min_enclosing_circle(points, center, radius)
    Rbind::cv_min_enclosing_circle(points, center, radius)
end

.min_max_loc(src, min_val, max_val = 0, min_loc = 0, max_loc = 0, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::minMaxLoc(const cv::Mat src, double *minVal, double *maxVal=0, cv::Point *minLoc=0, cv::Point *maxLoc=0, const cv::Mat mask=Mat())



1233
1234
1235
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1233

def self.min_max_loc(src, min_val, max_val = 0, min_loc = 0, max_loc = 0, mask = Cv::Mat.new())
    Rbind::cv_min_max_loc(src, min_val, max_val, min_loc, max_loc, mask)
end

.mix_channels(src, dst, from_to) ⇒ Object

wrapper for void cv::mixChannels(const vector_Mat src, const vector_Mat dst, const vector_int fromTo)



1253
1254
1255
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1253

def self.mix_channels(src, dst, from_to)
    Rbind::cv_mix_channels(src, dst, from_to)
end

.moments(array, binary_image = false) ⇒ Object

wrapper for cv::Moments cv::moments(const cv::Mat array, bool binaryImage=false)



1994
1995
1996
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1994

def self.moments(array, binary_image = false)
    Rbind::cv_moments(array, binary_image)
end

.morphology_default_border_value ⇒ Object

wrapper for cv::Scalar cv::morphologyDefaultBorderValue()



2404
2405
2406
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2404

def self.morphology_default_border_value()
    Rbind::cv_morphology_default_border_value()
end

.morphology_ex(src, dst, op, kernel, anchor = Cv::Point.new(-1,-1), iterations = 1, border_type = BORDER_CONSTANT, border_value = morphology_default_border_value()) ⇒ Object

wrapper for void cv::morphologyEx(const cv::Mat src, cv::Mat dst, int op, const cv::Mat kernel, const cv::Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const cv::Scalar borderValue=morphologyDefaultBorderValue())



1784
1785
1786
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1784

def self.morphology_ex(src, dst, op, kernel, anchor = Cv::Point.new(-1,-1), iterations = 1, border_type = BORDER_CONSTANT, border_value = morphology_default_border_value())
    Rbind::cv_morphology_ex(src, dst, op, kernel, anchor, iterations, border_type, border_value)
end

.move_window(winname, x, y) ⇒ Object

wrapper for void cv::moveWindow(const cv::String winname, int x, int y)



2324
2325
2326
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2324

def self.move_window(winname, x, y)
    Rbind::cv_move_window(winname, x, y)
end

.mul_spectrums(a, b, c, flags, conj_b = false) ⇒ Object

wrapper for void cv::mulSpectrums(const cv::Mat a, const cv::Mat b, cv::Mat c, int flags, bool conjB=false)



1533
1534
1535
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1533

def self.mul_spectrums(a, b, c, flags, conj_b = false)
    Rbind::cv_mul_spectrums(a, b, c, flags, conj_b)
end

.mul_transposed(src, dst, a_ta, delta = Cv::Mat.new(), scale = 1, dtype = -1)) ⇒ Object

wrapper for void cv::mulTransposed(const cv::Mat src, cv::Mat dst, bool aTa, const cv::Mat delta=Mat(), double scale=1, int dtype=-1)



1398
1399
1400
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1398

def self.mul_transposed(src, dst, a_ta, delta = Cv::Mat.new(), scale = 1, dtype = -1)
    Rbind::cv_mul_transposed(src, dst, a_ta, delta, scale, dtype)
end

.multiply(_src1, _src2, dst, scale = 1, dtype = -1)) ⇒ Object

wrapper for void cv::multiply(const cv::Mat src1, const cv::Mat src2, cv::Mat dst, double scale=1, int dtype=-1)



1111
1112
1113
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1111

def self.multiply(_src1, _src2, dst, scale = 1, dtype = -1)
    Rbind::cv_multiply(_src1, _src2, dst, scale, dtype)
end

.named_window(winname, flags = WINDOW_AUTOSIZE) ⇒ Object

wrapper for void cv::namedWindow(const cv::String winname, int flags=WINDOW_AUTOSIZE)



2289
2290
2291
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2289

def self.named_window(winname, flags = WINDOW_AUTOSIZE)
    Rbind::cv_named_window(winname, flags)
end

.norm(*args) ⇒ Object

wrapper for overloaded method norm

Raises:

  • (ArgumentError) 


1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1192

def self.norm(*args)
    # wrapper for double cv::norm(const cv::Mat src1, int normType=NORM_L2, const cv::Mat mask=Mat())
    @@cv_norm_defaults0 ||= [nil, NORM_L2, Cv::Mat.new()]
    if(args.size >= 1 && args.size <= 3)
        args.size.upto(2) do |i|
            args[i] = @@cv_norm_defaults0[i]
        end
        begin
            return Rbind::cv_norm(*args)
        rescue TypeError => e
            @error = e
        end
    end

    # wrapper for double cv::norm(const cv::Mat src1, const cv::Mat src2, int normType=NORM_L2, const cv::Mat mask=Mat())
    @@cv_norm2_defaults1 ||= [nil, nil, NORM_L2, Cv::Mat.new()]
    if(args.size >= 2 && args.size <= 4)
        args.size.upto(3) do |i|
            args[i] = @@cv_norm2_defaults1[i]
        end
        begin
            return Rbind::cv_norm2(*args)
        rescue TypeError => e
            @error = e
        end
    end

    raise ArgumentError, "No overloaded signature fits to: #{args.map(&:class)}"
end

.normalize(src, dst, alpha = 1, beta = 0, norm_type = NORM_L2, dtype = -1,, mask = Cv::Mat.new()) ⇒ Object

wrapper for void cv::normalize(const cv::Mat src, cv::Mat dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, const cv::Mat mask=Mat())



1228
1229
1230
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1228

def self.normalize(src, dst, alpha = 1, beta = 0, norm_type = NORM_L2, dtype = -1, mask = Cv::Mat.new())
    Rbind::cv_normalize(src, dst, alpha, beta, norm_type, dtype, mask)
end

.patch_na_ns(a, val = 0) ⇒ Object

wrapper for void cv::patchNaNs(cv::Mat a, double val=0)



1388
1389
1390
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1388

def self.patch_na_ns(a, val = 0)
    Rbind::cv_patch_na_ns(a, val)
end

.pca_back_project(data, mean, eigenvectors, result) ⇒ Object

wrapper for void cv::PCABackProject(const cv::Mat data, const cv::Mat mean, const cv::Mat eigenvectors, cv::Mat result)



1493
1494
1495
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1493

def self.pca_back_project(data, mean, eigenvectors, result)
    Rbind::cv_pca_back_project(data, mean, eigenvectors, result)
end

.pca_compute(data, mean, eigenvectors, max_components = 0) ⇒ Object

wrapper for void cv::PCACompute(const cv::Mat data, cv::Mat mean, cv::Mat eigenvectors, int maxComponents=0)



1478
1479
1480
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1478

def self.pca_compute(data, mean, eigenvectors, max_components = 0)
    Rbind::cv_pca_compute(data, mean, eigenvectors, max_components)
end

.pca_compute_var(data, mean, eigenvectors, retained_variance) ⇒ Object

wrapper for void cv::PCAComputeVar(const cv::Mat data, cv::Mat mean, cv::Mat eigenvectors, double retainedVariance)



1483
1484
1485
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1483

def self.pca_compute_var(data, mean, eigenvectors, retained_variance)
    Rbind::cv_pca_compute_var(data, mean, eigenvectors, retained_variance)
end

.pca_project(data, mean, eigenvectors, result) ⇒ Object

wrapper for void cv::PCAProject(const cv::Mat data, const cv::Mat mean, const cv::Mat eigenvectors, cv::Mat result)



1488
1489
1490
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1488

def self.pca_project(data, mean, eigenvectors, result)
    Rbind::cv_pca_project(data, mean, eigenvectors, result)
end

.perspective_transform(src, dst, m) ⇒ Object

wrapper for void cv::perspectiveTransform(const cv::Mat src, cv::Mat dst, const cv::Mat m)



1413
1414
1415
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1413

def self.perspective_transform(src, dst, m)
    Rbind::cv_perspective_transform(src, dst, m)
end

.phase(x, y, angle, angle_in_degrees = false) ⇒ Object

wrapper for void cv::phase(const cv::Mat x, const cv::Mat y, cv::Mat angle, bool angleInDegrees=false)



1373
1374
1375
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1373

def self.phase(x, y, angle, angle_in_degrees = false)
    Rbind::cv_phase(x, y, angle, angle_in_degrees)
end

.phase_correlate(_src1, _src2, window = Cv::Mat.new()) ⇒ Object

wrapper for cv::Point2d cv::phaseCorrelate(const cv::Mat src1, const cv::Mat src2, const cv::Mat window=Mat())



1879
1880
1881
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1879

def self.phase_correlate(_src1, _src2, window = Cv::Mat.new())
    Rbind::cv_phase_correlate(_src1, _src2, window)
end

.phase_correlate_res(_src1, _src2, window, response = 0) ⇒ Object

wrapper for cv::Point2d cv::phaseCorrelateRes(const cv::Mat src1, const cv::Mat src2, const cv::Mat window, double *response=0)



1884
1885
1886
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1884

def self.phase_correlate_res(_src1, _src2, window, response = 0)
    Rbind::cv_phase_correlate_res(_src1, _src2, window, response)
end

.point_polygon_test(contour, pt, measure_dist) ⇒ Object

wrapper for double cv::pointPolygonTest(const cv::Mat contour, const cv::Point2f pt, bool measureDist)



2084
2085
2086
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2084

def self.point_polygon_test(contour, pt, measure_dist)
    Rbind::cv_point_polygon_test(contour, pt, measure_dist)
end

.polar_to_cart(magnitude, angle, x, y, angle_in_degrees = false) ⇒ Object

wrapper for void cv::polarToCart(const cv::Mat magnitude, const cv::Mat angle, cv::Mat x, cv::Mat y, bool angleInDegrees=false)



1363
1364
1365
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1363

def self.polar_to_cart(magnitude, angle, x, y, angle_in_degrees = false)
    Rbind::cv_polar_to_cart(magnitude, angle, x, y, angle_in_degrees)
end

.polylines(img, pts, is_closed, color, thickness = 1, line_type = 8, shift = 0) ⇒ Object

wrapper for void cv::polylines(cv::Mat img, const vector_Mat pts, bool isClosed, const cv::Scalar color, int thickness=1, int lineType=8, int shift=0)



1619
1620
1621
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1619

def self.polylines(img, pts, is_closed, color, thickness = 1, line_type = 8, shift = 0)
    Rbind::cv_polylines(img, pts, is_closed, color, thickness, line_type, shift)
end

.pow(src, power, dst) ⇒ Object

wrapper for void cv::pow(const cv::Mat src, double power, cv::Mat dst)



1338
1339
1340
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1338

def self.pow(src, power, dst)
    Rbind::cv_pow(src, power, dst)
end

.pre_corner_detect(src, dst, ksize, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::preCornerDetect(const cv::Mat src, cv::Mat dst, int ksize, int borderType=BORDER_DEFAULT)



1744
1745
1746
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1744

def self.pre_corner_detect(src, dst, ksize, border_type = BORDER_DEFAULT)
    Rbind::cv_pre_corner_detect(src, dst, ksize, border_type)
end

.project_points(object_points, rvec, tvec, camera_matrix, dist_coeffs, image_points, jacobian = Cv::Mat.new(), aspect_ratio = 0) ⇒ Object

wrapper for void cv::projectPoints(const cv::Mat objectPoints, const cv::Mat rvec, const cv::Mat tvec, const cv::Mat cameraMatrix, const cv::Mat distCoeffs, cv::Mat imagePoints, cv::Mat jacobian=Mat(), double aspectRatio=0)



2164
2165
2166
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2164

def self.project_points(object_points, rvec, tvec, camera_matrix, dist_coeffs, image_points, jacobian = Cv::Mat.new(), aspect_ratio = 0)
    Rbind::cv_project_points(object_points, rvec, tvec, camera_matrix, dist_coeffs, image_points, jacobian, aspect_ratio)
end

.psnr(_src1, _src2) ⇒ Object

wrapper for double cv::PSNR(const cv::Mat src1, const cv::Mat src2)



1874
1875
1876
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1874

def self.psnr(_src1, _src2)
    Rbind::cv_psnr(_src1, _src2)
end

.put_text(img, text, org, font_face, font_scale, color, thickness = 1, line_type = 8, bottom_left_origin = false) ⇒ Object

wrapper for void cv::putText(cv::Mat img, const cv::String text, const cv::Point org, int fontFace, double fontScale, const cv::Scalar color, int thickness=1, int lineType=8, bool bottomLeftOrigin=false)



1634
1635
1636
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1634

def self.put_text(img, text, org, font_face, font_scale, color, thickness = 1, line_type = 8, bottom_left_origin = false)
    Rbind::cv_put_text(img, text, org, font_face, font_scale, color, thickness, line_type, bottom_left_origin)
end

.pyr_down(src, dst, dstsize = Cv::Size.new(), border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::pyrDown(const cv::Mat src, cv::Mat dst, const cv::Size dstsize=Size(), int borderType=BORDER_DEFAULT)



1904
1905
1906
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1904

def self.pyr_down(src, dst, dstsize = Cv::Size.new(), border_type = BORDER_DEFAULT)
    Rbind::cv_pyr_down(src, dst, dstsize, border_type)
end

.pyr_mean_shift_filtering(src, dst, sp, sr, max_level = 1, termcrit = Cv::TermCriteria.new( TermCriteria::MAX_ITER+TermCriteria::EPS,5,1)) ⇒ Object

wrapper for void cv::pyrMeanShiftFiltering(const cv::Mat src, cv::Mat dst, double sp, double sr, int maxLevel=1, const cv::TermCriteria termcrit=TermCriteria( TermCriteria::MAX_ITER+TermCriteria::EPS,5,1))



1964
1965
1966
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1964

def self.pyr_mean_shift_filtering(src, dst, sp, sr, max_level = 1, termcrit = Cv::TermCriteria.new( TermCriteria::MAX_ITER+TermCriteria::EPS,5,1))
    Rbind::cv_pyr_mean_shift_filtering(src, dst, sp, sr, max_level, termcrit)
end

.pyr_up(src, dst, dstsize = Cv::Size.new(), border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::pyrUp(const cv::Mat src, cv::Mat dst, const cv::Size dstsize=Size(), int borderType=BORDER_DEFAULT)



1909
1910
1911
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1909

def self.pyr_up(src, dst, dstsize = Cv::Size.new(), border_type = BORDER_DEFAULT)
    Rbind::cv_pyr_up(src, dst, dstsize, border_type)
end

.rand_shuffle(dst, iter_factor = 1.0) ⇒ Object

wrapper for void cv::randShuffle_(cv::Mat dst, double iterFactor=1.)



1558
1559
1560
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1558

def self.rand_shuffle(dst, iter_factor = 1.0)
    Rbind::cv_rand_shuffle(dst, iter_factor)
end

.randn(dst, mean, stddev) ⇒ Object

wrapper for void cv::randn(cv::Mat dst, const cv::Mat mean, const cv::Mat stddev)



1553
1554
1555
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1553

def self.randn(dst, mean, stddev)
    Rbind::cv_randn(dst, mean, stddev)
end

.randu(dst, low, high) ⇒ Object

wrapper for void cv::randu(cv::Mat dst, const cv::Mat low, const cv::Mat high)



1548
1549
1550
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1548

def self.randu(dst, low, high)
    Rbind::cv_randu(dst, low, high)
end

.rectangle(img, _pt1, _pt2, color, thickness = 1, line_type = 8, shift = 0) ⇒ Object

wrapper for void cv::rectangle(cv::Mat img, const cv::Point pt1, const cv::Point pt2, const cv::Scalar color, int thickness=1, int lineType=8, int shift=0)



1568
1569
1570
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1568

def self.rectangle(img, _pt1, _pt2, color, thickness = 1, line_type = 8, shift = 0)
    Rbind::cv_rectangle(img, _pt1, _pt2, color, thickness, line_type, shift)
end

.rectify3_collinear(_camera_matrix1, _dist_coeffs1, _camera_matrix2, _dist_coeffs2, _camera_matrix3, _dist_coeffs3, _imgpt1, _imgpt3, image_size, _r12, _t12, _r13, _t13, _r1, _r2, _r3, _p1, _p2, _p3, q, alpha, new_img_size, _roi1, _roi2, flags) ⇒ Object

wrapper for float cv::rectify3Collinear(const cv::Mat cameraMatrix1, const cv::Mat distCoeffs1, const cv::Mat cameraMatrix2, const cv::Mat distCoeffs2, const cv::Mat cameraMatrix3, const cv::Mat distCoeffs3, const vector_Mat imgpt1, const vector_Mat imgpt3, const cv::Size imageSize, const cv::Mat R12, const cv::Mat T12, const cv::Mat R13, const cv::Mat T13, cv::Mat R1, cv::Mat R2, cv::Mat R3, cv::Mat P1, cv::Mat P2, cv::Mat P3, cv::Mat Q, double alpha, const cv::Size newImgSize, cv::Rect *roi1, cv::Rect *roi2, int flags)



2229
2230
2231
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2229

def self.rectify3_collinear(_camera_matrix1, _dist_coeffs1, _camera_matrix2, _dist_coeffs2, _camera_matrix3, _dist_coeffs3, _imgpt1, _imgpt3, image_size, _r12, _t12, _r13, _t13, _r1, _r2, _r3, _p1, _p2, _p3, q, alpha, new_img_size, _roi1, _roi2, flags)
    Rbind::cv_rectify3_collinear(_camera_matrix1, _dist_coeffs1, _camera_matrix2, _dist_coeffs2, _camera_matrix3, _dist_coeffs3, _imgpt1, _imgpt3, image_size, _r12, _t12, _r13, _t13, _r1, _r2, _r3, _p1, _p2, _p3, q, alpha, new_img_size, _roi1, _roi2, flags)
end

.reduce(src, dst, dim, rtype, dtype = -1)) ⇒ Object

wrapper for void cv::reduce(const cv::Mat src, cv::Mat dst, int dim, int rtype, int dtype=-1)



1238
1239
1240
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1238

def self.reduce(src, dst, dim, rtype, dtype = -1)
    Rbind::cv_reduce(src, dst, dim, rtype, dtype)
end

.remap(src, dst, _map1, _map2, interpolation, border_mode = BORDER_CONSTANT, border_value = Cv::Scalar.new()) ⇒ Object

wrapper for void cv::remap(const cv::Mat src, cv::Mat dst, const cv::Mat map1, const cv::Mat map2, int interpolation, int borderMode=BORDER_CONSTANT, const cv::Scalar borderValue=Scalar())



1804
1805
1806
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1804

def self.remap(src, dst, _map1, _map2, interpolation, border_mode = BORDER_CONSTANT, border_value = Cv::Scalar.new())
    Rbind::cv_remap(src, dst, _map1, _map2, interpolation, border_mode, border_value)
end

.repeat(src, ny, nx, dst) ⇒ Object

wrapper for void cv::repeat(const cv::Mat src, int ny, int nx, cv::Mat dst)



1273
1274
1275
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1273

def self.repeat(src, ny, nx, dst)
    Rbind::cv_repeat(src, ny, nx, dst)
end

.reproject_image_to3d(disparity, __3d_image, q, handle_missing_values = false, ddepth = -1)) ⇒ Object

wrapper for void cv::reprojectImageTo3D(const cv::Mat disparity, cv::Mat _3dImage, const cv::Mat Q, bool handleMissingValues=false, int ddepth=-1)



2279
2280
2281
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2279

def self.reproject_image_to3d(disparity, __3d_image, q, handle_missing_values = false, ddepth = -1)
    Rbind::cv_reproject_image_to3d(disparity, __3d_image, q, handle_missing_values, ddepth)
end

.resize(src, dst, dsize, fx = 0, fy = 0, interpolation = INTER_LINEAR) ⇒ Object

wrapper for void cv::resize(const cv::Mat src, cv::Mat dst, const cv::Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)



1789
1790
1791
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1789

def self.resize(src, dst, dsize, fx = 0, fy = 0, interpolation = INTER_LINEAR)
    Rbind::cv_resize(src, dst, dsize, fx, fy, interpolation)
end

.resize_window(winname, width, height) ⇒ Object

wrapper for void cv::resizeWindow(const cv::String winname, int width, int height)



2319
2320
2321
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2319

def self.resize_window(winname, width, height)
    Rbind::cv_resize_window(winname, width, height)
end

.rodrigues(src, dst, jacobian = Cv::Mat.new()) ⇒ Object

wrapper for void cv::Rodrigues(const cv::Mat src, cv::Mat dst, cv::Mat jacobian=Mat())



2134
2135
2136
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2134

def self.rodrigues(src, dst, jacobian = Cv::Mat.new())
    Rbind::cv_rodrigues(src, dst, jacobian)
end

.rq_decomp_3x3(src, mtx_r, mtx_q, qx = Cv::Mat.new(), qy = Cv::Mat.new(), qz = Cv::Mat.new()) ⇒ Object

wrapper for cv::Vec3d cv::RQDecomp3x3(const cv::Mat src, cv::Mat mtxR, cv::Mat mtxQ, cv::Mat Qx=Mat(), cv::Mat Qy=Mat(), cv::Mat Qz=Mat())



2144
2145
2146
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2144

def self.rq_decomp_3x3(src, mtx_r, mtx_q, qx = Cv::Mat.new(), qy = Cv::Mat.new(), qz = Cv::Mat.new())
    Rbind::cv_rq_decomp_3x3(src, mtx_r, mtx_q, qx, qy, qz)
end

.scale_add(_src1, alpha, _src2, dst) ⇒ Object

wrapper for void cv::scaleAdd(const cv::Mat src1, double alpha, const cv::Mat src2, cv::Mat dst)



1147
1148
1149
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1147

def self.scale_add(_src1, alpha, _src2, dst)
    Rbind::cv_scale_add(_src1, alpha, _src2, dst)
end

.scharr(src, dst, ddepth, dx, dy, scale = 1, delta = 0, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::Scharr(const cv::Mat src, cv::Mat dst, int ddepth, int dx, int dy, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)



1714
1715
1716
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1714

def self.scharr(src, dst, ddepth, dx, dy, scale = 1, delta = 0, border_type = BORDER_DEFAULT)
    Rbind::cv_scharr(src, dst, ddepth, dx, dy, scale, delta, border_type)
end

.sep_filter2d(src, dst, ddepth, kernel_x, kernel_y, anchor = Cv::Point.new(-1,-1), delta = 0, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::sepFilter2D(const cv::Mat src, cv::Mat dst, int ddepth, const cv::Mat kernelX, const cv::Mat kernelY, const cv::Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)



1704
1705
1706
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1704

def self.sep_filter2d(src, dst, ddepth, kernel_x, kernel_y, anchor = Cv::Point.new(-1,-1), delta = 0, border_type = BORDER_DEFAULT)
    Rbind::cv_sep_filter2d(src, dst, ddepth, kernel_x, kernel_y, anchor, delta, border_type)
end

.set_identity(mtx, s = Cv::Scalar.new(1)) ⇒ Object

wrapper for void cv::setIdentity(cv::Mat mtx, const cv::Scalar s=Scalar(1))



1423
1424
1425
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1423

def self.set_identity(mtx, s = Cv::Scalar.new(1))
    Rbind::cv_set_identity(mtx, s)
end

.set_trackbar_pos(trackbarname, winname, pos) ⇒ Object

wrapper for void cv::setTrackbarPos(const cv::String trackbarname, const cv::String winname, int pos)



2344
2345
2346
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2344

def self.set_trackbar_pos(trackbarname, winname, pos)
    Rbind::cv_set_trackbar_pos(trackbarname, winname, pos)
end

.set_use_optimized(onoff) ⇒ Object

wrapper for void cv::setUseOptimized(bool onoff)



1091
1092
1093
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1091

def self.set_use_optimized(onoff)
    Rbind::cv_set_use_optimized(onoff)
end

.set_window_property(winname, prop_id, prop_value) ⇒ Object

wrapper for void cv::setWindowProperty(const cv::String winname, int prop_id, double prop_value)



2329
2330
2331
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2329

def self.set_window_property(winname, prop_id, prop_value)
    Rbind::cv_set_window_property(winname, prop_id, prop_value)
end

.sobel(src, dst, ddepth, dx, dy, ksize = 3, scale = 1, delta = 0, border_type = BORDER_DEFAULT) ⇒ Object

wrapper for void cv::Sobel(const cv::Mat src, cv::Mat dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)



1709
1710
1711
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1709

def self.sobel(src, dst, ddepth, dx, dy, ksize = 3, scale = 1, delta = 0, border_type = BORDER_DEFAULT)
    Rbind::cv_sobel(src, dst, ddepth, dx, dy, ksize, scale, delta, border_type)
end

.solve(_src1, _src2, dst, flags = DECOMP_LU) ⇒ Object

wrapper for bool cv::solve(const cv::Mat src1, const cv::Mat src2, cv::Mat dst, int flags=DECOMP_LU)



1443
1444
1445
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1443

def self.solve(_src1, _src2, dst, flags = DECOMP_LU)
    Rbind::cv_solve(_src1, _src2, dst, flags)
end

.solve_cubic(coeffs, roots) ⇒ Object

wrapper for int cv::solveCubic(const cv::Mat coeffs, cv::Mat roots)



1458
1459
1460
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1458

def self.solve_cubic(coeffs, roots)
    Rbind::cv_solve_cubic(coeffs, roots)
end

.solve_pnp(object_points, image_points, camera_matrix, dist_coeffs, rvec, tvec, use_extrinsic_guess = false, flags = ITERATIVE) ⇒ Object

wrapper for bool cv::solvePnP(const cv::Mat objectPoints, const cv::Mat imagePoints, const cv::Mat cameraMatrix, const cv::Mat distCoeffs, cv::Mat rvec, cv::Mat tvec, bool useExtrinsicGuess=false, int flags=ITERATIVE)



2169
2170
2171
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2169

def self.solve_pnp(object_points, image_points, camera_matrix, dist_coeffs, rvec, tvec, use_extrinsic_guess = false, flags = ITERATIVE)
    Rbind::cv_solve_pnp(object_points, image_points, camera_matrix, dist_coeffs, rvec, tvec, use_extrinsic_guess, flags)
end

.solve_pnp_ransac(object_points, image_points, camera_matrix, dist_coeffs, rvec, tvec, use_extrinsic_guess = false, iterations_count = 100, reprojection_error = 8.0, min_inliers_count = 100, inliers = Cv::Mat.new(), flags = ITERATIVE) ⇒ Object

wrapper for void cv::solvePnPRansac(const cv::Mat objectPoints, const cv::Mat imagePoints, const cv::Mat cameraMatrix, const cv::Mat distCoeffs, cv::Mat rvec, cv::Mat tvec, bool useExtrinsicGuess=false, int iterationsCount=100, float reprojectionError=8.0, int minInliersCount=100, cv::Mat inliers=Mat(), int flags=ITERATIVE)



2174
2175
2176
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2174

def self.solve_pnp_ransac(object_points, image_points, camera_matrix, dist_coeffs, rvec, tvec, use_extrinsic_guess = false, iterations_count = 100, reprojection_error = 8.0, min_inliers_count = 100, inliers = Cv::Mat.new(), flags = ITERATIVE)
    Rbind::cv_solve_pnp_ransac(object_points, image_points, camera_matrix, dist_coeffs, rvec, tvec, use_extrinsic_guess, iterations_count, reprojection_error, min_inliers_count, inliers, flags)
end

.solve_poly(coeffs, roots, max_iters = 300) ⇒ Object

wrapper for double cv::solvePoly(const cv::Mat coeffs, cv::Mat roots, int maxIters=300)



1463
1464
1465
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1463

def self.solve_poly(coeffs, roots, max_iters = 300)
    Rbind::cv_solve_poly(coeffs, roots, max_iters)
end

.sort(src, dst, flags) ⇒ Object

wrapper for void cv::sort(const cv::Mat src, cv::Mat dst, int flags)



1448
1449
1450
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1448

def self.sort(src, dst, flags)
    Rbind::cv_sort(src, dst, flags)
end

.sort_idx(src, dst, flags) ⇒ Object

wrapper for void cv::sortIdx(const cv::Mat src, cv::Mat dst, int flags)



1453
1454
1455
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1453

def self.sort_idx(src, dst, flags)
    Rbind::cv_sort_idx(src, dst, flags)
end

.split(m, mv) ⇒ Object

wrapper for void cv::split(const cv::Mat m, vector_Mat mv)



1248
1249
1250
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1248

def self.split(m, mv)
    Rbind::cv_split(m, mv)
end

.sqrt(src, dst) ⇒ Object

wrapper for void cv::sqrt(const cv::Mat src, cv::Mat dst)



1333
1334
1335
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1333

def self.sqrt(src, dst)
    Rbind::cv_sqrt(src, dst)
end

.start_window_thread ⇒ Object

wrapper for int cv::startWindowThread()



2304
2305
2306
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2304

def self.start_window_thread()
    Rbind::cv_start_window_thread()
end

.stereo_calibrate(object_points, _image_points1, _image_points2, _camera_matrix1, _dist_coeffs1, _camera_matrix2, _dist_coeffs2, image_size, r, t, e, f, criteria = Cv::TermCriteria.new(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6), flags = CALIB_FIX_INTRINSIC) ⇒ Object

wrapper for double cv::stereoCalibrate(const vector_Mat objectPoints, const vector_Mat imagePoints1, const vector_Mat imagePoints2, cv::Mat cameraMatrix1, cv::Mat distCoeffs1, cv::Mat cameraMatrix2, cv::Mat distCoeffs2, const cv::Size imageSize, cv::Mat R, cv::Mat T, cv::Mat E, cv::Mat F, const cv::TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC)



2214
2215
2216
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2214

def self.stereo_calibrate(object_points, _image_points1, _image_points2, _camera_matrix1, _dist_coeffs1, _camera_matrix2, _dist_coeffs2, image_size, r, t, e, f, criteria = Cv::TermCriteria.new(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6), flags = CALIB_FIX_INTRINSIC)
    Rbind::cv_stereo_calibrate(object_points, _image_points1, _image_points2, _camera_matrix1, _dist_coeffs1, _camera_matrix2, _dist_coeffs2, image_size, r, t, e, f, criteria, flags)
end

.stereo_rectify(_camera_matrix1, _dist_coeffs1, _camera_matrix2, _dist_coeffs2, image_size, r, t, _r1, _r2, _p1, _p2, q, flags = CALIB_ZERO_DISPARITY, alpha = -1,, new_image_size = Cv::Size.new(), _valid_pix_r_o_i1 = 0, _valid_pix_r_o_i2 = 0) ⇒ Object

wrapper for void cv::stereoRectify(const cv::Mat cameraMatrix1, const cv::Mat distCoeffs1, const cv::Mat cameraMatrix2, const cv::Mat distCoeffs2, const cv::Size imageSize, const cv::Mat R, const cv::Mat T, cv::Mat R1, cv::Mat R2, cv::Mat P1, cv::Mat P2, cv::Mat Q, int flags=CALIB_ZERO_DISPARITY, double alpha=-1, const cv::Size newImageSize=Size(), cv::Rect *validPixROI1=0, cv::Rect *validPixROI2=0)



2219
2220
2221
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2219

def self.stereo_rectify(_camera_matrix1, _dist_coeffs1, _camera_matrix2, _dist_coeffs2, image_size, r, t, _r1, _r2, _p1, _p2, q, flags = CALIB_ZERO_DISPARITY, alpha = -1, new_image_size = Cv::Size.new(), _valid_pix_r_o_i1 = 0, _valid_pix_r_o_i2 = 0)
    Rbind::cv_stereo_rectify(_camera_matrix1, _dist_coeffs1, _camera_matrix2, _dist_coeffs2, image_size, r, t, _r1, _r2, _p1, _p2, q, flags, alpha, new_image_size, _valid_pix_r_o_i1, _valid_pix_r_o_i2)
end

.stereo_rectify_uncalibrated(_points1, _points2, f, img_size, _h1, _h2, threshold = 5) ⇒ Object

wrapper for bool cv::stereoRectifyUncalibrated(const cv::Mat points1, const cv::Mat points2, const cv::Mat F, const cv::Size imgSize, cv::Mat H1, cv::Mat H2, double threshold=5)



2224
2225
2226
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2224

def self.stereo_rectify_uncalibrated(_points1, _points2, f, img_size, _h1, _h2, threshold = 5)
    Rbind::cv_stereo_rectify_uncalibrated(_points1, _points2, f, img_size, _h1, _h2, threshold)
end

.subtract(_src1, _src2, dst, mask = Cv::Mat.new(), dtype = -1)) ⇒ Object

wrapper for void cv::subtract(const cv::Mat src1, const cv::Mat src2, cv::Mat dst, const cv::Mat mask=Mat(), int dtype=-1)



1106
1107
1108
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1106

def self.subtract(_src1, _src2, dst, mask = Cv::Mat.new(), dtype = -1)
    Rbind::cv_subtract(_src1, _src2, dst, mask, dtype)
end

.sum_elems(src) ⇒ Object

wrapper for cv::Scalar cv::sum(const cv::Mat src)



1167
1168
1169
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1167

def self.sum_elems(src)
    Rbind::cv_sum_elems(src)
end

.sv_back_subst(w, u, vt, rhs, dst) ⇒ Object

wrapper for void cv::SVBackSubst(const cv::Mat w, const cv::Mat u, const cv::Mat vt, const cv::Mat rhs, cv::Mat dst)



1503
1504
1505
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1503

def self.sv_back_subst(w, u, vt, rhs, dst)
    Rbind::cv_sv_back_subst(w, u, vt, rhs, dst)
end

.sv_decomp(src, w, u, vt, flags = 0) ⇒ Object

wrapper for void cv::SVDecomp(const cv::Mat src, cv::Mat w, cv::Mat u, cv::Mat vt, int flags=0)



1498
1499
1500
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1498

def self.sv_decomp(src, w, u, vt, flags = 0)
    Rbind::cv_sv_decomp(src, w, u, vt, flags)
end

.threshold(src, dst, thresh, maxval, type) ⇒ Object

wrapper for double cv::threshold(const cv::Mat src, cv::Mat dst, double thresh, double maxval, int type)



1894
1895
1896
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1894

def self.threshold(src, dst, thresh, maxval, type)
    Rbind::cv_threshold(src, dst, thresh, maxval, type)
end

.trace(mtx) ⇒ Object

wrapper for cv::Scalar cv::trace(const cv::Mat mtx)



1433
1434
1435
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1433

def self.trace(mtx)
    Rbind::cv_trace(mtx)
end

.transform(src, dst, m) ⇒ Object

wrapper for void cv::transform(const cv::Mat src, cv::Mat dst, const cv::Mat m)



1408
1409
1410
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1408

def self.transform(src, dst, m)
    Rbind::cv_transform(src, dst, m)
end

.transpose(src, dst) ⇒ Object

wrapper for void cv::transpose(const cv::Mat src, cv::Mat dst)



1403
1404
1405
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1403

def self.transpose(src, dst)
    Rbind::cv_transpose(src, dst)
end

.triangulate_points(_proj_matr1, _proj_matr2, _proj_points1, _proj_points2, _points4_d) ⇒ Object

wrapper for void cv::triangulatePoints(const cv::Mat projMatr1, const cv::Mat projMatr2, const cv::Mat projPoints1, const cv::Mat projPoints2, cv::Mat points4D)



2254
2255
2256
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2254

def self.triangulate_points(_proj_matr1, _proj_matr2, _proj_points1, _proj_points2, _points4_d)
    Rbind::cv_triangulate_points(_proj_matr1, _proj_matr2, _proj_points1, _proj_points2, _points4_d)
end

.undistort(src, dst, camera_matrix, dist_coeffs, new_camera_matrix = Cv::Mat.new()) ⇒ Object

wrapper for void cv::undistort(const cv::Mat src, cv::Mat dst, const cv::Mat cameraMatrix, const cv::Mat distCoeffs, const cv::Mat newCameraMatrix=Mat())



1914
1915
1916
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1914

def self.undistort(src, dst, camera_matrix, dist_coeffs, new_camera_matrix = Cv::Mat.new())
    Rbind::cv_undistort(src, dst, camera_matrix, dist_coeffs, new_camera_matrix)
end

.undistort_points(src, dst, camera_matrix, dist_coeffs, r = Cv::Mat.new(), p = Cv::Mat.new()) ⇒ Object

wrapper for void cv::undistortPoints(const cv::Mat src, cv::Mat dst, const cv::Mat cameraMatrix, const cv::Mat distCoeffs, const cv::Mat R=Mat(), const cv::Mat P=Mat())



1934
1935
1936
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1934

def self.undistort_points(src, dst, camera_matrix, dist_coeffs, r = Cv::Mat.new(), p = Cv::Mat.new())
    Rbind::cv_undistort_points(src, dst, camera_matrix, dist_coeffs, r, p)
end

.use_optimized ⇒ Object

wrapper for bool cv::useOptimized()



1096
1097
1098
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1096

def self.use_optimized()
    Rbind::cv_use_optimized()
end

.validate_disparity(disparity, cost, min_disparity, number_of_disparities, _disp12_max_disp = 1) ⇒ Object

wrapper for void cv::validateDisparity(cv::Mat disparity, const cv::Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp=1)



2274
2275
2276
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2274

def self.validate_disparity(disparity, cost, min_disparity, number_of_disparities, _disp12_max_disp = 1)
    Rbind::cv_validate_disparity(disparity, cost, min_disparity, number_of_disparities, _disp12_max_disp)
end

.vconcat(src, dst) ⇒ Object

wrapper for void cv::vconcat(const vector_Mat src, cv::Mat dst)



1283
1284
1285
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1283

def self.vconcat(src, dst)
    Rbind::cv_vconcat(src, dst)
end

.wait_key(delay = 0) ⇒ Object

wrapper for int cv::waitKey(int delay=0)



2309
2310
2311
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 2309

def self.wait_key(delay = 0)
    Rbind::cv_wait_key(delay)
end

.warp_affine(src, dst, m, dsize, flags = INTER_LINEAR, border_mode = BORDER_CONSTANT, border_value = Cv::Scalar.new()) ⇒ Object

wrapper for void cv::warpAffine(const cv::Mat src, cv::Mat dst, const cv::Mat M, const cv::Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const cv::Scalar borderValue=Scalar())



1794
1795
1796
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1794

def self.warp_affine(src, dst, m, dsize, flags = INTER_LINEAR, border_mode = BORDER_CONSTANT, border_value = Cv::Scalar.new())
    Rbind::cv_warp_affine(src, dst, m, dsize, flags, border_mode, border_value)
end

.warp_perspective(src, dst, m, dsize, flags = INTER_LINEAR, border_mode = BORDER_CONSTANT, border_value = Cv::Scalar.new()) ⇒ Object

wrapper for void cv::warpPerspective(const cv::Mat src, cv::Mat dst, const cv::Mat M, const cv::Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const cv::Scalar borderValue=Scalar())



1799
1800
1801
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1799

def self.warp_perspective(src, dst, m, dsize, flags = INTER_LINEAR, border_mode = BORDER_CONSTANT, border_value = Cv::Scalar.new())
    Rbind::cv_warp_perspective(src, dst, m, dsize, flags, border_mode, border_value)
end

.watershed(image, markers) ⇒ Object

wrapper for void cv::watershed(const cv::Mat image, cv::Mat markers)



1959
1960
1961
 
# File 'lib/ruby/ropencv/ropencv_types.rb', line 1959

def self.watershed(image, markers)
    Rbind::cv_watershed(image, markers)
end