Module: OpenCV::Cv

Defined in:

lib/ropencv/ropencv_types.rb,
lib/ropencv/ropencv_ruby.rb

Overview

Note:

namespace wrapper for cv

ROpenCV API Documentation for OpenCV 2.4.11

Defined Under Namespace

Modules: DrawMatchesFlags, FREAK, FeatureEvaluator, Fisheye, Flann, Hamming, InputArray, Param, SVD, SelfSimDescriptor, SparseMat, Vec2x, Vec3x, Vecxd, Vecxf, Vecxi Classes: Algorithm, BFMatcher, BOWImgDescriptorExtractor, BOWKMeansTrainer, BOWTrainer, BRISK, BackgroundSubtractor, BackgroundSubtractorMOG, BackgroundSubtractorMOG2, CLAHE, CascadeClassifier, DMatch, DescriptorExtractor, DescriptorMatcher, EM, FaceRecognizer, FastFeatureDetector, Feature2D, FeatureDetector, FileNode, FileNodeIterator, FileStorage, FlannBasedMatcher, GFTTDetector, GridAdaptedFeatureDetector, HOGDescriptor, KDTree, KalmanFilter, KeyPoint, MSER, Mat, Moments, ORB, Point, Point2d, Point2f, Point3d, Point3f, Ptr, PyramidAdaptedFeatureDetector, RNG, Range, Rect, RotatedRect, SIFT, SURF, Scalar, SimpleBlobDetector, Size, Size2f, StarDetector, StereoBM, StereoSGBM, StereoVar, String, Subdiv2D, TermCriteria, Vec2d, Vec2f, Vec2i, Vec3d, Vec3f, Vec3i, Vec4d, Vec4f, Vec4i, Vec6d, Vec6f, Vec6i, VideoCapture, VideoWriter

Constants

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 =

0

CV_CALIB_FIX_ASPECT_RATIO =

0

CV_CALIB_FIX_PRINCIPAL_POINT =

0

CV_CALIB_ZERO_TANGENT_DIST =

0

CV_CALIB_FIX_FOCAL_LENGTH =

0

CV_CALIB_FIX_K1 =

0

CV_CALIB_FIX_K2 =

0

CV_CALIB_FIX_K3 =

0

CV_CALIB_FIX_K4 =

0

CV_CALIB_FIX_K5 =

0

CV_CALIB_FIX_K6 =

0

CV_CALIB_RATIONAL_MODEL =

0

CV_CALIB_THIN_PRISM_MODEL =

0

CV_CALIB_FIX_S1_S2_S3_S4 =

0

CV_CALIB_FIX_INTRINSIC =

0

CV_CALIB_SAME_FOCAL_LENGTH =

0

CV_CALIB_ZERO_DISPARITY =

0

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 =

0

CV_WINDOW_AUTOSIZE =

0

CV_WINDOW_OPENGL =

0

CV_WINDOW_FULLSCREEN =

1

CV_WINDOW_FREERATIO =

0

CV_WINDOW_KEEPRATIO =

0

CV_WND_PROP_FULLSCREEN =

0

CV_WND_PROP_AUTOSIZE =

1

CV_WND_PROP_ASPECT_RATIO =

2

CV_WND_PROP_OPENGL =

3

CV_LKFLOW_PYR_A_READY =

1

CV_LKFLOW_PYR_B_READY =

2

CV_LKFLOW_INITIAL_GUESSES =

4

CV_LKFLOW_GET_MIN_EIGENVALS =

8

INT_MAX =

2147483647

DBL_MAX =

1

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

DEPTH_MASK_8S =

1

DEPTH_MASK_16U =

1

DEPTH_MASK_16S =

1

DEPTH_MASK_32S =

1

DEPTH_MASK_32F =

1

DEPTH_MASK_64F =

1

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 =

0

TYPE_MASK =

0

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

FLOODFILL_MASK_ONLY =

1

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_RGB2YUV_I420 =

127

COLOR_BGR2YUV_I420 =

128

COLOR_RGB2YUV_IYUV =

COLOR_RGB2YUV_I420

COLOR_BGR2YUV_IYUV =

COLOR_BGR2YUV_I420

COLOR_RGBA2YUV_I420 =

129

COLOR_BGRA2YUV_I420 =

130

COLOR_RGBA2YUV_IYUV =

COLOR_RGBA2YUV_I420

COLOR_BGRA2YUV_IYUV =

COLOR_BGRA2YUV_I420

COLOR_RGB2YUV_YV12 =

131

COLOR_BGR2YUV_YV12 =

132

COLOR_RGBA2YUV_YV12 =

133

COLOR_BGRA2YUV_YV12 =

134

COLOR_COLORCVT_MAX =

135

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

OPTFLOW_USE_INITIAL_FLOW =

CV_LKFLOW_INITIAL_GUESSES

OPTFLOW_LK_GET_MIN_EIGENVALS =

CV_LKFLOW_GET_MIN_EIGENVALS

OPTFLOW_FARNEBACK_GAUSSIAN =

256

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

Constant Summary

GoodFeatureToTrackDetector =

reflect some typedefs

GFTTDetector

StarFeatureDetector =

StarDetector

Class Method Summary

• .abs(src) ⇒ Cv::Mat
• .absdiff(_src1, _src2, dst) ⇒ Void
• .accumulate(src, dst, mask = Cv::Mat.new()) ⇒ Void
• .accumulate_product(_src1, _src2, dst, mask = Cv::Mat.new()) ⇒ Void (also: accumulateProduct)
• .accumulate_square(src, dst, mask = Cv::Mat.new()) ⇒ Void (also: accumulateSquare)
• .accumulate_weighted(src, dst, alpha, mask = Cv::Mat.new()) ⇒ Void (also: accumulateWeighted)
• .adaptive_bilateral_filter(src, dst, ksize, sigma_space, max_sigma_color = 20.0, anchor = Cv::Point.new(-1, -1), border_type = BORDER_DEFAULT) ⇒ Void (also: adaptiveBilateralFilter)
• .adaptive_threshold(src, dst, max_value, adaptive_method, threshold_type, block_size, c) ⇒ Void (also: adaptiveThreshold)
• .add(_src1, _src2, dst, mask = Cv::Mat.new(), dtype = -1)) ⇒ Void
• .add_weighted(_src1, alpha, _src2, beta, gamma, dst, dtype = -1)) ⇒ Void (also: addWeighted)
• .apply_color_map(src, dst, colormap) ⇒ Void (also: applyColorMap)
• .approx_polydp(curve, approx_curve, epsilon, closed) ⇒ Void (also: approxPolyDP)
• .arc_length(curve, closed) ⇒ Double (also: arcLength)
• .arrowed_line(img, _pt1, _pt2, color, thickness = 1, line_type = 8, shift = 0, tip_length = 0.1) ⇒ Void (also: arrowedLine)
• .batch_distance(_src1, _src2, dist, dtype, nidx, norm_type = NORM_L2, k = 0, mask = Cv::Mat.new(), update = 0, crosscheck = false) ⇒ Void (also: batchDistance)
• .bilateral_filter(src, dst, d, sigma_color, sigma_space, border_type = BORDER_DEFAULT) ⇒ Void (also: bilateralFilter)
• .bitwise_and(_src1, _src2, dst, mask = Cv::Mat.new()) ⇒ Void
• .bitwise_not(src, dst, mask = Cv::Mat.new()) ⇒ Void
• .bitwise_or(_src1, _src2, dst, mask = Cv::Mat.new()) ⇒ Void
• .bitwise_xor(_src1, _src2, dst, mask = Cv::Mat.new()) ⇒ Void
• .blur(src, dst, ksize, anchor = Cv::Point.new(-1,-1), border_type = BORDER_DEFAULT) ⇒ Void
• .border_interpolate(p, len, border_type) ⇒ Fixnum (also: borderInterpolate)
• .bounding_rect(points) ⇒ Cv::Rect (also: boundingRect)
• .box_filter(src, dst, ddepth, ksize, anchor = Cv::Point.new(-1,-1), normalize = true, border_type = BORDER_DEFAULT) ⇒ Void (also: boxFilter)
• .build_optical_flow_pyramid(img, pyramid, win_size, max_level, with_derivatives = true, pyr_border = BORDER_REFLECT_101, deriv_border = BORDER_CONSTANT, try_reuse_input_image = true) ⇒ Fixnum (also: buildOpticalFlowPyramid)
• .calc_back_project(images, channels, hist, dst, ranges, scale) ⇒ Void (also: calcBackProject)
• .calc_covar_matrix(samples, covar, mean, flags, ctype = CV_64F) ⇒ Void (also: calcCovarMatrix)
• .calc_global_orientation(orientation, mask, mhi, timestamp, duration) ⇒ Double (also: calcGlobalOrientation)
• .calc_hist(images, channels, mask, hist, hist_size, ranges, accumulate = false) ⇒ Void (also: calcHist)
• .calc_motion_gradient(mhi, mask, orientation, _delta1, _delta2, aperture_size = 3) ⇒ Void (also: calcMotionGradient)
• .calc_optical_flow_farneback(prev, next_, flow, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags) ⇒ Void (also: calcOpticalFlowFarneback)
• .calc_optical_flow_pyrlk(prev_img, next_img, prev_pts, next_pts, status, err, win_size = Cv::Size.new(21,21), max_level = 3, criteria = Cv::TermCriteria.new(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), flags = 0, min_eig_threshold = 1e-4) ⇒ Void (also: calcOpticalFlowPyrLK)
• .calc_optical_flowsf(*args) ⇒ Object
• .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)) ⇒ Double (also: calibrateCamera)
• .calibration_matrix_values(camera_matrix, image_size, aperture_width, aperture_height, fovx, fovy, focal_length, principal_point, aspect_ratio) ⇒ Void (also: calibrationMatrixValues)
• .cam_shift(prob_image, window, criteria) ⇒ Cv::RotatedRect (also: CamShift)
• .canny(image, edges, _threshold1, _threshold2, aperture_size = 3, _l2gradient = false) ⇒ Void (also: Canny)
• .cart_to_polar(x, y, magnitude, angle, angle_in_degrees = false) ⇒ Void (also: cartToPolar)
• .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) ⇒ Fixnum (also: chamerMatching)
• .check_hardware_support(feature) ⇒ Bool (also: checkHardwareSupport)
• .check_range(a, quiet = true, pos = Cv::Point::null, min_val = -DBL_MAX,, max_val = DBL_MAX) ⇒ Bool (also: checkRange)
• .circle(img, center, radius, color, thickness = 1, line_type = 8, shift = 0) ⇒ Void
• .clip_line(img_rect, _pt1, _pt2) ⇒ Bool (also: clipLine)
• .compare(_src1, _src2, dst, cmpop) ⇒ Void
• .compare_hist(_h1, _h2, method) ⇒ Double (also: compareHist)
• .complete_symm(mtx, lower_to_upper = false) ⇒ Void (also: completeSymm)
• .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()) ⇒ Void (also: composeRT)
• .compute_correspond_epilines(points, which_image, f, lines) ⇒ Void (also: computeCorrespondEpilines)
• .contour_area(contour, oriented = false) ⇒ Double (also: contourArea)
• .convert_maps(_map1, _map2, _dstmap1, _dstmap2, _dstmap1type, nninterpolation = false) ⇒ Void (also: convertMaps)
• .convert_points_from_homogeneous(src, dst) ⇒ Void (also: convertPointsFromHomogeneous)
• .convert_points_to_homogeneous(src, dst) ⇒ Void (also: convertPointsToHomogeneous)
• .convert_scale_abs(src, dst, alpha = 1, beta = 0) ⇒ Void (also: convertScaleAbs)
• .convex_hull(points, hull, clockwise = false, return_points = true) ⇒ Void (also: convexHull)
• .convexity_defects(contour, convexhull, convexity_defects) ⇒ Void (also: convexityDefects)
• .copy_make_border(src, dst, top, bottom, left, right, border_type, value = Cv::Scalar.new()) ⇒ Void (also: copyMakeBorder)
• .corner_eigen_vals_and_vecs(src, dst, block_size, ksize, border_type = BORDER_DEFAULT) ⇒ Void (also: cornerEigenValsAndVecs)
• .corner_harris(src, dst, block_size, ksize, k, border_type = BORDER_DEFAULT) ⇒ Void (also: cornerHarris)
• .corner_min_eigen_val(src, dst, block_size, ksize = 3, border_type = BORDER_DEFAULT) ⇒ Void (also: cornerMinEigenVal)
• .corner_sub_pix(image, corners, win_size, zero_zone, criteria) ⇒ Void (also: cornerSubPix)
• .correct_matches(f, _points1, _points2, _new_points1, _new_points2) ⇒ Void (also: correctMatches)
• .count_non_zero(src) ⇒ Fixnum (also: countNonZero)
• .create_eigen_face_recognizer(num_components = 0, threshold = DBL_MAX) ⇒ Cv::Ptr::Cv_FaceRecognizer (also: createEigenFaceRecognizer)
• .create_fisher_face_recognizer(num_components = 0, threshold = DBL_MAX) ⇒ Cv::Ptr::Cv_FaceRecognizer (also: createFisherFaceRecognizer)
• .create_hanning_window(dst, win_size, type) ⇒ Void (also: createHanningWindow)
• .createclahe(clip_limit = 40.0, tile_grid_size = Cv::Size.new(8, 8)) ⇒ Cv::Ptr::Cv_CLAHE (also: createCLAHE)
• .createlbph_face_recognizer(radius = 1, neighbors = 8, grid_x = 8, grid_y = 8, threshold = DBL_MAX) ⇒ Cv::Ptr::Cv_FaceRecognizer (also: createLBPHFaceRecognizer)
• .cube_root(val) ⇒ Float (also: cubeRoot)
• .cvt_color(src, dst, code, dst_cn = 0) ⇒ Void (also: cvtColor)
• .dct(src, dst, flags = 0) ⇒ Void
• .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()) ⇒ Void (also: decomposeProjectionMatrix)
• .destroy_all_windows ⇒ Void (also: destroyAllWindows)
• .destroy_window(winname) ⇒ Void (also: destroyWindow)
• .determinant(mtx) ⇒ Double
• .dft(src, dst, flags = 0, nonzero_rows = 0) ⇒ Void
• .dilate(src, dst, kernel, anchor = Cv::Point.new(-1,-1), iterations = 1, border_type = BORDER_CONSTANT, border_value = morphology_default_border_value()) ⇒ Void
• .distance_transform(src, dst, distance_type, mask_size) ⇒ Void (also: distanceTransform)
• .distance_transform_with_labels(src, dst, labels, distance_type, mask_size, label_type = DIST_LABEL_CCOMP) ⇒ Void (also: distanceTransformWithLabels)
• .divide(*args) ⇒ Object
• .draw_chessboard_corners(image, pattern_size, corners, pattern_was_found) ⇒ Void (also: drawChessboardCorners)
• .draw_contours(image, contours, contour_idx, color, thickness = 1, line_type = 8, hierarchy = Cv::Mat.new(), max_level = INT_MAX, offset = Cv::Point.new()) ⇒ Void (also: drawContours)
• .draw_data_matrix_codes(image, codes, corners) ⇒ Void (also: drawDataMatrixCodes)
• .draw_keypoints(image, keypoints, out_image, color = Cv::Scalar::all(-1), flags = DrawMatchesFlags::DEFAULT) ⇒ Void (also: drawKeypoints)
• .draw_matches(_img1, _keypoints1, _img2, _keypoints2, _matches1to2, out_img, match_color = Cv::Scalar::all(-1), single_point_color = Cv::Scalar::all(-1), matches_mask = Std::Vector::Char.new(), flags = DrawMatchesFlags::DEFAULT) ⇒ Void (also: drawMatches)
• .eigen(src, compute_eigenvectors, eigenvalues, eigenvectors) ⇒ Bool
• .ellipse(*args) ⇒ Object
• .ellipse2_poly(center, axes, angle, arc_start, arc_end, delta, pts) ⇒ Void (also: ellipse2Poly)
• .equalize_hist(src, dst) ⇒ Void (also: equalizeHist)
• .erode(src, dst, kernel, anchor = Cv::Point.new(-1,-1), iterations = 1, border_type = BORDER_CONSTANT, border_value = morphology_default_border_value()) ⇒ Void
• .estimate_affine3d(src, dst, out, inliers, ransac_threshold = 3, confidence = 0.99) ⇒ Fixnum (also: estimateAffine3D)
• .estimate_rigid_transform(src, dst, full_affine) ⇒ Cv::Mat (also: estimateRigidTransform)
• .exp(src, dst) ⇒ Void
• .extract_channel(src, dst, coi) ⇒ Void (also: extractChannel)
• .fast_atan2(y, x) ⇒ Float (also: fastAtan2)
• .fast_nl_means_denoising(src, dst, h = 3, template_window_size = 7, search_window_size = 21) ⇒ Void (also: fastNlMeansDenoising)
• .fast_nl_means_denoising_colored(src, dst, h = 3, h_color = 3, template_window_size = 7, search_window_size = 21) ⇒ Void (also: fastNlMeansDenoisingColored)
• .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) ⇒ Void (also: fastNlMeansDenoisingColoredMulti)
• .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) ⇒ Void (also: fastNlMeansDenoisingMulti)
• .fill_convex_poly(img, points, color, line_type = 8, shift = 0) ⇒ Void (also: fillConvexPoly)
• .fill_poly(img, pts, color, line_type = 8, shift = 0, offset = Cv::Point.new()) ⇒ Void (also: fillPoly)
• .filter2d(src, dst, ddepth, kernel, anchor = Cv::Point.new(-1,-1), delta = 0, border_type = BORDER_DEFAULT) ⇒ Void (also: filter2D)
• .filter_speckles(img, new_val, max_speckle_size, max_diff, buf = Cv::Mat.new()) ⇒ Void (also: filterSpeckles)
• .find_chessboard_corners(image, pattern_size, corners, flags = CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE) ⇒ Bool (also: findChessboardCorners)
• .find_circles_grid(image, pattern_size, centers, flags = CALIB_CB_SYMMETRIC_GRID, blob_detector = Cv::SimpleBlobDetector.new()) ⇒ Bool (also: findCirclesGrid)
• .find_circles_grid_default(image, pattern_size, centers, flags = CALIB_CB_SYMMETRIC_GRID) ⇒ Bool (also: findCirclesGridDefault)
• .find_contours(image, contours, hierarchy, mode, method, offset = Cv::Point.new()) ⇒ Void (also: findContours)
• .find_data_matrix(image, codes, corners = Cv::Mat.new(), dmtx = Std::Vector::Cv_Mat.new()) ⇒ Void (also: findDataMatrix)
• .find_fundamental_mat(_points1, _points2, method = FM_RANSAC, _param1 = 3.0, _param2 = 0.99, mask = Cv::Mat.new()) ⇒ Cv::Mat (also: findFundamentalMat)
• .find_homography(src_points, dst_points, method = 0, ransac_reproj_threshold = 3, mask = Cv::Mat.new()) ⇒ Cv::Mat (also: findHomography)
• .find_non_zero(src, idx) ⇒ Void (also: findNonZero)
• .fit_ellipse(points) ⇒ Cv::RotatedRect (also: fitEllipse)
• .fit_line(points, line, dist_type, param, reps, aeps) ⇒ Void (also: fitLine)
• .flip(src, dst, flip_code) ⇒ Void
• .flood_fill(image, mask, seed_point, new_val, rect = Cv::Rect::null, lo_diff = Cv::Scalar.new(), up_diff = Cv::Scalar.new(), flags = 4) ⇒ Fixnum (also: floodFill)
• .gaussian_blur(src, dst, ksize, sigma_x, sigma_y = 0, border_type = BORDER_DEFAULT) ⇒ Void (also: GaussianBlur)
• .gemm(_src1, _src2, alpha, _src3, beta, dst, flags = 0) ⇒ Void
• .get_affine_transform(src, dst) ⇒ Cv::Mat (also: getAffineTransform)
• .get_build_information ⇒ Cv::String (also: getBuildInformation)
• .get_default_new_camera_matrix(camera_matrix, imgsize = Cv::Size.new(), center_principal_point = false) ⇒ Cv::Mat (also: getDefaultNewCameraMatrix)
• .get_deriv_kernels(kx, ky, dx, dy, ksize, normalize = false, ktype = CV_32F) ⇒ Void (also: getDerivKernels)
• .get_gabor_kernel(ksize, sigma, theta, lambd, gamma, psi = CV_PI*0.5, ktype = CV_64F) ⇒ Cv::Mat (also: getGaborKernel)
• .get_gaussian_kernel(ksize, sigma, ktype = CV_64F) ⇒ Cv::Mat (also: getGaussianKernel)
• .get_num_threads ⇒ Fixnum (also: getNumThreads)
• .get_number_ofcp_us ⇒ Fixnum (also: getNumberOfCPUs)
• .get_optimal_new_camera_matrix(camera_matrix, dist_coeffs, image_size, alpha, new_img_size = Cv::Size.new(), valid_pix_r_o_i = Cv::Rect::null, center_principal_point = false) ⇒ Cv::Mat (also: getOptimalNewCameraMatrix)
• .get_optimaldft_size(vecsize) ⇒ Fixnum (also: getOptimalDFTSize)
• .get_perspective_transform(src, dst) ⇒ Cv::Mat (also: getPerspectiveTransform)
• .get_rect_sub_pix(image, patch_size, center, patch, patch_type = -1)) ⇒ Void (also: getRectSubPix)
• .get_rotation_matrix2d(center, angle, scale) ⇒ Cv::Mat (also: getRotationMatrix2D)
• .get_structuring_element(shape, ksize, anchor = Cv::Point.new(-1,-1)) ⇒ Cv::Mat (also: getStructuringElement)
• .get_text_size(text, font_face, font_scale, thickness, base_line) ⇒ Cv::Size (also: getTextSize)
• .get_thread_num ⇒ Fixnum (also: getThreadNum)
• .get_tick_count ⇒ Fixnum (also: getTickCount)
• .get_tick_frequency ⇒ Double (also: getTickFrequency)
• .get_trackbar_pos(trackbarname, winname) ⇒ Fixnum (also: getTrackbarPos)
• .get_valid_disparityroi(_roi1, _roi2, min_disparity, number_of_disparities, s_a_d_window_size) ⇒ Cv::Rect (also: getValidDisparityROI)
• .get_window_property(winname, prop_id) ⇒ Double (also: getWindowProperty)
• .getcpu_tick_count ⇒ Fixnum (also: getCPUTickCount)
• .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) ⇒ Void (also: goodFeaturesToTrack)
• .grab_cut(img, mask, rect, bgd_model, fgd_model, iter_count, mode = GC_EVAL) ⇒ Void (also: grabCut)
• .group_rectangles(rect_list, weights, group_threshold, eps = 0.2) ⇒ Void (also: groupRectangles)
• .hconcat(src, dst) ⇒ Void
• .hough_circles(image, circles, method, dp, min_dist, _param1 = 100, _param2 = 100, min_radius = 0, max_radius = 0) ⇒ Void (also: HoughCircles)
• .hough_lines(image, lines, rho, theta, threshold, srn = 0, stn = 0) ⇒ Void (also: HoughLines)
• .hough_linesp(image, lines, rho, theta, threshold, min_line_length = 0, max_line_gap = 0) ⇒ Void (also: HoughLinesP)
• .hu_moments(m, hu) ⇒ Void (also: HuMoments)
• .idct(src, dst, flags = 0) ⇒ Void
• .idft(src, dst, flags = 0, nonzero_rows = 0) ⇒ Void
• .imdecode(buf, flags) ⇒ Cv::Mat
• .imencode(ext, img, buf, params = Std::Vector::Int.new()) ⇒ Bool
• .imread(filename, flags = 1) ⇒ Cv::Mat
• .imshow(winname, mat) ⇒ Void
• .imwrite(filename, img, params = Std::Vector::Int.new()) ⇒ Bool
• .in_range(src, lowerb, upperb, dst) ⇒ Void (also: inRange)
• .init_camera_matrix2d(object_points, image_points, image_size, aspect_ratio = 1.0) ⇒ Cv::Mat (also: initCameraMatrix2D)
• .init_module_nonfree ⇒ Bool (also: initModule_nonfree)
• .init_undistort_rectify_map(camera_matrix, dist_coeffs, r, new_camera_matrix, size, _m1type, _map1, _map2) ⇒ Void (also: initUndistortRectifyMap)
• .init_wide_angle_proj_map(camera_matrix, dist_coeffs, image_size, dest_image_width, _m1type, _map1, _map2, proj_type = PROJ_SPHERICAL_EQRECT, alpha = 0) ⇒ Float (also: initWideAngleProjMap)
• .inpaint(src, inpaint_mask, dst, inpaint_radius, flags) ⇒ Void
• .insert_channel(src, dst, coi) ⇒ Void (also: insertChannel)
• .integral(src, sum, sdepth = -1)) ⇒ Void
• .integral2(src, sum, sqsum, sdepth = -1)) ⇒ Void
• .integral3(src, sum, sqsum, tilted, sdepth = -1)) ⇒ Void
• .intersect_convex_convex(__p1, __p2, __p12, handle_nested = true) ⇒ Float (also: intersectConvexConvex)
• .invert(src, dst, flags = DECOMP_LU) ⇒ Double
• .invert_affine_transform(m, i_m) ⇒ Void (also: invertAffineTransform)
• .is_contour_convex(contour) ⇒ Bool (also: isContourConvex)
• .kmeans(data, k, best_labels, criteria, attempts, flags, centers = Cv::Mat.new()) ⇒ Double
• .laplacian(src, dst, ddepth, ksize = 1, scale = 1, delta = 0, border_type = BORDER_DEFAULT) ⇒ Void (also: Laplacian)
• .line(img, _pt1, _pt2, color, thickness = 1, line_type = 8, shift = 0) ⇒ Void
• .log(src, dst) ⇒ Void
• .lut(src, lut, dst, interpolation = 0) ⇒ Void (also: LUT)
• .magnitude(x, y, magnitude) ⇒ Void
• .mahalanobis(_v1, _v2, icovar) ⇒ Double (also: Mahalanobis)
• .mat_mul_deriv(a, b, d_a_bd_a, d_a_bd_b) ⇒ Void (also: matMulDeriv)
• .match_shapes(_contour1, _contour2, method, parameter) ⇒ Double (also: matchShapes)
• .match_template(image, templ, result, method) ⇒ Void (also: matchTemplate)
• .max(_src1, _src2, dst) ⇒ Void
• .mean(src, mask = Cv::Mat.new()) ⇒ Cv::Scalar
• .mean_shift(prob_image, window, criteria) ⇒ Fixnum (also: meanShift)
• .mean_std_dev(src, mean, stddev, mask = Cv::Mat.new()) ⇒ Void (also: meanStdDev)
• .median_blur(src, dst, ksize) ⇒ Void (also: medianBlur)
• .merge(mv, dst) ⇒ Void
• .min(_src1, _src2, dst) ⇒ Void
• .min_area_rect(points) ⇒ Cv::RotatedRect (also: minAreaRect)
• .min_enclosing_circle(points, center, radius) ⇒ Void (also: minEnclosingCircle)
• .min_max_loc(src, min_val, max_val = 0/O, min_loc = Cv::Point::null, max_loc = Cv::Point::null, mask = Cv::Mat.new()) ⇒ Void (also: minMaxLoc)
• .mix_channels(src, dst, from_to) ⇒ Void (also: mixChannels)
• .moments(array, binary_image = false) ⇒ Cv::Moments
• .morphology_default_border_value ⇒ Cv::Scalar (also: morphologyDefaultBorderValue)
• .morphology_ex(src, dst, op, kernel, anchor = Cv::Point.new(-1,-1), iterations = 1, border_type = BORDER_CONSTANT, border_value = morphology_default_border_value()) ⇒ Void (also: morphologyEx)
• .move_window(winname, x, y) ⇒ Void (also: moveWindow)
• .mul_spectrums(a, b, c, flags, conj_b = false) ⇒ Void (also: mulSpectrums)
• .mul_transposed(src, dst, a_ta, delta = Cv::Mat.new(), scale = 1, dtype = -1)) ⇒ Void (also: mulTransposed)
• .multiply(_src1, _src2, dst, scale = 1, dtype = -1)) ⇒ Void
• .named_window(winname, flags = WINDOW_AUTOSIZE) ⇒ Void (also: namedWindow)
• .norm(*args) ⇒ Object
• .normalize(src, dst, alpha = 1, beta = 0, norm_type = NORM_L2, dtype = -1,, mask = Cv::Mat.new()) ⇒ Void
• .patch_na_ns(a, val = 0) ⇒ Void (also: patchNaNs)
• .pca_back_project(data, mean, eigenvectors, result) ⇒ Void (also: PCABackProject)
• .pca_compute(data, mean, eigenvectors, max_components = 0) ⇒ Void (also: PCACompute)
• .pca_compute_var(data, mean, eigenvectors, retained_variance) ⇒ Void (also: PCAComputeVar)
• .pca_project(data, mean, eigenvectors, result) ⇒ Void (also: PCAProject)
• .perspective_transform(src, dst, m) ⇒ Void (also: perspectiveTransform)
• .phase(x, y, angle, angle_in_degrees = false) ⇒ Void
• .phase_correlate(_src1, _src2, window = Cv::Mat.new()) ⇒ Cv::Point2d (also: phaseCorrelate)
• .phase_correlate_res(_src1, _src2, window, response = 0/O) ⇒ Cv::Point2d (also: phaseCorrelateRes)
• .point_polygon_test(contour, pt, measure_dist) ⇒ Double (also: pointPolygonTest)
• .polar_to_cart(magnitude, angle, x, y, angle_in_degrees = false) ⇒ Void (also: polarToCart)
• .polyfit(srcx, srcy, dst, order) ⇒ Void
• .polylines(img, pts, is_closed, color, thickness = 1, line_type = 8, shift = 0) ⇒ Void
• .pow(src, power, dst) ⇒ Void
• .pre_corner_detect(src, dst, ksize, border_type = BORDER_DEFAULT) ⇒ Void (also: preCornerDetect)
• .project_points(object_points, rvec, tvec, camera_matrix, dist_coeffs, image_points, jacobian = Cv::Mat.new(), aspect_ratio = 0) ⇒ Void (also: projectPoints)
• .psnr(_src1, _src2) ⇒ Double (also: PSNR)
• .put_text(img, text, org, font_face, font_scale, color, thickness = 1, line_type = 8, bottom_left_origin = false) ⇒ Void (also: putText)
• .pyr_down(src, dst, dstsize = Cv::Size.new(), border_type = BORDER_DEFAULT) ⇒ Void (also: pyrDown)
• .pyr_mean_shift_filtering(src, dst, sp, sr, max_level = 1, termcrit = Cv::TermCriteria.new( TermCriteria::MAX_ITER+TermCriteria::EPS,5,1)) ⇒ Void (also: pyrMeanShiftFiltering)
• .pyr_up(src, dst, dstsize = Cv::Size.new(), border_type = BORDER_DEFAULT) ⇒ Void (also: pyrUp)
• .rand_shuffle(dst, iter_factor = 1.0) ⇒ Void (also: randShuffle)
• .randn(dst, mean, stddev) ⇒ Void
• .randu(dst, low, high) ⇒ Void
• .read_double(fn, val, default_val) ⇒ Void
• .read_float(fn, val, default_val) ⇒ Void
• .read_int(fn, val, default_val) ⇒ Void
• .read_mat(fn, val, default_val) ⇒ Void
• .read_string(fn, val, default_val) ⇒ Void
• .rectangle(img, _pt1, _pt2, color, thickness = 1, line_type = 8, shift = 0) ⇒ Void
• .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) ⇒ Float (also: rectify3Collinear)
• .reduce(src, dst, dim, rtype, dtype = -1)) ⇒ Void
• .remap(src, dst, _map1, _map2, interpolation, border_mode = BORDER_CONSTANT, border_value = Cv::Scalar.new()) ⇒ Void
• .repeat(src, ny, nx, dst) ⇒ Void
• .reproject_image_to3d(disparity, __3d_image, q, handle_missing_values = false, ddepth = -1)) ⇒ Void (also: reprojectImageTo3D)
• .resize(src, dst, dsize, fx = 0, fy = 0, interpolation = INTER_LINEAR) ⇒ Void
• .resize_window(winname, width, height) ⇒ Void (also: resizeWindow)
• .rodrigues(src, dst, jacobian = Cv::Mat.new()) ⇒ Void (also: Rodrigues)
• .rq_decomp_3x3(src, mtx_r, mtx_q, qx = Cv::Mat.new(), qy = Cv::Mat.new(), qz = Cv::Mat.new()) ⇒ Cv::Vec3d (also: RQDecomp3x3)
• .scale_add(_src1, alpha, _src2, dst) ⇒ Void (also: scaleAdd)
• .scharr(src, dst, ddepth, dx, dy, scale = 1, delta = 0, border_type = BORDER_DEFAULT) ⇒ Void (also: Scharr)
• .segment_motion(mhi, segmask, bounding_rects, timestamp, seg_thresh) ⇒ Void (also: segmentMotion)
• .sep_filter2d(src, dst, ddepth, kernel_x, kernel_y, anchor = Cv::Point.new(-1,-1), delta = 0, border_type = BORDER_DEFAULT) ⇒ Void (also: sepFilter2D)
• .set_identity(mtx, s = Cv::Scalar.new(1)) ⇒ Void (also: setIdentity)
• .set_num_threads(nthreads) ⇒ Void (also: setNumThreads)
• .set_trackbar_pos(trackbarname, winname, pos) ⇒ Void (also: setTrackbarPos)
• .set_use_optimized(onoff) ⇒ Void (also: setUseOptimized)
• .set_window_property(winname, prop_id, prop_value) ⇒ Void (also: setWindowProperty)
• .sobel(src, dst, ddepth, dx, dy, ksize = 3, scale = 1, delta = 0, border_type = BORDER_DEFAULT) ⇒ Void (also: Sobel)
• .solve(_src1, _src2, dst, flags = DECOMP_LU) ⇒ Bool
• .solve_cubic(coeffs, roots) ⇒ Fixnum (also: solveCubic)
• .solve_pnp(object_points, image_points, camera_matrix, dist_coeffs, rvec, tvec, use_extrinsic_guess = false, flags = ITERATIVE) ⇒ Bool (also: solvePnP)
• .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) ⇒ Void (also: solvePnPRansac)
• .solve_poly(coeffs, roots, max_iters = 300) ⇒ Double (also: solvePoly)
• .sort(src, dst, flags) ⇒ Void
• .sort_idx(src, dst, flags) ⇒ Void (also: sortIdx)
• .split(m, mv) ⇒ Void
• .sqrt(src, dst) ⇒ Void
• .start_window_thread ⇒ Fixnum (also: startWindowThread)
• .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) ⇒ Double (also: stereoCalibrate)
• .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 = Cv::Rect::null, _valid_pix_r_o_i2 = Cv::Rect::null) ⇒ Void (also: stereoRectify)
• .stereo_rectify_uncalibrated(_points1, _points2, f, img_size, _h1, _h2, threshold = 5) ⇒ Bool (also: stereoRectifyUncalibrated)
• .subtract(_src1, _src2, dst, mask = Cv::Mat.new(), dtype = -1)) ⇒ Void
• .sum(src) ⇒ Cv::Mat
• .sum_elems(src) ⇒ Cv::Scalar (also: sumElems)
• .sv_back_subst(w, u, vt, rhs, dst) ⇒ Void (also: SVBackSubst)
• .sv_decomp(src, w, u, vt, flags = 0) ⇒ Void (also: SVDecomp)
• .threshold(src, dst, thresh, maxval, type) ⇒ Double
• .trace(mtx) ⇒ Cv::Scalar
• .transform(src, dst, m) ⇒ Void
• .transpose(src, dst) ⇒ Void
• .triangulate_points(_proj_matr1, _proj_matr2, _proj_points1, _proj_points2, _points4_d) ⇒ Void (also: triangulatePoints)
• .undistort(src, dst, camera_matrix, dist_coeffs, new_camera_matrix = Cv::Mat.new()) ⇒ Void
• .undistort_points(src, dst, camera_matrix, dist_coeffs, r = Cv::Mat.new(), p = Cv::Mat.new()) ⇒ Void (also: undistortPoints)
• .update_motion_history(silhouette, mhi, timestamp, duration) ⇒ Void (also: updateMotionHistory)
• .use_optimized ⇒ Bool (also: useOptimized)
• .validate_disparity(disparity, cost, min_disparity, number_of_disparities, _disp12_max_disp = 1) ⇒ Void (also: validateDisparity)
• .vconcat(src, dst) ⇒ Void
• .wait_key(delay = 0) ⇒ Fixnum (also: waitKey)
• .warp_affine(src, dst, m, dsize, flags = INTER_LINEAR, border_mode = BORDER_CONSTANT, border_value = Cv::Scalar.new()) ⇒ Void (also: warpAffine)
• .warp_perspective(src, dst, m, dsize, flags = INTER_LINEAR, border_mode = BORDER_CONSTANT, border_value = Cv::Scalar.new()) ⇒ Void (also: warpPerspective)
• .watershed(image, markers) ⇒ Void
• .write_double(fs, name, val) ⇒ Void
• .write_float(fs, name, val) ⇒ Void
• .write_int(fs, name, val) ⇒ Void
• .write_mat(fs, name, val) ⇒ Void
• .write_point(fs, name, val) ⇒ Void
• .write_point_2d(fs, name, val) ⇒ Void (also: write_point2d)
• .write_point_2f(fs, name, val) ⇒ Void (also: write_point2f)
• .write_point_3d(fs, name, val) ⇒ Void (also: write_point3d)
• .write_point_3f(fs, name, val) ⇒ Void (also: write_point3f)
• .write_range(fs, name, val) ⇒ Void
• .write_rect(fs, name, val) ⇒ Void
• .write_scalar(fs, name, val) ⇒ Void
• .write_scalar_double(fs, val) ⇒ Void
• .write_scalar_float(fs, val) ⇒ Void
• .write_scalar_int(fs, val) ⇒ Void
• .write_scalar_string(fs, val) ⇒ Void
• .write_size(fs, name, val) ⇒ Void
• .write_string(fs, name, val) ⇒ Void
• .write_vec_2d(fs, name, val) ⇒ Void (also: write_vec2d)
• .write_vec_2f(fs, name, val) ⇒ Void (also: write_vec2f)
• .write_vec_3d(fs, name, val) ⇒ Void (also: write_vec3d)
• .write_vec_3f(fs, name, val) ⇒ Void (also: write_vec3f)

Class Method Details

.abs(src) ⇒ Cv::Mat

Note:

wrapper for static method cv::Mat cv::abs(const cv::Mat src)

Parameters:

• src (Cv::Mat)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 4591

def self.abs(src)
    Rbind::cv_abs(src)
end

.absdiff(_src1, _src2, dst) ⇒ Void

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1838

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

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

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3077

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()) ⇒ Void Also known as: accumulateProduct

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3097

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()) ⇒ Void Also known as: accumulateSquare

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3086

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()) ⇒ Void Also known as: accumulateWeighted

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• alpha (Double)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3108

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

.adaptive_bilateral_filter(src, dst, ksize, sigma_space, max_sigma_color = 20.0, anchor = Cv::Point.new(-1, -1), border_type = BORDER_DEFAULT) ⇒ Void Also known as: adaptiveBilateralFilter

Note:

wrapper for static method void cv::adaptiveBilateralFilter(const cv::Mat src, cv::Mat& dst, const cv::Size ksize, double sigmaSpace, double maxSigmaColor = 20.0, const cv::Point anchor = Point(-1, -1), int borderType = BORDER_DEFAULT)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ksize (Cv::Size)
• sigma_space (Double)
• max_sigma_color (Double) (defaults to: 20.0)
• anchor (Cv::Point) (defaults to: Cv::Point.new(-1, -1))
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2649

def self.adaptive_bilateral_filter(src, dst, ksize, sigma_space, max_sigma_color = 20.0, anchor = Cv::Point.new(-1, -1), border_type = BORDER_DEFAULT)
    Rbind::cv_adaptive_bilateral_filter(src, dst, ksize, sigma_space, max_sigma_color, anchor, border_type)
end

.adaptive_threshold(src, dst, max_value, adaptive_method, threshold_type, block_size, c) ⇒ Void Also known as: adaptiveThreshold

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• max_value (Double)
• adaptive_method (Fixnum)
• threshold_type (Fixnum)
• block_size (Fixnum)
• c (Double)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3173

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)) ⇒ Void

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())
• dtype (Fixnum) (defaults to: -1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1445

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)) ⇒ Void Also known as: addWeighted

Note:

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

Parameters:

• _src1 (Cv::Mat)
• alpha (Double)
• _src2 (Cv::Mat)
• beta (Double)
• gamma (Double)
• dst (Cv::Mat)
• dtype (Fixnum) (defaults to: -1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1537

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) ⇒ Void Also known as: applyColorMap

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• colormap (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4542

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

.approx_polydp(curve, approx_curve, epsilon, closed) ⇒ Void Also known as: approxPolyDP

Note:

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

Parameters:

• curve (Cv::Mat)
• approx_curve (Cv::Mat)
• epsilon (Double)
• closed (Bool)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3468

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

.arc_length(curve, closed) ⇒ Double Also known as: arcLength

Note:

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

Parameters:

• curve (Cv::Mat)
• closed (Bool)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 3477

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

.arrowed_line(img, _pt1, _pt2, color, thickness = 1, line_type = 8, shift = 0, tip_length = 0.1) ⇒ Void Also known as: arrowedLine

Note:

wrapper for static method void cv::arrowedLine(cv::Mat& img, const cv::Point pt1, const cv::Point pt2, const cv::Scalar color, int thickness = 1, int line_type = 8, int shift = 0, double tipLength = 0.1)

Parameters:

• img (Cv::Mat)
• _pt1 (Cv::Point)
• _pt2 (Cv::Point)
• color (Cv::Scalar)
• thickness (Fixnum) (defaults to: 1)
• line_type (Fixnum) (defaults to: 8)
• shift (Fixnum) (defaults to: 0)
• tip_length (Double) (defaults to: 0.1)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2358

def self.arrowed_line(img, _pt1, _pt2, color, thickness = 1, line_type = 8, shift = 0, tip_length = 0.1)
    Rbind::cv_arrowed_line(img, _pt1, _pt2, color, thickness, line_type, shift, tip_length)
end

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

Note:

wrapper for static method 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)

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dist (Cv::Mat)
• dtype (Fixnum)
• nidx (Cv::Mat)
• norm_type (Fixnum) (defaults to: NORM_L2)
• k (Fixnum) (defaults to: 0)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())
• update (Fixnum) (defaults to: 0)
• crosscheck (Bool) (defaults to: false)

Returns:

• (Void)

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

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) ⇒ Void Also known as: bilateralFilter

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• d (Fixnum)
• sigma_color (Double)
• sigma_space (Double)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2635

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()) ⇒ Void

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1800

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()) ⇒ Void

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

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

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()) ⇒ Void

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

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

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()) ⇒ Void

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

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

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) ⇒ Void

Note:

wrapper for static method 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)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ksize (Cv::Size)
• anchor (Cv::Point) (defaults to: Cv::Point.new(-1,-1))
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2675

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) ⇒ Fixnum Also known as: borderInterpolate

Note:

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

Parameters:

• p (Fixnum)
• len (Fixnum)
• border_type (Fixnum)

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 2536

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

.bounding_rect(points) ⇒ Cv::Rect Also known as: boundingRect

Note:

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

Parameters:

• points (Cv::Mat)

Returns:

• (Cv::Rect)

# File 'lib/ropencv/ropencv_types.rb', line 3485

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) ⇒ Void Also known as: boxFilter

Note:

wrapper for static method 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)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ddepth (Fixnum)
• ksize (Cv::Size)
• anchor (Cv::Point) (defaults to: Cv::Point.new(-1,-1))
• normalize (Bool) (defaults to: true)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2663

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

.build_optical_flow_pyramid(img, pyramid, win_size, max_level, with_derivatives = true, pyr_border = BORDER_REFLECT_101, deriv_border = BORDER_CONSTANT, try_reuse_input_image = true) ⇒ Fixnum Also known as: buildOpticalFlowPyramid

Note:

wrapper for static method int cv::buildOpticalFlowPyramid(const cv::Mat img, std::vectorcv::Mat& pyramid, const cv::Size winSize, int maxLevel, bool withDerivatives = true, int pyrBorder = BORDER_REFLECT_101, int derivBorder = BORDER_CONSTANT, bool tryReuseInputImage = true)

Parameters:

• img (Cv::Mat)
• pyramid (Std::Vector::Cv_Mat)
• win_size (Cv::Size)
• max_level (Fixnum)
• with_derivatives (Bool) (defaults to: true)
• pyr_border (Fixnum) (defaults to: BORDER_REFLECT_101)
• deriv_border (Fixnum) (defaults to: BORDER_CONSTANT)
• try_reuse_input_image (Bool) (defaults to: true)

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 3742

def self.build_optical_flow_pyramid(img, pyramid, win_size, max_level, with_derivatives = true, pyr_border = BORDER_REFLECT_101, deriv_border = BORDER_CONSTANT, try_reuse_input_image = true)
    Rbind::cv_build_optical_flow_pyramid(img, pyramid, win_size, max_level, with_derivatives, pyr_border, deriv_border, try_reuse_input_image)
end

.calc_back_project(images, channels, hist, dst, ranges, scale) ⇒ Void Also known as: calcBackProject

Note:

wrapper for static method void cv::calcBackProject(const std::vectorcv::Mat images, const std::vector channels, const cv::Mat hist, cv::Mat& dst, const std::vector ranges, double scale)

Parameters:

• images (Std::Vector::Cv_Mat)
• channels (Std::Vector::Int)
• hist (Cv::Mat)
• dst (Cv::Mat)
• ranges (Std::Vector::Float)
• scale (Double)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3287

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) ⇒ Void Also known as: calcCovarMatrix

Note:

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

Parameters:

• samples (Cv::Mat)
• covar (Cv::Mat)
• mean (Cv::Mat)
• flags (Fixnum)
• ctype (Fixnum) (defaults to: CV_64F)

Returns:

• (Void)

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

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

.calc_global_orientation(orientation, mask, mhi, timestamp, duration) ⇒ Double Also known as: calcGlobalOrientation

Note:

wrapper for static method double cv::calcGlobalOrientation(const cv::Mat orientation, const cv::Mat mask, const cv::Mat mhi, double timestamp, double duration)

Parameters:

• orientation (Cv::Mat)
• mask (Cv::Mat)
• mhi (Cv::Mat)
• timestamp (Double)
• duration (Double)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 3695

def self.calc_global_orientation(orientation, mask, mhi, timestamp, duration)
    Rbind::cv_calc_global_orientation(orientation, mask, mhi, timestamp, duration)
end

.calc_hist(images, channels, mask, hist, hist_size, ranges, accumulate = false) ⇒ Void Also known as: calcHist

Note:

wrapper for static method void cv::calcHist(const std::vectorcv::Mat images, const std::vector channels, const cv::Mat mask, cv::Mat& hist, const std::vector histSize, const std::vector ranges, bool accumulate = false)

Parameters:

• images (Std::Vector::Cv_Mat)
• channels (Std::Vector::Int)
• mask (Cv::Mat)
• hist (Cv::Mat)
• hist_size (Std::Vector::Int)
• ranges (Std::Vector::Float)
• accumulate (Bool) (defaults to: false)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3274

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

.calc_motion_gradient(mhi, mask, orientation, _delta1, _delta2, aperture_size = 3) ⇒ Void Also known as: calcMotionGradient

Note:

wrapper for static method void cv::calcMotionGradient(const cv::Mat mhi, cv::Mat& mask, cv::Mat& orientation, double delta1, double delta2, int apertureSize = 3)

Parameters:

• mhi (Cv::Mat)
• mask (Cv::Mat)
• orientation (Cv::Mat)
• _delta1 (Double)
• _delta2 (Double)
• aperture_size (Fixnum) (defaults to: 3)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3683

def self.calc_motion_gradient(mhi, mask, orientation, _delta1, _delta2, aperture_size = 3)
    Rbind::cv_calc_motion_gradient(mhi, mask, orientation, _delta1, _delta2, aperture_size)
end

.calc_optical_flow_farneback(prev, next_, flow, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags) ⇒ Void Also known as: calcOpticalFlowFarneback

Note:

wrapper for static method void cv::calcOpticalFlowFarneback(const cv::Mat prev, const cv::Mat next, cv::Mat& flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags)

Parameters:

• prev (Cv::Mat)
• next_ (Cv::Mat)
• flow (Cv::Mat)
• pyr_scale (Double)
• levels (Fixnum)
• winsize (Fixnum)
• iterations (Fixnum)
• poly_n (Fixnum)
• poly_sigma (Double)
• flags (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3777

def self.calc_optical_flow_farneback(prev, next_, flow, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags)
    Rbind::cv_calc_optical_flow_farneback(prev, next_, flow, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags)
end

.calc_optical_flow_pyrlk(prev_img, next_img, prev_pts, next_pts, status, err, win_size = Cv::Size.new(21,21), max_level = 3, criteria = Cv::TermCriteria.new(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), flags = 0, min_eig_threshold = 1e-4) ⇒ Void Also known as: calcOpticalFlowPyrLK

Note:

wrapper for static method void cv::calcOpticalFlowPyrLK(const cv::Mat prevImg, const cv::Mat nextImg, const cv::Mat prevPts, cv::Mat& nextPts, cv::Mat& status, cv::Mat& err, const cv::Size winSize = Size(21,21), int maxLevel = 3, const cv::TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags = 0, double minEigThreshold = 1e-4)

Parameters:

• prev_img (Cv::Mat)
• next_img (Cv::Mat)
• prev_pts (Cv::Mat)
• next_pts (Cv::Mat)
• status (Cv::Mat)
• err (Cv::Mat)
• win_size (Cv::Size) (defaults to: Cv::Size.new(21,21))
• max_level (Fixnum) (defaults to: 3)
• criteria (Cv::TermCriteria) (defaults to: Cv::TermCriteria.new(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01))
• flags (Fixnum) (defaults to: 0)
• min_eig_threshold (Double) (defaults to: 1e-4)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3760

def self.calc_optical_flow_pyrlk(prev_img, next_img, prev_pts, next_pts, status, err, win_size = Cv::Size.new(21,21), max_level = 3, criteria = Cv::TermCriteria.new(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), flags = 0, min_eig_threshold = 1e-4)
    Rbind::cv_calc_optical_flow_pyrlk(prev_img, next_img, prev_pts, next_pts, status, err, win_size, max_level, criteria, flags, min_eig_threshold)
end

.calc_optical_flowsf(from, to, flow, layers, averaging_block_size, max_flow) ⇒ Void .calc_optical_flowsf(from, to, flow, layers, averaging_block_size, max_flow, sigma_dist, sigma_color, postprocess_window, sigma_dist_fix, sigma_color_fix, occ_thr, upscale_averaging_radius, upscale_sigma_dist, upscale_sigma_color, speed_up_thr) ⇒ Void

Note:

wrapper for overloaded static method calc_optical_flowsf

Overloads:

• .calc_optical_flowsf(from, to, flow, layers, averaging_block_size, max_flow) ⇒ Void

  Parameters:

  • from (Cv::Mat)
  • to (Cv::Mat)
  • flow (Cv::Mat)
  • layers (Fixnum)
  • averaging_block_size (Fixnum)
  • max_flow (Fixnum)

  Returns:

  • (Void)
• .calc_optical_flowsf(from, to, flow, layers, averaging_block_size, max_flow, sigma_dist, sigma_color, postprocess_window, sigma_dist_fix, sigma_color_fix, occ_thr, upscale_averaging_radius, upscale_sigma_dist, upscale_sigma_color, speed_up_thr) ⇒ Void

  Parameters:

  • from (Cv::Mat)
  • to (Cv::Mat)
  • flow (Cv::Mat)
  • layers (Fixnum)
  • averaging_block_size (Fixnum)
  • max_flow (Fixnum)
  • sigma_dist (Double)
  • sigma_color (Double)
  • postprocess_window (Fixnum)
  • sigma_dist_fix (Double)
  • sigma_color_fix (Double)
  • occ_thr (Double)
  • upscale_averaging_radius (Fixnum)
  • upscale_sigma_dist (Double)
  • upscale_sigma_color (Double)
  • speed_up_thr (Double)

  Returns:

  • (Void)

Raises:

• (ArgumentError)

# File 'lib/ropencv/ropencv_types.rb', line 3820

def self.calc_optical_flowsf(*args)
    # overloaded method wrapper for void cv::calcOpticalFlowSF(cv::Mat from, cv::Mat to, cv::Mat flow, int layers, int averaging_block_size, int max_flow)
    @@cv_calc_optical_flowsf_defaults0 ||= [nil, nil, nil, nil, nil, nil]
    if(args.size >= 6 && args.size <= 6)
        targs = args.clone
        targs.size.upto(5) do |i|
            targs[i] = @@cv_calc_optical_flowsf_defaults0[i]
        end
        begin
                return Rbind::cv_calc_optical_flowsf(*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method wrapper for void cv::calcOpticalFlowSF(cv::Mat from, cv::Mat to, cv::Mat flow, int layers, int averaging_block_size, int max_flow, double sigma_dist, double sigma_color, int postprocess_window, double sigma_dist_fix, double sigma_color_fix, double occ_thr, int upscale_averaging_radius, double upscale_sigma_dist, double upscale_sigma_color, double speed_up_thr)
    @@cv_calc_optical_flowsf2_defaults1 ||= [nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil]
    if(args.size >= 16 && args.size <= 16)
        targs = args.clone
        targs.size.upto(15) do |i|
            targs[i] = @@cv_calc_optical_flowsf2_defaults1[i]
        end
        begin
                return Rbind::cv_calc_optical_flowsf2(*targs)
        rescue TypeError => e
            @error = e
        end
    end

    raise ArgumentError, "No overloaded signature fits to: #{args.map(&:class)}"
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)) ⇒ Double Also known as: calibrateCamera

Note:

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

Parameters:

• object_points (Std::Vector::Cv_Mat)
• image_points (Std::Vector::Cv_Mat)
• image_size (Cv::Size)
• camera_matrix (Cv::Mat)
• dist_coeffs (Cv::Mat)
• rvecs (Std::Vector::Cv_Mat)
• tvecs (Std::Vector::Cv_Mat)
• flags (Fixnum) (defaults to: 0)
• criteria (Cv::TermCriteria) (defaults to: Cv::TermCriteria.new( TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 4093

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) ⇒ Void Also known as: calibrationMatrixValues

Note:

wrapper for static method 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)

Parameters:

• camera_matrix (Cv::Mat)
• image_size (Cv::Size)
• aperture_width (Double)
• aperture_height (Double)
• fovx (FFI::MemoryPointer)
• fovy (FFI::MemoryPointer)
• focal_length (FFI::MemoryPointer)
• principal_point (Cv::Point2d)
• aspect_ratio (FFI::MemoryPointer)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4109

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

.cam_shift(prob_image, window, criteria) ⇒ Cv::RotatedRect Also known as: CamShift

Note:

wrapper for static method cv::RotatedRect cv::CamShift(const cv::Mat probImage, cv::Rect& window, const cv::TermCriteria criteria)

Parameters:

• prob_image (Cv::Mat)
• window (Cv::Rect)
• criteria (Cv::TermCriteria)

Returns:

• (Cv::RotatedRect)

# File 'lib/ropencv/ropencv_types.rb', line 3717

def self.cam_shift(prob_image, window, criteria)
    Rbind::cv_cam_shift(prob_image, window, criteria)
end

.canny(image, edges, _threshold1, _threshold2, aperture_size = 3, _l2gradient = false) ⇒ Void Also known as: Canny

Note:

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

Parameters:

• image (Cv::Mat)
• edges (Cv::Mat)
• _threshold1 (Double)
• _threshold2 (Double)
• aperture_size (Fixnum) (defaults to: 3)
• _l2gradient (Bool) (defaults to: false)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2761

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) ⇒ Void Also known as: cartToPolar

Note:

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

Parameters:

• x (Cv::Mat)
• y (Cv::Mat)
• magnitude (Cv::Mat)
• angle (Cv::Mat)
• angle_in_degrees (Bool) (defaults to: false)

Returns:

• (Void)

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

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) ⇒ Fixnum Also known as: chamerMatching

Note:

wrapper for static method int cv::chamerMatching(cv::Mat img, cv::Mat templ, std::vectorstd::vector<cv::Point >& results, std::vector& 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)

Parameters:

• img (Cv::Mat)
• templ (Cv::Mat)
• results (Std::Vector::Std_Vector_Cv_Point)
• cost (Std::Vector::Float)
• templ_scale (Double) (defaults to: 1)
• max_matches (Fixnum) (defaults to: 20)
• min_match_distance (Double) (defaults to: 1.0)
• pad_x (Fixnum) (defaults to: 3)
• pad_y (Fixnum) (defaults to: 3)
• scales (Fixnum) (defaults to: 5)
• min_scale (Double) (defaults to: 0.6)
• max_scale (Double) (defaults to: 1.6)
• orientation_weight (Double) (defaults to: 0.5)
• truncate (Double) (defaults to: 20)

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 4502

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) ⇒ Bool Also known as: checkHardwareSupport

Note:

wrapper for static method bool cv::checkHardwareSupport(int feature)

Parameters:

• feature (Fixnum)

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 1411

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

.check_range(a, quiet = true, pos = Cv::Point::null, min_val = -DBL_MAX,, max_val = DBL_MAX) ⇒ Bool Also known as: checkRange

Note:

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

Parameters:

• a (Cv::Mat)
• quiet (Bool) (defaults to: true)
• pos (Cv::Point) (defaults to: Cv::Point::null)
• min_val (Double) (defaults to: -DBL_MAX,)
• max_val (Double) (defaults to: DBL_MAX)

Returns:

• (Bool)

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

def self.check_range(a, quiet = true, pos = Cv::Point::null, 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) ⇒ Void

Note:

wrapper for static method 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)

Parameters:

• img (Cv::Mat)
• center (Cv::Point)
• radius (Fixnum)
• color (Cv::Scalar)
• thickness (Fixnum) (defaults to: 1)
• line_type (Fixnum) (defaults to: 8)
• shift (Fixnum) (defaults to: 0)

Returns:

• (Void)

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

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) ⇒ Bool Also known as: clipLine

Note:

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

Parameters:

• img_rect (Cv::Rect)
• _pt1 (Cv::Point)
• _pt2 (Cv::Point)

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 2484

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

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

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)
• cmpop (Fixnum)

Returns:

• (Void)

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

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

.compare_hist(_h1, _h2, method) ⇒ Double Also known as: compareHist

Note:

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

Parameters:

• _h1 (Cv::Mat)
• _h2 (Cv::Mat)
• method (Fixnum)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 3297

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

.complete_symm(mtx, lower_to_upper = false) ⇒ Void Also known as: completeSymm

Note:

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

Parameters:

• mtx (Cv::Mat)
• lower_to_upper (Bool) (defaults to: false)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2052

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()) ⇒ Void Also known as: composeRT

Note:

wrapper for static method 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, const cv::Mat dr3dr1 = Mat()/O, const cv::Mat dr3dt1 = Mat()/O, const cv::Mat dr3dr2 = Mat()/O, const cv::Mat dr3dt2 = Mat()/O, const cv::Mat dt3dr1 = Mat()/O, const cv::Mat dt3dt1 = Mat()/O, const cv::Mat dt3dr2 = Mat()/O, const cv::Mat dt3dt2 = Mat()/O)

Parameters:

• _rvec1 (Cv::Mat)
• _tvec1 (Cv::Mat)
• _rvec2 (Cv::Mat)
• _tvec2 (Cv::Mat)
• _rvec3 (Cv::Mat)
• _tvec3 (Cv::Mat)
• _dr3dr1 (Cv::Mat) (defaults to: Cv::Mat.new())
• _dr3dt1 (Cv::Mat) (defaults to: Cv::Mat.new())
• _dr3dr2 (Cv::Mat) (defaults to: Cv::Mat.new())
• _dr3dt2 (Cv::Mat) (defaults to: Cv::Mat.new())
• _dt3dr1 (Cv::Mat) (defaults to: Cv::Mat.new())
• _dt3dt1 (Cv::Mat) (defaults to: Cv::Mat.new())
• _dt3dr2 (Cv::Mat) (defaults to: Cv::Mat.new())
• _dt3dt2 (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3972

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

.compute_correspond_epilines(points, which_image, f, lines) ⇒ Void Also known as: computeCorrespondEpilines

Note:

wrapper for static method void cv::computeCorrespondEpilines(const cv::Mat points, int whichImage, const cv::Mat F, cv::Mat& lines)

Parameters:

• points (Cv::Mat)
• which_image (Fixnum)
• f (Cv::Mat)
• lines (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4256

def self.compute_correspond_epilines(points, which_image, f, lines)
    Rbind::cv_compute_correspond_epilines(points, which_image, f, lines)
end

.contour_area(contour, oriented = false) ⇒ Double Also known as: contourArea

Note:

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

Parameters:

• contour (Cv::Mat)
• oriented (Bool) (defaults to: false)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 3494

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

.convert_maps(_map1, _map2, _dstmap1, _dstmap2, _dstmap1type, nninterpolation = false) ⇒ Void Also known as: convertMaps

Note:

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

Parameters:

• _map1 (Cv::Mat)
• _map2 (Cv::Mat)
• _dstmap1 (Cv::Mat)
• _dstmap2 (Cv::Mat)
• _dstmap1type (Fixnum)
• nninterpolation (Bool) (defaults to: false)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2988

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) ⇒ Void Also known as: convertPointsFromHomogeneous

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4232

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

.convert_points_to_homogeneous(src, dst) ⇒ Void Also known as: convertPointsToHomogeneous

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4223

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) ⇒ Void Also known as: convertScaleAbs

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• alpha (Double) (defaults to: 1)
• beta (Double) (defaults to: 0)

Returns:

• (Void)

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

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) ⇒ Void Also known as: convexHull

Note:

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

Parameters:

• points (Cv::Mat)
• hull (Cv::Mat)
• clockwise (Bool) (defaults to: false)
• return_points (Bool) (defaults to: true)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3534

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) ⇒ Void Also known as: convexityDefects

Note:

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

Parameters:

• contour (Cv::Mat)
• convexhull (Cv::Mat)
• convexity_defects (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3544

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()) ⇒ Void Also known as: copyMakeBorder

Note:

wrapper for static method 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())

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• top (Fixnum)
• bottom (Fixnum)
• left (Fixnum)
• right (Fixnum)
• border_type (Fixnum)
• value (Cv::Scalar) (defaults to: Cv::Scalar.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2599

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) ⇒ Void Also known as: cornerEigenValsAndVecs

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• block_size (Fixnum)
• ksize (Fixnum)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2798

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) ⇒ Void Also known as: cornerHarris

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• block_size (Fixnum)
• ksize (Fixnum)
• k (Double)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2786

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) ⇒ Void Also known as: cornerMinEigenVal

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• block_size (Fixnum)
• ksize (Fixnum) (defaults to: 3)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2773

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) ⇒ Void Also known as: cornerSubPix

Note:

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

Parameters:

• image (Cv::Mat)
• corners (Cv::Mat)
• win_size (Cv::Size)
• zero_zone (Cv::Size)
• criteria (Cv::TermCriteria)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2821

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) ⇒ Void Also known as: correctMatches

Note:

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

Parameters:

• f (Cv::Mat)
• _points1 (Cv::Mat)
• _points2 (Cv::Mat)
• _new_points1 (Cv::Mat)
• _new_points2 (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4280

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) ⇒ Fixnum Also known as: countNonZero

Note:

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

Parameters:

• src (Cv::Mat)

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 1582

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

.create_eigen_face_recognizer(num_components = 0, threshold = DBL_MAX) ⇒ Cv::Ptr::Cv_FaceRecognizer Also known as: createEigenFaceRecognizer

Note:

wrapper for static method cv::Ptrcv::FaceRecognizer cv::createEigenFaceRecognizer(int num_components = 0, double threshold = DBL_MAX)

Parameters:

• num_components (Fixnum) (defaults to: 0)
• threshold (Double) (defaults to: DBL_MAX)

Returns:

• (Cv::Ptr::Cv_FaceRecognizer)

# File 'lib/ropencv/ropencv_types.rb', line 4511

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) ⇒ Cv::Ptr::Cv_FaceRecognizer Also known as: createFisherFaceRecognizer

Note:

wrapper for static method cv::Ptrcv::FaceRecognizer cv::createFisherFaceRecognizer(int num_components = 0, double threshold = DBL_MAX)

Parameters:

• num_components (Fixnum) (defaults to: 0)
• threshold (Double) (defaults to: DBL_MAX)

Returns:

• (Cv::Ptr::Cv_FaceRecognizer)

# File 'lib/ropencv/ropencv_types.rb', line 4520

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) ⇒ Void Also known as: createHanningWindow

Note:

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

Parameters:

• dst (Cv::Mat)
• win_size (Cv::Size)
• type (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3148

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

.createclahe(clip_limit = 40.0, tile_grid_size = Cv::Size.new(8, 8)) ⇒ Cv::Ptr::Cv_CLAHE Also known as: createCLAHE

Note:

wrapper for static method cv::Ptrcv::CLAHE cv::createCLAHE(double clipLimit = 40.0, const cv::Size tileGridSize = Size(8, 8))

Parameters:

• clip_limit (Double) (defaults to: 40.0)
• tile_grid_size (Cv::Size) (defaults to: Cv::Size.new(8, 8))

Returns:

• (Cv::Ptr::Cv_CLAHE)

# File 'lib/ropencv/ropencv_types.rb', line 3315

def self.createclahe(clip_limit = 40.0, tile_grid_size = Cv::Size.new(8, 8))
    Rbind::cv_createclahe(clip_limit, tile_grid_size)
end

.createlbph_face_recognizer(radius = 1, neighbors = 8, grid_x = 8, grid_y = 8, threshold = DBL_MAX) ⇒ Cv::Ptr::Cv_FaceRecognizer Also known as: createLBPHFaceRecognizer

Note:

wrapper for static method cv::Ptrcv::FaceRecognizer cv::createLBPHFaceRecognizer(int radius = 1, int neighbors = 8, int grid_x = 8, int grid_y = 8, double threshold = DBL_MAX)

Parameters:

• radius (Fixnum) (defaults to: 1)
• neighbors (Fixnum) (defaults to: 8)
• grid_x (Fixnum) (defaults to: 8)
• grid_y (Fixnum) (defaults to: 8)
• threshold (Double) (defaults to: DBL_MAX)

Returns:

• (Cv::Ptr::Cv_FaceRecognizer)

# File 'lib/ropencv/ropencv_types.rb', line 4532

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) ⇒ Float Also known as: cubeRoot

Note:

wrapper for static method float cv::cubeRoot(float val)

Parameters:

• val (Float)

Returns:

• (Float)

# File 'lib/ropencv/ropencv_types.rb', line 1917

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

.cvt_color(src, dst, code, dst_cn = 0) ⇒ Void Also known as: cvtColor

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• code (Fixnum)
• dst_cn (Fixnum) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3400

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) ⇒ Void

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• flags (Fixnum) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2262

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()) ⇒ Void Also known as: decomposeProjectionMatrix

Note:

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

Parameters:

• proj_matrix (Cv::Mat)
• camera_matrix (Cv::Mat)
• rot_matrix (Cv::Mat)
• trans_vect (Cv::Mat)
• rot_matrix_x (Cv::Mat) (defaults to: Cv::Mat.new())
• rot_matrix_y (Cv::Mat) (defaults to: Cv::Mat.new())
• rot_matrix_z (Cv::Mat) (defaults to: Cv::Mat.new())
• euler_angles (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3940

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 ⇒ Void Also known as: destroyAllWindows

Note:

wrapper for static method void cv::destroyAllWindows()

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4365

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

.destroy_window(winname) ⇒ Void Also known as: destroyWindow

Note:

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

Parameters:

• winname (Cv::String)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4358

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

.determinant(mtx) ⇒ Double

Note:

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

Parameters:

• mtx (Cv::Mat)

Returns:

• (Double)

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

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

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

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• flags (Fixnum) (defaults to: 0)
• nonzero_rows (Fixnum) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2243

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()) ⇒ Void

Note:

wrapper for static method 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())

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• kernel (Cv::Mat)
• anchor (Cv::Point) (defaults to: Cv::Point.new(-1,-1))
• iterations (Fixnum) (defaults to: 1)
• border_type (Fixnum) (defaults to: BORDER_CONSTANT)
• border_value (Cv::Scalar) (defaults to: morphology_default_border_value())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2908

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) ⇒ Void Also known as: distanceTransform

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• distance_type (Fixnum)
• mask_size (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3374

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) ⇒ Void Also known as: distanceTransformWithLabels

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• labels (Cv::Mat)
• distance_type (Fixnum)
• mask_size (Fixnum)
• label_type (Fixnum) (defaults to: DIST_LABEL_CCOMP)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3363

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(_src1, _src2, dst, scale = 1, dtype = -1) ⇒ Void .divide(scale, _src2, dst, dtype = -1) ⇒ Void

Note:

wrapper for overloaded static method divide

Overloads:

• .divide(_src1, _src2, dst, scale = 1, dtype = -1) ⇒ Void

  Parameters:

  • _src1 (Cv::Mat)
  • _src2 (Cv::Mat)
  • dst (Cv::Mat)
  • scale (Double) (defaults to: 1)
  • dtype (Fixnum) (defaults to: -1)

  Returns:

  • (Void)
• .divide(scale, _src2, dst, dtype = -1) ⇒ Void

  Parameters:

  • scale (Double)
  • _src2 (Cv::Mat)
  • dst (Cv::Mat)
  • dtype (Fixnum) (defaults to: -1)

  Returns:

  • (Void)

Raises:

• (ArgumentError)

# File 'lib/ropencv/ropencv_types.rb', line 1486

def self.divide(*args)
    # overloaded method 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)
        targs = args.clone
        targs.size.upto(4) do |i|
            targs[i] = @@cv_divide_defaults0[i]
        end
        begin
                return Rbind::cv_divide(*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method 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)
        targs = args.clone
        targs.size.upto(3) do |i|
            targs[i] = @@cv_divide2_defaults1[i]
        end
        begin
                return Rbind::cv_divide2(*targs)
        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) ⇒ Void Also known as: drawChessboardCorners

Note:

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

Parameters:

• image (Cv::Mat)
• pattern_size (Cv::Size)
• corners (Cv::Mat)
• pattern_was_found (Bool)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4054

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()) ⇒ Void Also known as: drawContours

Note:

wrapper for static method void cv::drawContours(cv::Mat& image, const std::vectorcv::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())

Parameters:

• image (Cv::Mat)
• contours (Std::Vector::Cv_Mat)
• contour_idx (Fixnum)
• color (Cv::Scalar)
• thickness (Fixnum) (defaults to: 1)
• line_type (Fixnum) (defaults to: 8)
• hierarchy (Cv::Mat) (defaults to: Cv::Mat.new())
• max_level (Fixnum) (defaults to: INT_MAX)
• offset (Cv::Point) (defaults to: Cv::Point.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3457

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) ⇒ Void Also known as: drawDataMatrixCodes

Note:

wrapper for static method void cv::drawDataMatrixCodes(cv::Mat& image, const std::vectorcv::String codes, const cv::Mat corners)

Parameters:

• image (Cv::Mat)
• codes (Std::Vector::Cv_String)
• corners (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3890

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) ⇒ Void Also known as: drawKeypoints

Note:

wrapper for static method void cv::drawKeypoints(const cv::Mat image, const std::vectorcv::KeyPoint keypoints, cv::Mat& outImage, const cv::Scalar color = Scalar::all(-1), int flags = DrawMatchesFlags::DEFAULT)

Parameters:

• image (Cv::Mat)
• keypoints (Std::Vector::Cv_KeyPoint)
• out_image (Cv::Mat)
• color (Cv::Scalar) (defaults to: Cv::Scalar::all(-1))
• flags (Fixnum) (defaults to: DrawMatchesFlags::DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3858

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 = Std::Vector::Char.new(), flags = DrawMatchesFlags::DEFAULT) ⇒ Void Also known as: drawMatches

Note:

wrapper for static method void cv::drawMatches(const cv::Mat img1, const std::vectorcv::KeyPoint keypoints1, const cv::Mat img2, const std::vectorcv::KeyPoint keypoints2, const std::vectorcv::DMatch matches1to2, cv::Mat& outImg, const cv::Scalar matchColor = Scalar::all(-1), const cv::Scalar singlePointColor = Scalar::all(-1), const std::vector matchesMask = std::vector(), int flags = DrawMatchesFlags::DEFAULT)

Parameters:

• _img1 (Cv::Mat)
• _keypoints1 (Std::Vector::Cv_KeyPoint)
• _img2 (Cv::Mat)
• _keypoints2 (Std::Vector::Cv_KeyPoint)
• _matches1to2 (Std::Vector::Cv_DMatch)
• out_img (Cv::Mat)
• match_color (Cv::Scalar) (defaults to: Cv::Scalar::all(-1))
• single_point_color (Cv::Scalar) (defaults to: Cv::Scalar::all(-1))
• matches_mask (Std::Vector::Char) (defaults to: Std::Vector::Char.new())
• flags (Fixnum) (defaults to: DrawMatchesFlags::DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4566

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 = Std::Vector::Char.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) ⇒ Bool

Note:

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

Parameters:

• src (Cv::Mat)
• compute_eigenvectors (Bool)
• eigenvalues (Cv::Mat)
• eigenvectors (Cv::Mat)

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 2143

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

.ellipse(img, center, axes, angle, start_angle, end_angle, color, thickness = 1, line_type = 8, shift = 0) ⇒ Void .ellipse(img, box, color, thickness = 1, line_type = 8) ⇒ Void

Note:

wrapper for overloaded static method ellipse

Overloads:

• .ellipse(img, center, axes, angle, start_angle, end_angle, color, thickness = 1, line_type = 8, shift = 0) ⇒ Void

  Parameters:

  • img (Cv::Mat)
  • center (Cv::Point)
  • axes (Cv::Size)
  • angle (Double)
  • start_angle (Double)
  • end_angle (Double)
  • color (Cv::Scalar)
  • thickness (Fixnum) (defaults to: 1)
  • line_type (Fixnum) (defaults to: 8)
  • shift (Fixnum) (defaults to: 0)

  Returns:

  • (Void)
• .ellipse(img, box, color, thickness = 1, line_type = 8) ⇒ Void

  Parameters:

  • img (Cv::Mat)
  • box (Cv::RotatedRect)
  • color (Cv::Scalar)
  • thickness (Fixnum) (defaults to: 1)
  • line_type (Fixnum) (defaults to: 8)

  Returns:

  • (Void)

Raises:

• (ArgumentError)

# File 'lib/ropencv/ropencv_types.rb', line 2410

def self.ellipse(*args)
    # overloaded method 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)
        targs = args.clone
        targs.size.upto(9) do |i|
            targs[i] = @@cv_ellipse_defaults0[i]
        end
        begin
                return Rbind::cv_ellipse(*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method 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)
        targs = args.clone
        targs.size.upto(4) do |i|
            targs[i] = @@cv_ellipse2_defaults1[i]
        end
        begin
                return Rbind::cv_ellipse2(*targs)
        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) ⇒ Void Also known as: ellipse2Poly

Note:

wrapper for static method void cv::ellipse2Poly(const cv::Point center, const cv::Size axes, int angle, int arcStart, int arcEnd, int delta, std::vectorcv::Point& pts)

Parameters:

• center (Cv::Point)
• axes (Cv::Size)
• angle (Fixnum)
• arc_start (Fixnum)
• arc_end (Fixnum)
• delta (Fixnum)
• pts (Std::Vector::Cv_Point)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2498

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) ⇒ Void Also known as: equalizeHist

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3306

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()) ⇒ Void

Note:

wrapper for static method 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())

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• kernel (Cv::Mat)
• anchor (Cv::Point) (defaults to: Cv::Point.new(-1,-1))
• iterations (Fixnum) (defaults to: 1)
• border_type (Fixnum) (defaults to: BORDER_CONSTANT)
• border_value (Cv::Scalar) (defaults to: morphology_default_border_value())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2895

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) ⇒ Fixnum Also known as: estimateAffine3D

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• out (Cv::Mat)
• inliers (Cv::Mat)
• ransac_threshold (Double) (defaults to: 3)
• confidence (Double) (defaults to: 0.99)

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 4341

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

.estimate_rigid_transform(src, dst, full_affine) ⇒ Cv::Mat Also known as: estimateRigidTransform

Note:

wrapper for static method cv::Mat cv::estimateRigidTransform(const cv::Mat src, const cv::Mat dst, bool fullAffine)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• full_affine (Bool)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 3787

def self.estimate_rigid_transform(src, dst, full_affine)
    Rbind::cv_estimate_rigid_transform(src, dst, full_affine)
end

.exp(src, dst) ⇒ Void

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1902

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

.extract_channel(src, dst, coi) ⇒ Void Also known as: extractChannel

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• coi (Fixnum)

Returns:

• (Void)

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

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

.fast_atan2(y, x) ⇒ Float Also known as: fastAtan2

Note:

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

Parameters:

• y (Float)
• x (Float)

Returns:

• (Float)

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

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) ⇒ Void Also known as: fastNlMeansDenoising

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• h (Float) (defaults to: 3)
• template_window_size (Fixnum) (defaults to: 7)
• search_window_size (Fixnum) (defaults to: 21)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3617

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) ⇒ Void Also known as: fastNlMeansDenoisingColored

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• h (Float) (defaults to: 3)
• h_color (Float) (defaults to: 3)
• template_window_size (Fixnum) (defaults to: 7)
• search_window_size (Fixnum) (defaults to: 21)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3630

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) ⇒ Void Also known as: fastNlMeansDenoisingColoredMulti

Note:

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

Parameters:

• src_imgs (Std::Vector::Cv_Mat)
• dst (Cv::Mat)
• img_to_denoise_index (Fixnum)
• temporal_window_size (Fixnum)
• h (Float) (defaults to: 3)
• h_color (Float) (defaults to: 3)
• template_window_size (Fixnum) (defaults to: 7)
• search_window_size (Fixnum) (defaults to: 21)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3659

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) ⇒ Void Also known as: fastNlMeansDenoisingMulti

Note:

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

Parameters:

• src_imgs (Std::Vector::Cv_Mat)
• dst (Cv::Mat)
• img_to_denoise_index (Fixnum)
• temporal_window_size (Fixnum)
• h (Float) (defaults to: 3)
• template_window_size (Fixnum) (defaults to: 7)
• search_window_size (Fixnum) (defaults to: 21)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3644

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) ⇒ Void Also known as: fillConvexPoly

Note:

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

Parameters:

• img (Cv::Mat)
• points (Cv::Mat)
• color (Cv::Scalar)
• line_type (Fixnum) (defaults to: 8)
• shift (Fixnum) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2448

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()) ⇒ Void Also known as: fillPoly

Note:

wrapper for static method void cv::fillPoly(cv::Mat& img, const std::vectorcv::Mat pts, const cv::Scalar color, int lineType = 8, int shift = 0, const cv::Point offset = Point())

Parameters:

• img (Cv::Mat)
• pts (Std::Vector::Cv_Mat)
• color (Cv::Scalar)
• line_type (Fixnum) (defaults to: 8)
• shift (Fixnum) (defaults to: 0)
• offset (Cv::Point) (defaults to: Cv::Point.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2461

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) ⇒ Void Also known as: filter2D

Note:

wrapper for static method 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)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ddepth (Fixnum)
• kernel (Cv::Mat)
• anchor (Cv::Point) (defaults to: Cv::Point.new(-1,-1))
• delta (Double) (defaults to: 0)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2688

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()) ⇒ Void Also known as: filterSpeckles

Note:

wrapper for static method void cv::filterSpeckles(cv::Mat& img, double newVal, int maxSpeckleSize, double maxDiff, const cv::Mat buf = Mat()/IO)

Parameters:

• img (Cv::Mat)
• new_val (Double)
• max_speckle_size (Fixnum)
• max_diff (Double)
• buf (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4292

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) ⇒ Bool Also known as: findChessboardCorners

Note:

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

Parameters:

• image (Cv::Mat)
• pattern_size (Cv::Size)
• corners (Cv::Mat)
• flags (Fixnum) (defaults to: CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE)

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 4043

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()) ⇒ Bool Also known as: findCirclesGrid

Note:

wrapper for static method bool cv::findCirclesGrid(const cv::Mat image, const cv::Size patternSize, cv::Mat& centers, int flags = CALIB_CB_SYMMETRIC_GRID, const cv::Ptrcv::FeatureDetector blobDetector = new SimpleBlobDetector())

Parameters:

• image (Cv::Mat)
• pattern_size (Cv::Size)
• centers (Cv::Mat)
• flags (Fixnum) (defaults to: CALIB_CB_SYMMETRIC_GRID)
• blob_detector (Cv::Ptr::Cv_FeatureDetector) (defaults to: Cv::SimpleBlobDetector.new())

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 4066

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) ⇒ Bool Also known as: findCirclesGridDefault

Note:

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

Parameters:

• image (Cv::Mat)
• pattern_size (Cv::Size)
• centers (Cv::Mat)
• flags (Fixnum) (defaults to: CALIB_CB_SYMMETRIC_GRID)

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 4077

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()) ⇒ Void Also known as: findContours

Note:

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

Parameters:

• image (Cv::Mat)
• contours (Std::Vector::Cv_Mat)
• hierarchy (Cv::Mat)
• mode (Fixnum)
• method (Fixnum)
• offset (Cv::Point) (defaults to: Cv::Point.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3441

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 = Std::Vector::Cv_Mat.new()) ⇒ Void Also known as: findDataMatrix

Note:

wrapper for static method void cv::findDataMatrix(const cv::Mat image, std::vectorcv::String& codes, const cv::Mat corners = Mat()/O, const std::vectorcv::Mat dmtx = vector()/O)

Parameters:

• image (Cv::Mat)
• codes (Std::Vector::Cv_String)
• corners (Cv::Mat) (defaults to: Cv::Mat.new())
• dmtx (Std::Vector::Cv_Mat) (defaults to: Std::Vector::Cv_Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3880

def self.find_data_matrix(image, codes, corners = Cv::Mat.new(), dmtx = Std::Vector::Cv_Mat.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()) ⇒ Cv::Mat Also known as: findFundamentalMat

Note:

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

Parameters:

• _points1 (Cv::Mat)
• _points2 (Cv::Mat)
• method (Fixnum) (defaults to: FM_RANSAC)
• _param1 (Double) (defaults to: 3.0)
• _param2 (Double) (defaults to: 0.99)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 4245

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()) ⇒ Cv::Mat Also known as: findHomography

Note:

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

Parameters:

• src_points (Cv::Mat)
• dst_points (Cv::Mat)
• method (Fixnum) (defaults to: 0)
• ransac_reproj_threshold (Double) (defaults to: 3)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 3912

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) ⇒ Void Also known as: findNonZero

Note:

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

Parameters:

• src (Cv::Mat)
• idx (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1591

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

.fit_ellipse(points) ⇒ Cv::RotatedRect Also known as: fitEllipse

Note:

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

Parameters:

• points (Cv::Mat)

Returns:

• (Cv::RotatedRect)

# File 'lib/ropencv/ropencv_types.rb', line 3571

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

.fit_line(points, line, dist_type, param, reps, aeps) ⇒ Void Also known as: fitLine

Note:

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

Parameters:

• points (Cv::Mat)
• line (Cv::Mat)
• dist_type (Fixnum)
• param (Double)
• reps (Double)
• aeps (Double)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3584

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) ⇒ Void

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• flip_code (Fixnum)

Returns:

• (Void)

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

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

.flood_fill(image, mask, seed_point, new_val, rect = Cv::Rect::null, lo_diff = Cv::Scalar.new(), up_diff = Cv::Scalar.new(), flags = 4) ⇒ Fixnum Also known as: floodFill

Note:

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

Parameters:

• image (Cv::Mat)
• mask (Cv::Mat)
• seed_point (Cv::Point)
• new_val (Cv::Scalar)
• rect (Cv::Rect) (defaults to: Cv::Rect::null)
• lo_diff (Cv::Scalar) (defaults to: Cv::Scalar.new())
• up_diff (Cv::Scalar) (defaults to: Cv::Scalar.new())
• flags (Fixnum) (defaults to: 4)

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 3389

def self.flood_fill(image, mask, seed_point, new_val, rect = Cv::Rect::null, 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) ⇒ Void Also known as: GaussianBlur

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ksize (Cv::Size)
• sigma_x (Double)
• sigma_y (Double) (defaults to: 0)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2622

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, beta, dst, flags = 0) ⇒ Void

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• alpha (Double)
• _src3 (Cv::Mat)
• beta (Double)
• dst (Cv::Mat)
• flags (Fixnum) (defaults to: 0)

Returns:

• (Void)

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

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

.get_affine_transform(src, dst) ⇒ Cv::Mat Also known as: getAffineTransform

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 3025

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

.get_build_information ⇒ Cv::String Also known as: getBuildInformation

Note:

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

Returns:

• (Cv::String)

# File 'lib/ropencv/ropencv_types.rb', line 1382

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) ⇒ Cv::Mat Also known as: getDefaultNewCameraMatrix

Note:

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

Parameters:

• camera_matrix (Cv::Mat)
• imgsize (Cv::Size) (defaults to: Cv::Size.new())
• center_principal_point (Bool) (defaults to: false)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 3247

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) ⇒ Void Also known as: getDerivKernels

Note:

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

Parameters:

• kx (Cv::Mat)
• ky (Cv::Mat)
• dx (Fixnum)
• dy (Fixnum)
• ksize (Fixnum)
• normalize (Bool) (defaults to: false)
• ktype (Fixnum) (defaults to: CV_32F)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2560

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) ⇒ Cv::Mat Also known as: getGaborKernel

Note:

wrapper for static method 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)

Parameters:

• ksize (Cv::Size)
• sigma (Double)
• theta (Double)
• lambd (Double)
• gamma (Double)
• psi (Double) (defaults to: CV_PI*0.5)
• ktype (Fixnum) (defaults to: CV_64F)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 2574

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) ⇒ Cv::Mat Also known as: getGaussianKernel

Note:

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

Parameters:

• ksize (Fixnum)
• sigma (Double)
• ktype (Fixnum) (defaults to: CV_64F)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 2546

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

.get_num_threads ⇒ Fixnum Also known as: getNumThreads

Note:

wrapper for static method int cv::getNumThreads()

Returns:

• (Fixnum)

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

def self.get_num_threads()
    Rbind::cv_get_num_threads()
end

.get_number_ofcp_us ⇒ Fixnum Also known as: getNumberOfCPUs

Note:

wrapper for static method int cv::getNumberOfCPUs()

Returns:

• (Fixnum)

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

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 = Cv::Rect::null, center_principal_point = false) ⇒ Cv::Mat Also known as: getOptimalNewCameraMatrix

Note:

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

Parameters:

• camera_matrix (Cv::Mat)
• dist_coeffs (Cv::Mat)
• image_size (Cv::Size)
• alpha (Double)
• new_img_size (Cv::Size) (defaults to: Cv::Size.new())
• valid_pix_r_o_i (Cv::Rect) (defaults to: Cv::Rect::null)
• center_principal_point (Bool) (defaults to: false)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 4214

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 = Cv::Rect::null, 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) ⇒ Fixnum Also known as: getOptimalDFTSize

Note:

wrapper for static method int cv::getOptimalDFTSize(int vecsize)

Parameters:

• vecsize (Fixnum)

Returns:

• (Fixnum)

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

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

.get_perspective_transform(src, dst) ⇒ Cv::Mat Also known as: getPerspectiveTransform

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 3016

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)) ⇒ Void Also known as: getRectSubPix

Note:

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

Parameters:

• image (Cv::Mat)
• patch_size (Cv::Size)
• center (Cv::Point2f)
• patch (Cv::Mat)
• patch_type (Fixnum) (defaults to: -1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3037

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) ⇒ Cv::Mat Also known as: getRotationMatrix2D

Note:

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

Parameters:

• center (Cv::Point2f)
• angle (Double)
• scale (Double)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 2998

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)) ⇒ Cv::Mat Also known as: getStructuringElement

Note:

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

Parameters:

• shape (Fixnum)
• ksize (Cv::Size)
• anchor (Cv::Point) (defaults to: Cv::Point.new(-1,-1))

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 2584

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) ⇒ Cv::Size Also known as: getTextSize

Note:

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

Parameters:

• text (Cv::String)
• font_face (Fixnum)
• font_scale (Double)
• thickness (Fixnum)
• base_line (FFI::MemoryPointer)

Returns:

• (Cv::Size)

# File 'lib/ropencv/ropencv_types.rb', line 2526

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_thread_num ⇒ Fixnum Also known as: getThreadNum

Note:

wrapper for static method int cv::getThreadNum()

Returns:

• (Fixnum)

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

def self.get_thread_num()
    Rbind::cv_get_thread_num()
end

.get_tick_count ⇒ Fixnum Also known as: getTickCount

Note:

wrapper for static method int64 cv::getTickCount()

Returns:

• (Fixnum)

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

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

.get_tick_frequency ⇒ Double Also known as: getTickFrequency

Note:

wrapper for static method double cv::getTickFrequency()

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 1396

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

.get_trackbar_pos(trackbarname, winname) ⇒ Fixnum Also known as: getTrackbarPos

Note:

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

Parameters:

• trackbarname (Cv::String)
• winname (Cv::String)

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 4436

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) ⇒ Cv::Rect Also known as: getValidDisparityROI

Note:

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

Parameters:

• _roi1 (Cv::Rect)
• _roi2 (Cv::Rect)
• min_disparity (Fixnum)
• number_of_disparities (Fixnum)
• s_a_d_window_size (Fixnum)

Returns:

• (Cv::Rect)

# File 'lib/ropencv/ropencv_types.rb', line 4304

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) ⇒ Double Also known as: getWindowProperty

Note:

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

Parameters:

• winname (Cv::String)
• prop_id (Fixnum)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 4427

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

.getcpu_tick_count ⇒ Fixnum Also known as: getCPUTickCount

Note:

wrapper for static method int64 cv::getCPUTickCount()

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 1403

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) ⇒ Void Also known as: goodFeaturesToTrack

Note:

wrapper for static method 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)

Parameters:

• image (Cv::Mat)
• corners (Cv::Mat)
• max_corners (Fixnum)
• quality_level (Double)
• min_distance (Double)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())
• block_size (Fixnum) (defaults to: 3)
• use_harris_detector (Bool) (defaults to: false)
• k (Double) (defaults to: 0.04)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2837

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) ⇒ Void Also known as: grabCut

Note:

wrapper for static method 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)

Parameters:

• img (Cv::Mat)
• mask (Cv::Mat)
• rect (Cv::Rect)
• bgd_model (Cv::Mat)
• fgd_model (Cv::Mat)
• iter_count (Fixnum)
• mode (Fixnum) (defaults to: GC_EVAL)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3350

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) ⇒ Void Also known as: groupRectangles

Note:

wrapper for static method void cv::groupRectangles(std::vectorcv::Rect& rectList, std::vector& weights, int groupThreshold, double eps = 0.2)

Parameters:

• rect_list (Std::Vector::Cv_Rect)
• weights (Std::Vector::Int)
• group_threshold (Fixnum)
• eps (Double) (defaults to: 0.2)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3869

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) ⇒ Void

Note:

wrapper for static method void cv::hconcat(const std::vectorcv::Mat src, cv::Mat& dst)

Parameters:

• src (Std::Vector::Cv_Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1782

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) ⇒ Void Also known as: HoughCircles

Note:

wrapper for static method 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)

Parameters:

• image (Cv::Mat)
• circles (Cv::Mat)
• method (Fixnum)
• dp (Double)
• min_dist (Double)
• _param1 (Double) (defaults to: 100)
• _param2 (Double) (defaults to: 100)
• min_radius (Fixnum) (defaults to: 0)
• max_radius (Fixnum) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2881

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) ⇒ Void Also known as: HoughLines

Note:

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

Parameters:

• image (Cv::Mat)
• lines (Cv::Mat)
• rho (Double)
• theta (Double)
• threshold (Fixnum)
• srn (Double) (defaults to: 0)
• stn (Double) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2851

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) ⇒ Void Also known as: HoughLinesP

Note:

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

Parameters:

• image (Cv::Mat)
• lines (Cv::Mat)
• rho (Double)
• theta (Double)
• threshold (Fixnum)
• min_line_length (Double) (defaults to: 0)
• max_line_gap (Double) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2865

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) ⇒ Void Also known as: HuMoments

Note:

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

Parameters:

• m (Cv::Moments)
• hu (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3417

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

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

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• flags (Fixnum) (defaults to: 0)

Returns:

• (Void)

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

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

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

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• flags (Fixnum) (defaults to: 0)
• nonzero_rows (Fixnum) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2253

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

.imdecode(buf, flags) ⇒ Cv::Mat

Note:

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

Parameters:

• buf (Cv::Mat)
• flags (Fixnum)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 4472

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

.imencode(ext, img, buf, params = Std::Vector::Int.new()) ⇒ Bool

Note:

wrapper for static method bool cv::imencode(const cv::String ext, const cv::Mat img, std::vector& buf, const std::vector params = vector())

Parameters:

• ext (Cv::String)
• img (Cv::Mat)
• buf (Std::Vector::Uchar)
• params (Std::Vector::Int) (defaults to: Std::Vector::Int.new())

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 4482

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

.imread(filename, flags = 1) ⇒ Cv::Mat

Note:

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

Parameters:

• filename (Cv::String)
• flags (Fixnum) (defaults to: 1)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 4455

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

.imshow(winname, mat) ⇒ Void

Note:

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

Parameters:

• winname (Cv::String)
• mat (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4389

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

.imwrite(filename, img, params = Std::Vector::Int.new()) ⇒ Bool

Note:

wrapper for static method bool cv::imwrite(const cv::String filename, const cv::Mat img, const std::vector params = vector())

Parameters:

• filename (Cv::String)
• img (Cv::Mat)
• params (Std::Vector::Int) (defaults to: Std::Vector::Int.new())

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 4464

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

.in_range(src, lowerb, upperb, dst) ⇒ Void Also known as: inRange

Note:

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

Parameters:

• src (Cv::Mat)
• lowerb (Cv::Mat)
• upperb (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1848

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) ⇒ Cv::Mat Also known as: initCameraMatrix2D

Note:

wrapper for static method cv::Mat cv::initCameraMatrix2D(const std::vectorcv::Mat objectPoints, const std::vectorcv::Mat imagePoints, const cv::Size imageSize, double aspectRatio = 1.)

Parameters:

• object_points (Std::Vector::Cv_Mat)
• image_points (Std::Vector::Cv_Mat)
• image_size (Cv::Size)
• aspect_ratio (Double) (defaults to: 1.0)

Returns:

• (Cv::Mat)

# File 'lib/ropencv/ropencv_types.rb', line 4032

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 ⇒ Bool Also known as: initModule_nonfree

Note:

wrapper for static method bool cv::initModule_nonfree()

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 4549

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) ⇒ Void Also known as: initUndistortRectifyMap

Note:

wrapper for static method 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)

Parameters:

• camera_matrix (Cv::Mat)
• dist_coeffs (Cv::Mat)
• r (Cv::Mat)
• new_camera_matrix (Cv::Mat)
• size (Cv::Size)
• _m1type (Fixnum)
• _map1 (Cv::Mat)
• _map2 (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3221

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) ⇒ Float Also known as: initWideAngleProjMap

Note:

wrapper for static method 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)

Parameters:

• camera_matrix (Cv::Mat)
• dist_coeffs (Cv::Mat)
• image_size (Cv::Size)
• dest_image_width (Fixnum)
• _m1type (Fixnum)
• _map1 (Cv::Mat)
• _map2 (Cv::Mat)
• proj_type (Fixnum) (defaults to: PROJ_SPHERICAL_EQRECT)
• alpha (Double) (defaults to: 0)

Returns:

• (Float)

# File 'lib/ropencv/ropencv_types.rb', line 3237

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) ⇒ Void

Note:

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

Parameters:

• src (Cv::Mat)
• inpaint_mask (Cv::Mat)
• dst (Cv::Mat)
• inpaint_radius (Double)
• flags (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3606

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) ⇒ Void Also known as: insertChannel

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• coi (Fixnum)

Returns:

• (Void)

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

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

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

Note:

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

Parameters:

• src (Cv::Mat)
• sum (Cv::Mat)
• sdepth (Fixnum) (defaults to: -1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3047

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

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

Note:

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

Parameters:

• src (Cv::Mat)
• sum (Cv::Mat)
• sqsum (Cv::Mat)
• sdepth (Fixnum) (defaults to: -1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3057

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

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

Note:

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

Parameters:

• src (Cv::Mat)
• sum (Cv::Mat)
• sqsum (Cv::Mat)
• tilted (Cv::Mat)
• sdepth (Fixnum) (defaults to: -1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3068

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) ⇒ Float Also known as: intersectConvexConvex

Note:

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

Parameters:

• __p1 (Cv::Mat)
• __p2 (Cv::Mat)
• __p12 (Cv::Mat)
• handle_nested (Bool) (defaults to: true)

Returns:

• (Float)

# File 'lib/ropencv/ropencv_types.rb', line 3563

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) ⇒ Double

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• flags (Fixnum) (defaults to: DECOMP_LU)

Returns:

• (Double)

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

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

.invert_affine_transform(m, i_m) ⇒ Void Also known as: invertAffineTransform

Note:

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

Parameters:

• m (Cv::Mat)
• i_m (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3007

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

.is_contour_convex(contour) ⇒ Bool Also known as: isContourConvex

Note:

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

Parameters:

• contour (Cv::Mat)

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 3552

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()) ⇒ Double

Note:

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

Parameters:

• data (Cv::Mat)
• k (Fixnum)
• best_labels (Cv::Mat)
• criteria (Cv::TermCriteria)
• attempts (Fixnum)
• flags (Fixnum)
• centers (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 2304

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) ⇒ Void Also known as: Laplacian

Note:

wrapper for static method 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)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ddepth (Fixnum)
• ksize (Fixnum) (defaults to: 1)
• scale (Double) (defaults to: 1)
• delta (Double) (defaults to: 0)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2748

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) ⇒ Void

Note:

wrapper for static method 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)

Parameters:

• img (Cv::Mat)
• _pt1 (Cv::Point)
• _pt2 (Cv::Point)
• color (Cv::Scalar)
• thickness (Fixnum) (defaults to: 1)
• line_type (Fixnum) (defaults to: 8)
• shift (Fixnum) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2344

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) ⇒ Void

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

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

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

.lut(src, lut, dst, interpolation = 0) ⇒ Void Also known as: LUT

Note:

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

Parameters:

• src (Cv::Mat)
• lut (Cv::Mat)
• dst (Cv::Mat)
• interpolation (Fixnum) (defaults to: 0)

Returns:

• (Void)

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

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

.magnitude(x, y, magnitude) ⇒ Void

Note:

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

Parameters:

• x (Cv::Mat)
• y (Cv::Mat)
• magnitude (Cv::Mat)

Returns:

• (Void)

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

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

.mahalanobis(_v1, _v2, icovar) ⇒ Double Also known as: Mahalanobis

Note:

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

Parameters:

• _v1 (Cv::Mat)
• _v2 (Cv::Mat)
• icovar (Cv::Mat)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 2232

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) ⇒ Void Also known as: matMulDeriv

Note:

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

Parameters:

• a (Cv::Mat)
• b (Cv::Mat)
• d_a_bd_a (Cv::Mat)
• d_a_bd_b (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3951

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) ⇒ Double Also known as: matchShapes

Note:

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

Parameters:

• _contour1 (Cv::Mat)
• _contour2 (Cv::Mat)
• method (Fixnum)
• parameter (Double)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 3523

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

.match_template(image, templ, result, method) ⇒ Void Also known as: matchTemplate

Note:

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

Parameters:

• image (Cv::Mat)
• templ (Cv::Mat)
• result (Cv::Mat)
• method (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3428

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

.max(_src1, _src2, dst) ⇒ Void

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1877

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

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

Note:

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

Parameters:

• src (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Cv::Scalar)

# File 'lib/ropencv/ropencv_types.rb', line 1600

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

.mean_shift(prob_image, window, criteria) ⇒ Fixnum Also known as: meanShift

Note:

wrapper for static method int cv::meanShift(const cv::Mat probImage, cv::Rect& window, const cv::TermCriteria criteria)

Parameters:

• prob_image (Cv::Mat)
• window (Cv::Rect)
• criteria (Cv::TermCriteria)

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 3727

def self.mean_shift(prob_image, window, criteria)
    Rbind::cv_mean_shift(prob_image, window, criteria)
end

.mean_std_dev(src, mean, stddev, mask = Cv::Mat.new()) ⇒ Void Also known as: meanStdDev

Note:

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

Parameters:

• src (Cv::Mat)
• mean (Cv::Mat)
• stddev (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

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

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) ⇒ Void Also known as: medianBlur

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ksize (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2609

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

.merge(mv, dst) ⇒ Void

Note:

wrapper for static method void cv::merge(const std::vectorcv::Mat mv, cv::Mat& dst)

Parameters:

• mv (Std::Vector::Cv_Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1717

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

.min(_src1, _src2, dst) ⇒ Void

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1868

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

.min_area_rect(points) ⇒ Cv::RotatedRect Also known as: minAreaRect

Note:

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

Parameters:

• points (Cv::Mat)

Returns:

• (Cv::RotatedRect)

# File 'lib/ropencv/ropencv_types.rb', line 3502

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

.min_enclosing_circle(points, center, radius) ⇒ Void Also known as: minEnclosingCircle

Note:

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

Parameters:

• points (Cv::Mat)
• center (Cv::Point2f)
• radius (FFI::MemoryPointer)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3512

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/O, min_loc = Cv::Point::null, max_loc = Cv::Point::null, mask = Cv::Mat.new()) ⇒ Void Also known as: minMaxLoc

Note:

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

Parameters:

• src (Cv::Mat)
• min_val (FFI::MemoryPointer)
• max_val (FFI::MemoryPointer) (defaults to: 0/O)
• min_loc (Cv::Point) (defaults to: Cv::Point::null)
• max_loc (Cv::Point) (defaults to: Cv::Point::null)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1697

def self.min_max_loc(src,min_loc = Point.new,max_loc = Point.new,mask = Mat.new)
    p = FFI::MemoryPointer.new(:double,2)
    Rbind::cv_min_max_loc(src, p[0], p[1], min_loc, max_loc, mask)
    [p[0].read_double,p[1].read_double]
end

.mix_channels(src, dst, from_to) ⇒ Void Also known as: mixChannels

Note:

wrapper for static method void cv::mixChannels(const std::vectorcv::Mat src, const std::vectorcv::Mat dst, const std::vector fromTo)

Parameters:

• src (Std::Vector::Cv_Mat)
• dst (Std::Vector::Cv_Mat)
• from_to (Std::Vector::Int)

Returns:

• (Void)

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

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

.moments(array, binary_image = false) ⇒ Cv::Moments

Note:

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

Parameters:

• array (Cv::Mat)
• binary_image (Bool) (defaults to: false)

Returns:

• (Cv::Moments)

# File 'lib/ropencv/ropencv_types.rb', line 3409

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

.morphology_default_border_value ⇒ Cv::Scalar Also known as: morphologyDefaultBorderValue

Note:

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

Returns:

• (Cv::Scalar)

# File 'lib/ropencv/ropencv_types.rb', line 4573

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()) ⇒ Void Also known as: morphologyEx

Note:

wrapper for static method 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())

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• op (Fixnum)
• kernel (Cv::Mat)
• anchor (Cv::Point) (defaults to: Cv::Point.new(-1,-1))
• iterations (Fixnum) (defaults to: 1)
• border_type (Fixnum) (defaults to: BORDER_CONSTANT)
• border_value (Cv::Scalar) (defaults to: morphology_default_border_value())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2922

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) ⇒ Void Also known as: moveWindow

Note:

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

Parameters:

• winname (Cv::String)
• x (Fixnum)
• y (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4408

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

.mul_spectrums(a, b, c, flags, conj_b = false) ⇒ Void Also known as: mulSpectrums

Note:

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

Parameters:

• a (Cv::Mat)
• b (Cv::Mat)
• c (Cv::Mat)
• flags (Fixnum)
• conj_b (Bool) (defaults to: false)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2282

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)) ⇒ Void Also known as: mulTransposed

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• a_ta (Bool)
• delta (Cv::Mat) (defaults to: Cv::Mat.new())
• scale (Double) (defaults to: 1)
• dtype (Fixnum) (defaults to: -1))

Returns:

• (Void)

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

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)) ⇒ Void

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)
• scale (Double) (defaults to: 1)
• dtype (Fixnum) (defaults to: -1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1467

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) ⇒ Void Also known as: namedWindow

Note:

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

Parameters:

• winname (Cv::String)
• flags (Fixnum) (defaults to: WINDOW_AUTOSIZE)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4350

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

.norm(_src1, norm_type = NORM_L2, mask = Cv::Mat.new()) ⇒ Double .norm(_src1, _src2, norm_type = NORM_L2, mask = Cv::Mat.new()) ⇒ Double

Note:

wrapper for overloaded static method norm

Overloads:

• .norm(_src1, norm_type = NORM_L2, mask = Cv::Mat.new()) ⇒ Double

  Parameters:

  • _src1 (Cv::Mat)
  • norm_type (Fixnum) (defaults to: NORM_L2)
  • mask (Cv::Mat) (defaults to: Cv::Mat.new())

  Returns:

  • (Double)
• .norm(_src1, _src2, norm_type = NORM_L2, mask = Cv::Mat.new()) ⇒ Double

  Parameters:

  • _src1 (Cv::Mat)
  • _src2 (Cv::Mat)
  • norm_type (Fixnum) (defaults to: NORM_L2)
  • mask (Cv::Mat) (defaults to: Cv::Mat.new())

  Returns:

  • (Double)

Raises:

• (ArgumentError)

# File 'lib/ropencv/ropencv_types.rb', line 1628

def self.norm(*args)
    # overloaded method 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)
        targs = args.clone
        targs.size.upto(2) do |i|
            targs[i] = @@cv_norm_defaults0[i]
        end
        begin
                return Rbind::cv_norm(*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method 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)
        targs = args.clone
        targs.size.upto(3) do |i|
            targs[i] = @@cv_norm2_defaults1[i]
        end
        begin
                return Rbind::cv_norm2(*targs)
        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()) ⇒ Void

Note:

wrapper for static method 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())

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• alpha (Double) (defaults to: 1)
• beta (Double) (defaults to: 0)
• norm_type (Fixnum) (defaults to: NORM_L2)
• dtype (Fixnum) (defaults to: -1,)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

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

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) ⇒ Void Also known as: patchNaNs

Note:

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

Parameters:

• a (Cv::Mat)
• val (Double) (defaults to: 0)

Returns:

• (Void)

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

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

.pca_back_project(data, mean, eigenvectors, result) ⇒ Void Also known as: PCABackProject

Note:

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

Parameters:

• data (Cv::Mat)
• mean (Cv::Mat)
• eigenvectors (Cv::Mat)
• result (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2198

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) ⇒ Void Also known as: PCACompute

Note:

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

Parameters:

• data (Cv::Mat)
• mean (Cv::Mat)
• eigenvectors (Cv::Mat)
• max_components (Fixnum) (defaults to: 0)

Returns:

• (Void)

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

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) ⇒ Void Also known as: PCAComputeVar

Note:

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

Parameters:

• data (Cv::Mat)
• mean (Cv::Mat)
• eigenvectors (Cv::Mat)
• retained_variance (Double)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2176

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) ⇒ Void Also known as: PCAProject

Note:

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

Parameters:

• data (Cv::Mat)
• mean (Cv::Mat)
• eigenvectors (Cv::Mat)
• result (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2187

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

.perspective_transform(src, dst, m) ⇒ Void Also known as: perspectiveTransform

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• m (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2043

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

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

Note:

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

Parameters:

• x (Cv::Mat)
• y (Cv::Mat)
• angle (Cv::Mat)
• angle_in_degrees (Bool) (defaults to: false)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1961

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()) ⇒ Cv::Point2d Also known as: phaseCorrelate

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• window (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Cv::Point2d)

# File 'lib/ropencv/ropencv_types.rb', line 3127

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/O) ⇒ Cv::Point2d Also known as: phaseCorrelateRes

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• window (Cv::Mat)
• response (FFI::MemoryPointer) (defaults to: 0/O)

Returns:

• (Cv::Point2d)

# File 'lib/ropencv/ropencv_types.rb', line 3138

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

.point_polygon_test(contour, pt, measure_dist) ⇒ Double Also known as: pointPolygonTest

Note:

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

Parameters:

• contour (Cv::Mat)
• pt (Cv::Point2f)
• measure_dist (Bool)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 3594

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) ⇒ Void Also known as: polarToCart

Note:

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

Parameters:

• magnitude (Cv::Mat)
• angle (Cv::Mat)
• x (Cv::Mat)
• y (Cv::Mat)
• angle_in_degrees (Bool) (defaults to: false)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1938

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

.polyfit(srcx, srcy, dst, order) ⇒ Void

Note:

wrapper for static method void cv::polyfit(const cv::Mat srcx, const cv::Mat srcy, cv::Mat& dst, int order)

Parameters:

• srcx (Cv::Mat)
• srcy (Cv::Mat)
• dst (Cv::Mat)
• order (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4584

def self.polyfit(srcx, srcy, dst, order)
    Rbind::cv_polyfit(srcx, srcy, dst, order)
end

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

Note:

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

Parameters:

• img (Cv::Mat)
• pts (Std::Vector::Cv_Mat)
• is_closed (Bool)
• color (Cv::Scalar)
• thickness (Fixnum) (defaults to: 1)
• line_type (Fixnum) (defaults to: 8)
• shift (Fixnum) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2475

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) ⇒ Void

Note:

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

Parameters:

• src (Cv::Mat)
• power (Double)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1894

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

.pre_corner_detect(src, dst, ksize, border_type = BORDER_DEFAULT) ⇒ Void Also known as: preCornerDetect

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ksize (Fixnum)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2809

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) ⇒ Void Also known as: projectPoints

Note:

wrapper for static method 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, const cv::Mat jacobian = Mat()/O, double aspectRatio = 0)

Parameters:

• object_points (Cv::Mat)
• rvec (Cv::Mat)
• tvec (Cv::Mat)
• camera_matrix (Cv::Mat)
• dist_coeffs (Cv::Mat)
• image_points (Cv::Mat)
• jacobian (Cv::Mat) (defaults to: Cv::Mat.new())
• aspect_ratio (Double) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3987

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) ⇒ Double Also known as: PSNR

Note:

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

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 3117

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) ⇒ Void Also known as: putText

Note:

wrapper for static method 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)

Parameters:

• img (Cv::Mat)
• text (Cv::String)
• org (Cv::Point)
• font_face (Fixnum)
• font_scale (Double)
• color (Cv::Scalar)
• thickness (Fixnum) (defaults to: 1)
• line_type (Fixnum) (defaults to: 8)
• bottom_left_origin (Bool) (defaults to: false)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2514

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) ⇒ Void Also known as: pyrDown

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• dstsize (Cv::Size) (defaults to: Cv::Size.new())
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3184

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)) ⇒ Void Also known as: pyrMeanShiftFiltering

Note:

wrapper for static method 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))

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• sp (Double)
• sr (Double)
• max_level (Fixnum) (defaults to: 1)
• termcrit (Cv::TermCriteria) (defaults to: Cv::TermCriteria.new( TermCriteria::MAX_ITER+TermCriteria::EPS,5,1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3336

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) ⇒ Void Also known as: pyrUp

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• dstsize (Cv::Size) (defaults to: Cv::Size.new())
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3195

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) ⇒ Void Also known as: randShuffle

Note:

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

Parameters:

• dst (Cv::Mat)
• iter_factor (Double) (defaults to: 1.0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2330

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

.randn(dst, mean, stddev) ⇒ Void

Note:

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

Parameters:

• dst (Cv::Mat)
• mean (Cv::Mat)
• stddev (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2322

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

.randu(dst, low, high) ⇒ Void

Note:

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

Parameters:

• dst (Cv::Mat)
• low (Cv::Mat)
• high (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2313

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

.read_double(fn, val, default_val) ⇒ Void

Note:

wrapper for static method void cv::read(cv::FileNode& fn, double& val, double default_val)

Parameters:

• fn (Cv::FileNode)
• val (FFI::MemoryPointer)
• default_val (Double)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1336

def self.read_double(fn, val, default_val)
    Rbind::cv_read_double(fn, val, default_val)
end

.read_float(fn, val, default_val) ⇒ Void

Note:

wrapper for static method void cv::read(cv::FileNode& fn, float& val, float default_val)

Parameters:

• fn (Cv::FileNode)
• val (FFI::MemoryPointer)
• default_val (Float)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1327

def self.read_float(fn, val, default_val)
    Rbind::cv_read_float(fn, val, default_val)
end

.read_int(fn, val, default_val) ⇒ Void

Note:

wrapper for static method void cv::read(cv::FileNode& fn, int& val, int default_val)

Parameters:

• fn (Cv::FileNode)
• val (FFI::MemoryPointer)
• default_val (Fixnum)

Returns:

• (Void)

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

def self.read_int(fn, val, default_val)
    Rbind::cv_read_int(fn, val, default_val)
end

.read_mat(fn, val, default_val) ⇒ Void

Note:

wrapper for static method void cv::read(cv::FileNode& fn, cv::Mat& val, const cv::Mat default_val)

Parameters:

• fn (Cv::FileNode)
• val (Cv::Mat)
• default_val (Cv::Mat)

Returns:

• (Void)

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

def self.read_mat(fn, val, default_val)
    Rbind::cv_read_mat(fn, val, default_val)
end

.read_string(fn, val, default_val) ⇒ Void

Note:

wrapper for static method void cv::read(cv::FileNode& fn, cv::String& val, const cv::String default_val)

Parameters:

• fn (Cv::FileNode)
• val (Cv::String)
• default_val (Cv::String)

Returns:

• (Void)

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

def self.read_string(fn, val, default_val)
    Rbind::cv_read_string(fn, val, default_val)
end

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

Note:

wrapper for static method 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)

Parameters:

• img (Cv::Mat)
• _pt1 (Cv::Point)
• _pt2 (Cv::Point)
• color (Cv::Scalar)
• thickness (Fixnum) (defaults to: 1)
• line_type (Fixnum) (defaults to: 8)
• shift (Fixnum) (defaults to: 0)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2372

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) ⇒ Float Also known as: rectify3Collinear

Note:

wrapper for static method 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 std::vectorcv::Mat imgpt1, const std::vectorcv::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)

Parameters:

• _camera_matrix1 (Cv::Mat)
• _dist_coeffs1 (Cv::Mat)
• _camera_matrix2 (Cv::Mat)
• _dist_coeffs2 (Cv::Mat)
• _camera_matrix3 (Cv::Mat)
• _dist_coeffs3 (Cv::Mat)
• _imgpt1 (Std::Vector::Cv_Mat)
• _imgpt3 (Std::Vector::Cv_Mat)
• image_size (Cv::Size)
• _r12 (Cv::Mat)
• _t12 (Cv::Mat)
• _r13 (Cv::Mat)
• _t13 (Cv::Mat)
• _r1 (Cv::Mat)
• _r2 (Cv::Mat)
• _r3 (Cv::Mat)
• _p1 (Cv::Mat)
• _p2 (Cv::Mat)
• _p3 (Cv::Mat)
• q (Cv::Mat)
• alpha (Double)
• new_img_size (Cv::Size)
• _roi1 (Cv::Rect)
• _roi2 (Cv::Rect)
• flags (Fixnum)

Returns:

• (Float)

# File 'lib/ropencv/ropencv_types.rb', line 4200

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)) ⇒ Void

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• dim (Fixnum)
• rtype (Fixnum)
• dtype (Fixnum) (defaults to: -1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1709

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()) ⇒ Void

Note:

wrapper for static method 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())

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• _map1 (Cv::Mat)
• _map2 (Cv::Mat)
• interpolation (Fixnum)
• border_mode (Fixnum) (defaults to: BORDER_CONSTANT)
• border_value (Cv::Scalar) (defaults to: Cv::Scalar.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2976

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) ⇒ Void

Note:

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

Parameters:

• src (Cv::Mat)
• ny (Fixnum)
• nx (Fixnum)
• dst (Cv::Mat)

Returns:

• (Void)

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

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)) ⇒ Void Also known as: reprojectImageTo3D

Note:

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

Parameters:

• disparity (Cv::Mat)
• __3d_image (Cv::Mat)
• q (Cv::Mat)
• handle_missing_values (Bool) (defaults to: false)
• ddepth (Fixnum) (defaults to: -1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4328

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) ⇒ Void

Note:

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

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• dsize (Cv::Size)
• fx (Double) (defaults to: 0)
• fy (Double) (defaults to: 0)
• interpolation (Fixnum) (defaults to: INTER_LINEAR)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2935

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) ⇒ Void Also known as: resizeWindow

Note:

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

Parameters:

• winname (Cv::String)
• width (Fixnum)
• height (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4398

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

.rodrigues(src, dst, jacobian = Cv::Mat.new()) ⇒ Void Also known as: Rodrigues

Note:

wrapper for static method void cv::Rodrigues(const cv::Mat src, cv::Mat& dst, const cv::Mat jacobian = Mat()/O)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• jacobian (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3900

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()) ⇒ Cv::Vec3d Also known as: RQDecomp3x3

Note:

wrapper for static method cv::Vec3d cv::RQDecomp3x3(const cv::Mat src, cv::Mat& mtxR, cv::Mat& mtxQ, const cv::Mat Qx = Mat()/O, const cv::Mat Qy = Mat()/O, const cv::Mat Qz = Mat()/O)

Parameters:

• src (Cv::Mat)
• mtx_r (Cv::Mat)
• mtx_q (Cv::Mat)
• qx (Cv::Mat) (defaults to: Cv::Mat.new())
• qy (Cv::Mat) (defaults to: Cv::Mat.new())
• qz (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Cv::Vec3d)

# File 'lib/ropencv/ropencv_types.rb', line 3925

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) ⇒ Void Also known as: scaleAdd

Note:

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

Parameters:

• _src1 (Cv::Mat)
• alpha (Double)
• _src2 (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

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

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) ⇒ Void Also known as: Scharr

Note:

wrapper for static method 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)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ddepth (Fixnum)
• dx (Fixnum)
• dy (Fixnum)
• scale (Double) (defaults to: 1)
• delta (Double) (defaults to: 0)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2734

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

.segment_motion(mhi, segmask, bounding_rects, timestamp, seg_thresh) ⇒ Void Also known as: segmentMotion

Note:

wrapper for static method void cv::segmentMotion(const cv::Mat mhi, cv::Mat& segmask, std::vectorcv::Rect& boundingRects, double timestamp, double segThresh)

Parameters:

• mhi (Cv::Mat)
• segmask (Cv::Mat)
• bounding_rects (Std::Vector::Cv_Rect)
• timestamp (Double)
• seg_thresh (Double)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3707

def self.segment_motion(mhi, segmask, bounding_rects, timestamp, seg_thresh)
    Rbind::cv_segment_motion(mhi, segmask, bounding_rects, timestamp, seg_thresh)
end

.sep_filter2d(src, dst, ddepth, kernel_x, kernel_y, anchor = Cv::Point.new(-1,-1), delta = 0, border_type = BORDER_DEFAULT) ⇒ Void Also known as: sepFilter2D

Note:

wrapper for static method 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)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ddepth (Fixnum)
• kernel_x (Cv::Mat)
• kernel_y (Cv::Mat)
• anchor (Cv::Point) (defaults to: Cv::Point.new(-1,-1))
• delta (Double) (defaults to: 0)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2703

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)) ⇒ Void Also known as: setIdentity

Note:

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

Parameters:

• mtx (Cv::Mat)
• s (Cv::Scalar) (defaults to: Cv::Scalar.new(1))

Returns:

• (Void)

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

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

.set_num_threads(nthreads) ⇒ Void Also known as: setNumThreads

Note:

wrapper for static method void cv::setNumThreads(int nthreads)

Parameters:

• nthreads (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1361

def self.set_num_threads(nthreads)
    Rbind::cv_set_num_threads(nthreads)
end

.set_trackbar_pos(trackbarname, winname, pos) ⇒ Void Also known as: setTrackbarPos

Note:

wrapper for static method void cv::setTrackbarPos(const cv::String trackbarname, const cv::String winname, int pos)

Parameters:

• trackbarname (Cv::String)
• winname (Cv::String)
• pos (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4446

def self.set_trackbar_pos(trackbarname, winname, pos)
    Rbind::cv_set_trackbar_pos(trackbarname, winname, pos)
end

.set_use_optimized(onoff) ⇒ Void Also known as: setUseOptimized

Note:

wrapper for static method void cv::setUseOptimized(bool onoff)

Parameters:

• onoff (Bool)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1426

def self.set_use_optimized(onoff)
    Rbind::cv_set_use_optimized(onoff)
end

.set_window_property(winname, prop_id, prop_value) ⇒ Void Also known as: setWindowProperty

Note:

wrapper for static method void cv::setWindowProperty(const cv::String winname, int prop_id, double prop_value)

Parameters:

• winname (Cv::String)
• prop_id (Fixnum)
• prop_value (Double)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4418

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) ⇒ Void Also known as: Sobel

Note:

wrapper for static method 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)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• ddepth (Fixnum)
• dx (Fixnum)
• dy (Fixnum)
• ksize (Fixnum) (defaults to: 3)
• scale (Double) (defaults to: 1)
• delta (Double) (defaults to: 0)
• border_type (Fixnum) (defaults to: BORDER_DEFAULT)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2719

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) ⇒ Bool

Note:

wrapper for static method bool cv::solve(const cv::Mat src1, const cv::Mat src2, cv::Mat& dst, int flags = DECOMP_LU)

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)
• flags (Fixnum) (defaults to: DECOMP_LU)

Returns:

• (Bool)

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

def self.solve(_src1, _src2, dst, flags = DECOMP_LU)
    Rbind::cv_solve(_src1, _src2, dst, flags)
end

.solve_cubic(coeffs, roots) ⇒ Fixnum Also known as: solveCubic

Note:

wrapper for static method int cv::solveCubic(const cv::Mat coeffs, cv::Mat& roots)

Parameters:

• coeffs (Cv::Mat)
• roots (Cv::Mat)

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 2122

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) ⇒ Bool Also known as: solvePnP

Note:

wrapper for static method 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)

Parameters:

• object_points (Cv::Mat)
• image_points (Cv::Mat)
• camera_matrix (Cv::Mat)
• dist_coeffs (Cv::Mat)
• rvec (Cv::Mat)
• tvec (Cv::Mat)
• use_extrinsic_guess (Bool) (defaults to: false)
• flags (Fixnum) (defaults to: ITERATIVE)

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 4002

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) ⇒ Void Also known as: solvePnPRansac

Note:

wrapper for static method 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, const cv::Mat inliers = Mat()/O, int flags = ITERATIVE)

Parameters:

• object_points (Cv::Mat)
• image_points (Cv::Mat)
• camera_matrix (Cv::Mat)
• dist_coeffs (Cv::Mat)
• rvec (Cv::Mat)
• tvec (Cv::Mat)
• use_extrinsic_guess (Bool) (defaults to: false)
• iterations_count (Fixnum) (defaults to: 100)
• reprojection_error (Float) (defaults to: 8.0)
• min_inliers_count (Fixnum) (defaults to: 100)
• inliers (Cv::Mat) (defaults to: Cv::Mat.new())
• flags (Fixnum) (defaults to: ITERATIVE)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4021

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) ⇒ Double Also known as: solvePoly

Note:

wrapper for static method double cv::solvePoly(const cv::Mat coeffs, cv::Mat& roots, int maxIters = 300)

Parameters:

• coeffs (Cv::Mat)
• roots (Cv::Mat)
• max_iters (Fixnum) (defaults to: 300)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 2132

def self.solve_poly(coeffs, roots, max_iters = 300)
    Rbind::cv_solve_poly(coeffs, roots, max_iters)
end

.sort(src, dst, flags) ⇒ Void

Note:

wrapper for static method void cv::sort(const cv::Mat src, cv::Mat& dst, int flags)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• flags (Fixnum)

Returns:

• (Void)

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

def self.sort(src, dst, flags)
    Rbind::cv_sort(src, dst, flags)
end

.sort_idx(src, dst, flags) ⇒ Void Also known as: sortIdx

Note:

wrapper for static method void cv::sortIdx(const cv::Mat src, cv::Mat& dst, int flags)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• flags (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2113

def self.sort_idx(src, dst, flags)
    Rbind::cv_sort_idx(src, dst, flags)
end

.split(m, mv) ⇒ Void

Note:

wrapper for static method void cv::split(const cv::Mat m, std::vectorcv::Mat& mv)

Parameters:

• m (Cv::Mat)
• mv (Std::Vector::Cv_Mat)

Returns:

• (Void)

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

def self.split(m, mv)
    Rbind::cv_split(m, mv)
end

.sqrt(src, dst) ⇒ Void

Note:

wrapper for static method void cv::sqrt(const cv::Mat src, cv::Mat& dst)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

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

def self.sqrt(src, dst)
    Rbind::cv_sqrt(src, dst)
end

.start_window_thread ⇒ Fixnum Also known as: startWindowThread

Note:

wrapper for static method int cv::startWindowThread()

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 4372

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) ⇒ Double Also known as: stereoCalibrate

Note:

wrapper for static method double cv::stereoCalibrate(const std::vectorcv::Mat objectPoints, const std::vectorcv::Mat imagePoints1, const std::vectorcv::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)

Parameters:

• object_points (Std::Vector::Cv_Mat)
• _image_points1 (Std::Vector::Cv_Mat)
• _image_points2 (Std::Vector::Cv_Mat)
• _camera_matrix1 (Cv::Mat)
• _dist_coeffs1 (Cv::Mat)
• _camera_matrix2 (Cv::Mat)
• _dist_coeffs2 (Cv::Mat)
• image_size (Cv::Size)
• r (Cv::Mat)
• t (Cv::Mat)
• e (Cv::Mat)
• f (Cv::Mat)
• criteria (Cv::TermCriteria) (defaults to: Cv::TermCriteria.new(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
• flags (Fixnum) (defaults to: CALIB_FIX_INTRINSIC)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 4130

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 = Cv::Rect::null, _valid_pix_r_o_i2 = Cv::Rect::null) ⇒ Void Also known as: stereoRectify

Note:

wrapper for static method 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(), const cv::Rect* validPixROI1 = 0/O, const cv::Rect* validPixROI2 = 0/O)

Parameters:

• _camera_matrix1 (Cv::Mat)
• _dist_coeffs1 (Cv::Mat)
• _camera_matrix2 (Cv::Mat)
• _dist_coeffs2 (Cv::Mat)
• image_size (Cv::Size)
• r (Cv::Mat)
• t (Cv::Mat)
• _r1 (Cv::Mat)
• _r2 (Cv::Mat)
• _p1 (Cv::Mat)
• _p2 (Cv::Mat)
• q (Cv::Mat)
• flags (Fixnum) (defaults to: CALIB_ZERO_DISPARITY)
• alpha (Double) (defaults to: -1,)
• new_image_size (Cv::Size) (defaults to: Cv::Size.new())
• _valid_pix_r_o_i1 (Cv::Rect) (defaults to: Cv::Rect::null)
• _valid_pix_r_o_i2 (Cv::Rect) (defaults to: Cv::Rect::null)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4154

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 = Cv::Rect::null, _valid_pix_r_o_i2 = Cv::Rect::null)
    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) ⇒ Bool Also known as: stereoRectifyUncalibrated

Note:

wrapper for static method 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)

Parameters:

• _points1 (Cv::Mat)
• _points2 (Cv::Mat)
• f (Cv::Mat)
• img_size (Cv::Size)
• _h1 (Cv::Mat)
• _h2 (Cv::Mat)
• threshold (Double) (defaults to: 5)

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 4168

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)) ⇒ Void

Note:

wrapper for static method void cv::subtract(const cv::Mat src1, const cv::Mat src2, cv::Mat& dst, const cv::Mat mask = Mat(), int dtype = -1)

Parameters:

• _src1 (Cv::Mat)
• _src2 (Cv::Mat)
• dst (Cv::Mat)
• mask (Cv::Mat) (defaults to: Cv::Mat.new())
• dtype (Fixnum) (defaults to: -1))

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1456

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

.sum(src) ⇒ Cv::Mat

Note:

wrapper for static method cv::Mat cv::sum(const cv::Mat src)

Parameters:

• src (Cv::Mat)

Returns:

• (Cv::Mat)

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

def self.sum(src)
    Rbind::cv_sum(src)
end

.sum_elems(src) ⇒ Cv::Scalar Also known as: sumElems

Note:

wrapper for static method cv::Scalar cv::sum(const cv::Mat src)

Parameters:

• src (Cv::Mat)

Returns:

• (Cv::Scalar)

# File 'lib/ropencv/ropencv_types.rb', line 1567

def self.sum_elems(src)
    Rbind::cv_sum_elems(src)
end

.sv_back_subst(w, u, vt, rhs, dst) ⇒ Void Also known as: SVBackSubst

Note:

wrapper for static method void cv::SVBackSubst(const cv::Mat w, const cv::Mat u, const cv::Mat vt, const cv::Mat rhs, cv::Mat& dst)

Parameters:

• w (Cv::Mat)
• u (Cv::Mat)
• vt (Cv::Mat)
• rhs (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2222

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) ⇒ Void Also known as: SVDecomp

Note:

wrapper for static method void cv::SVDecomp(const cv::Mat src, cv::Mat& w, cv::Mat& u, cv::Mat& vt, int flags = 0)

Parameters:

• src (Cv::Mat)
• w (Cv::Mat)
• u (Cv::Mat)
• vt (Cv::Mat)
• flags (Fixnum) (defaults to: 0)

Returns:

• (Void)

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

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) ⇒ Double

Note:

wrapper for static method double cv::threshold(const cv::Mat src, cv::Mat& dst, double thresh, double maxval, int type)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• thresh (Double)
• maxval (Double)
• type (Fixnum)

Returns:

• (Double)

# File 'lib/ropencv/ropencv_types.rb', line 3160

def self.threshold(src, dst, thresh, maxval, type)
    Rbind::cv_threshold(src, dst, thresh, maxval, type)
end

.trace(mtx) ⇒ Cv::Scalar

Note:

wrapper for static method cv::Scalar cv::trace(const cv::Mat mtx)

Parameters:

• mtx (Cv::Mat)

Returns:

• (Cv::Scalar)

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

def self.trace(mtx)
    Rbind::cv_trace(mtx)
end

.transform(src, dst, m) ⇒ Void

Note:

wrapper for static method void cv::transform(const cv::Mat src, cv::Mat& dst, const cv::Mat m)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• m (Cv::Mat)

Returns:

• (Void)

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

def self.transform(src, dst, m)
    Rbind::cv_transform(src, dst, m)
end

.transpose(src, dst) ⇒ Void

Note:

wrapper for static method void cv::transpose(const cv::Mat src, cv::Mat& dst)

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)

Returns:

• (Void)

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

def self.transpose(src, dst)
    Rbind::cv_transpose(src, dst)
end

.triangulate_points(_proj_matr1, _proj_matr2, _proj_points1, _proj_points2, _points4_d) ⇒ Void Also known as: triangulatePoints

Note:

wrapper for static method void cv::triangulatePoints(const cv::Mat projMatr1, const cv::Mat projMatr2, const cv::Mat projPoints1, const cv::Mat projPoints2, cv::Mat& points4D)

Parameters:

• _proj_matr1 (Cv::Mat)
• _proj_matr2 (Cv::Mat)
• _proj_points1 (Cv::Mat)
• _proj_points2 (Cv::Mat)
• _points4_d (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4268

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()) ⇒ Void

Note:

wrapper for static method void cv::undistort(const cv::Mat src, cv::Mat& dst, const cv::Mat cameraMatrix, const cv::Mat distCoeffs, const cv::Mat newCameraMatrix = Mat())

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• camera_matrix (Cv::Mat)
• dist_coeffs (Cv::Mat)
• new_camera_matrix (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3207

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()) ⇒ Void Also known as: undistortPoints

Note:

wrapper for static method 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())

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• camera_matrix (Cv::Mat)
• dist_coeffs (Cv::Mat)
• r (Cv::Mat) (defaults to: Cv::Mat.new())
• p (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3260

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

.update_motion_history(silhouette, mhi, timestamp, duration) ⇒ Void Also known as: updateMotionHistory

Note:

wrapper for static method void cv::updateMotionHistory(const cv::Mat silhouette, cv::Mat& mhi, double timestamp, double duration)

Parameters:

• silhouette (Cv::Mat)
• mhi (Cv::Mat)
• timestamp (Double)
• duration (Double)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3670

def self.update_motion_history(silhouette, mhi, timestamp, duration)
    Rbind::cv_update_motion_history(silhouette, mhi, timestamp, duration)
end

.use_optimized ⇒ Bool Also known as: useOptimized

Note:

wrapper for static method bool cv::useOptimized()

Returns:

• (Bool)

# File 'lib/ropencv/ropencv_types.rb', line 1433

def self.use_optimized()
    Rbind::cv_use_optimized()
end

.validate_disparity(disparity, cost, min_disparity, number_of_disparities, _disp12_max_disp = 1) ⇒ Void Also known as: validateDisparity

Note:

wrapper for static method void cv::validateDisparity(cv::Mat& disparity, const cv::Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp = 1)

Parameters:

• disparity (Cv::Mat)
• cost (Cv::Mat)
• min_disparity (Fixnum)
• number_of_disparities (Fixnum)
• _disp12_max_disp (Fixnum) (defaults to: 1)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 4316

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) ⇒ Void

Note:

wrapper for static method void cv::vconcat(const std::vectorcv::Mat src, cv::Mat& dst)

Parameters:

• src (Std::Vector::Cv_Mat)
• dst (Cv::Mat)

Returns:

• (Void)

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

def self.vconcat(src, dst)
    Rbind::cv_vconcat(src, dst)
end

.wait_key(delay = 0) ⇒ Fixnum Also known as: waitKey

Note:

wrapper for static method int cv::waitKey(int delay = 0)

Parameters:

• delay (Fixnum) (defaults to: 0)

Returns:

• (Fixnum)

# File 'lib/ropencv/ropencv_types.rb', line 4380

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()) ⇒ Void Also known as: warpAffine

Note:

wrapper for static method 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())

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• m (Cv::Mat)
• dsize (Cv::Size)
• flags (Fixnum) (defaults to: INTER_LINEAR)
• border_mode (Fixnum) (defaults to: BORDER_CONSTANT)
• border_value (Cv::Scalar) (defaults to: Cv::Scalar.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2948

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()) ⇒ Void Also known as: warpPerspective

Note:

wrapper for static method 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())

Parameters:

• src (Cv::Mat)
• dst (Cv::Mat)
• m (Cv::Mat)
• dsize (Cv::Size)
• flags (Fixnum) (defaults to: INTER_LINEAR)
• border_mode (Fixnum) (defaults to: BORDER_CONSTANT)
• border_value (Cv::Scalar) (defaults to: Cv::Scalar.new())

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 2962

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) ⇒ Void

Note:

wrapper for static method void cv::watershed(const cv::Mat image, cv::Mat& markers)

Parameters:

• image (Cv::Mat)
• markers (Cv::Mat)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 3324

def self.watershed(image, markers)
    Rbind::cv_watershed(image, markers)
end

.write_double(fs, name, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, double val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Double)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1166

def self.write_double(fs, name, val)
    Rbind::cv_write_double(fs, name, val)
end

.write_float(fs, name, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, float val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Float)

Returns:

• (Void)

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

def self.write_float(fs, name, val)
    Rbind::cv_write_float(fs, name, val)
end

.write_int(fs, name, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, int val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Fixnum)

Returns:

• (Void)

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

def self.write_int(fs, name, val)
    Rbind::cv_write_int(fs, name, val)
end

.write_mat(fs, name, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Mat val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Mat)

Returns:

• (Void)

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

def self.write_mat(fs, name, val)
    Rbind::cv_write_mat(fs, name, val)
end

.write_point(fs, name, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Point val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Point)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1193

def self.write_point(fs, name, val)
    Rbind::cv_write_point(fs, name, val)
end

.write_point_2d(fs, name, val) ⇒ Void Also known as: write_point2d

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Point2d val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Point2d)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1222

def self.write_point_2d(fs, name, val)
    Rbind::cv_write_point_2d(fs, name, val)
end

.write_point_2f(fs, name, val) ⇒ Void Also known as: write_point2f

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Point2f val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Point2f)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1202

def self.write_point_2f(fs, name, val)
    Rbind::cv_write_point_2f(fs, name, val)
end

.write_point_3d(fs, name, val) ⇒ Void Also known as: write_point3d

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Point3d val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Point3d)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1232

def self.write_point_3d(fs, name, val)
    Rbind::cv_write_point_3d(fs, name, val)
end

.write_point_3f(fs, name, val) ⇒ Void Also known as: write_point3f

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Point3f val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Point3f)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1212

def self.write_point_3f(fs, name, val)
    Rbind::cv_write_point_3f(fs, name, val)
end

.write_range(fs, name, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Range val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Range)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1251

def self.write_range(fs, name, val)
    Rbind::cv_write_range(fs, name, val)
end

.write_rect(fs, name, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Rect val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Rect)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1242

def self.write_rect(fs, name, val)
    Rbind::cv_write_rect(fs, name, val)
end

.write_scalar(fs, name, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Scalar val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Scalar)

Returns:

• (Void)

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

def self.write_scalar(fs, name, val)
    Rbind::cv_write_scalar(fs, name, val)
end

.write_scalar_double(fs, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, double val)

Parameters:

• fs (Cv::FileStorage)
• val (Double)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1131

def self.write_scalar_double(fs, val)
    Rbind::cv_write_scalar_double(fs, val)
end

.write_scalar_float(fs, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, float val)

Parameters:

• fs (Cv::FileStorage)
• val (Float)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1123

def self.write_scalar_float(fs, val)
    Rbind::cv_write_scalar_float(fs, val)
end

.write_scalar_int(fs, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, int val)

Parameters:

• fs (Cv::FileStorage)
• val (Fixnum)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1115

def self.write_scalar_int(fs, val)
    Rbind::cv_write_scalar_int(fs, val)
end

.write_scalar_string(fs, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String val)

Parameters:

• fs (Cv::FileStorage)
• val (Cv::String)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1139

def self.write_scalar_string(fs, val)
    Rbind::cv_write_scalar_string(fs, val)
end

.write_size(fs, name, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Size val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Size)

Returns:

• (Void)

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

def self.write_size(fs, name, val)
    Rbind::cv_write_size(fs, name, val)
end

.write_string(fs, name, val) ⇒ Void

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::String val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::String)

Returns:

• (Void)

# File 'lib/ropencv/ropencv_types.rb', line 1175

def self.write_string(fs, name, val)
    Rbind::cv_write_string(fs, name, val)
end

.write_vec_2d(fs, name, val) ⇒ Void Also known as: write_vec2d

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Vec2d val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Vec2d)

Returns:

• (Void)

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

def self.write_vec_2d(fs, name, val)
    Rbind::cv_write_vec_2d(fs, name, val)
end

.write_vec_2f(fs, name, val) ⇒ Void Also known as: write_vec2f

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Vec2f val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Vec2f)

Returns:

• (Void)

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

def self.write_vec_2f(fs, name, val)
    Rbind::cv_write_vec_2f(fs, name, val)
end

.write_vec_3d(fs, name, val) ⇒ Void Also known as: write_vec3d

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Vec3d val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Vec3d)

Returns:

• (Void)

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

def self.write_vec_3d(fs, name, val)
    Rbind::cv_write_vec_3d(fs, name, val)
end

.write_vec_3f(fs, name, val) ⇒ Void Also known as: write_vec3f

Note:

wrapper for static method void cv::write(cv::FileStorage& fs, const cv::String name, const cv::Vec3f val)

Parameters:

• fs (Cv::FileStorage)
• name (Cv::String)
• val (Cv::Vec3f)

Returns:

• (Void)

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

def self.write_vec_3f(fs, name, val)
    Rbind::cv_write_vec_3f(fs, name, val)
end