opencv: cv Namespace Reference

Classes | Typedefs | Enumerations | Functions | Variables

# cv Namespace Reference

## Classes
struct | Accumulator
struct | Accumulator< char >
struct | Accumulator< short >
struct | Accumulator< unsigned char >
struct | Accumulator< unsigned short >
class | AdjusterAdapter
| A feature detector parameter adjuster, this is used by the DynamicAdaptedFeatureDetector and is a wrapper for FeatureDetector that allow them to be adjusted after a detection. More...
class | Allocator
class | AutoBuffer
class | BackgroundSubtractor
class | BackgroundSubtractorMOG
class | BaseColumnFilter
class | BaseFilter
struct | BaseKeypoint
class | BaseRowFilter
class | BlockedRange
class | BOWImgDescriptorExtractor
class | BOWKMeansTrainer
class | BOWTrainer
class | BriefDescriptorExtractor
class | BruteForceMatcher
class | CalonderDescriptorExtractor
class | CascadeClassifier
class | Complex
class | CvAffinePose
class | DataDepth
class | DataDepth< _Tp * >
class | DataDepth< bool >
class | DataDepth< char >
class | DataDepth< double >
class | DataDepth< float >
class | DataDepth< int >
class | DataDepth< schar >
class | DataDepth< short >
class | DataDepth< uchar >
class | DataDepth< unsigned >
class | DataDepth< ushort >
class | DataType
class | DataType< bool >
class | DataType< char >
class | DataType< Complex< _Tp > >
class | DataType< double >
class | DataType< float >
class | DataType< int >
class | DataType< Point3_< _Tp > >
class | DataType< Point_< _Tp > >
class | DataType< Range >
class | DataType< Rect_< _Tp > >
class | DataType< Scalar_< _Tp > >
class | DataType< schar >
class | DataType< short >
class | DataType< Size_< _Tp > >
class | DataType< std::complex< _Tp > >
class | DataType< uchar >
class | DataType< ushort >
class | DataType< Vec< _Tp, cn > >
struct | DefaultRngAuto
class | DenseFeatureDetector
class | DescriptorExtractor
class | DescriptorMatcher
struct | DMatch
struct | DrawMatchesFlags
class | DynamicAdaptedFeatureDetector
| an adaptively adjusting detector that iteratively detects until the desired number of features are detected. Beware that this is not thread safe - as the adjustment of parameters breaks the const of the detection routine... /TODO Make this const correct and thread safe More...
class | Exception
class | FastAdjuster
| an adjust for the FAST detector. This will basically decrement or increment the threshhold by 1 More...
class | FastFeatureDetector
class | FeatureDetector
class | FeatureEvaluator
class | FernClassifier
class | FernDescriptorMatcher
class | FileNode
class | FileNodeIterator
class | FileStorage
class | FilterEngine
class | FlannBasedMatcher
struct | Formatted
class | Formatter
class | GenericDescriptorMatcher
class | GoodFeaturesToTrackDetector
class | GreaterEq
class | GreaterEqIdx
class | GridAdaptedFeatureDetector
struct | Hamming
struct | HammingLUT
struct | HOGDescriptor
class | KalmanFilter
class | KDTree
class | KeyPoint
struct | L1
struct | L2
class | LDetector
class | LessThan
class | LessThanIdx
class | LevMarqSparse
class | LineIterator
class | Mat
class | Mat_
class | MatAllocator
class | MatCommaInitializer_
class | MatConstIterator
class | MatConstIterator_
class | MatExpr
class | MatIterator_
class | MatOp
class | Matx
struct | Matx_AddOp
struct | Matx_DetOp
struct | Matx_DetOp< _Tp, 1 >
struct | Matx_DetOp< _Tp, 2 >
struct | Matx_DetOp< _Tp, 3 >
struct | Matx_FastInvOp
struct | Matx_FastInvOp< _Tp, 2 >
struct | Matx_FastInvOp< _Tp, 3 >
struct | Matx_FastSolveOp
struct | Matx_FastSolveOp< _Tp, 2, 1 >
struct | Matx_FastSolveOp< _Tp, 3, 1 >
struct | Matx_MatMulOp
struct | Matx_MulOp
struct | Matx_ScaleOp
struct | Matx_SubOp
struct | Matx_TOp
class | MatxCommaInitializer
class | Mesh3D
class | Moments
| raster image moments More...
class | MSER
class | MserFeatureDetector
class | NAryMatIterator
class | Octree
class | OneWayDescriptor
class | OneWayDescriptorBase
class | OneWayDescriptorMatcher
class | OneWayDescriptorObject
class | OpponentColorDescriptorExtractor
class | PatchGenerator
class | PCA
class | PlanarObjectDetector
class | Point3_
class | Point_
class | Ptr
class | PyramidAdaptedFeatureDetector
class | RandomizedTree
class | Range
class | Rect_
class | RNG
class | RotatedRect
class | RTreeClassifier
struct | RTreeNode
struct | RTTIImpl
class | Scalar_
class | SelfSimDescriptor
class | Seq
class | SeqIterator
class | SIFT
class | SiftDescriptorExtractor
class | SiftFeatureDetector
class | Size_
class | SparseMat
class | SparseMat_
class | SparseMatConstIterator
class | SparseMatConstIterator_
class | SparseMatIterator
class | SparseMatIterator_
class | SpinImageModel
class | Split
class | StarAdjuster
class | StarDetector
class | StarFeatureDetector
class | StereoBM
class | StereoSGBM
class | SURF
class | SurfAdjuster
class | SurfDescriptorExtractor
class | SurfFeatureDetector
class | SVD
class | TermCriteria
class | TickMeter
class | Vec
class | VecCommaInitializer
class | VecReaderProxy
class | VecReaderProxy< _Tp, 1 >
class | Vector
class | VectorDescriptorMatcher
class | VecWriterProxy
class | VecWriterProxy< _Tp, 1 >
class | VideoCapture
class | VideoWriter
class | WImage
class | WImageBuffer
class | WImageBufferC
class | WImageC
class | WImageView
class | WImageViewC
class | WriteStructContext
## Typedefs
typedef CvANN_MLP_TrainParams | ANN_MLP_TrainParams
typedef CvBoost | Boost
typedef CvBoostParams | BoostParams
typedef CvBoostTree | BoostTree
typedef void(CV_CDECL * | ButtonCallback )(int state, void *userdata)
typedef Complex< double > | Complexd
typedef Complex< float > | Complexf
typedef std::vector< Rect > | ConcurrentRectVector
typedef void(* | ConvertData )(const void *from, void *to, int cn)
typedef void(* | ConvertScaleData )(const void *from, void *to, int cn, double alpha, double beta)
typedef CvDTree | DecisionTree
typedef CvDTreeParams | DTreeParams
typedef CvEMParams | EMParams
typedef int(CV_CDECL * | ErrorCallback )(int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata)
typedef CvForestERTree | ERTree
typedef CvERTrees | ERTrees
typedef CvERTreeTrainData | ERTreeTRainData
typedef CvEM | ExpectationMaximization
typedef FernDescriptorMatcher | FernDescriptorMatch
typedef CvForestTree | ForestTree
typedef GenericDescriptorMatcher | GenericDescriptorMatch
typedef CvGBTreesParams | GradientBoostingTreeParams
typedef CvGBTrees | GradientBoostingTrees
typedef CvKNearest | KNearest
typedef Mat_< uchar > | Mat1b
typedef Mat_< double > | Mat1d
typedef Mat_< float > | Mat1f
typedef Mat_< int > | Mat1i
typedef Mat_< short > | Mat1s
typedef Mat_< ushort > | Mat1w
typedef Mat_< Vec2b > | Mat2b
typedef Mat_< Vec2d > | Mat2d
typedef Mat_< Vec2f > | Mat2f
typedef Mat_< Vec2i > | Mat2i
typedef Mat_< Vec2s > | Mat2s
typedef Mat_< Vec2w > | Mat2w
typedef Mat_< Vec3b > | Mat3b
typedef Mat_< Vec3d > | Mat3d
typedef Mat_< Vec3f > | Mat3f
typedef Mat_< Vec3i > | Mat3i
typedef Mat_< Vec3s > | Mat3s
typedef Mat_< Vec3w > | Mat3w
typedef Mat_< Vec4b > | Mat4b
typedef Mat_< Vec4d > | Mat4d
typedef Mat_< Vec4f > | Mat4f
typedef Mat_< Vec4i > | Mat4i
typedef Mat_< Vec4s > | Mat4s
typedef Mat_< Vec4w > | Mat4w
typedef Mat | MatND
typedef Matx< double, 1, 2 > | Matx12d
typedef Matx< float, 1, 2 > | Matx12f
typedef Matx< double, 1, 3 > | Matx13d
typedef Matx< float, 1, 3 > | Matx13f
typedef Matx< double, 1, 4 > | Matx14d
typedef Matx< float, 1, 4 > | Matx14f
typedef Matx< double, 1, 6 > | Matx16d
typedef Matx< float, 1, 6 > | Matx16f
typedef Matx< double, 2, 1 > | Matx21d
typedef Matx< float, 2, 1 > | Matx21f
typedef Matx< double, 2, 2 > | Matx22d
typedef Matx< float, 2, 2 > | Matx22f
typedef Matx< double, 2, 3 > | Matx23d
typedef Matx< float, 2, 3 > | Matx23f
typedef Matx< double, 3, 1 > | Matx31d
typedef Matx< float, 3, 1 > | Matx31f
typedef Matx< double, 3, 2 > | Matx32d
typedef Matx< float, 3, 2 > | Matx32f
typedef Matx< double, 3, 3 > | Matx33d
typedef Matx< float, 3, 3 > | Matx33f
typedef Matx< double, 3, 4 > | Matx34d
typedef Matx< float, 3, 4 > | Matx34f
typedef Matx< double, 4, 1 > | Matx41d
typedef Matx< float, 4, 1 > | Matx41f
typedef Matx< double, 4, 3 > | Matx43d
typedef Matx< float, 4, 3 > | Matx43f
typedef Matx< double, 4, 4 > | Matx44d
typedef Matx< float, 4, 4 > | Matx44f
typedef Matx< double, 6, 1 > | Matx61d
typedef Matx< float, 6, 1 > | Matx61f
typedef Matx< double, 6, 6 > | Matx66d
typedef Matx< float, 6, 6 > | Matx66f
typedef Ptr< CvMemStorage > | MemStorage
typedef void(* | MouseCallback )(int event, int x, int y, int flags, void *param)
typedef CvANN_MLP | NeuralNet_MLP
typedef CvNormalBayesClassifier | NormalBayesClassifier
typedef OneWayDescriptorMatcher | OneWayDescriptorMatch
typedef void(CV_CDECL * | OpenGLCallback )(void *userdata)
typedef CvParamGrid | ParamGrid
typedef Point2i | Point
typedef Point_< double > | Point2d
typedef Point_< float > | Point2f
typedef Point_< int > | Point2i
typedef Point3_< double > | Point3d
typedef Point3_< float > | Point3f
typedef Point3_< int > | Point3i
typedef CvRTParams | RandomTreeParams
typedef CvRTrees | RandomTrees
typedef Rect_< int > | Rect
typedef Scalar_< double > | Scalar
typedef Size2i | Size
typedef Size_< float > | Size2f
typedef Size_< int > | Size2i
typedef CvStatModel | StatModel
typedef std::string | String
typedef CvSVM | SVM
typedef CvSVMKernel | SVMKernel
typedef CvSVMParams | SVMParams
typedef CvSVMSolver | SVMSolver
typedef void(CV_CDECL * | TrackbarCallback )(int pos, void *userdata)
typedef CvMLData | TrainData
typedef Vec< uchar, 2 > | Vec2b
typedef Vec< double, 2 > | Vec2d
typedef Vec< float, 2 > | Vec2f
typedef Vec< int, 2 > | Vec2i
typedef Vec< short, 2 > | Vec2s
typedef Vec< ushort, 2 > | Vec2w
typedef Vec< uchar, 3 > | Vec3b
typedef Vec< double, 3 > | Vec3d
typedef Vec< float, 3 > | Vec3f
typedef Vec< int, 3 > | Vec3i
typedef Vec< short, 3 > | Vec3s
typedef Vec< ushort, 3 > | Vec3w
typedef Vec< uchar, 4 > | Vec4b
typedef Vec< double, 4 > | Vec4d
typedef Vec< float, 4 > | Vec4f
typedef Vec< int, 4 > | Vec4i
typedef Vec< short, 4 > | Vec4s
typedef Vec< ushort, 4 > | Vec4w
typedef Vec< double, 6 > | Vec6d
typedef Vec< float, 6 > | Vec6f
typedef VectorDescriptorMatcher | VectorDescriptorMatch
typedef WImageC< short, 1 > | WImage1_16s
typedef WImageC< ushort, 1 > | WImage1_16u
typedef WImageC< uchar, 1 > | WImage1_b
typedef WImageC< float, 1 > | WImage1_f
typedef WImageC< short, 3 > | WImage3_16s
typedef WImageC< ushort, 3 > | WImage3_16u
typedef WImageC< uchar, 3 > | WImage3_b
typedef WImageC< float, 3 > | WImage3_f
typedef WImage< short > | WImage_16s
typedef WImage< ushort > | WImage_16u
typedef WImage< uchar > | WImage_b
typedef WImage< float > | WImage_f
typedef WImageBufferC< short, 1 > | WImageBuffer1_16s
typedef WImageBufferC< ushort, 1 > | WImageBuffer1_16u
typedef WImageBufferC< uchar, 1 > | WImageBuffer1_b
typedef WImageBufferC< float, 1 > | WImageBuffer1_f
typedef WImageBufferC< short, 3 > | WImageBuffer3_16s
typedef WImageBufferC< ushort, 3 > | WImageBuffer3_16u
typedef WImageBufferC< uchar, 3 > | WImageBuffer3_b
typedef WImageBufferC< float, 3 > | WImageBuffer3_f
typedef WImageBuffer< short > | WImageBuffer_16s
typedef WImageBuffer< ushort > | WImageBuffer_16u
typedef WImageBuffer< uchar > | WImageBuffer_b
typedef WImageBuffer< float > | WImageBuffer_f
typedef WImageViewC< short, 1 > | WImageView1_16s
typedef WImageViewC< ushort, 1 > | WImageView1_16u
typedef WImageViewC< uchar, 1 > | WImageView1_b
typedef WImageViewC< float, 1 > | WImageView1_f
typedef WImageViewC< short, 3 > | WImageView3_16s
typedef WImageViewC< ushort, 3 > | WImageView3_16u
typedef WImageViewC< uchar, 3 > | WImageView3_b
typedef WImageViewC< float, 3 > | WImageView3_f
typedef WImageView< short > | WImageView_16s
typedef WImageView< ushort > | WImageView_16u
typedef WImageView< uchar > | WImageView_b
typedef WImageView< float > | WImageView_f
typedef std::basic_string < wchar_t > | WString
typedef LDetector | YAPE
## Enumerations
enum | { DECOMP_LU = 0, DECOMP_SVD = 1, DECOMP_EIG = 2, DECOMP_CHOLESKY = 3, DECOMP_QR = 4, DECOMP_NORMAL = 16 }
enum | { NORM_INF = 1, NORM_L1 = 2, NORM_L2 = 4, NORM_TYPE_MASK = 7, NORM_RELATIVE = 8, NORM_MINMAX = 32 }
enum | { LMEDS = CV_LMEDS, RANSAC = CV_RANSAC }
| type of the robust estimation algorithm More...
enum | { CALIB_CB_ADAPTIVE_THRESH = 1, CALIB_CB_NORMALIZE_IMAGE = 2, CALIB_CB_FILTER_QUADS = 4, CALIB_CB_FAST_CHECK = 8 }
enum | { 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 }
enum | { FM_7POINT = CV_FM_7POINT, FM_8POINT = CV_FM_8POINT, FM_LMEDS = CV_FM_LMEDS, FM_RANSAC = CV_FM_RANSAC }
| the algorithm for finding fundamental matrix More...
enum | { OPTFLOW_USE_INITIAL_FLOW = 4, OPTFLOW_FARNEBACK_GAUSSIAN = 256 }
enum | { WINDOW_AUTOSIZE = 1 }
enum | { CMP_EQ = 0, CMP_GT = 1, CMP_GE = 2, CMP_LT = 3, CMP_LE = 4, CMP_NE = 5 }
enum | { GEMM_1_T = 1, GEMM_2_T = 2, GEMM_3_T = 4 }
enum | { 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 }
enum | { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 }
enum | { KMEANS_RANDOM_CENTERS = 0, KMEANS_PP_CENTERS = 2, KMEANS_USE_INITIAL_LABELS = 1 }
enum | { 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 }
| various border interpolation methods More...
enum | { KERNEL_GENERAL = 0, KERNEL_SYMMETRICAL = 1, KERNEL_ASYMMETRICAL = 2, KERNEL_SMOOTH = 4, KERNEL_INTEGER = 8 }
| type of the kernel More...
enum | { MORPH_ERODE = 0, MORPH_DILATE = 1, MORPH_OPEN = 2, MORPH_CLOSE = 3, MORPH_GRADIENT = 4, MORPH_TOPHAT = 5, MORPH_BLACKHAT = 6 }
| type of morphological operation More...
enum | { MORPH_RECT = 0, MORPH_CROSS = 1, MORPH_ELLIPSE = 2 }
| shape of the structuring element More...
enum | { INTER_NEAREST = 0, INTER_LINEAR = 1, INTER_CUBIC = 2, INTER_AREA = 3, INTER_LANCZOS4 = 4, INTER_MAX = 7, WARP_INVERSE_MAP = 16 }
| interpolation algorithm More...
enum | { INTER_BITS = 5, INTER_BITS2 = INTER_BITS*2, INTER_TAB_SIZE = (1<<INTER_BITS), INTER_TAB_SIZE2 = INTER_TAB_SIZE*INTER_TAB_SIZE }
enum | { THRESH_BINARY = 0, THRESH_BINARY_INV = 1, THRESH_TRUNC = 2, THRESH_TOZERO = 3, THRESH_TOZERO_INV = 4, THRESH_MASK = 7, THRESH_OTSU = 8 }
| type of the threshold operation More...
enum | { ADAPTIVE_THRESH_MEAN_C = 0, ADAPTIVE_THRESH_GAUSSIAN_C = 1 }
| adaptive threshold algorithm More...
enum | { PROJ_SPHERICAL_ORTHO = 0, PROJ_SPHERICAL_EQRECT = 1 }
enum | { GC_BGD = 0, GC_FGD = 1, GC_PR_BGD = 2, GC_PR_FGD = 3 }
| class of the pixel in GrabCut algorithm More...
enum | { 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 }
enum | { GC_INIT_WITH_RECT = 0, GC_INIT_WITH_MASK = 1, GC_EVAL = 2 }
| GrabCut algorithm flags. More...
enum | { INPAINT_NS = 0, INPAINT_TELEA = 1 }
| the inpainting algorithm More...
enum | { FLOODFILL_FIXED_RANGE = 1 << 16, FLOODFILL_MASK_ONLY = 1 << 17 }
enum | { TM_SQDIFF = 0, TM_SQDIFF_NORMED = 1, TM_CCORR = 2, TM_CCORR_NORMED = 3, TM_CCOEFF = 4, TM_CCOEFF_NORMED = 5 }
| type of the template matching operation More...
enum | { RETR_EXTERNAL = 0, RETR_LIST = 1, RETR_CCOMP = 2, RETR_TREE = 3 }
| mode of the contour retrieval algorithm More...
enum | { CHAIN_APPROX_NONE = 0, CHAIN_APPROX_SIMPLE = 1, CHAIN_APPROX_TC89_L1 = 2, CHAIN_APPROX_TC89_KCOS = 3 }
| the contour approximation algorithm More...
## Functions
MatExpr | abs (const Mat &m)
MatExpr | abs (const MatExpr &e)
CV_EXPORTS_W void | absdiff (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst)
| computes element-wise absolute difference of array and scalar (dst = abs(src1 - src2))
CV_EXPORTS_W void | absdiff (const Mat &src1, const Mat &src2, CV_OUT Mat &dst)
| computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
CV_EXPORTS_W void | accumulate (const Mat &src, CV_IN_OUT Mat &dst, const Mat &mask=Mat())
| adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.
CV_EXPORTS_W void | accumulateProduct (const Mat &src1, const Mat &src2, CV_IN_OUT Mat &dst, const Mat &mask=Mat())
| adds product of the 2 images to the accumulator (dst += src1*src2).
CV_EXPORTS_W void | accumulateSquare (const Mat &src, CV_IN_OUT Mat &dst, const Mat &mask=Mat())
| adds squared src image to the accumulator (dst += src*src).
CV_EXPORTS_W void | accumulateWeighted (const Mat &src, CV_IN_OUT Mat &dst, double alpha, const Mat &mask=Mat())
| updates the running average (dst = dst*(1-alpha) + src*alpha)
CV_EXPORTS_W void | adaptiveThreshold (const Mat &src, CV_OUT Mat &dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
| applies variable (adaptive) threshold to the image
CV_EXPORTS_W void | add (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask CV_WRAP_DEFAULT(Mat()))
| adds one matrix to another (dst = src1 + src2)
CV_EXPORTS_W void | add (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| adds scalar to a matrix (dst = src1 + src2)
void | add (const Mat &src1, const Mat &src2, CV_OUT Mat &dst)
| adds one matrix to another (dst = src1 + src2)
void | addText (const Mat &img, const string &text, Point org, CvFont font)
CV_EXPORTS_W void | addWeighted (const Mat &src1, double alpha, const Mat &src2, double beta, double gamma, CV_OUT Mat &dst)
| computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
void | approxPolyDP (const Mat &curve, CV_OUT vector< Point > &approxCurve, double epsilon, bool closed)
| approximates contour or a curve using Douglas-Peucker algorithm
CV_EXPORTS_W double | arcLength (const Mat &curve, bool closed)
| computes the contour perimeter (closed=true) or a curve length
CV_EXPORTS_W void | bilateralFilter (const Mat &src, CV_OUT Mat &dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)
| smooths the image using bilateral filter
CV_EXPORTS_W void | bitwise_and (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise conjunction of the two arrays (dst = src1 & src2)
CV_EXPORTS_W void | bitwise_and (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise conjunction of an array and scalar (dst = src1 & src2)
CV_EXPORTS_W void | bitwise_not (const Mat &src, CV_OUT Mat &dst)
| inverts each bit of array (dst = ~src)
CV_EXPORTS_W void | bitwise_or (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise disjunction of the two arrays (dst = src1 | src2)
CV_EXPORTS_W void | bitwise_or (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise disjunction of an array and scalar (dst = src1 | src2)
CV_EXPORTS_W void | bitwise_xor (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
CV_EXPORTS_W void | bitwise_xor (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise exclusive-or of an array and scalar (dst = src1 ^ src2)
CV_EXPORTS_W void | blur (const Mat &src, CV_OUT Mat &dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)
| a synonym for normalized box filter
CV_EXPORTS_W int | borderInterpolate (int p, int len, int borderType)
| 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.
CV_EXPORTS_W Rect | boundingRect (const Mat &points)
| computes the bounding rectangle for a contour
CV_EXPORTS_W void | boxFilter (const Mat &src, CV_OUT Mat &dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
| smooths the image using the box filter. Each pixel is processed in O(1) time
void | buildPyramid (const Mat &src, CV_OUT vector< Mat > &dst, int maxlevel)
| builds the gaussian pyramid using pyrDown() as a basic operation
void | calcBackProject (const Mat *images, int nimages, const int *channels, const Mat &hist, Mat &backProject, const float **ranges, double scale=1, bool uniform=true)
| computes back projection for the set of images
void | calcBackProject (const Mat *images, int nimages, const int *channels, const SparseMat &hist, Mat &backProject, const float **ranges, double scale=1, bool uniform=true)
| computes back projection for the set of images
CV_EXPORTS_W void | calcCovarMatrix (const Mat &samples, CV_OUT Mat &covar, CV_OUT Mat &mean, int flags, int ctype=CV_64F)
| computes covariation matrix of a set of samples
void | calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=CV_64F)
| computes covariation matrix of a set of samples
CV_EXPORTS_W double | calcGlobalOrientation (const Mat &orientation, const Mat &mask, const Mat &mhi, double timestamp, double duration)
| computes the global orientation of the selected motion history image part
void | calcHist (const Mat *images, int nimages, const int *channels, const Mat &mask, SparseMat &hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false)
| computes the joint sparse histogram for a set of images.
void | calcHist (const Mat *images, int nimages, const int *channels, const Mat &mask, Mat &hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false)
| computes the joint dense histogram for a set of images.
CV_EXPORTS_W void | calcMotionGradient (const Mat &mhi, CV_OUT Mat &mask, CV_OUT Mat &orientation, double delta1, double delta2, int apertureSize=3)
| computes the motion gradient orientation image from the motion history image
CV_EXPORTS_W void | calcOpticalFlowFarneback (const Mat &prev, const Mat &next, CV_OUT Mat &flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags)
| computes dense optical flow using Farneback algorithm
CV_EXPORTS_W void | calcOpticalFlowPyrLK (const Mat &prevImg, const Mat &nextImg, const vector< Point2f > &prevPts, CV_OUT vector< Point2f > &nextPts, CV_OUT vector< uchar > &status, CV_OUT vector< float > &err, Size winSize=Size(15, 15), int maxLevel=3, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), double derivLambda=0.5, int flags=0)
| computes sparse optical flow using multi-scale Lucas-Kanade algorithm
CV_EXPORTS_W double | calibrateCamera (const vector< vector< Point3f > > &objectPoints, const vector< vector< Point2f > > &imagePoints, Size imageSize, CV_IN_OUT Mat &cameraMatrix, CV_IN_OUT Mat &distCoeffs, CV_OUT vector< Mat > &rvecs, CV_OUT vector< Mat > &tvecs, int flags=0)
| finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
CV_EXPORTS_W void | calibrationMatrixValues (const Mat &cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, CV_OUT double &fovx, CV_OUT double &fovy, CV_OUT double &focalLength, CV_OUT Point2d &principalPoint, CV_OUT double &aspectRatio)
| computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.
CV_EXPORTS_W RotatedRect | CamShift (const Mat &probImage, CV_IN_OUT Rect &window, TermCriteria criteria)
| updates the object tracking window using CAMSHIFT algorithm
CV_EXPORTS_W void | cartToPolar (const Mat &x, const Mat &y, CV_OUT Mat &magnitude, CV_OUT Mat &angle, bool angleInDegrees=false)
| converts Cartesian coordinates to polar
int | chamerMatching (Mat &img, Mat &templ, vector< vector< Point > > &results, vector< float > &cost, double templScale=1, int maxMatches=20, double minMatchDistance=1.0, int padX=3, int padY=3, int scales=5, double minScale=0.6, double maxScale=1.6, double orientationWeight=0.5, double truncate=20)
CV_EXPORTS_W bool | checkHardwareSupport (int feature)
CV_EXPORTS_W bool | checkRange (const Mat &a, bool quiet=true, CV_OUT Point *pt=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
| checks that each matrix element is within the specified range.
bool | Cholesky (float *A, int m, float *b, int n)
bool | Cholesky (double *A, int m, double *b, int n)
CV_EXPORTS_W void | circle (Mat &img, Point center, int radius, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
| draws the circle outline or a solid circle in the image
void | clearSeq (CvSeq *seq)
bool | clipLine (Size imgSize, CV_IN_OUT Point &pt1, CV_IN_OUT Point &pt2)
| clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
CV_EXPORTS_W bool | clipLine (Rect imgRect, CV_IN_OUT Point &pt1, CV_IN_OUT Point &pt2)
| clips the line segment by the rectangle imgRect
CV_EXPORTS_W void | compare (const Mat &src1, double s, CV_OUT Mat &dst, int cmpop)
| compares elements of array with scalar (dst = src1 <cmpop> src2)
CV_EXPORTS_W void | compare (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, int cmpop)
| compares elements of two arrays (dst = src1 <cmpop> src2)
CV_EXPORTS_W double | compareHist (const Mat &H1, const Mat &H2, int method)
| compares two histograms stored in dense arrays
double | compareHist (const SparseMat &H1, const SparseMat &H2, int method)
| compares two histograms stored in sparse arrays
CV_EXPORTS_W void | completeSymm (Mat &mtx, bool lowerToUpper=false)
| extends the symmetrical matrix from the lower half or from the upper half
CV_EXPORTS_W void | composeRT (const Mat &rvec1, const Mat &tvec1, const Mat &rvec2, const Mat &tvec2, CV_OUT Mat &rvec3, CV_OUT Mat &tvec3)
| composes 2 [R|t] transformations together
void | computeCorrespondEpilines (const Mat &points1, int whichImage, const Mat &F, CV_OUT vector< Vec3f > &lines)
| finds coordinates of epipolar lines corresponding the specified points
void | computeRecallPrecisionCurve (const vector< vector< DMatch > > &matches1to2, const vector< vector< uchar > > &correctMatches1to2Mask, vector< Point2f > &recallPrecisionCurve)
CV_EXPORTS_W double | contourArea (const Mat &contour, bool oriented=false)
| computes the contour area
CV_EXPORTS_W void | convertMaps (const Mat &map1, const Mat &map2, CV_OUT Mat &dstmap1, CV_OUT Mat &dstmap2, int dstmap1type, bool nninterpolation=false)
| converts maps for remap from floating-point to fixed-point format or backwards
void | convertPointsHomogeneous (const Mat &src, CV_OUT vector< Point3f > &dst)
| converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
void | convertPointsHomogeneous (const Mat &src, CV_OUT vector< Point2f > &dst)
| converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
CV_EXPORTS_W void | convertScaleAbs (const Mat &src, CV_OUT Mat &dst, double alpha=1, double beta=0)
| scales array elements, computes absolute values and converts the results to 8-bit unsigned integers: dst(i)=saturate_cast<uchar>abs(src(i)*alpha+beta)
void | convexHull (const Mat &points, CV_OUT vector< int > &hull, bool clockwise=false)
| computes convex hull for a set of 2D points.
void | convexHull (const Mat &points, CV_OUT vector< Point > &hull, bool clockwise=false)
| computes convex hull for a set of 2D points.
CV_EXPORTS_W void | copyMakeBorder (const Mat &src, CV_OUT Mat &dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar())
| copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode
CV_EXPORTS_W void | cornerEigenValsAndVecs (const Mat &src, CV_OUT Mat &dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT)
| computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix.
CV_EXPORTS_W void | cornerHarris (const Mat &src, CV_OUT Mat &dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT)
| computes Harris cornerness criteria at each image pixel
CV_EXPORTS_W void | cornerMinEigenVal (const Mat &src, CV_OUT Mat &dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT)
| computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
void | cornerSubPix (const Mat &image, vector< Point2f > &corners, Size winSize, Size zeroZone, TermCriteria criteria)
| adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria
CV_EXPORTS_W int | countNonZero (const Mat &src)
| computes the number of nonzero array elements
Ptr< FilterEngine > | createBoxFilter (int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
| returns box filter engine
int | createButton (const string &bar_name, ButtonCallback on_change, void *userdata CV_DEFAULT(NULL), int type CV_DEFAULT(CV_PUSH_BUTTON), bool initial_button_state CV_DEFAULT(0))
Ptr< FilterEngine > | createDerivFilter (int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT)
| returns filter engine for the generalized Sobel operator
Ptr< FilterEngine > | createGaussianFilter (int type, Size ksize, double sigma1, double sigma2=0, int borderType=BORDER_DEFAULT)
| returns the Gaussian filter engine
Ptr< FilterEngine > | createLinearFilter (int srcType, int dstType, const Mat &kernel, Point _anchor=Point(-1,-1), double delta=0, int _rowBorderType=BORDER_DEFAULT, int _columnBorderType=-1, const Scalar &_borderValue=Scalar())
| returns the non-separable linear filter engine
Ptr< FilterEngine > | createMorphologyFilter (int op, int type, const Mat &kernel, Point anchor=Point(-1,-1), int _rowBorderType=BORDER_CONSTANT, int _columnBorderType=-1, const Scalar &_borderValue=morphologyDefaultBorderValue())
| returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
void | createOpenGLCallback (const string &winname, CvOpenGLCallback callbackOpenGL, void *userdata CV_DEFAULT(0))
Ptr< FilterEngine > | createSeparableLinearFilter (int srcType, int dstType, const Mat &rowKernel, const Mat &columnKernel, Point _anchor=Point(-1,-1), double delta=0, int _rowBorderType=BORDER_DEFAULT, int _columnBorderType=-1, const Scalar &_borderValue=Scalar())
| returns the separable linear filter engine
int | createTrackbar (const string &trackbarname, const string &winname, int *value, int count, TrackbarCallback onChange CV_DEFAULT(0), void *userdata CV_DEFAULT(0))
CV_EXPORTS_W float | cubeRoot (float val)
| computes cube root of the argument
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst)
template<typename _Tp >
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst)
template<typename _Tp >
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst)
template<typename _Tp >
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst)
| CV_EXPORTS_AS (gaussianBlur) void GaussianBlur(const Mat &src
| smooths the image using Gaussian filter.
| CV_EXPORTS_AS (sobel) void Sobel(const Mat &src
| applies generalized Sobel operator to the image
| CV_EXPORTS_AS (scharr) void Scharr(const Mat &src
| applies the vertical or horizontal Scharr operator to the image
| CV_EXPORTS_AS (laplacian) void Laplacian(const Mat &src
| applies Laplacian operator to the image
| CV_EXPORTS_AS (canny) void Canny(const Mat &image
| applies Canny edge detector and produces the edge map.
| CV_EXPORTS_AS (houghLines) void HoughLines(const Mat &image
| finds lines in the black-n-white image using the standard or pyramid Hough transform
| CV_EXPORTS_AS (houghLinesP) void HoughLinesP(Mat &image
| finds line segments in the black-n-white image using probabalistic Hough transform
| CV_EXPORTS_AS (houghCircles) void HoughCircles(const Mat &image
| finds circles in the grayscale image using 2+1 gradient Hough transform
| CV_EXPORTS_AS (integral2) void integral(const Mat &src
| computes the integral image and integral for the squared image
| CV_EXPORTS_AS (integral3) void integral(const Mat &src
| computes the integral image, integral for the squared image and the tilted integral image
| CV_EXPORTS_AS (floodFillMask) int floodFill(Mat &image
| fills the semi-uniform image region and/or the mask starting from the specified seed point
| CV_EXPORTS_AS (RodriguesJ) void Rodrigues(const Mat &src
| converts rotation vector to rotation matrix or vice versa using Rodrigues transformation. Also computes the Jacobian matrix
| CV_EXPORTS_AS (findHomographyAndOutliers) Mat findHomography(const Mat &srcPoints
| computes the best-fit perspective transformation mapping srcPoints to dstPoints.
| CV_EXPORTS_AS (composeRT_J) void composeRT(const Mat &rvec1
| composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments
| CV_EXPORTS_AS (projectPointsJ) void projectPoints(const Mat &objectPoints
| projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters
Mat | cvarrToMat (const CvArr *arr, bool copyData=false, bool allowND=true, int coiMode=0)
| converts array (CvMat or IplImage) to cv::Mat
CV_EXPORTS_W void | cvtColor (const Mat &src, CV_OUT Mat &dst, int code, int dstCn=0)
| converts image from one color space to another
CV_EXPORTS_W void | dct (const Mat &src, CV_OUT Mat &dst, int flags=0)
| performs forward or inverse 1D or 2D Discrete Cosine Transformation
void | decomposeProjectionMatrix (const Mat &projMatrix, Mat &cameraMatrix, Mat &rotMatrix, Mat &transVect)
| Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector.
CV_EXPORTS_W void | decomposeProjectionMatrix (const Mat &projMatrix, CV_OUT Mat &cameraMatrix, CV_OUT Mat &rotMatrix, CV_OUT Mat &transVect, CV_OUT Mat &rotMatrixX, CV_OUT Mat &rotMatrixY, CV_OUT Mat &rotMatrixZ, CV_OUT Vec3d &eulerAngles)
| Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector. The rotation matrix is further decomposed.
CV_EXPORTS_W void | destroyWindow (const string &winname)
CV_EXPORTS_W double | determinant (const Mat &mtx)
| computes determinant of a square matrix
CV_EXPORTS_W void | dft (const Mat &src, CV_OUT Mat &dst, int flags=0, int nonzeroRows=0)
| performs forward or inverse 1D or 2D Discrete Fourier Transformation
CV_EXPORTS_W void | dilate (const Mat &src, CV_OUT Mat &dst, const Mat &kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
| dilates the image (applies the local maximum operator)
void | displayOverlay (const string &winname, const string &text, int delayms)
void | displayStatusBar (const string &winname, const string &text, int delayms)
void | distanceTransform (const Mat &src, CV_OUT Mat &dst, Mat &labels, int distanceType, int maskSize)
| builds the discrete Voronoi diagram
CV_EXPORTS_W void | distanceTransform (const Mat &src, CV_OUT Mat &dst, int distanceType, int maskSize)
| computes the distance transform map
CV_EXPORTS_W void | divide (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, double scale=1)
| computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2)
CV_EXPORTS_W void | divide (double scale, const Mat &src2, CV_OUT Mat &dst)
| computes element-wise weighted reciprocal of an array (dst = scale/src2)
template<typename _Tp >
DataType< _Tp >::work_type | dot (const Vector< _Tp > &v1, const Vector< _Tp > &v2)
CV_EXPORTS_W void | drawChessboardCorners (Mat &image, Size patternSize, const Mat &corners, bool patternWasFound)
| draws the checkerboard pattern (found or partly found) in the image
void | drawChessboardCorners (Mat &image, Size patternSize, const vector< Point2f > &corners, bool patternWasFound)
void | drawContours (Mat &image, const vector< vector< Point > > &contours, int contourIdx, const Scalar &color, int thickness=1, int lineType=8, const vector< Vec4i > &hierarchy=vector< Vec4i >(), int maxLevel=INT_MAX, Point offset=Point())
| draws contours in the image
void | drawKeypoints (const Mat &image, const vector< KeyPoint > &keypoints, Mat &outImg, const Scalar &color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT)
void | drawMatches (const Mat &img1, const vector< KeyPoint > &keypoints1, const Mat &img2, const vector< KeyPoint > &keypoints2, const vector< vector< DMatch > > &matches1to2, Mat &outImg, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const vector< vector< char > > &matchesMask=vector< vector< char > >(), int flags=DrawMatchesFlags::DEFAULT)
void | drawMatches (const Mat &img1, const vector< KeyPoint > &keypoints1, const Mat &img2, const vector< KeyPoint > &keypoints2, const vector< DMatch > &matches1to2, Mat &outImg, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const vector< char > &matchesMask=vector< char >(), int flags=DrawMatchesFlags::DEFAULT)
bool | eigen (const Mat &src, CV_OUT Mat &eigenvalues, int lowindex=-1, int highindex=-1)
| finds eigenvalues of a symmetric matrix
bool | eigen (const Mat &src, CV_OUT Mat &eigenvalues, CV_OUT Mat &eigenvectors, int lowindex=-1, int highindex=-1)
| finds eigenvalues and eigenvectors of a symmetric matrix
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
void | eigen2cv (const Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &src, Mat &dst)
CV_EXPORTS_W void | ellipse (Mat &img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
| draws an elliptic arc, ellipse sector or a rotated ellipse in the image
CV_EXPORTS_W void | ellipse (Mat &img, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=8)
| draws a rotated ellipse in the image
CV_EXPORTS_W void | ellipse2Poly (Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, CV_OUT vector< Point > &pts)
| converts elliptic arc to a polygonal curve
CV_EXPORTS_W void | equalizeHist (const Mat &src, CV_OUT Mat &dst)
| normalizes the grayscale image brightness and contrast by normalizing its histogram
CV_EXPORTS_W void | erode (const Mat &src, CV_OUT Mat &dst, const Mat &kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
| erodes the image (applies the local minimum operator)
void | error (const Exception &exc)
| Signals an error and raises the exception.
int | estimateAffine3D (const Mat &from, const Mat &to, CV_OUT Mat &dst, CV_OUT vector< uchar > &outliers, double param1=3.0, double param2=0.99)
| computes the best-fit affine transformation that maps one 3D point set to another (RANSAC algorithm is used)
CV_EXPORTS_W Mat | estimateRigidTransform (const Mat &A, const Mat &B, bool fullAffine)
| estimates the best-fit affine transformation that maps one 2D point set to another or one image to another.
void | evaluateFeatureDetector (const Mat &img1, const Mat &img2, const Mat &H1to2, vector< KeyPoint > *keypoints1, vector< KeyPoint > *keypoints2, float &repeatability, int &correspCount, const Ptr< FeatureDetector > &fdetector=Ptr< FeatureDetector >())
void | evaluateGenericDescriptorMatcher (const Mat &img1, const Mat &img2, const Mat &H1to2, vector< KeyPoint > &keypoints1, vector< KeyPoint > &keypoints2, vector< vector< DMatch > > *matches1to2, vector< vector< uchar > > *correctMatches1to2Mask, vector< Point2f > &recallPrecisionCurve, const Ptr< GenericDescriptorMatcher > &dmatch=Ptr< GenericDescriptorMatcher >())
CV_EXPORTS_W void | exp (const Mat &src, CV_OUT Mat &dst)
| computes exponent of each matrix element (dst = e**src)
void | extractImageCOI (const CvArr *arr, CV_OUT Mat &coiimg, int coi=-1)
| extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
void | FAST (const Mat &image, CV_OUT vector< KeyPoint > &keypoints, int threshold, bool nonmaxSupression=true)
| detects corners using FAST algorithm by E. Rosten
CV_EXPORTS_W float | fastAtan2 (float y, float x)
| computes the angle in degrees (0..360) of the vector (x,y)
void | fastFree (void *ptr)
void * | fastMalloc (size_t bufSize)
void | fillConvexPoly (Mat &img, const Point *pts, int npts, const Scalar &color, int lineType=8, int shift=0)
| draws a filled convex polygon in the image
void | fillPoly (Mat &img, const Point **pts, const int *npts, int ncontours, const Scalar &color, int lineType=8, int shift=0, Point offset=Point())
| fills an area bounded by one or more polygons
CV_EXPORTS_W void | filter2D (const Mat &src, CV_OUT Mat &dst, int ddepth, const Mat &kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)
| applies non-separable 2D linear filter to the image
CV_EXPORTS_W void | filterSpeckles (Mat &img, double newVal, int maxSpeckleSize, double maxDiff, Mat &buf)
| filters off speckles (small regions of incorrectly computed disparity)
bool | find4QuadCornerSubpix (const Mat &img, std::vector< Point2f > &corners, Size region_size)
CV_EXPORTS_W bool | findChessboardCorners (const Mat &image, Size patternSize, CV_OUT vector< Point2f > &corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE)
| finds checkerboard pattern of the specified size in the image
void | findContours (Mat &image, CV_OUT vector< vector< Point > > &contours, int mode, int method, Point offset=Point())
| retrieves contours from black-n-white image.
void | findContours (Mat &image, CV_OUT vector< vector< Point > > &contours, vector< Vec4i > &hierarchy, int mode, int method, Point offset=Point())
| retrieves contours and the hierarchical information from black-n-white image.
Mat | findFundamentalMat (const Mat &points1, const Mat &points2, CV_OUT vector< uchar > &mask, int method=FM_RANSAC, double param1=3., double param2=0.99)
| finds fundamental matrix from a set of corresponding 2D points
CV_EXPORTS_W Mat | findFundamentalMat (const Mat &points1, const Mat &points2, int method=FM_RANSAC, double param1=3., double param2=0.99)
| finds fundamental matrix from a set of corresponding 2D points
CV_EXPORTS_W Mat | findHomography (const Mat &srcPoints, const Mat &dstPoints, int method=0, double ransacReprojThreshold=3)
| computes the best-fit perspective transformation mapping srcPoints to dstPoints.
CV_EXPORTS_W RotatedRect | fitEllipse (const Mat &points)
| fits ellipse to the set of 2D points
void | fitLine (const Mat &points, CV_OUT Vec4f &line, int distType, double param, double reps, double aeps)
| fits line to the set of 2D points using M-estimator algorithm
CV_EXPORTS_W void | flip (const Mat &src, CV_OUT Mat &dst, int flipCode)
| reverses the order of the rows, columns or both in a matrix
CV_EXPORTS_W int | floodFill (Mat &image, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)
| fills the semi-uniform image region starting from the specified seed point
CvFont | fontQt (const string &nameFont, int pointSize CV_DEFAULT(-1), Scalar color CV_DEFAULT(Scalar::all(0)), int weight CV_DEFAULT(CV_FONT_NORMAL), int style CV_DEFAULT(CV_STYLE_NORMAL), int spacing CV_DEFAULT(0))
string | format (const char *fmt,...)
string | fromUtf16 (const WString &str)
CV_EXPORTS_W void | gemm (const Mat &src1, const Mat &src2, double alpha, const Mat &src3, double gamma, CV_OUT Mat &dst, int flags=0)
| implements generalized matrix product algorithm GEMM from BLAS
Mat | getAffineTransform (const Point2f src[], const Point2f dst[])
| returns 2x3 affine transformation for the corresponding 3 point pairs.
Ptr< BaseColumnFilter > | getColumnSumFilter (int sumType, int dstType, int ksize, int anchor=-1, double scale=1)
| returns vertical 1D box filter
ConvertData | getConvertElem (int fromType, int toType)
| returns the function for converting pixels from one data type to another
ConvertScaleData | getConvertScaleElem (int fromType, int toType)
| returns the function for converting pixels from one data type to another with the optional scaling
int64 | getCPUTickCount ()
uchar * | getData (IplImage *image)
CV_EXPORTS_W Mat | getDefaultNewCameraMatrix (const Mat &cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false)
| returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)
CV_EXPORTS_W void | getDerivKernels (CV_OUT Mat &kx, CV_OUT Mat &ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F)
| initializes kernels of the generalized Sobel operator
CV_EXPORTS_W Mat | getGaussianKernel (int ksize, double sigma, int ktype=CV_64F)
| returns the Gaussian kernel with the specified parameters
int | getKernelType (const Mat &kernel, Point anchor)
| returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients.
Ptr< BaseColumnFilter > | getLinearColumnFilter (int bufType, int dstType, const Mat &kernel, int anchor, int symmetryType, double delta=0, int bits=0)
| returns the primitive column filter with the specified kernel
Ptr< BaseFilter > | getLinearFilter (int srcType, int dstType, const Mat &kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0)
| returns 2D filter with the specified kernel
Ptr< BaseRowFilter > | getLinearRowFilter (int srcType, int bufType, const Mat &kernel, int anchor, int symmetryType)
| returns the primitive row filter with the specified kernel
Ptr< BaseColumnFilter > | getMorphologyColumnFilter (int op, int type, int ksize, int anchor=-1)
| returns vertical 1D morphological filter
Ptr< BaseFilter > | getMorphologyFilter (int op, int type, const Mat &kernel, Point anchor=Point(-1,-1))
| returns 2D morphological filter
Ptr< BaseRowFilter > | getMorphologyRowFilter (int op, int type, int ksize, int anchor=-1)
| returns horizontal 1D morphological filter
int | getNumThreads ()
CV_EXPORTS_W int | getOptimalDFTSize (int vecsize)
| computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently
CV_EXPORTS_W Mat | getOptimalNewCameraMatrix (const Mat &cameraMatrix, const Mat &distCoeffs, Size imageSize, double alpha, Size newImgSize=Size(), CV_OUT Rect *validPixROI=0)
| returns the optimal new camera matrix
Mat | getPerspectiveTransform (const Point2f src[], const Point2f dst[])
| returns 3x3 perspective transformation for the corresponding 4 point pairs.
float | getRecall (const vector< Point2f > &recallPrecisionCurve, float l_precision)
CV_EXPORTS_W void | getRectSubPix (const Mat &image, Size patchSize, Point2f center, CV_OUT Mat &patch, int patchType=-1)
| extracts rectangle from the image at sub-pixel location
CV_EXPORTS_W Mat | getRotationMatrix2D (Point2f center, double angle, double scale)
| returns 2x3 affine transformation matrix for the planar rotation.
Ptr< BaseRowFilter > | getRowSumFilter (int srcType, int sumType, int ksize, int anchor=-1)
| returns horizontal 1D box filter
schar * | getSeqElem (const CvSeq *seq, int index)
CV_EXPORTS_W Mat | getStructuringElement (int shape, Size ksize, Point anchor=Point(-1,-1))
| returns structuring element of the specified shape and size
CV_EXPORTS_W Size | getTextSize (const string &text, int fontFace, double fontScale, int thickness, CV_OUT int *baseLine)
| returns bounding box of the text string
int | getThreadNum ()
int64 | getTickCount ()
| Returns the number of ticks.
CV_EXPORTS_W double | getTickFrequency ()
CV_EXPORTS_W int | getTrackbarPos (const string &trackbarname, const string &winname)
CV_EXPORTS_W Rect | getValidDisparityROI (Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)
| computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())
CV_EXPORTS_W double | getWindowProperty (const string &winname, int prop_id)
CV_EXPORTS_W void | goodFeaturesToTrack (const Mat &image, CV_OUT vector< Point2f > &corners, int maxCorners, double qualityLevel, double minDistance, const Mat &mask=Mat(), int blockSize=3, bool useHarrisDetector=false, double k=0.04)
| finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima
CV_EXPORTS_W void | grabCut (const Mat &img, Mat &mask, Rect rect, Mat &bgdModel, Mat &fgdModel, int iterCount, int mode=GC_EVAL)
| segments the image using GrabCut algorithm
CV_EXPORTS_W void | groupRectangles (vector< Rect > &rectList, CV_OUT vector< int > &weights, int groupThreshold, double eps=0.2)
CV_EXPORTS_W void | groupRectangles (vector< Rect > &rectList, int groupThreshold, double eps=0.2)
void | hconcat (const Mat *src, size_t nsrc, Mat &dst)
void | hconcat (const Mat &src1, const Mat &src2, Mat &dst)
CV_EXPORTS_W void | hconcat (const vector< Mat > &src, CV_OUT Mat &dst)
void | HuMoments (const Moments &moments, double hu[7])
| computes 7 Hu invariants from the moments
CV_EXPORTS_W void | idct (const Mat &src, CV_OUT Mat &dst, int flags=0)
| performs inverse 1D or 2D Discrete Cosine Transformation
CV_EXPORTS_W void | idft (const Mat &src, CV_OUT Mat &dst, int flags=0, int nonzeroRows=0)
| performs inverse 1D or 2D Discrete Fourier Transformation
CV_EXPORTS_W Mat | imdecode (const Mat &buf, int flags)
CV_EXPORTS_W bool | imencode (const string &ext, const Mat &img, CV_OUT vector< uchar > &buf, const vector< int > &params=vector< int >())
CV_EXPORTS_W Mat | imread (const string &filename, int flags=1)
CV_EXPORTS_W void | imshow (const string &winname, const Mat &mat)
CV_EXPORTS_W bool | imwrite (const string &filename, const Mat &img, const vector< int > &params=vector< int >())
CV_EXPORTS_W Mat | initCameraMatrix2D (const vector< vector< Point3f > > &objectPoints, const vector< vector< Point2f > > &imagePoints, Size imageSize, double aspectRatio=1.)
| initializes camera matrix from a few 3D points and the corresponding projections.
CV_EXPORTS_W void | initUndistortRectifyMap (const Mat &cameraMatrix, const Mat &distCoeffs, const Mat &R, const Mat &newCameraMatrix, Size size, int m1type, CV_OUT Mat &map1, CV_OUT Mat &map2)
| initializes maps for cv::remap() to correct lens distortion and optionally rectify the image
CV_EXPORTS_W float | initWideAngleProjMap (const Mat &cameraMatrix, const Mat &distCoeffs, Size imageSize, int destImageWidth, int m1type, CV_OUT Mat &map1, CV_OUT Mat &map2, int projType=PROJ_SPHERICAL_EQRECT, double alpha=0)
| initializes maps for cv::remap() for wide-angle
CV_EXPORTS_W void | inpaint (const Mat &src, const Mat &inpaintMask, CV_OUT Mat &dst, double inpaintRange, int flags)
| restores the damaged image areas using one of the available intpainting algorithms
CV_EXPORTS_W void | inRange (const Mat &src, const Mat &lowerb, const Mat &upperb, CV_OUT Mat &dst)
| set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
CV_EXPORTS_W void | inRange (const Mat &src, const Scalar &lowerb, const Scalar &upperb, CV_OUT Mat &dst)
| set mask elements for those array elements which are within the fixed bounding box (dst = lowerb <= src && src < upperb)
void | insertImageCOI (const Mat &coiimg, CvArr *arr, int coi=-1)
| inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
CV_EXPORTS_W void | integral (const Mat &src, CV_OUT Mat &sum, int sdepth=-1)
| computes the integral image
CV_EXPORTS_W double | invert (const Mat &src, CV_OUT Mat &dst, int flags=DECOMP_LU)
| computes inverse or pseudo-inverse matrix
CV_EXPORTS_W void | invertAffineTransform (const Mat &M, CV_OUT Mat &iM)
| computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.
CV_EXPORTS_W bool | isContourConvex (const Mat &contour)
| returns true iff the contour is convex. Does not support contours with self-intersection
CV_EXPORTS_W double | kmeans (const Mat &data, int K, CV_OUT Mat &bestLabels, TermCriteria criteria, int attempts, int flags, CV_OUT Mat *centers=0)
| clusters the input data using k-Means algorithm
CV_EXPORTS_W void | line (Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
| draws the line segment (pt1, pt2) in the image
void | loadWindowParameters (const string &windowName)
CV_EXPORTS_W void | log (const Mat &src, CV_OUT Mat &dst)
| computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
int | LU (float *A, int m, float *b, int n)
int | LU (double *A, int m, double *b, int n)
CV_EXPORTS_W void | LUT (const Mat &src, const Mat &lut, CV_OUT Mat &dst)
| transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
CV_EXPORTS_W void | magnitude (const Mat &x, const Mat &y, CV_OUT Mat &magnitude)
| computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
CV_EXPORTS_W double | Mahalanobis (const Mat &v1, const Mat &v2, const Mat &icovar)
| computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix
double | Mahalonobis (const Mat &v1, const Mat &v2, const Mat &icovar)
| a synonym for Mahalanobis
CV_EXPORTS_W double | matchShapes (const Mat &contour1, const Mat &contour2, int method, double parameter)
| matches two contours using one of the available algorithms
CV_EXPORTS_W void | matchTemplate (const Mat &image, const Mat &templ, CV_OUT Mat &result, int method)
| computes the proximity map for the raster template and the image where the template is searched for
CV_EXPORTS_W void | matMulDeriv (const Mat &A, const Mat &B, CV_OUT Mat &dABdA, CV_OUT Mat &dABdB)
| computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients
CV_EXPORTS_W void | max (const Mat &src1, const Mat &src2, CV_OUT Mat &dst)
| computes per-element maximum of two arrays (dst = max(src1, src2))
CV_EXPORTS_W void | max (const Mat &src1, double src2, CV_OUT Mat &dst)
| computes per-element maximum of array and scalar (dst = max(src1, src2))
MatExpr | max (const Mat &a, const Mat &b)
MatExpr | max (const Mat &a, double s)
MatExpr | max (double s, const Mat &a)
Scalar | mean (const Mat &src)
| computes mean value of array elements
CV_EXPORTS_W Scalar | mean (const Mat &src, const Mat &mask CV_WRAP_DEFAULT(Mat()))
| computes mean value of selected array elements
CV_EXPORTS_W int | meanShift (const Mat &probImage, CV_IN_OUT Rect &window, TermCriteria criteria)
| updates the object tracking window using meanshift algorithm
CV_EXPORTS_W void | meanStdDev (const Mat &src, CV_OUT Scalar &mean, CV_OUT Scalar &stddev, const Mat &mask=Mat())
| computes mean value and standard deviation of all or selected array elements
CV_EXPORTS_W void | medianBlur (const Mat &src, CV_OUT Mat &dst, int ksize)
| smooths the image using median filter.
void | merge (const Mat *mv, size_t count, CV_OUT Mat &dst)
| makes multi-channel array out of several single-channel arrays
CV_EXPORTS_W void | merge (const vector< Mat > &mv, Mat &dst)
| makes multi-channel array out of several single-channel arrays
CV_EXPORTS_W void | min (const Mat &src1, const Mat &src2, CV_OUT Mat &dst)
| computes per-element minimum of two arrays (dst = min(src1, src2))
CV_EXPORTS_W void | min (const Mat &src1, double src2, CV_OUT Mat &dst)
| computes per-element minimum of array and scalar (dst = min(src1, src2))
MatExpr | min (const Mat &a, const Mat &b)
MatExpr | min (const Mat &a, double s)
MatExpr | min (double s, const Mat &a)
CV_EXPORTS_W RotatedRect | minAreaRect (const Mat &points)
| computes the minimal rotated rectangle for a set of points
CV_EXPORTS_W void | minEnclosingCircle (const Mat &points, Point2f &center, float &radius)
| computes the minimal enclosing circle for a set of points
void | minMaxIdx (const Mat &src, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0, const Mat &mask=Mat())
void | minMaxLoc (const SparseMat &a, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0)
| finds global minimum and maximum sparse array elements and returns their values and their locations
CV_EXPORTS_W void | minMaxLoc (const Mat &src, CV_OUT double *minVal, CV_OUT double *maxVal=0, CV_OUT Point *minLoc=0, CV_OUT Point *maxLoc=0, const Mat &mask=Mat())
| finds global minimum and maximum array elements and returns their values and their locations
void | mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs)
| copies selected channels from the input arrays to the selected channels of the output arrays
void | mixChannels (const vector< Mat > &src, vector< Mat > &dst, const int *fromTo, int npairs)
CV_EXPORTS_W Moments | moments (const Mat &array, bool binaryImage=false)
| computes moments of the rasterized shape or a vector of points
CV_EXPORTS_W void | morphologyEx (const Mat &src, CV_OUT Mat &dst, int op, const Mat &kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
| applies an advanced morphological operation to the image
CV_EXPORTS_W void | mulSpectrums (const Mat &a, const Mat &b, CV_OUT Mat &c, int flags, bool conjB=false)
| computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication
CV_EXPORTS_W void | multiply (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, double scale=1)
| computes element-wise weighted product of the two arrays (dst = scale*src1*src2)
CV_EXPORTS_W void | mulTransposed (const Mat &src, CV_OUT Mat &dst, bool aTa, const Mat &delta=Mat(), double scale=1, int rtype=-1)
| multiplies matrix by its transposition from the left or from the right
CV_EXPORTS_W void | namedWindow (const string &winname, int flags CV_DEFAULT(WINDOW_AUTOSIZE))
double | norm (const SparseMat &src, int normType)
| computes norm of a sparse matrix
double | norm (const Mat &src1, int normType=NORM_L2)
| computes norm of array
double | norm (const Mat &src1, const Mat &src2, int normType=NORM_L2)
| computes norm of the difference between two arrays
CV_EXPORTS_W double | norm (const Mat &src1, int normType, const Mat &mask CV_WRAP_DEFAULT(Mat()))
| computes norm of the selected array part
CV_EXPORTS_W double | norm (const Mat &src1, const Mat &src2, int normType, const Mat &mask CV_WRAP_DEFAULT(Mat()))
| computes norm of selected part of the difference between two arrays
void | normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType)
| scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
CV_EXPORTS_W void | normalize (const Mat &src, CV_OUT Mat &dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int rtype=-1, const Mat &mask=Mat())
| scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
template<typename _Tp >
bool | operator!= (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b)
MatExpr | operator!= (const Mat &a, const Mat &b)
MatExpr | operator!= (const Mat &a, double s)
MatExpr | operator!= (double s, const Mat &a)
MatExpr | operator& (const Mat &a, const Mat &b)
MatExpr | operator& (const Mat &a, const Scalar &s)
MatExpr | operator& (const Scalar &s, const Mat &a)
MatExpr | operator* (const Mat &m, const MatExpr &e)
MatExpr | operator* (double s, const MatExpr &e)
MatExpr | operator* (const Mat &a, const Mat &b)
MatExpr | operator* (const MatExpr &e, const Mat &m)
MatExpr | operator* (const Mat &a, double s)
MatExpr | operator* (const MatExpr &e, double s)
MatExpr | operator* (const MatExpr &e1, const MatExpr &e2)
MatExpr | operator* (double s, const Mat &a)
MatExpr | operator+ (const Mat &m, const MatExpr &e)
MatExpr | operator+ (const Mat &a, const Mat &b)
MatExpr | operator+ (const Mat &a, const Scalar &s)
MatExpr | operator+ (const Scalar &s, const Mat &a)
MatExpr | operator+ (const MatExpr &e, const Mat &m)
MatExpr | operator+ (const MatExpr &e, const Scalar &s)
MatExpr | operator+ (const Scalar &s, const MatExpr &e)
MatExpr | operator+ (const MatExpr &e1, const MatExpr &e2)
template<typename _Tp >
ptrdiff_t | operator- (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b)
MatExpr | operator- (const Mat &m)
ptrdiff_t | operator- (const MatConstIterator &b, const MatConstIterator &a)
MatExpr | operator- (const MatExpr &e1, const MatExpr &e2)
MatExpr | operator- (const Mat &m, const MatExpr &e)
MatExpr | operator- (const Mat &a, const Scalar &s)
MatExpr | operator- (const Scalar &s, const Mat &a)
MatExpr | operator- (const MatExpr &e, const Mat &m)
MatExpr | operator- (const MatExpr &e, const Scalar &s)
MatExpr | operator- (const Scalar &s, const MatExpr &e)
MatExpr | operator- (const Mat &a, const Mat &b)
MatExpr | operator- (const MatExpr &e)
MatExpr | operator/ (const Mat &a, double s)
MatExpr | operator/ (const MatExpr &e, const Mat &m)
MatExpr | operator/ (const Mat &m, const MatExpr &e)
MatExpr | operator/ (const MatExpr &e, double s)
MatExpr | operator/ (const MatExpr &e1, const MatExpr &e2)
MatExpr | operator/ (const Mat &a, const Mat &b)
MatExpr | operator/ (double s, const MatExpr &e)
MatExpr | operator/ (double s, const Mat &a)
MatExpr | operator< (double s, const Mat &a)
MatExpr | operator< (const Mat &a, double s)
MatExpr | operator< (const Mat &a, const Mat &b)
template<typename _Tp >
std::ostream & | operator<< (std::ostream &out, const Point3_< _Tp > &p)
FileStorage & | operator<< (FileStorage &fs, const string &str)
template<typename _Tp >
std::ostream & | operator<< (std::ostream &out, const Point_< _Tp > &p)
std::ostream & | operator<< (std::ostream &out, const TickMeter &tm)
MatExpr | operator<= (const Mat &a, double s)
MatExpr | operator<= (double s, const Mat &a)
MatExpr | operator<= (const Mat &a, const Mat &b)
template<typename _Tp >
bool | operator== (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b)
MatExpr | operator== (const Mat &a, const Mat &b)
MatExpr | operator== (const Mat &a, double s)
MatExpr | operator== (double s, const Mat &a)
MatExpr | operator> (double s, const Mat &a)
MatExpr | operator> (const Mat &a, const Mat &b)
MatExpr | operator> (const Mat &a, double s)
MatExpr | operator>= (const Mat &a, const Mat &b)
MatExpr | operator>= (const Mat &a, double s)
MatExpr | operator>= (double s, const Mat &a)
MatExpr | operator^ (const Mat &a, const Scalar &s)
MatExpr | operator^ (const Mat &a, const Mat &b)
MatExpr | operator^ (const Scalar &s, const Mat &a)
MatExpr | operator| (const Scalar &s, const Mat &a)
MatExpr | operator| (const Mat &a, const Scalar &s)
MatExpr | operator| (const Mat &a, const Mat &b)
MatExpr | operator~ (const Mat &m)
template<typename _Tp , class _EqPredicate >
int | partition (const vector< _Tp > &_vec, vector< int > &labels, _EqPredicate predicate=_EqPredicate())
CV_EXPORTS_W void | perspectiveTransform (const Mat &src, CV_OUT Mat &dst, const Mat &m)
| performs perspective transformation of each element of multi-channel input matrix
CV_EXPORTS_W void | phase (const Mat &x, const Mat &y, CV_OUT Mat &angle, bool angleInDegrees=false)
| computes angle (angle(i)) of each (x(i), y(i)) vector
CV_EXPORTS_W double | pointPolygonTest (const Mat &contour, Point2f pt, bool measureDist)
| checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
CV_EXPORTS_W void | polarToCart (const Mat &magnitude, const Mat &angle, CV_OUT Mat &x, CV_OUT Mat &y, bool angleInDegrees=false)
| converts polar coordinates to Cartesian
void | polylines (Mat &img, const Point **pts, const int *npts, int ncontours, bool isClosed, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
| draws one or more polygonal curves
CV_EXPORTS_W void | pow (const Mat &src, double power, CV_OUT Mat &dst)
| raises the input matrix elements to the specified power (b = a**power)
CV_EXPORTS_W void | preCornerDetect (const Mat &src, CV_OUT Mat &dst, int ksize, int borderType=BORDER_DEFAULT)
| computes another complex cornerness criteria at each pixel
template<typename T1 , typename T2 , typename Op >
void | process (const Mat_< T1 > &m1, Mat_< T2 > &m2, Op op)
template<typename T1 , typename T2 , typename T3 , typename Op >
void | process (const Mat_< T1 > &m1, const Mat_< T2 > &m2, Mat_< T3 > &m3, Op op)
CV_EXPORTS_W void | projectPoints (const Mat &objectPoints, const Mat &rvec, const Mat &tvec, const Mat &cameraMatrix, const Mat &distCoeffs, CV_OUT vector< Point2f > &imagePoints)
| projects points from the model coordinate space to the image coordinates. Takes the intrinsic and extrinsic camera parameters into account
CV_EXPORTS_W void | putText (Mat &img, const string &text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int linetype=8, bool bottomLeftOrigin=false)
| renders text string in the image
CV_EXPORTS_W void | pyrDown (const Mat &src, CV_OUT Mat &dst, const Size &dstsize=Size())
| smooths and downsamples the image
CV_EXPORTS_W void | pyrMeanShiftFiltering (const Mat &src, CV_OUT Mat &dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1))
| filters image using meanshift algorithm
CV_EXPORTS_W void | pyrUp (const Mat &src, CV_OUT Mat &dst, const Size &dstsize=Size())
| upsamples and smoothes the image
CV_EXPORTS_W void | randn (CV_OUT Mat &dst, const Scalar &mean, const Scalar &stddev)
| fills array with normally-distributed random numbers with the specified mean and the standard deviation
void | randShuffle (Mat &dst, double iterFactor=1., RNG *rng=0)
| shuffles the input array elements
CV_EXPORTS_W void | randu (CV_OUT Mat &dst, const Scalar &low, const Scalar &high)
| fills array with uniformly-distributed random numbers from the range [low, high)
void | read (const FileNode &node, SparseMat &mat, const SparseMat &default_mat=SparseMat())
CV_EXPORTS_W void | read (const FileNode &node, Mat &mat, const Mat &default_mat=Mat())
void | read (const FileNode &node, CV_OUT vector< KeyPoint > &keypoints)
| reads vector of keypoints from the specified file storage node
void | rectangle (Mat &img, Rect rec, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
| draws the rectangle outline or a solid rectangle covering rec in the image
CV_EXPORTS_W void | rectangle (Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
| draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image
CV_EXPORTS_W float | rectify3Collinear (const Mat &cameraMatrix1, const Mat &distCoeffs1, const Mat &cameraMatrix2, const Mat &distCoeffs2, const Mat &cameraMatrix3, const Mat &distCoeffs3, const vector< vector< Point2f > > &imgpt1, const vector< vector< Point2f > > &imgpt3, Size imageSize, const Mat &R12, const Mat &T12, const Mat &R13, const Mat &T13, CV_OUT Mat &R1, CV_OUT Mat &R2, CV_OUT Mat &R3, CV_OUT Mat &P1, CV_OUT Mat &P2, CV_OUT Mat &P3, CV_OUT Mat &Q, double alpha, Size newImgSize, CV_OUT Rect *roi1, CV_OUT Rect *roi2, int flags)
| computes the rectification transformations for 3-head camera, where all the heads are on the same line.
ErrorCallback | redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0)
| Sets the new error handler and the optional user data.
CV_EXPORTS_W void | reduce (const Mat &src, CV_OUT Mat &dst, int dim, int rtype, int dtype=-1)
| transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows
CV_EXPORTS_W void | remap (const Mat &src, CV_OUT Mat &dst, const Mat &map1, const Mat &map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
| warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format
CV_EXPORTS_W void | repeat (const Mat &src, int ny, int nx, CV_OUT Mat &dst)
| replicates the input matrix the specified number of times in the horizontal and/or vertical direction
Mat | repeat (const Mat &src, int ny, int nx)
CV_EXPORTS_W void | reprojectImageTo3D (const Mat &disparity, CV_OUT Mat &_3dImage, const Mat &Q, bool handleMissingValues=false)
| reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify
CV_EXPORTS_W void | resize (const Mat &src, CV_OUT Mat &dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
| resizes the image
CV_EXPORTS_W void | Rodrigues (const Mat &src, CV_OUT Mat &dst)
| converts rotation vector to rotation matrix or vice versa using Rodrigues transformation
void | RQDecomp3x3 (const Mat &M, Mat &R, Mat &Q)
| Computes RQ decomposition of 3x3 matrix.
CV_EXPORTS_W Vec3d | RQDecomp3x3 (const Mat &M, Mat &R, Mat &Q, CV_OUT Mat &Qx, CV_OUT Mat &Qy, CV_OUT Mat &Qz)
| Computes RQ decomposition of 3x3 matrix. Also, decomposes the output orthogonal matrix into the 3 primitive rotation matrices.
template<>
int | saturate_cast< int > (double v)
template<>
int | saturate_cast< int > (float v)
template<>
schar | saturate_cast< schar > (double v)
template<>
schar | saturate_cast< schar > (int v)
template<>
schar | saturate_cast< schar > (short v)
template<>
schar | saturate_cast< schar > (unsigned v)
template<>
schar | saturate_cast< schar > (float v)
template<>
schar | saturate_cast< schar > (ushort v)
template<>
schar | saturate_cast< schar > (uchar v)
template<>
short | saturate_cast< short > (int v)
template<>
short | saturate_cast< short > (double v)
template<>
short | saturate_cast< short > (ushort v)
template<>
short | saturate_cast< short > (unsigned v)
template<>
short | saturate_cast< short > (float v)
template<>
uchar | saturate_cast< uchar > (schar v)
template<>
uchar | saturate_cast< uchar > (float v)
template<>
uchar | saturate_cast< uchar > (short v)
template<>
uchar | saturate_cast< uchar > (unsigned v)
template<>
uchar | saturate_cast< uchar > (int v)
template<>
uchar | saturate_cast< uchar > (double v)
template<>
uchar | saturate_cast< uchar > (ushort v)
template<>
unsigned | saturate_cast< unsigned > (float v)
template<>
unsigned | saturate_cast< unsigned > (double v)
template<>
ushort | saturate_cast< ushort > (short v)
template<>
ushort | saturate_cast< ushort > (int v)
template<>
ushort | saturate_cast< ushort > (unsigned v)
template<>
ushort | saturate_cast< ushort > (double v)
template<>
ushort | saturate_cast< ushort > (float v)
template<>
ushort | saturate_cast< ushort > (schar v)
void | saveWindowParameters (const string &windowName)
void | scalarToRawData (const Scalar &s, void *buf, int type, int unroll_to=0)
CV_EXPORTS_W void | scaleAdd (const Mat &src1, double alpha, const Mat &src2, CV_OUT Mat &dst)
| adds scaled array to another one (dst = alpha*src1 + src2)
CV_EXPORTS_W void | sepFilter2D (const Mat &src, CV_OUT Mat &dst, int ddepth, const Mat &kernelX, const Mat &kernelY, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)
| applies separable 2D linear filter to the image
void | seqInsertSlice (CvSeq *seq, int before_index, const CvArr *from_arr)
void | seqPop (CvSeq *seq, void *element=0)
void | seqPopFront (CvSeq *seq, void *element=0)
void | seqPopMulti (CvSeq *seq, void *elements, int count, int in_front=0)
schar * | seqPush (CvSeq *seq, const void *element=0)
schar * | seqPushFront (CvSeq *seq, const void *element=0)
void | seqRemove (CvSeq *seq, int index)
void | seqRemoveSlice (CvSeq *seq, CvSlice slice)
bool | setBreakOnError (bool flag)
| Sets/resets the break-on-error mode.
CV_EXPORTS_W void | setIdentity (Mat &mtx, const Scalar &s=Scalar(1))
| initializes scaled identity matrix
void | setMouseCallback (const string &windowName, MouseCallback onMouse, void *param=0)
| assigns callback for mouse events
void | setNumThreads (int nthreads)
CV_EXPORTS_W void | setTrackbarPos (const string &trackbarname, const string &winname, int pos)
CV_EXPORTS_W void | setUseOptimized (bool onoff)
CV_EXPORTS_W void | setWindowProperty (const string &winname, int prop_id, double prop_value)
CV_EXPORTS_W bool | solve (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, int flags=DECOMP_LU)
| solves linear system or a least-square problem
CV_EXPORTS_W int | solveCubic (const Mat &coeffs, CV_OUT Mat &roots)
| finds real roots of a cubic polynomial
CV_EXPORTS_W void | solvePnP (const Mat &objectPoints, const Mat &imagePoints, const Mat &cameraMatrix, const Mat &distCoeffs, CV_OUT Mat &rvec, CV_OUT Mat &tvec, bool useExtrinsicGuess=false)
| computes the camera pose from a few 3D points and the corresponding projections. The outliers are not handled.
CV_EXPORTS_W double | solvePoly (const Mat &coeffs, CV_OUT Mat &roots, int maxIters=300)
| finds real and complex roots of a polynomial
template<typename _Tp , class _LT >
void | sort (vector< _Tp > &vec, _LT LT=_LT())
CV_EXPORTS_W void | sort (const Mat &src, CV_OUT Mat &dst, int flags)
| sorts independently each matrix row or each matrix column
CV_EXPORTS_W void | sortIdx (const Mat &src, CV_OUT Mat &dst, int flags)
| sorts independently each matrix row or each matrix column
CV_EXPORTS_W void | split (const Mat &m, vector< Mat > &mv)
| copies each plane of a multi-channel array to a dedicated array
void | split (const Mat &src, Mat *mvbegin)
| copies each plane of a multi-channel array to a dedicated array
template<typename _Tp >
void | split (const Mat &src, vector< Mat_< _Tp > > &mv)
CV_EXPORTS_W void | sqrt (const Mat &src, CV_OUT Mat &dst)
| computes square root of each matrix element (dst = src**0.5)
int | startLoop (int(*pt2Func)(int argc, char *argv[]), int argc, char *argv[])
CV_EXPORTS_W int | startWindowThread ()
CV_EXPORTS_W double | stereoCalibrate (const vector< vector< Point3f > > &objectPoints, const vector< vector< Point2f > > &imagePoints1, const vector< vector< Point2f > > &imagePoints2, CV_IN_OUT Mat &cameraMatrix1, CV_IN_OUT Mat &distCoeffs1, CV_IN_OUT Mat &cameraMatrix2, CV_IN_OUT Mat &distCoeffs2, Size imageSize, CV_OUT Mat &R, CV_OUT Mat &T, CV_OUT Mat &E, CV_OUT Mat &F, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC)
| finds intrinsic and extrinsic parameters of a stereo camera
CV_EXPORTS_W void | stereoRectify (const Mat &cameraMatrix1, const Mat &distCoeffs1, const Mat &cameraMatrix2, const Mat &distCoeffs2, Size imageSize, const Mat &R, const Mat &T, CV_OUT Mat &R1, CV_OUT Mat &R2, CV_OUT Mat &P1, CV_OUT Mat &P2, CV_OUT Mat &Q, double alpha, Size newImageSize=Size(), CV_OUT Rect *validPixROI1=0, CV_OUT Rect *validPixROI2=0, int flags=CALIB_ZERO_DISPARITY)
| computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
void | stereoRectify (const Mat &cameraMatrix1, const Mat &distCoeffs1, const Mat &cameraMatrix2, const Mat &distCoeffs2, Size imageSize, const Mat &R, const Mat &T, CV_OUT Mat &R1, CV_OUT Mat &R2, CV_OUT Mat &P1, CV_OUT Mat &P2, CV_OUT Mat &Q, int flags=CALIB_ZERO_DISPARITY)
| computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
CV_EXPORTS_W bool | stereoRectifyUncalibrated (const Mat &points1, const Mat &points2, const Mat &F, Size imgSize, CV_OUT Mat &H1, CV_OUT Mat &H2, double threshold=5)
| computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)
void | stopLoop ()
CV_EXPORTS_W void | subtract (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask CV_WRAP_DEFAULT(Mat()))
| subtracts one matrix from another (dst = src1 - src2)
CV_EXPORTS_W void | subtract (const Scalar &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| subtracts matrix from scalar (dst = src1 - src2)
CV_EXPORTS_W void | subtract (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| subtracts scalar from a matrix (dst = src1 - src2)
void | subtract (const Mat &src1, const Mat &src2, CV_OUT Mat &dst)
| subtracts one matrix from another (dst = src1 - src2)
CV_EXPORTS_W Scalar | sum (const Mat &src)
| computes sum of array elements
void | swap (Mat &a, Mat &b)
| swaps two matrices
RNG & | theRNG ()
| returns the thread-local Random number generator
CV_EXPORTS_W double | threshold (const Mat &src, CV_OUT Mat &dst, double thresh, double maxval, int type)
| applies fixed threshold to the image
WString | toUtf16 (const string &str)
CV_EXPORTS_W Scalar | trace (const Mat &mtx)
| computes trace of a matrix
CV_EXPORTS_W void | transform (const Mat &src, CV_OUT Mat &dst, const Mat &m)
| performs affine transformation of each element of multi-channel input matrix
CV_EXPORTS_W void | transpose (const Mat &src, CV_OUT Mat &dst)
| transposes the matrix
CV_EXPORTS_W void | undistort (const Mat &src, CV_OUT Mat &dst, const Mat &cameraMatrix, const Mat &distCoeffs, const Mat &newCameraMatrix=Mat())
| corrects lens distortion for the given camera matrix and distortion coefficients
void | undistortPoints (const Mat &src, CV_OUT vector< Point2f > &dst, const Mat &cameraMatrix, const Mat &distCoeffs, const Mat &R=Mat(), const Mat &P=Mat())
| returns points' coordinates after lens distortion correction
CV_EXPORTS_W void | undistortPoints (const Mat &src, CV_OUT Mat &dst, const Mat &cameraMatrix, const Mat &distCoeffs, const Mat &R=Mat(), const Mat &P=Mat())
| returns points' coordinates after lens distortion correction
CV_EXPORTS_W void | updateMotionHistory (const Mat &silhouette, Mat &mhi, double timestamp, double duration)
| updates motion history image using the current silhouette
CV_EXPORTS_W bool | useOptimized ()
CV_EXPORTS_W void | validateDisparity (Mat &disparity, const Mat &cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp=1)
| validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm
void | vconcat (const Mat *src, size_t nsrc, Mat &dst)
void | vconcat (const Mat &src1, const Mat &src2, Mat &dst)
CV_EXPORTS_W void | vconcat (const vector< Mat > &src, CV_OUT Mat &dst)
CV_EXPORTS_W int | waitKey (int delay=0)
CV_EXPORTS_W void | warpAffine (const Mat &src, CV_OUT Mat &dst, const Mat &M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
| warps the image using affine transformation
CV_EXPORTS_W void | warpPerspective (const Mat &src, CV_OUT Mat &dst, const Mat &M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
| warps the image using perspective transformation
CV_EXPORTS_W void | watershed (const Mat &image, Mat &markers)
| segments the image using watershed algorithm
Mat | windowedMatchingMask (const vector< KeyPoint > &keypoints1, const vector< KeyPoint > &keypoints2, float maxDeltaX, float maxDeltaY)
template<>
void | write (FileStorage &fs, const string &value)
template<typename _Tp >
void | write (FileStorage &fs, const string &name, const Rect_< _Tp > &r)
void | write (FileStorage &fs, const string &name, const Range &r)
template<typename _Tp >
void | write (FileStorage &fs, const string &name, const Point_< _Tp > &pt)
template<>
void | write (FileStorage &fs, const double &value)
template<typename _Tp >
void | write (FileStorage &fs, const Point_< _Tp > &pt)
CV_EXPORTS_W void | write (FileStorage &fs, const string &name, double value)
template<typename _Tp >
void | write (FileStorage &fs, const Complex< _Tp > &c)
CV_EXPORTS_W void | write (FileStorage &fs, const string &name, float value)
template<typename _Tp >
void | write (FileStorage &fs, const Size_< _Tp > &sz)
CV_EXPORTS_W void | write (FileStorage &fs, const string &name, int value)
template<typename _Tp >
void | write (FileStorage &fs, const string &name, const Scalar_< _Tp > &s)
template<typename _Tp >
void | write (FileStorage &fs, const Point3_< _Tp > &pt)
template<typename _Tp >
void | write (FileStorage &fs, const Scalar_< _Tp > &s)
template<typename _Tp , int cn>
void | write (FileStorage &fs, const string &name, const Vec< _Tp, cn > &v)
void | write (FileStorage &fs, const Range &r)
template<typename _Tp >
void | write (FileStorage &fs, const Rect_< _Tp > &r)
template<typename _Tp , int cn>
void | write (FileStorage &fs, const Vec< _Tp, cn > &v)
void | write (FileStorage &fs, const string &name, const vector< KeyPoint > &keypoints)
| writes vector of keypoints to the file storage
template<typename _Tp >
void | write (FileStorage &fs, const string &name, const Size_< _Tp > &sz)
void | write (FileStorage &fs, const string &name, const SparseMat &value)
template<typename _Tp >
void | write (FileStorage &fs, const string &name, const Point3_< _Tp > &pt)
template<>
void | write (FileStorage &fs, const int &value)
template<>
void | write (FileStorage &fs, const float &value)
template<typename _Tp >
void | write (FileStorage &fs, const _Tp &value)
template<typename _Tp >
void | write (FileStorage &fs, const string &name, const Complex< _Tp > &c)
CV_EXPORTS_W void | write (FileStorage &fs, const string &name, const Mat &value)
CV_EXPORTS_W void | write (FileStorage &fs, const string &name, const string &value)
void | writeScalar (FileStorage &fs, const string &value)
void | writeScalar (FileStorage &fs, double value)
void | writeScalar (FileStorage &fs, int value)
void | writeScalar (FileStorage &fs, float value)
## Variables
CV_OUT Mat double double int | apertureSize = 3
const Mat const Mat const Mat const Mat CV_OUT vector < Point2f > CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat double | aspectRatio = 0 )
CV_OUT Mat Size double double int | borderType = BORDER_DEFAULT )
const Mat const Mat const Mat & | cameraMatrix
CV_OUT vector< Vec3f > & | circles
CV_OUT Mat int | ddepth
CV_OUT Mat int int int int double double | delta = 0
const Mat const Mat const Mat const Mat & | distCoeffs
CV_OUT vector< Vec3f > int double | dp
const Mat const Mat const Mat const Mat CV_OUT vector < Point2f > CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dpdc
const Mat const Mat const Mat const Mat CV_OUT vector < Point2f > CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dpddist
const Mat const Mat const Mat const Mat CV_OUT vector < Point2f > CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dpdf
const Mat const Mat const Mat const Mat CV_OUT vector < Point2f > CV_OUT Mat & | dpdrot
const Mat const Mat const Mat const Mat CV_OUT vector < Point2f > CV_OUT Mat CV_OUT Mat & | dpdt
const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dr3dr1
const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dr3dr2
const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dr3dt1
const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dr3dt2
CV_OUT Mat & | dst
const Mat & | dstPoints
const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dt3dr1
const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dt3dr2
const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dt3dt1
const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat & | dt3dt2
CV_OUT Mat int int | dx
CV_OUT Mat int int int | dy
CV_OUT Mat & | edges
Mat Point Scalar CV_OUT Rect Scalar Scalar int | flags = 4 )
const Mat const Mat const Mat const Mat CV_OUT vector < Point2f > & | imagePoints
CV_OUT Mat CV_OUT Mat & | jacobian
CV_OUT Mat Size | ksize = 3
CV_OUT Mat double double int bool | L2gradient = false )
CV_OUT vector< Vec2f > & | lines
Mat Point Scalar CV_OUT Rect Scalar | loDiff = Scalar()
Mat & | mask
CV_OUT vector< Vec4i > double double int double double | maxLineGap = 0 )
CV_OUT vector< Vec3f > int double double double double int int | maxRadius = 0 )
CV_OUT vector< Vec3f > int | method = 0
CV_OUT vector< Vec3f > int double double | minDist
CV_OUT vector< Vec4i > double double int double | minLineLength = 0
CV_OUT vector< Vec3f > int double double double double int | minRadius = 0
Mat Point Scalar | newVal
CV_OUT vector< Vec3f > int double double double | param1 = 100
CV_OUT vector< Vec3f > int double double double double | param2 = 100
const Mat vector< uchar > int double | ransacReprojThreshold = 3 )
Mat Point Scalar CV_OUT Rect * | rect = 0
CV_OUT vector< Vec2f > double | rho
const Mat & | rvec
const Mat const Mat & | rvec2
const Mat const Mat const Mat CV_OUT Mat & | rvec3
CV_OUT Mat int int int int double | scale = 1
CV_OUT Mat CV_OUT Mat int | sdepth = -1 )
Mat Point | seedPoint
CV_OUT Mat Size double | sigma1
CV_OUT Mat Size double double | sigma2 = 0
CV_OUT Mat CV_OUT Mat & | sqsum
CV_OUT vector< Vec2f > double double int double | srn = 0
CV_OUT vector< Vec2f > double double int double double | stn = 0 )
CV_OUT Mat & | sum
CV_OUT vector< Vec2f > double double | theta
CV_OUT vector< Vec2f > double double int | threshold
CV_OUT Mat double | threshold1
CV_OUT Mat double double | threshold2
CV_OUT Mat CV_OUT Mat CV_OUT Mat & | tilted
const Mat const Mat & | tvec
const Mat & | tvec1
const Mat const Mat const Mat & | tvec2
const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat & | tvec3
Mat Point Scalar CV_OUT Rect Scalar Scalar | upDiff = Scalar()

## Detailed Description

Namespace where all the C++ OpenCV functionality resides

## Typedef Documentation

typedef CvANN_MLP_TrainParams cv::ANN_MLP_TrainParams

typedef CvBoost cv::Boost

typedef CvBoostParams cv::BoostParams

typedef CvBoostTree cv::BoostTree

typedef void(CV_CDECL * cv::ButtonCallback)(int state, void *userdata)

typedef Complex<double> cv::Complexd

typedef Complex<float> cv::Complexf

typedef std::vector<Rect> cv::ConcurrentRectVector

typedef void(* cv::ConvertData)(const void *from, void *to, int cn)

typedef void(* cv::ConvertScaleData)(const void *from, void *to, int cn, double alpha, double beta)

typedef CvDTree cv::DecisionTree

typedef CvDTreeParams cv::DTreeParams

typedef CvEMParams cv::EMParams

typedef int(CV_CDECL * cv::ErrorCallback)(int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata)

typedef CvForestERTree cv::ERTree

typedef CvERTrees cv::ERTrees

typedef CvERTreeTrainData cv::ERTreeTRainData

typedef CvEM cv::ExpectationMaximization

typedef FernDescriptorMatcher cv::FernDescriptorMatch

typedef CvForestTree cv::ForestTree

typedef GenericDescriptorMatcher cv::GenericDescriptorMatch

typedef CvGBTreesParams cv::GradientBoostingTreeParams

typedef CvGBTrees cv::GradientBoostingTrees

typedef CvKNearest cv::KNearest

typedef Mat_<uchar> cv::Mat1b

typedef Mat_<double> cv::Mat1d

typedef Mat_<float> cv::Mat1f

typedef Mat_<int> cv::Mat1i

typedef Mat_<short> cv::Mat1s

typedef Mat_<ushort> cv::Mat1w

typedef Mat_<Vec2b> cv::Mat2b

typedef Mat_<Vec2d> cv::Mat2d

typedef Mat_<Vec2f> cv::Mat2f

typedef Mat_<Vec2i> cv::Mat2i

typedef Mat_<Vec2s> cv::Mat2s

typedef Mat_<Vec2w> cv::Mat2w

typedef Mat_<Vec3b> cv::Mat3b

typedef Mat_<Vec3d> cv::Mat3d

typedef Mat_<Vec3f> cv::Mat3f

typedef Mat_<Vec3i> cv::Mat3i

typedef Mat_<Vec3s> cv::Mat3s

typedef Mat_<Vec3w> cv::Mat3w

typedef Mat_<Vec4b> cv::Mat4b

typedef Mat_<Vec4d> cv::Mat4d

typedef Mat_<Vec4f> cv::Mat4f

typedef Mat_<Vec4i> cv::Mat4i

typedef Mat_<Vec4s> cv::Mat4s

typedef Mat_<Vec4w> cv::Mat4w

typedef Mat cv::MatND

typedef Matx<double, 1, 2> cv::Matx12d

typedef Matx<float, 1, 2> cv::Matx12f

typedef Matx<double, 1, 3> cv::Matx13d

typedef Matx<float, 1, 3> cv::Matx13f

typedef Matx<double, 1, 4> cv::Matx14d

typedef Matx<float, 1, 4> cv::Matx14f

typedef Matx<double, 1, 6> cv::Matx16d

typedef Matx<float, 1, 6> cv::Matx16f

typedef Matx<double, 2, 1> cv::Matx21d

typedef Matx<float, 2, 1> cv::Matx21f

typedef Matx<double, 2, 2> cv::Matx22d

typedef Matx<float, 2, 2> cv::Matx22f

typedef Matx<double, 2, 3> cv::Matx23d

typedef Matx<float, 2, 3> cv::Matx23f

typedef Matx<double, 3, 1> cv::Matx31d

typedef Matx<float, 3, 1> cv::Matx31f

typedef Matx<double, 3, 2> cv::Matx32d

typedef Matx<float, 3, 2> cv::Matx32f

typedef Matx<double, 3, 3> cv::Matx33d

typedef Matx<float, 3, 3> cv::Matx33f

typedef Matx<double, 3, 4> cv::Matx34d

typedef Matx<float, 3, 4> cv::Matx34f

typedef Matx<double, 4, 1> cv::Matx41d

typedef Matx<float, 4, 1> cv::Matx41f

typedef Matx<double, 4, 3> cv::Matx43d

typedef Matx<float, 4, 3> cv::Matx43f

typedef Matx<double, 4, 4> cv::Matx44d

typedef Matx<float, 4, 4> cv::Matx44f

typedef Matx<double, 6, 1> cv::Matx61d

typedef Matx<float, 6, 1> cv::Matx61f

typedef Matx<double, 6, 6> cv::Matx66d

typedef Matx<float, 6, 6> cv::Matx66f

typedef Ptr<CvMemStorage> cv::MemStorage

typedef void(* cv::MouseCallback)(int event, int x, int y, int flags, void *param)

typedef CvANN_MLP cv::NeuralNet_MLP

typedef CvNormalBayesClassifier cv::NormalBayesClassifier

typedef OneWayDescriptorMatcher cv::OneWayDescriptorMatch

typedef void(CV_CDECL * cv::OpenGLCallback)(void *userdata)

typedef CvParamGrid cv::ParamGrid

typedef Point2i cv::Point

typedef Point_<double> cv::Point2d

typedef Point_<float> cv::Point2f

typedef Point_<int> cv::Point2i

typedef Point3_<double> cv::Point3d

typedef Point3_<float> cv::Point3f

typedef Point3_<int> cv::Point3i

typedef CvRTParams cv::RandomTreeParams

typedef CvRTrees cv::RandomTrees

typedef Rect_<int> cv::Rect

typedef Scalar_<double> cv::Scalar

typedef Size2i cv::Size

typedef Size_<float> cv::Size2f

typedef Size_<int> cv::Size2i

typedef CvStatModel cv::StatModel

typedef std::string cv::String

typedef CvSVM cv::SVM

typedef CvSVMKernel cv::SVMKernel

typedef CvSVMParams cv::SVMParams

typedef CvSVMSolver cv::SVMSolver

typedef void(CV_CDECL * cv::TrackbarCallback)(int pos, void *userdata)

typedef CvMLData cv::TrainData

typedef Vec<uchar, 2> cv::Vec2b

typedef Vec<double, 2> cv::Vec2d

typedef Vec<float, 2> cv::Vec2f

typedef Vec<int, 2> cv::Vec2i

typedef Vec<short, 2> cv::Vec2s

typedef Vec<ushort, 2> cv::Vec2w

typedef Vec<uchar, 3> cv::Vec3b

typedef Vec<double, 3> cv::Vec3d

typedef Vec<float, 3> cv::Vec3f

typedef Vec<int, 3> cv::Vec3i

typedef Vec<short, 3> cv::Vec3s

typedef Vec<ushort, 3> cv::Vec3w

typedef Vec<uchar, 4> cv::Vec4b

typedef Vec<double, 4> cv::Vec4d

typedef Vec<float, 4> cv::Vec4f

typedef Vec<int, 4> cv::Vec4i

typedef Vec<short, 4> cv::Vec4s

typedef Vec<ushort, 4> cv::Vec4w

typedef Vec<double, 6> cv::Vec6d

typedef Vec<float, 6> cv::Vec6f

typedef VectorDescriptorMatcher cv::VectorDescriptorMatch

typedef WImageC<short, 1> cv::WImage1_16s

typedef WImageC<ushort, 1> cv::WImage1_16u

typedef WImageC<uchar, 1> cv::WImage1_b

typedef WImageC<float, 1> cv::WImage1_f

typedef WImageC<short, 3> cv::WImage3_16s

typedef WImageC<ushort, 3> cv::WImage3_16u

typedef WImageC<uchar, 3> cv::WImage3_b

typedef WImageC<float, 3> cv::WImage3_f

typedef WImage<short> cv::WImage_16s

typedef WImage<ushort> cv::WImage_16u

typedef WImage<uchar> cv::WImage_b

typedef WImage<float> cv::WImage_f

typedef WImageBufferC<short, 1> cv::WImageBuffer1_16s

typedef WImageBufferC<ushort, 1> cv::WImageBuffer1_16u

typedef WImageBufferC<uchar, 1> cv::WImageBuffer1_b

typedef WImageBufferC<float, 1> cv::WImageBuffer1_f

typedef WImageBufferC<short, 3> cv::WImageBuffer3_16s

typedef WImageBufferC<ushort, 3> cv::WImageBuffer3_16u

typedef WImageBufferC<uchar, 3> cv::WImageBuffer3_b

typedef WImageBufferC<float, 3> cv::WImageBuffer3_f

typedef WImageBuffer<short> cv::WImageBuffer_16s

typedef WImageBuffer<ushort> cv::WImageBuffer_16u

typedef WImageBuffer<uchar> cv::WImageBuffer_b

typedef WImageBuffer<float> cv::WImageBuffer_f

typedef WImageViewC<short, 1> cv::WImageView1_16s

typedef WImageViewC<ushort, 1> cv::WImageView1_16u

typedef WImageViewC<uchar, 1> cv::WImageView1_b

typedef WImageViewC<float, 1> cv::WImageView1_f

typedef WImageViewC<short, 3> cv::WImageView3_16s

typedef WImageViewC<ushort, 3> cv::WImageView3_16u

typedef WImageViewC<uchar, 3> cv::WImageView3_b

typedef WImageViewC<float, 3> cv::WImageView3_f

typedef WImageView<short> cv::WImageView_16s

typedef WImageView<ushort> cv::WImageView_16u

typedef WImageView<uchar> cv::WImageView_b

typedef WImageView<float> cv::WImageView_f

typedef std::basic_string<wchar_t> cv::WString

typedef LDetector cv::YAPE

## Enumeration Type Documentation

anonymous enum

Enumerator:

  DECOMP_LU |
  DECOMP_SVD |
  DECOMP_EIG |
  DECOMP_CHOLESKY |
  DECOMP_QR |
  DECOMP_NORMAL |

anonymous enum

Enumerator:

  NORM_INF |
  NORM_L1 |
  NORM_L2 |
  NORM_TYPE_MASK |
  NORM_RELATIVE |
  NORM_MINMAX |

anonymous enum

type of the robust estimation algorithm

Enumerator:

  LMEDS | least-median algorithm
  RANSAC | RANSAC algorithm.

anonymous enum

Enumerator:

  CALIB_CB_ADAPTIVE_THRESH |
  CALIB_CB_NORMALIZE_IMAGE |
  CALIB_CB_FILTER_QUADS |
  CALIB_CB_FAST_CHECK |

anonymous enum

Enumerator:

  CALIB_USE_INTRINSIC_GUESS |
  CALIB_FIX_ASPECT_RATIO |
  CALIB_FIX_PRINCIPAL_POINT |
  CALIB_ZERO_TANGENT_DIST |
  CALIB_FIX_FOCAL_LENGTH |
  CALIB_FIX_K1 |
  CALIB_FIX_K2 |
  CALIB_FIX_K3 |
  CALIB_FIX_K4 |
  CALIB_FIX_K5 |
  CALIB_FIX_K6 |
  CALIB_RATIONAL_MODEL |
  CALIB_FIX_INTRINSIC |
  CALIB_SAME_FOCAL_LENGTH |
  CALIB_ZERO_DISPARITY |

anonymous enum

the algorithm for finding fundamental matrix

Enumerator:

  FM_7POINT | 7-point algorithm
  FM_8POINT | 8-point algorithm
  FM_LMEDS | least-median algorithm
  FM_RANSAC | RANSAC algorithm.

anonymous enum

Enumerator:

  OPTFLOW_USE_INITIAL_FLOW |
  OPTFLOW_FARNEBACK_GAUSSIAN |

anonymous enum

Enumerator:

  WINDOW_AUTOSIZE |

anonymous enum

Enumerator:

  CMP_EQ |
  CMP_GT |
  CMP_GE |
  CMP_LT |
  CMP_LE |
  CMP_NE |

anonymous enum

Enumerator:

  GEMM_1_T |
  GEMM_2_T |
  GEMM_3_T |

anonymous enum

Enumerator:

  DFT_INVERSE |
  DFT_SCALE |
  DFT_ROWS |
  DFT_COMPLEX_OUTPUT |
  DFT_REAL_OUTPUT |
  DCT_INVERSE |
  DCT_ROWS |

anonymous enum

Enumerator:

  MAGIC_MASK |
  TYPE_MASK |
  DEPTH_MASK |

anonymous enum

Various k-Means flags

Enumerator:

  KMEANS_RANDOM_CENTERS |
  KMEANS_PP_CENTERS |
  KMEANS_USE_INITIAL_LABELS |

anonymous enum

various border interpolation methods

Enumerator:

  BORDER_REPLICATE |
  BORDER_CONSTANT |
  BORDER_REFLECT |
  BORDER_WRAP |
  BORDER_REFLECT_101 |
  BORDER_REFLECT101 |
  BORDER_TRANSPARENT |
  BORDER_DEFAULT |
  BORDER_ISOLATED |

anonymous enum

type of the kernel

Enumerator:

  KERNEL_GENERAL |
  KERNEL_SYMMETRICAL |
  KERNEL_ASYMMETRICAL |
  KERNEL_SMOOTH |
  KERNEL_INTEGER |

anonymous enum

type of morphological operation

Enumerator:

  MORPH_ERODE |
  MORPH_DILATE |
  MORPH_OPEN |
  MORPH_CLOSE |
  MORPH_GRADIENT |
  MORPH_TOPHAT |
  MORPH_BLACKHAT |

anonymous enum

shape of the structuring element

Enumerator:

  MORPH_RECT |
  MORPH_CROSS |
  MORPH_ELLIPSE |

anonymous enum

interpolation algorithm

Enumerator:

  INTER_NEAREST | nearest neighbor interpolation
  INTER_LINEAR | bilinear interpolation
  INTER_CUBIC | bicubic interpolation
  INTER_AREA | area-based (or super) interpolation
  INTER_LANCZOS4 | Lanczos interpolation over 8x8 neighborhood.
  INTER_MAX |
  WARP_INVERSE_MAP |

anonymous enum

Enumerator:

  INTER_BITS |
  INTER_BITS2 |
  INTER_TAB_SIZE |
  INTER_TAB_SIZE2 |

anonymous enum

type of the threshold operation

Enumerator:

  THRESH_BINARY |
  THRESH_BINARY_INV |
  THRESH_TRUNC |
  THRESH_TOZERO |
  THRESH_TOZERO_INV |
  THRESH_MASK |
  THRESH_OTSU |

anonymous enum

adaptive threshold algorithm

Enumerator:

  ADAPTIVE_THRESH_MEAN_C |
  ADAPTIVE_THRESH_GAUSSIAN_C |

anonymous enum

Enumerator:

  PROJ_SPHERICAL_ORTHO |
  PROJ_SPHERICAL_EQRECT |

anonymous enum

class of the pixel in GrabCut algorithm

Enumerator:

  GC_BGD | background
  GC_FGD | foreground
  GC_PR_BGD | most probably background
  GC_PR_FGD | most probably foreground

anonymous enum

Enumerator:

  FONT_HERSHEY_SIMPLEX |
  FONT_HERSHEY_PLAIN |
  FONT_HERSHEY_DUPLEX |
  FONT_HERSHEY_COMPLEX |
  FONT_HERSHEY_TRIPLEX |
  FONT_HERSHEY_COMPLEX_SMALL |
  FONT_HERSHEY_SCRIPT_SIMPLEX |
  FONT_HERSHEY_SCRIPT_COMPLEX |
  FONT_ITALIC |

anonymous enum

GrabCut algorithm flags.

Enumerator:

  GC_INIT_WITH_RECT |
  GC_INIT_WITH_MASK |
  GC_EVAL |

anonymous enum

the inpainting algorithm

Enumerator:

  INPAINT_NS |
  INPAINT_TELEA |

anonymous enum

Enumerator:

  FLOODFILL_FIXED_RANGE |
  FLOODFILL_MASK_ONLY |

anonymous enum

type of the template matching operation

Enumerator:

  TM_SQDIFF |
  TM_SQDIFF_NORMED |
  TM_CCORR |
  TM_CCORR_NORMED |
  TM_CCOEFF |
  TM_CCOEFF_NORMED |

anonymous enum

mode of the contour retrieval algorithm

Enumerator:

  RETR_EXTERNAL | retrieve only the most external (top-level) contours
  RETR_LIST | retrieve all the contours without any hierarchical information
  RETR_CCOMP | retrieve the connected components (that can possibly be nested)
  RETR_TREE | retrieve all the contours and the whole hierarchy

anonymous enum

the contour approximation algorithm

Enumerator:

  CHAIN_APPROX_NONE |
  CHAIN_APPROX_SIMPLE |
  CHAIN_APPROX_TC89_L1 |
  CHAIN_APPROX_TC89_KCOS |

## Function Documentation

MatExpr cv::abs | ( | const Mat & | m ) |

MatExpr cv::abs | ( | const MatExpr & | e ) |

CV_EXPORTS_W void cv::absdiff | ( | const Mat & | src1,
|  | const Scalar & | src2,
|  | CV_OUT Mat & | dst
| ) |  |

computes element-wise absolute difference of array and scalar (dst = abs(src1 - src2))

CV_EXPORTS_W void cv::absdiff | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst
| ) |  |

computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))

CV_EXPORTS_W void cv::accumulate | ( | const Mat & | src,
|  | CV_IN_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.

CV_EXPORTS_W void cv::accumulateProduct | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_IN_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

adds product of the 2 images to the accumulator (dst += src1*src2).

CV_EXPORTS_W void cv::accumulateSquare | ( | const Mat & | src,
|  | CV_IN_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

adds squared src image to the accumulator (dst += src*src).

CV_EXPORTS_W void cv::accumulateWeighted | ( | const Mat & | src,
|  | CV_IN_OUT Mat & | dst,
|  | double | alpha,
|  | const Mat & | mask = `Mat()`
| ) |  |

updates the running average (dst = dst*(1-alpha) + src*alpha)

CV_EXPORTS_W void cv::adaptiveThreshold | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | double | maxValue,
|  | int | adaptiveMethod,
|  | int | thresholdType,
|  | int | blockSize,
|  | double | C
| ) |  |

applies variable (adaptive) threshold to the image

CV_EXPORTS_W void cv::add | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat &mask | CV_WRAP_DEFAULTMat()
| ) |  |

adds one matrix to another (dst = src1 + src2)

CV_EXPORTS_W void cv::add | ( | const Mat & | src1,
|  | const Scalar & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

adds scalar to a matrix (dst = src1 + src2)

void cv::add | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst
| ) |  |

adds one matrix to another (dst = src1 + src2)

void cv::addText | ( | const Mat & | img,
|  | const string & | text,
|  | Point | org,
|  | CvFont | font
| ) |  |

CV_EXPORTS_W void cv::addWeighted | ( | const Mat & | src1,
|  | double | alpha,
|  | const Mat & | src2,
|  | double | beta,
|  | double | gamma,
|  | CV_OUT Mat & | dst
| ) |  |

computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)

void cv::approxPolyDP | ( | const Mat & | curve,
|  | CV_OUT vector< Point > & | approxCurve,
|  | double | epsilon,
|  | bool | closed
| ) |  |

approximates contour or a curve using Douglas-Peucker algorithm

CV_EXPORTS_W double cv::arcLength | ( | const Mat & | curve,
|  | bool | closed
| ) |  |

computes the contour perimeter (closed=true) or a curve length

CV_EXPORTS_W void cv::bilateralFilter | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | d,
|  | double | sigmaColor,
|  | double | sigmaSpace,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

smooths the image using bilateral filter

CV_EXPORTS_W void cv::bitwise_and | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

computes bitwise conjunction of the two arrays (dst = src1 & src2)

CV_EXPORTS_W void cv::bitwise_and | ( | const Mat & | src1,
|  | const Scalar & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

computes bitwise conjunction of an array and scalar (dst = src1 & src2)

CV_EXPORTS_W void cv::bitwise_not | ( | const Mat & | src,
|  | CV_OUT Mat & | dst
| ) |  |

inverts each bit of array (dst = ~src)

CV_EXPORTS_W void cv::bitwise_or | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

computes bitwise disjunction of the two arrays (dst = src1 | src2)

CV_EXPORTS_W void cv::bitwise_or | ( | const Mat & | src1,
|  | const Scalar & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

computes bitwise disjunction of an array and scalar (dst = src1 | src2)

CV_EXPORTS_W void cv::bitwise_xor | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)

CV_EXPORTS_W void cv::bitwise_xor | ( | const Mat & | src1,
|  | const Scalar & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

computes bitwise exclusive-or of an array and scalar (dst = src1 ^ src2)

CV_EXPORTS_W void cv::blur | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | Size | ksize,
|  | Point | anchor = `Point(-1,-1)`,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

a synonym for normalized box filter

CV_EXPORTS_W int cv::borderInterpolate | ( | int | p,
|  | int | len,
|  | int | borderType
| ) |  |

1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.

CV_EXPORTS_W Rect cv::boundingRect | ( | const Mat & | points ) |

computes the bounding rectangle for a contour

CV_EXPORTS_W void cv::boxFilter | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | ddepth,
|  | Size | ksize,
|  | Point | anchor = `Point(-1,-1)`,
|  | bool | normalize = `true`,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

smooths the image using the box filter. Each pixel is processed in O(1) time

void cv::buildPyramid | ( | const Mat & | src,
|  | CV_OUT vector< Mat > & | dst,
|  | int | maxlevel
| ) |  |

builds the gaussian pyramid using pyrDown() as a basic operation

void cv::calcBackProject | ( | const Mat * | images,
|  | int | nimages,
|  | const int * | channels,
|  | const Mat & | hist,
|  | Mat & | backProject,
|  | const float ** | ranges,
|  | double | scale = `1`,
|  | bool | uniform = `true`
| ) |  |

computes back projection for the set of images

void cv::calcBackProject | ( | const Mat * | images,
|  | int | nimages,
|  | const int * | channels,
|  | const SparseMat & | hist,
|  | Mat & | backProject,
|  | const float ** | ranges,
|  | double | scale = `1`,
|  | bool | uniform = `true`
| ) |  |

computes back projection for the set of images

CV_EXPORTS_W void cv::calcCovarMatrix | ( | const Mat & | samples,
|  | CV_OUT Mat & | covar,
|  | CV_OUT Mat & | mean,
|  | int | flags,
|  | int | ctype = `CV_64F`
| ) |  |

computes covariation matrix of a set of samples

void cv::calcCovarMatrix | ( | const Mat * | samples,
|  | int | nsamples,
|  | Mat & | covar,
|  | Mat & | mean,
|  | int | flags,
|  | int | ctype = `CV_64F`
| ) |  |

computes covariation matrix of a set of samples

CV_EXPORTS_W double cv::calcGlobalOrientation | ( | const Mat & | orientation,
|  | const Mat & | mask,
|  | const Mat & | mhi,
|  | double | timestamp,
|  | double | duration
| ) |  |

computes the global orientation of the selected motion history image part

void cv::calcHist | ( | const Mat * | images,
|  | int | nimages,
|  | const int * | channels,
|  | const Mat & | mask,
|  | SparseMat & | hist,
|  | int | dims,
|  | const int * | histSize,
|  | const float ** | ranges,
|  | bool | uniform = `true`,
|  | bool | accumulate = `false`
| ) |  |

computes the joint sparse histogram for a set of images.

void cv::calcHist | ( | const Mat * | images,
|  | int | nimages,
|  | const int * | channels,
|  | const Mat & | mask,
|  | Mat & | hist,
|  | int | dims,
|  | const int * | histSize,
|  | const float ** | ranges,
|  | bool | uniform = `true`,
|  | bool | accumulate = `false`
| ) |  |

computes the joint dense histogram for a set of images.

CV_EXPORTS_W void cv::calcMotionGradient | ( | const Mat & | mhi,
|  | CV_OUT Mat & | mask,
|  | CV_OUT Mat & | orientation,
|  | double | delta1,
|  | double | delta2,
|  | int | apertureSize = `3`
| ) |  |

computes the motion gradient orientation image from the motion history image

CV_EXPORTS_W void cv::calcOpticalFlowFarneback | ( | const Mat & | prev,
|  | const Mat & | next,
|  | CV_OUT Mat & | flow,
|  | double | pyr_scale,
|  | int | levels,
|  | int | winsize,
|  | int | iterations,
|  | int | poly_n,
|  | double | poly_sigma,
|  | int | flags
| ) |  |

computes dense optical flow using Farneback algorithm

CV_EXPORTS_W void cv::calcOpticalFlowPyrLK | ( | const Mat & | prevImg,
|  | const Mat & | nextImg,
|  | const vector< Point2f > & | prevPts,
|  | CV_OUT vector< Point2f > & | nextPts,
|  | CV_OUT vector< uchar > & | status,
|  | CV_OUT vector< float > & | err,
|  | Size | winSize = `Size(15, 15)`,
|  | int | maxLevel = `3`,
|  | TermCriteria | criteria = `TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01)`,
|  | double | derivLambda = `0.5`,
|  | int | flags = `0`
| ) |  |

computes sparse optical flow using multi-scale Lucas-Kanade algorithm

CV_EXPORTS_W double cv::calibrateCamera | ( | const vector< vector< Point3f > > & | objectPoints,
|  | const vector< vector< Point2f > > & | imagePoints,
|  | Size | imageSize,
|  | CV_IN_OUT Mat & | cameraMatrix,
|  | CV_IN_OUT Mat & | distCoeffs,
|  | CV_OUT vector< Mat > & | rvecs,
|  | CV_OUT vector< Mat > & | tvecs,
|  | int | flags = `0`
| ) |  |

finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.

CV_EXPORTS_W void cv::calibrationMatrixValues | ( | const Mat & | cameraMatrix,
|  | Size | imageSize,
|  | double | apertureWidth,
|  | double | apertureHeight,
|  | CV_OUT double & | fovx,
|  | CV_OUT double & | fovy,
|  | CV_OUT double & | focalLength,
|  | CV_OUT Point2d & | principalPoint,
|  | CV_OUT double & | aspectRatio
| ) |  |

computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.

CV_EXPORTS_W RotatedRect cv::CamShift | ( | const Mat & | probImage,
|  | CV_IN_OUT Rect & | window,
|  | TermCriteria | criteria
| ) |  |

updates the object tracking window using CAMSHIFT algorithm

CV_EXPORTS_W void cv::cartToPolar | ( | const Mat & | x,
|  | const Mat & | y,
|  | CV_OUT Mat & | magnitude,
|  | CV_OUT Mat & | angle,
|  | bool | angleInDegrees = `false`
| ) |  |

converts Cartesian coordinates to polar

int cv::chamerMatching | ( | Mat & | img,
|  | Mat & | templ,
|  | vector< vector< Point > > & | results,
|  | vector< float > & | cost,
|  | double | templScale = `1`,
|  | int | maxMatches = `20`,
|  | double | minMatchDistance = `1.0`,
|  | int | padX = `3`,
|  | int | padY = `3`,
|  | int | scales = `5`,
|  | double | minScale = `0.6`,
|  | double | maxScale = `1.6`,
|  | double | orientationWeight = `0.5`,
|  | double | truncate = `20`
| ) |  |

CV_EXPORTS_W bool cv::checkHardwareSupport | ( | int | feature ) |

Returns SSE etc. support status

The function returns true if certain hardware features are available. Currently, the following features are recognized:

- CV_CPU_MMX - MMX
- CV_CPU_SSE - SSE
- CV_CPU_SSE2 - SSE 2
- CV_CPU_SSE3 - SSE 3
- CV_CPU_SSSE3 - SSSE 3
- CV_CPU_SSE4_1 - SSE 4.1
- CV_CPU_SSE4_2 - SSE 4.2
- CV_CPU_AVX - AVX

Note:
  {Note that the function output is not static. Once you called cv::useOptimized(false), most of the hardware acceleration is disabled and thus the function will returns false, until you call cv::useOptimized(true)}

CV_EXPORTS_W bool cv::checkRange | ( | const Mat & | a,
|  | bool | quiet = `true`,
|  | CV_OUT Point * | pt = `0`,
|  | double | minVal = `-DBL_MAX`,
|  | double | maxVal = `DBL_MAX`
| ) |  |

checks that each matrix element is within the specified range.

bool cv::Cholesky | ( | float * | A,
|  | int | m,
|  | float * | b,
|  | int | n
| ) |  |

bool cv::Cholesky | ( | double * | A,
|  | int | m,
|  | double * | b,
|  | int | n
| ) |  |

CV_EXPORTS_W void cv::circle | ( | Mat & | img,
|  | Point | center,
|  | int | radius,
|  | const Scalar & | color,
|  | int | thickness = `1`,
|  | int | lineType = `8`,
|  | int | shift = `0`
| ) |  |

draws the circle outline or a solid circle in the image

void cv::clearSeq | ( | CvSeq * | seq ) |

bool cv::clipLine | ( | Size | imgSize,
|  | CV_IN_OUT Point & | pt1,
|  | CV_IN_OUT Point & | pt2
| ) |  |

clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)

CV_EXPORTS_W bool cv::clipLine | ( | Rect | imgRect,
|  | CV_IN_OUT Point & | pt1,
|  | CV_IN_OUT Point & | pt2
| ) |  |

clips the line segment by the rectangle imgRect

CV_EXPORTS_W void cv::compare | ( | const Mat & | src1,
|  | double | s,
|  | CV_OUT Mat & | dst,
|  | int | cmpop
| ) |  |

compares elements of array with scalar (dst = src1 <cmpop> src2)

CV_EXPORTS_W void cv::compare | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst,
|  | int | cmpop
| ) |  |

compares elements of two arrays (dst = src1 <cmpop> src2)

CV_EXPORTS_W double cv::compareHist | ( | const Mat & | H1,
|  | const Mat & | H2,
|  | int | method
| ) |  |

compares two histograms stored in dense arrays

double cv::compareHist | ( | const SparseMat & | H1,
|  | const SparseMat & | H2,
|  | int | method
| ) |  |

compares two histograms stored in sparse arrays

CV_EXPORTS_W void cv::completeSymm | ( | Mat & | mtx,
|  | bool | lowerToUpper = `false`
| ) |  |

extends the symmetrical matrix from the lower half or from the upper half

CV_EXPORTS_W void cv::composeRT | ( | const Mat & | rvec1,
|  | const Mat & | tvec1,
|  | const Mat & | rvec2,
|  | const Mat & | tvec2,
|  | CV_OUT Mat & | rvec3,
|  | CV_OUT Mat & | tvec3
| ) |  |

composes 2 [R|t] transformations together

void cv::computeCorrespondEpilines | ( | const Mat & | points1,
|  | int | whichImage,
|  | const Mat & | F,
|  | CV_OUT vector< Vec3f > & | lines
| ) |  |

finds coordinates of epipolar lines corresponding the specified points

void cv::computeRecallPrecisionCurve | ( | const vector< vector< DMatch > > & | matches1to2,
|  | const vector< vector< uchar > > & | correctMatches1to2Mask,
|  | vector< Point2f > & | recallPrecisionCurve
| ) |  |

CV_EXPORTS_W double cv::contourArea | ( | const Mat & | contour,
|  | bool | oriented = `false`
| ) |  |

computes the contour area

CV_EXPORTS_W void cv::convertMaps | ( | const Mat & | map1,
|  | const Mat & | map2,
|  | CV_OUT Mat & | dstmap1,
|  | CV_OUT Mat & | dstmap2,
|  | int | dstmap1type,
|  | bool | nninterpolation = `false`
| ) |  |

converts maps for remap from floating-point to fixed-point format or backwards

void cv::convertPointsHomogeneous | ( | const Mat & | src,
|  | CV_OUT vector< Point3f > & | dst
| ) |  |

converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))

void cv::convertPointsHomogeneous | ( | const Mat & | src,
|  | CV_OUT vector< Point2f > & | dst
| ) |  |

converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))

CV_EXPORTS_W void cv::convertScaleAbs | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | double | alpha = `1`,
|  | double | beta = `0`
| ) |  |

scales array elements, computes absolute values and converts the results to 8-bit unsigned integers: dst(i)=saturate_cast<uchar>abs(src(i)*alpha+beta)

void cv::convexHull | ( | const Mat & | points,
|  | CV_OUT vector< int > & | hull,
|  | bool | clockwise = `false`
| ) |  |

computes convex hull for a set of 2D points.

void cv::convexHull | ( | const Mat & | points,
|  | CV_OUT vector< Point > & | hull,
|  | bool | clockwise = `false`
| ) |  |

computes convex hull for a set of 2D points.

CV_EXPORTS_W void cv::copyMakeBorder | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | top,
|  | int | bottom,
|  | int | left,
|  | int | right,
|  | int | borderType,
|  | const Scalar & | value = `Scalar()`
| ) |  |

copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode

CV_EXPORTS_W void cv::cornerEigenValsAndVecs | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | blockSize,
|  | int | ksize,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix.

CV_EXPORTS_W void cv::cornerHarris | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | blockSize,
|  | int | ksize,
|  | double | k,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

computes Harris cornerness criteria at each image pixel

CV_EXPORTS_W void cv::cornerMinEigenVal | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | blockSize,
|  | int | ksize = `3`,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria

void cv::cornerSubPix | ( | const Mat & | image,
|  | vector< Point2f > & | corners,
|  | Size | winSize,
|  | Size | zeroZone,
|  | TermCriteria | criteria
| ) |  |

adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria

CV_EXPORTS_W int cv::countNonZero | ( | const Mat & | src ) |

computes the number of nonzero array elements

Ptr<FilterEngine> cv::createBoxFilter | ( | int | srcType,
|  | int | dstType,
|  | Size | ksize,
|  | Point | anchor = `Point(-1,-1)`,
|  | bool | normalize = `true`,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

returns box filter engine

int cv::createButton | ( | const string & | bar_name,
|  | ButtonCallback | on_change,
|  | void *userdata | CV_DEFAULTNULL,
|  | int type | CV_DEFAULTCV_PUSH_BUTTON,
|  | bool initial_button_state | CV_DEFAULT0
| ) |  |

Ptr<FilterEngine> cv::createDerivFilter | ( | int | srcType,
|  | int | dstType,
|  | int | dx,
|  | int | dy,
|  | int | ksize,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

returns filter engine for the generalized Sobel operator

Ptr<FilterEngine> cv::createGaussianFilter | ( | int | type,
|  | Size | ksize,
|  | double | sigma1,
|  | double | sigma2 = `0`,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

returns the Gaussian filter engine

Ptr<FilterEngine> cv::createLinearFilter | ( | int | srcType,
|  | int | dstType,
|  | const Mat & | kernel,
|  | Point | _anchor = `Point(-1,-1)`,
|  | double | delta = `0`,
|  | int | _rowBorderType = `BORDER_DEFAULT`,
|  | int | _columnBorderType = `-1`,
|  | const Scalar & | _borderValue = `Scalar()`
| ) |  |

returns the non-separable linear filter engine

Ptr<FilterEngine> cv::createMorphologyFilter | ( | int | op,
|  | int | type,
|  | const Mat & | kernel,
|  | Point | anchor = `Point(-1,-1)`,
|  | int | _rowBorderType = `BORDER_CONSTANT`,
|  | int | _columnBorderType = `-1`,
|  | const Scalar & | _borderValue = `morphologyDefaultBorderValue()`
| ) |  |

returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.

void cv::createOpenGLCallback | ( | const string & | winname,
|  | CvOpenGLCallback | callbackOpenGL,
|  | void *userdata | CV_DEFAULT0
| ) |  |

Ptr<FilterEngine> cv::createSeparableLinearFilter | ( | int | srcType,
|  | int | dstType,
|  | const Mat & | rowKernel,
|  | const Mat & | columnKernel,
|  | Point | _anchor = `Point(-1,-1)`,
|  | double | delta = `0`,
|  | int | _rowBorderType = `BORDER_DEFAULT`,
|  | int | _columnBorderType = `-1`,
|  | const Scalar & | _borderValue = `Scalar()`
| ) |  |

returns the separable linear filter engine

int cv::createTrackbar | ( | const string & | trackbarname,
|  | const string & | winname,
|  | int * | value,
|  | int | count,
|  | TrackbarCallback onChange | CV_DEFAULT0,
|  | void *userdata | CV_DEFAULT0
| ) |  |

CV_EXPORTS_W float cv::cubeRoot | ( | float | val ) |

computes cube root of the argument

template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>

void cv::cv2eigen | ( | const Mat & | src,
|  | Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > & | dst
| ) |  |

template<typename _Tp >

void cv::cv2eigen | ( | const Mat & | src,
|  | Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > & | dst
| ) |  |

template<typename _Tp >

void cv::cv2eigen | ( | const Mat & | src,
|  | Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > & | dst
| ) |  |

template<typename _Tp >

void cv::cv2eigen | ( | const Mat & | src,
|  | Eigen::Matrix< _Tp, 1, Eigen::Dynamic > & | dst
| ) |  |

cv::CV_EXPORTS_AS | ( | gaussianBlur | ) | const

smooths the image using Gaussian filter.

cv::CV_EXPORTS_AS | ( | sobel | ) | const

applies generalized Sobel operator to the image

cv::CV_EXPORTS_AS | ( | scharr | ) | const

applies the vertical or horizontal Scharr operator to the image

cv::CV_EXPORTS_AS | ( | laplacian | ) | const

applies Laplacian operator to the image

cv::CV_EXPORTS_AS | ( | canny | ) | const

applies Canny edge detector and produces the edge map.

cv::CV_EXPORTS_AS | ( | houghLines | ) | const

finds lines in the black-n-white image using the standard or pyramid Hough transform

cv::CV_EXPORTS_AS | ( | houghLinesP | ) |

finds line segments in the black-n-white image using probabalistic Hough transform

cv::CV_EXPORTS_AS | ( | houghCircles | ) | const

finds circles in the grayscale image using 2+1 gradient Hough transform

cv::CV_EXPORTS_AS | ( | integral2 | ) | const

computes the integral image and integral for the squared image

cv::CV_EXPORTS_AS | ( | integral3 | ) | const

computes the integral image, integral for the squared image and the tilted integral image

cv::CV_EXPORTS_AS | ( | floodFillMask | ) |

fills the semi-uniform image region and/or the mask starting from the specified seed point

cv::CV_EXPORTS_AS | ( | RodriguesJ | ) | const

converts rotation vector to rotation matrix or vice versa using Rodrigues transformation. Also computes the Jacobian matrix

cv::CV_EXPORTS_AS | ( | findHomographyAndOutliers | ) | const

computes the best-fit perspective transformation mapping srcPoints to dstPoints.

cv::CV_EXPORTS_AS | ( | composeRT_J | ) | const

composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments

cv::CV_EXPORTS_AS | ( | projectPointsJ | ) | const

projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters

Mat cv::cvarrToMat | ( | const CvArr * | arr,
|  | bool | copyData = `false`,
|  | bool | allowND = `true`,
|  | int | coiMode = `0`
| ) |  |

converts array (CvMat or IplImage) to cv::Mat

CV_EXPORTS_W void cv::cvtColor | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | code,
|  | int | dstCn = `0`
| ) |  |

converts image from one color space to another

CV_EXPORTS_W void cv::dct | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | flags = `0`
| ) |  |

performs forward or inverse 1D or 2D Discrete Cosine Transformation

void cv::decomposeProjectionMatrix | ( | const Mat & | projMatrix,
|  | Mat & | cameraMatrix,
|  | Mat & | rotMatrix,
|  | Mat & | transVect
| ) |  |

Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector.

CV_EXPORTS_W void cv::decomposeProjectionMatrix | ( | const Mat & | projMatrix,
|  | CV_OUT Mat & | cameraMatrix,
|  | CV_OUT Mat & | rotMatrix,
|  | CV_OUT Mat & | transVect,
|  | CV_OUT Mat & | rotMatrixX,
|  | CV_OUT Mat & | rotMatrixY,
|  | CV_OUT Mat & | rotMatrixZ,
|  | CV_OUT Vec3d & | eulerAngles
| ) |  |

Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector. The rotation matrix is further decomposed.

CV_EXPORTS_W void cv::destroyWindow | ( | const string & | winname ) |

CV_EXPORTS_W double cv::determinant | ( | const Mat & | mtx ) |

computes determinant of a square matrix

CV_EXPORTS_W void cv::dft | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | flags = `0`,
|  | int | nonzeroRows = `0`
| ) |  |

performs forward or inverse 1D or 2D Discrete Fourier Transformation

CV_EXPORTS_W void cv::dilate | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Mat & | kernel,
|  | Point | anchor = `Point(-1,-1)`,
|  | int | iterations = `1`,
|  | int | borderType = `BORDER_CONSTANT`,
|  | const Scalar & | borderValue = `morphologyDefaultBorderValue()`
| ) |  |

dilates the image (applies the local maximum operator)

void cv::displayOverlay | ( | const string & | winname,
|  | const string & | text,
|  | int | delayms
| ) |  |

void cv::displayStatusBar | ( | const string & | winname,
|  | const string & | text,
|  | int | delayms
| ) |  |

void cv::distanceTransform | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | Mat & | labels,
|  | int | distanceType,
|  | int | maskSize
| ) |  |

builds the discrete Voronoi diagram

CV_EXPORTS_W void cv::distanceTransform | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | distanceType,
|  | int | maskSize
| ) |  |

computes the distance transform map

CV_EXPORTS_W void cv::divide | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst,
|  | double | scale = `1`
| ) |  |

computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2)

CV_EXPORTS_W void cv::divide | ( | double | scale,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst
| ) |  |

computes element-wise weighted reciprocal of an array (dst = scale/src2)

template<typename _Tp >

DataType<_Tp>::work_type cv::dot | ( | const Vector< _Tp > & | v1,
|  | const Vector< _Tp > & | v2
| ) |  | `[inline]`

CV_EXPORTS_W void cv::drawChessboardCorners | ( | Mat & | image,
|  | Size | patternSize,
|  | const Mat & | corners,
|  | bool | patternWasFound
| ) |  |

draws the checkerboard pattern (found or partly found) in the image

void cv::drawChessboardCorners | ( | Mat & | image,
|  | Size | patternSize,
|  | const vector< Point2f > & | corners,
|  | bool | patternWasFound
| ) |  |

void cv::drawContours | ( | Mat & | image,
|  | const vector< vector< Point > > & | contours,
|  | int | contourIdx,
|  | const Scalar & | color,
|  | int | thickness = `1`,
|  | int | lineType = `8`,
|  | const vector< Vec4i > & | hierarchy = `vector< Vec4i >()`,
|  | int | maxLevel = `INT_MAX`,
|  | Point | offset = `Point()`
| ) |  |

draws contours in the image

void cv::drawKeypoints | ( | const Mat & | image,
|  | const vector< KeyPoint > & | keypoints,
|  | Mat & | outImg,
|  | const Scalar & | color = `Scalar::all(-1)`,
|  | int | flags = `DrawMatchesFlags::DEFAULT`
| ) |  |

void cv::drawMatches | ( | const Mat & | img1,
|  | const vector< KeyPoint > & | keypoints1,
|  | const Mat & | img2,
|  | const vector< KeyPoint > & | keypoints2,
|  | const vector< vector< DMatch > > & | matches1to2,
|  | Mat & | outImg,
|  | const Scalar & | matchColor = `Scalar::all(-1)`,
|  | const Scalar & | singlePointColor = `Scalar::all(-1)`,
|  | const vector< vector< char > > & | matchesMask = `vector< vector< char > >()`,
|  | int | flags = `DrawMatchesFlags::DEFAULT`
| ) |  |

void cv::drawMatches | ( | const Mat & | img1,
|  | const vector< KeyPoint > & | keypoints1,
|  | const Mat & | img2,
|  | const vector< KeyPoint > & | keypoints2,
|  | const vector< DMatch > & | matches1to2,
|  | Mat & | outImg,
|  | const Scalar & | matchColor = `Scalar::all(-1)`,
|  | const Scalar & | singlePointColor = `Scalar::all(-1)`,
|  | const vector< char > & | matchesMask = `vector< char >()`,
|  | int | flags = `DrawMatchesFlags::DEFAULT`
| ) |  |

bool cv::eigen | ( | const Mat & | src,
|  | CV_OUT Mat & | eigenvalues,
|  | int | lowindex = `-1`,
|  | int | highindex = `-1`
| ) |  |

finds eigenvalues of a symmetric matrix

bool cv::eigen | ( | const Mat & | src,
|  | CV_OUT Mat & | eigenvalues,
|  | CV_OUT Mat & | eigenvectors,
|  | int | lowindex = `-1`,
|  | int | highindex = `-1`
| ) |  |

finds eigenvalues and eigenvectors of a symmetric matrix

template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>

void cv::eigen2cv | ( | const Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > & | src,
|  | Mat & | dst
| ) |  |

CV_EXPORTS_W void cv::ellipse | ( | Mat & | img,
|  | Point | center,
|  | Size | axes,
|  | double | angle,
|  | double | startAngle,
|  | double | endAngle,
|  | const Scalar & | color,
|  | int | thickness = `1`,
|  | int | lineType = `8`,
|  | int | shift = `0`
| ) |  |

draws an elliptic arc, ellipse sector or a rotated ellipse in the image

CV_EXPORTS_W void cv::ellipse | ( | Mat & | img,
|  | const RotatedRect & | box,
|  | const Scalar & | color,
|  | int | thickness = `1`,
|  | int | lineType = `8`
| ) |  |

draws a rotated ellipse in the image

CV_EXPORTS_W void cv::ellipse2Poly | ( | Point | center,
|  | Size | axes,
|  | int | angle,
|  | int | arcStart,
|  | int | arcEnd,
|  | int | delta,
|  | CV_OUT vector< Point > & | pts
| ) |  |

converts elliptic arc to a polygonal curve

CV_EXPORTS_W void cv::equalizeHist | ( | const Mat & | src,
|  | CV_OUT Mat & | dst
| ) |  |

normalizes the grayscale image brightness and contrast by normalizing its histogram

CV_EXPORTS_W void cv::erode | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Mat & | kernel,
|  | Point | anchor = `Point(-1,-1)`,
|  | int | iterations = `1`,
|  | int | borderType = `BORDER_CONSTANT`,
|  | const Scalar & | borderValue = `morphologyDefaultBorderValue()`
| ) |  |

erodes the image (applies the local minimum operator)

void cv::error | ( | const Exception & | exc ) |

Signals an error and raises the exception.

By default the function prints information about the error to stderr, then it either stops if setBreakOnError() had been called before or raises the exception. It is possible to alternate error processing by using redirectError().

Parameters:

  exc | the exception raisen.

int cv::estimateAffine3D | ( | const Mat & | from,
|  | const Mat & | to,
|  | CV_OUT Mat & | dst,
|  | CV_OUT vector< uchar > & | outliers,
|  | double | param1 = `3.0`,
|  | double | param2 = `0.99`
| ) |  |

computes the best-fit affine transformation that maps one 3D point set to another (RANSAC algorithm is used)

CV_EXPORTS_W Mat cv::estimateRigidTransform | ( | const Mat & | A,
|  | const Mat & | B,
|  | bool | fullAffine
| ) |  |

estimates the best-fit affine transformation that maps one 2D point set to another or one image to another.

void cv::evaluateFeatureDetector | ( | const Mat & | img1,
|  | const Mat & | img2,
|  | const Mat & | H1to2,
|  | vector< KeyPoint > * | keypoints1,
|  | vector< KeyPoint > * | keypoints2,
|  | float & | repeatability,
|  | int & | correspCount,
|  | const Ptr< FeatureDetector > & | fdetector = `Ptr< FeatureDetector >()`
| ) |  |

void cv::evaluateGenericDescriptorMatcher | ( | const Mat & | img1,
|  | const Mat & | img2,
|  | const Mat & | H1to2,
|  | vector< KeyPoint > & | keypoints1,
|  | vector< KeyPoint > & | keypoints2,
|  | vector< vector< DMatch > > * | matches1to2,
|  | vector< vector< uchar > > * | correctMatches1to2Mask,
|  | vector< Point2f > & | recallPrecisionCurve,
|  | const Ptr< GenericDescriptorMatcher > & | dmatch = `Ptr< GenericDescriptorMatcher >()`
| ) |  |

CV_EXPORTS_W void cv::exp | ( | const Mat & | src,
|  | CV_OUT Mat & | dst
| ) |  |

computes exponent of each matrix element (dst = e**src)

void cv::extractImageCOI | ( | const CvArr * | arr,
|  | CV_OUT Mat & | coiimg,
|  | int | coi = `-1`
| ) |  |

extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.

void cv::FAST | ( | const Mat & | image,
|  | CV_OUT vector< KeyPoint > & | keypoints,
|  | int | threshold,
|  | bool | nonmaxSupression = `true`
| ) |  |

detects corners using FAST algorithm by E. Rosten

CV_EXPORTS_W float cv::fastAtan2 | ( | float | y,
|  | float | x
| ) |  |

computes the angle in degrees (0..360) of the vector (x,y)

void cv::fastFree | ( | void * | ptr ) |

Frees the memory allocated with cv::fastMalloc

This is the corresponding deallocation function for cv::fastMalloc(). When ptr==NULL, the function has no effect.

void* cv::fastMalloc | ( | size_t | bufSize ) |

Allocates memory buffer

This is specialized OpenCV memory allocation function that returns properly aligned memory buffers. The usage is identical to malloc(). The allocated buffers must be freed with cv::fastFree(). If there is not enough memory, the function calls cv::error(), which raises an exception.

Parameters:

  bufSize | buffer size in bytes

Returns:
  the allocated memory buffer.

void cv::fillConvexPoly | ( | Mat & | img,
|  | const Point * | pts,
|  | int | npts,
|  | const Scalar & | color,
|  | int | lineType = `8`,
|  | int | shift = `0`
| ) |  |

draws a filled convex polygon in the image

void cv::fillPoly | ( | Mat & | img,
|  | const Point ** | pts,
|  | const int * | npts,
|  | int | ncontours,
|  | const Scalar & | color,
|  | int | lineType = `8`,
|  | int | shift = `0`,
|  | Point | offset = `Point()`
| ) |  |

fills an area bounded by one or more polygons

CV_EXPORTS_W void cv::filter2D | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | ddepth,
|  | const Mat & | kernel,
|  | Point | anchor = `Point(-1,-1)`,
|  | double | delta = `0`,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

applies non-separable 2D linear filter to the image

CV_EXPORTS_W void cv::filterSpeckles | ( | Mat & | img,
|  | double | newVal,
|  | int | maxSpeckleSize,
|  | double | maxDiff,
|  | Mat & | buf
| ) |  |

filters off speckles (small regions of incorrectly computed disparity)

bool cv::find4QuadCornerSubpix | ( | const Mat & | img,
|  | std::vector< Point2f > & | corners,
|  | Size | region_size
| ) |  |

CV_EXPORTS_W bool cv::findChessboardCorners | ( | const Mat & | image,
|  | Size | patternSize,
|  | CV_OUT vector< Point2f > & | corners,
|  | int | flags = `CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE`
| ) |  |

finds checkerboard pattern of the specified size in the image

void cv::findContours | ( | Mat & | image,
|  | CV_OUT vector< vector< Point > > & | contours,
|  | int | mode,
|  | int | method,
|  | Point | offset = `Point()`
| ) |  |

retrieves contours from black-n-white image.

void cv::findContours | ( | Mat & | image,
|  | CV_OUT vector< vector< Point > > & | contours,
|  | vector< Vec4i > & | hierarchy,
|  | int | mode,
|  | int | method,
|  | Point | offset = `Point()`
| ) |  |

retrieves contours and the hierarchical information from black-n-white image.

Mat cv::findFundamentalMat | ( | const Mat & | points1,
|  | const Mat & | points2,
|  | CV_OUT vector< uchar > & | mask,
|  | int | method = `FM_RANSAC`,
|  | double | param1 = `3.`,
|  | double | param2 = `0.99`
| ) |  |

finds fundamental matrix from a set of corresponding 2D points

CV_EXPORTS_W Mat cv::findFundamentalMat | ( | const Mat & | points1,
|  | const Mat & | points2,
|  | int | method = `FM_RANSAC`,
|  | double | param1 = `3.`,
|  | double | param2 = `0.99`
| ) |  |

finds fundamental matrix from a set of corresponding 2D points

CV_EXPORTS_W Mat cv::findHomography | ( | const Mat & | srcPoints,
|  | const Mat & | dstPoints,
|  | int | method = `0`,
|  | double | ransacReprojThreshold = `3`
| ) |  |

computes the best-fit perspective transformation mapping srcPoints to dstPoints.

CV_EXPORTS_W RotatedRect cv::fitEllipse | ( | const Mat & | points ) |

fits ellipse to the set of 2D points

void cv::fitLine | ( | const Mat & | points,
|  | CV_OUT Vec4f & | line,
|  | int | distType,
|  | double | param,
|  | double | reps,
|  | double | aeps
| ) |  |

fits line to the set of 2D points using M-estimator algorithm

fits line to the set of 3D points using M-estimator algorithm

CV_EXPORTS_W void cv::flip | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | flipCode
| ) |  |

reverses the order of the rows, columns or both in a matrix

CV_EXPORTS_W int cv::floodFill | ( | Mat & | image,
|  | Point | seedPoint,
|  | Scalar | newVal,
|  | CV_OUT Rect * | rect = `0`,
|  | Scalar | loDiff = `Scalar()`,
|  | Scalar | upDiff = `Scalar()`,
|  | int | flags = `4`
| ) |  |

fills the semi-uniform image region starting from the specified seed point

CvFont cv::fontQt | ( | const string & | nameFont,
|  | int pointSize | CV_DEFAULT-1,
|  | Scalar color | CV_DEFAULTScalar::all(0),
|  | int weight | CV_DEFAULTCV_FONT_NORMAL,
|  | int style | CV_DEFAULTCV_STYLE_NORMAL,
|  | int spacing | CV_DEFAULT0
| ) |  |

string cv::format | ( | const char * | fmt,
|  |  | ...
| ) |  |

string cv::fromUtf16 | ( | const WString & | str ) |

CV_EXPORTS_W void cv::gemm | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | double | alpha,
|  | const Mat & | src3,
|  | double | gamma,
|  | CV_OUT Mat & | dst,
|  | int | flags = `0`
| ) |  |

implements generalized matrix product algorithm GEMM from BLAS

Mat cv::getAffineTransform | ( | const Point2f | src[],
|  | const Point2f | dst[]
| ) |  |

returns 2x3 affine transformation for the corresponding 3 point pairs.

Ptr<BaseColumnFilter> cv::getColumnSumFilter | ( | int | sumType,
|  | int | dstType,
|  | int | ksize,
|  | int | anchor = `-1`,
|  | double | scale = `1`
| ) |  |

returns vertical 1D box filter

ConvertData cv::getConvertElem | ( | int | fromType,
|  | int | toType
| ) |  |

returns the function for converting pixels from one data type to another

ConvertScaleData cv::getConvertScaleElem | ( | int | fromType,
|  | int | toType
| ) |  |

returns the function for converting pixels from one data type to another with the optional scaling

int64 cv::getCPUTickCount | ( | ) |

Returns the number of CPU ticks.

On platforms where the feature is available, the function returns the number of CPU ticks since the certain event (normally, the system power-on moment). Using this function one can accurately measure the execution time of very small code fragments, for which cv::getTickCount() granularity is not enough.

uchar* cv::getData | ( | IplImage * | image ) | `[inline]`

CV_EXPORTS_W Mat cv::getDefaultNewCameraMatrix | ( | const Mat & | cameraMatrix,
|  | Size | imgsize = `Size()`,
|  | bool | centerPrincipalPoint = `false`
| ) |  |

returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)

CV_EXPORTS_W void cv::getDerivKernels | ( | CV_OUT Mat & | kx,
|  | CV_OUT Mat & | ky,
|  | int | dx,
|  | int | dy,
|  | int | ksize,
|  | bool | normalize = `false`,
|  | int | ktype = `CV_32F`
| ) |  |

initializes kernels of the generalized Sobel operator

CV_EXPORTS_W Mat cv::getGaussianKernel | ( | int | ksize,
|  | double | sigma,
|  | int | ktype = `CV_64F`
| ) |  |

returns the Gaussian kernel with the specified parameters

int cv::getKernelType | ( | const Mat & | kernel,
|  | Point | anchor
| ) |  |

returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients.

Ptr<BaseColumnFilter> cv::getLinearColumnFilter | ( | int | bufType,
|  | int | dstType,
|  | const Mat & | kernel,
|  | int | anchor,
|  | int | symmetryType,
|  | double | delta = `0`,
|  | int | bits = `0`
| ) |  |

returns the primitive column filter with the specified kernel

Ptr<BaseFilter> cv::getLinearFilter | ( | int | srcType,
|  | int | dstType,
|  | const Mat & | kernel,
|  | Point | anchor = `Point(-1,-1)`,
|  | double | delta = `0`,
|  | int | bits = `0`
| ) |  |

returns 2D filter with the specified kernel

Ptr<BaseRowFilter> cv::getLinearRowFilter | ( | int | srcType,
|  | int | bufType,
|  | const Mat & | kernel,
|  | int | anchor,
|  | int | symmetryType
| ) |  |

returns the primitive row filter with the specified kernel

Ptr<BaseColumnFilter> cv::getMorphologyColumnFilter | ( | int | op,
|  | int | type,
|  | int | ksize,
|  | int | anchor = `-1`
| ) |  |

returns vertical 1D morphological filter

Ptr<BaseFilter> cv::getMorphologyFilter | ( | int | op,
|  | int | type,
|  | const Mat & | kernel,
|  | Point | anchor = `Point(-1,-1)`
| ) |  |

returns 2D morphological filter

Ptr<BaseRowFilter> cv::getMorphologyRowFilter | ( | int | op,
|  | int | type,
|  | int | ksize,
|  | int | anchor = `-1`
| ) |  |

returns horizontal 1D morphological filter

int cv::getNumThreads | ( | ) |

CV_EXPORTS_W int cv::getOptimalDFTSize | ( | int | vecsize ) |

computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently

CV_EXPORTS_W Mat cv::getOptimalNewCameraMatrix | ( | const Mat & | cameraMatrix,
|  | const Mat & | distCoeffs,
|  | Size | imageSize,
|  | double | alpha,
|  | Size | newImgSize = `Size()`,
|  | CV_OUT Rect * | validPixROI = `0`
| ) |  |

returns the optimal new camera matrix

Mat cv::getPerspectiveTransform | ( | const Point2f | src[],
|  | const Point2f | dst[]
| ) |  |

returns 3x3 perspective transformation for the corresponding 4 point pairs.

float cv::getRecall | ( | const vector< Point2f > & | recallPrecisionCurve,
|  | float | l_precision
| ) |  |

CV_EXPORTS_W void cv::getRectSubPix | ( | const Mat & | image,
|  | Size | patchSize,
|  | Point2f | center,
|  | CV_OUT Mat & | patch,
|  | int | patchType = `-1`
| ) |  |

extracts rectangle from the image at sub-pixel location

CV_EXPORTS_W Mat cv::getRotationMatrix2D | ( | Point2f | center,
|  | double | angle,
|  | double | scale
| ) |  |

returns 2x3 affine transformation matrix for the planar rotation.

Ptr<BaseRowFilter> cv::getRowSumFilter | ( | int | srcType,
|  | int | sumType,
|  | int | ksize,
|  | int | anchor = `-1`
| ) |  |

returns horizontal 1D box filter

schar* cv::getSeqElem | ( | const CvSeq * | seq,
|  | int | index
| ) |  |

CV_EXPORTS_W Mat cv::getStructuringElement | ( | int | shape,
|  | Size | ksize,
|  | Point | anchor = `Point(-1,-1)`
| ) |  |

returns structuring element of the specified shape and size

CV_EXPORTS_W Size cv::getTextSize | ( | const string & | text,
|  | int | fontFace,
|  | double | fontScale,
|  | int | thickness,
|  | CV_OUT int * | baseLine
| ) |  |

returns bounding box of the text string

int cv::getThreadNum | ( | ) |

int64 cv::getTickCount | ( | ) |

Returns the number of ticks.

The function returns the number of ticks since the certain event (e.g. when the machine was turned on). It can be used to initialize cv::RNG or to measure a function execution time by reading the tick count before and after the function call. The granularity of ticks depends on the hardware and OS used. Use cv::getTickFrequency() to convert ticks to seconds.

CV_EXPORTS_W double cv::getTickFrequency | ( | ) |

Returns the number of ticks per seconds.

The function returns the number of ticks (as returned by cv::getTickCount()) per second. The following code computes the execution time in milliseconds:

      double exec_time = (double)getTickCount();
      // do something ...
      exec_time = ((double)getTickCount() - exec_time)*1000./getTickFrequency();

CV_EXPORTS_W int cv::getTrackbarPos | ( | const string & | trackbarname,
|  | const string & | winname
| ) |  |

CV_EXPORTS_W Rect cv::getValidDisparityROI | ( | Rect | roi1,
|  | Rect | roi2,
|  | int | minDisparity,
|  | int | numberOfDisparities,
|  | int | SADWindowSize
| ) |  |

computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())

CV_EXPORTS_W double cv::getWindowProperty | ( | const string & | winname,
|  | int | prop_id
| ) |  |

CV_EXPORTS_W void cv::goodFeaturesToTrack | ( | const Mat & | image,
|  | CV_OUT vector< Point2f > & | corners,
|  | int | maxCorners,
|  | double | qualityLevel,
|  | double | minDistance,
|  | const Mat & | mask = `Mat()`,
|  | int | blockSize = `3`,
|  | bool | useHarrisDetector = `false`,
|  | double | k = `0.04`
| ) |  |

finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima

CV_EXPORTS_W void cv::grabCut | ( | const Mat & | img,
|  | Mat & | mask,
|  | Rect | rect,
|  | Mat & | bgdModel,
|  | Mat & | fgdModel,
|  | int | iterCount,
|  | int | mode = `GC_EVAL`
| ) |  |

segments the image using GrabCut algorithm

CV_EXPORTS_W void cv::groupRectangles | ( | vector< Rect > & | rectList,
|  | CV_OUT vector< int > & | weights,
|  | int | groupThreshold,
|  | double | eps = `0.2`
| ) |  |

CV_EXPORTS_W void cv::groupRectangles | ( | vector< Rect > & | rectList,
|  | int | groupThreshold,
|  | double | eps = `0.2`
| ) |  |

void cv::hconcat | ( | const Mat * | src,
|  | size_t | nsrc,
|  | Mat & | dst
| ) |  |

void cv::hconcat | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | Mat & | dst
| ) |  |

CV_EXPORTS_W void cv::hconcat | ( | const vector< Mat > & | src,
|  | CV_OUT Mat & | dst
| ) |  |

void cv::HuMoments | ( | const Moments & | moments,
|  | double | hu[7]
| ) |  |

computes 7 Hu invariants from the moments

CV_EXPORTS_W void cv::idct | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | flags = `0`
| ) |  |

performs inverse 1D or 2D Discrete Cosine Transformation

CV_EXPORTS_W void cv::idft | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | flags = `0`,
|  | int | nonzeroRows = `0`
| ) |  |

performs inverse 1D or 2D Discrete Fourier Transformation

CV_EXPORTS_W Mat cv::imdecode | ( | const Mat & | buf,
|  | int | flags
| ) |  |

CV_EXPORTS_W bool cv::imencode | ( | const string & | ext,
|  | const Mat & | img,
|  | CV_OUT vector< uchar > & | buf,
|  | const vector< int > & | params = `vector< int >()`
| ) |  |

CV_EXPORTS_W Mat cv::imread | ( | const string & | filename,
|  | int | flags = `1`
| ) |  |

CV_EXPORTS_W void cv::imshow | ( | const string & | winname,
|  | const Mat & | mat
| ) |  |

CV_EXPORTS_W bool cv::imwrite | ( | const string & | filename,
|  | const Mat & | img,
|  | const vector< int > & | params = `vector< int >()`
| ) |  |

CV_EXPORTS_W Mat cv::initCameraMatrix2D | ( | const vector< vector< Point3f > > & | objectPoints,
|  | const vector< vector< Point2f > > & | imagePoints,
|  | Size | imageSize,
|  | double | aspectRatio = `1.`
| ) |  |

initializes camera matrix from a few 3D points and the corresponding projections.

CV_EXPORTS_W void cv::initUndistortRectifyMap | ( | const Mat & | cameraMatrix,
|  | const Mat & | distCoeffs,
|  | const Mat & | R,
|  | const Mat & | newCameraMatrix,
|  | Size | size,
|  | int | m1type,
|  | CV_OUT Mat & | map1,
|  | CV_OUT Mat & | map2
| ) |  |

initializes maps for cv::remap() to correct lens distortion and optionally rectify the image

CV_EXPORTS_W float cv::initWideAngleProjMap | ( | const Mat & | cameraMatrix,
|  | const Mat & | distCoeffs,
|  | Size | imageSize,
|  | int | destImageWidth,
|  | int | m1type,
|  | CV_OUT Mat & | map1,
|  | CV_OUT Mat & | map2,
|  | int | projType = `PROJ_SPHERICAL_EQRECT`,
|  | double | alpha = `0`
| ) |  |

initializes maps for cv::remap() for wide-angle

CV_EXPORTS_W void cv::inpaint | ( | const Mat & | src,
|  | const Mat & | inpaintMask,
|  | CV_OUT Mat & | dst,
|  | double | inpaintRange,
|  | int | flags
| ) |  |

restores the damaged image areas using one of the available intpainting algorithms

CV_EXPORTS_W void cv::inRange | ( | const Mat & | src,
|  | const Mat & | lowerb,
|  | const Mat & | upperb,
|  | CV_OUT Mat & | dst
| ) |  |

set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)

CV_EXPORTS_W void cv::inRange | ( | const Mat & | src,
|  | const Scalar & | lowerb,
|  | const Scalar & | upperb,
|  | CV_OUT Mat & | dst
| ) |  |

set mask elements for those array elements which are within the fixed bounding box (dst = lowerb <= src && src < upperb)

void cv::insertImageCOI | ( | const Mat & | coiimg,
|  | CvArr * | arr,
|  | int | coi = `-1`
| ) |  |

inserts single-channel cv::Mat into a multi-channel CvMat or IplImage

CV_EXPORTS_W void cv::integral | ( | const Mat & | src,
|  | CV_OUT Mat & | sum,
|  | int | sdepth = `-1`
| ) |  |

computes the integral image

CV_EXPORTS_W double cv::invert | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | flags = `DECOMP_LU`
| ) |  |

computes inverse or pseudo-inverse matrix

CV_EXPORTS_W void cv::invertAffineTransform | ( | const Mat & | M,
|  | CV_OUT Mat & | iM
| ) |  |

computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.

CV_EXPORTS_W bool cv::isContourConvex | ( | const Mat & | contour ) |

returns true iff the contour is convex. Does not support contours with self-intersection

CV_EXPORTS_W double cv::kmeans | ( | const Mat & | data,
|  | int | K,
|  | CV_OUT Mat & | bestLabels,
|  | TermCriteria | criteria,
|  | int | attempts,
|  | int | flags,
|  | CV_OUT Mat * | centers = `0`
| ) |  |

clusters the input data using k-Means algorithm

CV_EXPORTS_W void cv::line | ( | Mat & | img,
|  | Point | pt1,
|  | Point | pt2,
|  | const Scalar & | color,
|  | int | thickness = `1`,
|  | int | lineType = `8`,
|  | int | shift = `0`
| ) |  |

draws the line segment (pt1, pt2) in the image

void cv::loadWindowParameters | ( | const string & | windowName ) |

CV_EXPORTS_W void cv::log | ( | const Mat & | src,
|  | CV_OUT Mat & | dst
| ) |  |

computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))

int cv::LU | ( | float * | A,
|  | int | m,
|  | float * | b,
|  | int | n
| ) |  |

int cv::LU | ( | double * | A,
|  | int | m,
|  | double * | b,
|  | int | n
| ) |  |

CV_EXPORTS_W void cv::LUT | ( | const Mat & | src,
|  | const Mat & | lut,
|  | CV_OUT Mat & | dst
| ) |  |

transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))

CV_EXPORTS_W void cv::magnitude | ( | const Mat & | x,
|  | const Mat & | y,
|  | CV_OUT Mat & | magnitude
| ) |  |

computes magnitude (magnitude(i)) of each (x(i), y(i)) vector

CV_EXPORTS_W double cv::Mahalanobis | ( | const Mat & | v1,
|  | const Mat & | v2,
|  | const Mat & | icovar
| ) |  |

computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix

double cv::Mahalonobis | ( | const Mat & | v1,
|  | const Mat & | v2,
|  | const Mat & | icovar
| ) |  |

a synonym for Mahalanobis

CV_EXPORTS_W double cv::matchShapes | ( | const Mat & | contour1,
|  | const Mat & | contour2,
|  | int | method,
|  | double | parameter
| ) |  |

matches two contours using one of the available algorithms

CV_EXPORTS_W void cv::matchTemplate | ( | const Mat & | image,
|  | const Mat & | templ,
|  | CV_OUT Mat & | result,
|  | int | method
| ) |  |

computes the proximity map for the raster template and the image where the template is searched for

CV_EXPORTS_W void cv::matMulDeriv | ( | const Mat & | A,
|  | const Mat & | B,
|  | CV_OUT Mat & | dABdA,
|  | CV_OUT Mat & | dABdB
| ) |  |

computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients

CV_EXPORTS_W void cv::max | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst
| ) |  |

computes per-element maximum of two arrays (dst = max(src1, src2))

CV_EXPORTS_W void cv::max | ( | const Mat & | src1,
|  | double | src2,
|  | CV_OUT Mat & | dst
| ) |  |

computes per-element maximum of array and scalar (dst = max(src1, src2))

MatExpr cv::max | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::max | ( | const Mat & | a,
|  | double | s
| ) |  |

MatExpr cv::max | ( | double | s,
|  | const Mat & | a
| ) |  |

Scalar cv::mean | ( | const Mat & | src ) |

computes mean value of array elements

CV_EXPORTS_W Scalar cv::mean | ( | const Mat & | src,
|  | const Mat &mask | CV_WRAP_DEFAULTMat()
| ) |  |

computes mean value of selected array elements

CV_EXPORTS_W int cv::meanShift | ( | const Mat & | probImage,
|  | CV_IN_OUT Rect & | window,
|  | TermCriteria | criteria
| ) |  |

updates the object tracking window using meanshift algorithm

CV_EXPORTS_W void cv::meanStdDev | ( | const Mat & | src,
|  | CV_OUT Scalar & | mean,
|  | CV_OUT Scalar & | stddev,
|  | const Mat & | mask = `Mat()`
| ) |  |

computes mean value and standard deviation of all or selected array elements

CV_EXPORTS_W void cv::medianBlur | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | ksize
| ) |  |

smooths the image using median filter.

void cv::merge | ( | const Mat * | mv,
|  | size_t | count,
|  | CV_OUT Mat & | dst
| ) |  |

makes multi-channel array out of several single-channel arrays

CV_EXPORTS_W void cv::merge | ( | const vector< Mat > & | mv,
|  | Mat & | dst
| ) |  |

makes multi-channel array out of several single-channel arrays

CV_EXPORTS_W void cv::min | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst
| ) |  |

computes per-element minimum of two arrays (dst = min(src1, src2))

CV_EXPORTS_W void cv::min | ( | const Mat & | src1,
|  | double | src2,
|  | CV_OUT Mat & | dst
| ) |  |

computes per-element minimum of array and scalar (dst = min(src1, src2))

MatExpr cv::min | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::min | ( | const Mat & | a,
|  | double | s
| ) |  |

MatExpr cv::min | ( | double | s,
|  | const Mat & | a
| ) |  |

CV_EXPORTS_W RotatedRect cv::minAreaRect | ( | const Mat & | points ) |

computes the minimal rotated rectangle for a set of points

CV_EXPORTS_W void cv::minEnclosingCircle | ( | const Mat & | points,
|  | Point2f & | center,
|  | float & | radius
| ) |  |

computes the minimal enclosing circle for a set of points

void cv::minMaxIdx | ( | const Mat & | src,
|  | double * | minVal,
|  | double * | maxVal,
|  | int * | minIdx = `0`,
|  | int * | maxIdx = `0`,
|  | const Mat & | mask = `Mat()`
| ) |  |

void cv::minMaxLoc | ( | const SparseMat & | a,
|  | double * | minVal,
|  | double * | maxVal,
|  | int * | minIdx = `0`,
|  | int * | maxIdx = `0`
| ) |  |

finds global minimum and maximum sparse array elements and returns their values and their locations

CV_EXPORTS_W void cv::minMaxLoc | ( | const Mat & | src,
|  | CV_OUT double * | minVal,
|  | CV_OUT double * | maxVal = `0`,
|  | CV_OUT Point * | minLoc = `0`,
|  | CV_OUT Point * | maxLoc = `0`,
|  | const Mat & | mask = `Mat()`
| ) |  |

finds global minimum and maximum array elements and returns their values and their locations

void cv::mixChannels | ( | const Mat * | src,
|  | size_t | nsrcs,
|  | Mat * | dst,
|  | size_t | ndsts,
|  | const int * | fromTo,
|  | size_t | npairs
| ) |  |

copies selected channels from the input arrays to the selected channels of the output arrays

void cv::mixChannels | ( | const vector< Mat > & | src,
|  | vector< Mat > & | dst,
|  | const int * | fromTo,
|  | int | npairs
| ) |  |

CV_EXPORTS_W Moments cv::moments | ( | const Mat & | array,
|  | bool | binaryImage = `false`
| ) |  |

computes moments of the rasterized shape or a vector of points

CV_EXPORTS_W void cv::morphologyEx | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | op,
|  | const Mat & | kernel,
|  | Point | anchor = `Point(-1,-1)`,
|  | int | iterations = `1`,
|  | int | borderType = `BORDER_CONSTANT`,
|  | const Scalar & | borderValue = `morphologyDefaultBorderValue()`
| ) |  |

applies an advanced morphological operation to the image

CV_EXPORTS_W void cv::mulSpectrums | ( | const Mat & | a,
|  | const Mat & | b,
|  | CV_OUT Mat & | c,
|  | int | flags,
|  | bool | conjB = `false`
| ) |  |

computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication

CV_EXPORTS_W void cv::multiply | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst,
|  | double | scale = `1`
| ) |  |

computes element-wise weighted product of the two arrays (dst = scale*src1*src2)

CV_EXPORTS_W void cv::mulTransposed | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | bool | aTa,
|  | const Mat & | delta = `Mat()`,
|  | double | scale = `1`,
|  | int | rtype = `-1`
| ) |  |

multiplies matrix by its transposition from the left or from the right

CV_EXPORTS_W void cv::namedWindow | ( | const string & | winname,
|  | int flags | CV_DEFAULTWINDOW_AUTOSIZE
| ) |  |

double cv::norm | ( | const SparseMat & | src,
|  | int | normType
| ) |  |

computes norm of a sparse matrix

double cv::norm | ( | const Mat & | src1,
|  | int | normType = `NORM_L2`
| ) |  |

computes norm of array

double cv::norm | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | int | normType = `NORM_L2`
| ) |  |

computes norm of the difference between two arrays

CV_EXPORTS_W double cv::norm | ( | const Mat & | src1,
|  | int | normType,
|  | const Mat &mask | CV_WRAP_DEFAULTMat()
| ) |  |

computes norm of the selected array part

CV_EXPORTS_W double cv::norm | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | int | normType,
|  | const Mat &mask | CV_WRAP_DEFAULTMat()
| ) |  |

computes norm of selected part of the difference between two arrays

void cv::normalize | ( | const SparseMat & | src,
|  | SparseMat & | dst,
|  | double | alpha,
|  | int | normType
| ) |  |

scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values

CV_EXPORTS_W void cv::normalize | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | double | alpha = `1`,
|  | double | beta = `0`,
|  | int | norm_type = `NORM_L2`,
|  | int | rtype = `-1`,
|  | const Mat & | mask = `Mat()`
| ) |  |

scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values

template<typename _Tp >

bool cv::operator!= | ( | const SeqIterator< _Tp > & | a,
|  | const SeqIterator< _Tp > & | b
| ) |  | `[inline]`

MatExpr cv::operator!= | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator!= | ( | const Mat & | a,
|  | double | s
| ) |  |

MatExpr cv::operator!= | ( | double | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator& | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator& | ( | const Mat & | a,
|  | const Scalar & | s
| ) |  |

MatExpr cv::operator& | ( | const Scalar & | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator* | ( | const Mat & | m,
|  | const MatExpr & | e
| ) |  |

MatExpr cv::operator* | ( | double | s,
|  | const MatExpr & | e
| ) |  |

MatExpr cv::operator* | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator* | ( | const MatExpr & | e,
|  | const Mat & | m
| ) |  |

MatExpr cv::operator* | ( | const Mat & | a,
|  | double | s
| ) |  |

MatExpr cv::operator* | ( | const MatExpr & | e,
|  | double | s
| ) |  |

MatExpr cv::operator* | ( | const MatExpr & | e1,
|  | const MatExpr & | e2
| ) |  |

MatExpr cv::operator* | ( | double | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator+ | ( | const Mat & | m,
|  | const MatExpr & | e
| ) |  |

MatExpr cv::operator+ | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator+ | ( | const Mat & | a,
|  | const Scalar & | s
| ) |  |

MatExpr cv::operator+ | ( | const Scalar & | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator+ | ( | const MatExpr & | e,
|  | const Mat & | m
| ) |  |

MatExpr cv::operator+ | ( | const MatExpr & | e,
|  | const Scalar & | s
| ) |  |

MatExpr cv::operator+ | ( | const Scalar & | s,
|  | const MatExpr & | e
| ) |  |

MatExpr cv::operator+ | ( | const MatExpr & | e1,
|  | const MatExpr & | e2
| ) |  |

template<typename _Tp >

ptrdiff_t cv::operator- | ( | const SeqIterator< _Tp > & | a,
|  | const SeqIterator< _Tp > & | b
| ) |  | `[inline]`

MatExpr cv::operator- | ( | const Mat & | m ) |

ptrdiff_t cv::operator- | ( | const MatConstIterator & | b,
|  | const MatConstIterator & | a
| ) |  |

MatExpr cv::operator- | ( | const MatExpr & | e1,
|  | const MatExpr & | e2
| ) |  |

MatExpr cv::operator- | ( | const Mat & | m,
|  | const MatExpr & | e
| ) |  |

MatExpr cv::operator- | ( | const Mat & | a,
|  | const Scalar & | s
| ) |  |

MatExpr cv::operator- | ( | const Scalar & | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator- | ( | const MatExpr & | e,
|  | const Mat & | m
| ) |  |

MatExpr cv::operator- | ( | const MatExpr & | e,
|  | const Scalar & | s
| ) |  |

MatExpr cv::operator- | ( | const Scalar & | s,
|  | const MatExpr & | e
| ) |  |

MatExpr cv::operator- | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator- | ( | const MatExpr & | e ) |

MatExpr cv::operator/ | ( | const Mat & | a,
|  | double | s
| ) |  |

MatExpr cv::operator/ | ( | const MatExpr & | e,
|  | const Mat & | m
| ) |  |

MatExpr cv::operator/ | ( | const Mat & | m,
|  | const MatExpr & | e
| ) |  |

MatExpr cv::operator/ | ( | const MatExpr & | e,
|  | double | s
| ) |  |

MatExpr cv::operator/ | ( | const MatExpr & | e1,
|  | const MatExpr & | e2
| ) |  |

MatExpr cv::operator/ | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator/ | ( | double | s,
|  | const MatExpr & | e
| ) |  |

MatExpr cv::operator/ | ( | double | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator< | ( | double | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator< | ( | const Mat & | a,
|  | double | s
| ) |  |

MatExpr cv::operator< | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

template<typename _Tp >

std::ostream& cv::operator<< | ( | std::ostream & | out,
|  | const Point3_< _Tp > & | p
| ) |  | `[inline]`

Writes a point to an output stream in Matlab notation

FileStorage& cv::operator<< | ( | FileStorage & | fs,
|  | const string & | str
| ) |  |

template<typename _Tp >

std::ostream& cv::operator<< | ( | std::ostream & | out,
|  | const Point_< _Tp > & | p
| ) |  | `[inline]`

Writes a point to an output stream in Matlab notation

std::ostream& cv::operator<< | ( | std::ostream & | out,
|  | const TickMeter & | tm
| ) |  |

MatExpr cv::operator<= | ( | const Mat & | a,
|  | double | s
| ) |  |

MatExpr cv::operator<= | ( | double | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator<= | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

template<typename _Tp >

bool cv::operator== | ( | const SeqIterator< _Tp > & | a,
|  | const SeqIterator< _Tp > & | b
| ) |  | `[inline]`

MatExpr cv::operator== | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator== | ( | const Mat & | a,
|  | double | s
| ) |  |

MatExpr cv::operator== | ( | double | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator> | ( | double | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator> | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator> | ( | const Mat & | a,
|  | double | s
| ) |  |

MatExpr cv::operator>= | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator>= | ( | const Mat & | a,
|  | double | s
| ) |  |

MatExpr cv::operator>= | ( | double | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator^ | ( | const Mat & | a,
|  | const Scalar & | s
| ) |  |

MatExpr cv::operator^ | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator^ | ( | const Scalar & | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator| | ( | const Scalar & | s,
|  | const Mat & | a
| ) |  |

MatExpr cv::operator| | ( | const Mat & | a,
|  | const Scalar & | s
| ) |  |

MatExpr cv::operator| | ( | const Mat & | a,
|  | const Mat & | b
| ) |  |

MatExpr cv::operator~ | ( | const Mat & | m ) |

template<typename _Tp , class _EqPredicate >

int cv::partition | ( | const vector< _Tp > & | _vec,
|  | vector< int > & | labels,
|  | _EqPredicate | predicate = `_EqPredicate()`
| ) |  |

CV_EXPORTS_W void cv::perspectiveTransform | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Mat & | m
| ) |  |

performs perspective transformation of each element of multi-channel input matrix

CV_EXPORTS_W void cv::phase | ( | const Mat & | x,
|  | const Mat & | y,
|  | CV_OUT Mat & | angle,
|  | bool | angleInDegrees = `false`
| ) |  |

computes angle (angle(i)) of each (x(i), y(i)) vector

CV_EXPORTS_W double cv::pointPolygonTest | ( | const Mat & | contour,
|  | Point2f | pt,
|  | bool | measureDist
| ) |  |

checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary

CV_EXPORTS_W void cv::polarToCart | ( | const Mat & | magnitude,
|  | const Mat & | angle,
|  | CV_OUT Mat & | x,
|  | CV_OUT Mat & | y,
|  | bool | angleInDegrees = `false`
| ) |  |

converts polar coordinates to Cartesian

void cv::polylines | ( | Mat & | img,
|  | const Point ** | pts,
|  | const int * | npts,
|  | int | ncontours,
|  | bool | isClosed,
|  | const Scalar & | color,
|  | int | thickness = `1`,
|  | int | lineType = `8`,
|  | int | shift = `0`
| ) |  |

draws one or more polygonal curves

CV_EXPORTS_W void cv::pow | ( | const Mat & | src,
|  | double | power,
|  | CV_OUT Mat & | dst
| ) |  |

raises the input matrix elements to the specified power (b = a**power)

CV_EXPORTS_W void cv::preCornerDetect | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | ksize,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

computes another complex cornerness criteria at each pixel

template<typename T1 , typename T2 , typename Op >

void cv::process | ( | const Mat_< T1 > & | m1,
|  | Mat_< T2 > & | m2,
|  | Op | op
| ) |  | `[inline]`

template<typename T1 , typename T2 , typename T3 , typename Op >

void cv::process | ( | const Mat_< T1 > & | m1,
|  | const Mat_< T2 > & | m2,
|  | Mat_< T3 > & | m3,
|  | Op | op
| ) |  | `[inline]`

CV_EXPORTS_W void cv::projectPoints | ( | const Mat & | objectPoints,
|  | const Mat & | rvec,
|  | const Mat & | tvec,
|  | const Mat & | cameraMatrix,
|  | const Mat & | distCoeffs,
|  | CV_OUT vector< Point2f > & | imagePoints
| ) |  |

projects points from the model coordinate space to the image coordinates. Takes the intrinsic and extrinsic camera parameters into account

CV_EXPORTS_W void cv::putText | ( | Mat & | img,
|  | const string & | text,
|  | Point | org,
|  | int | fontFace,
|  | double | fontScale,
|  | Scalar | color,
|  | int | thickness = `1`,
|  | int | linetype = `8`,
|  | bool | bottomLeftOrigin = `false`
| ) |  |

renders text string in the image

CV_EXPORTS_W void cv::pyrDown | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Size & | dstsize = `Size()`
| ) |  |

smooths and downsamples the image

CV_EXPORTS_W void cv::pyrMeanShiftFiltering | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | double | sp,
|  | double | sr,
|  | int | maxLevel = `1`,
|  | TermCriteria | termcrit = `TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1)`
| ) |  |

filters image using meanshift algorithm

CV_EXPORTS_W void cv::pyrUp | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Size & | dstsize = `Size()`
| ) |  |

upsamples and smoothes the image

CV_EXPORTS_W void cv::randn | ( | CV_OUT Mat & | dst,
|  | const Scalar & | mean,
|  | const Scalar & | stddev
| ) |  |

fills array with normally-distributed random numbers with the specified mean and the standard deviation

void cv::randShuffle | ( | Mat & | dst,
|  | double | iterFactor = `1.`,
|  | RNG * | rng = `0`
| ) |  |

shuffles the input array elements

CV_EXPORTS_W void cv::randu | ( | CV_OUT Mat & | dst,
|  | const Scalar & | low,
|  | const Scalar & | high
| ) |  |

fills array with uniformly-distributed random numbers from the range [low, high)

void cv::read | ( | const FileNode & | node,
|  | SparseMat & | mat,
|  | const SparseMat & | default_mat = `SparseMat()`
| ) |  |

CV_EXPORTS_W void cv::read | ( | const FileNode & | node,
|  | Mat & | mat,
|  | const Mat & | default_mat = `Mat()`
| ) |  |

void cv::read | ( | const FileNode & | node,
|  | CV_OUT vector< KeyPoint > & | keypoints
| ) |  |

reads vector of keypoints from the specified file storage node

void cv::rectangle | ( | Mat & | img,
|  | Rect | rec,
|  | const Scalar & | color,
|  | int | thickness = `1`,
|  | int | lineType = `8`,
|  | int | shift = `0`
| ) |  |

draws the rectangle outline or a solid rectangle covering rec in the image

CV_EXPORTS_W void cv::rectangle | ( | Mat & | img,
|  | Point | pt1,
|  | Point | pt2,
|  | const Scalar & | color,
|  | int | thickness = `1`,
|  | int | lineType = `8`,
|  | int | shift = `0`
| ) |  |

draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image

CV_EXPORTS_W float cv::rectify3Collinear | ( | const Mat & | cameraMatrix1,
|  | const Mat & | distCoeffs1,
|  | const Mat & | cameraMatrix2,
|  | const Mat & | distCoeffs2,
|  | const Mat & | cameraMatrix3,
|  | const Mat & | distCoeffs3,
|  | const vector< vector< Point2f > > & | imgpt1,
|  | const vector< vector< Point2f > > & | imgpt3,
|  | Size | imageSize,
|  | const Mat & | R12,
|  | const Mat & | T12,
|  | const Mat & | R13,
|  | const Mat & | T13,
|  | CV_OUT Mat & | R1,
|  | CV_OUT Mat & | R2,
|  | CV_OUT Mat & | R3,
|  | CV_OUT Mat & | P1,
|  | CV_OUT Mat & | P2,
|  | CV_OUT Mat & | P3,
|  | CV_OUT Mat & | Q,
|  | double | alpha,
|  | Size | newImgSize,
|  | CV_OUT Rect * | roi1,
|  | CV_OUT Rect * | roi2,
|  | int | flags
| ) |  |

computes the rectification transformations for 3-head camera, where all the heads are on the same line.

ErrorCallback cv::redirectError | ( | ErrorCallback | errCallback,
|  | void * | userdata = `0`,
|  | void ** | prevUserdata = `0`
| ) |  |

Sets the new error handler and the optional user data.

The function sets the new error handler, called from cv::error().

Parameters:

  errCallback | the new error handler. If NULL, the default error handler is used.
  userdata | the optional user data pointer, passed to the callback.
  prevUserdata | the optional output parameter where the previous user data pointer is stored

Returns:
  the previous error handler

CV_EXPORTS_W void cv::reduce | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | dim,
|  | int | rtype,
|  | int | dtype = `-1`
| ) |  |

transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows

CV_EXPORTS_W void cv::remap | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Mat & | map1,
|  | const Mat & | map2,
|  | int | interpolation,
|  | int | borderMode = `BORDER_CONSTANT`,
|  | const Scalar & | borderValue = `Scalar()`
| ) |  |

warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format

CV_EXPORTS_W void cv::repeat | ( | const Mat & | src,
|  | int | ny,
|  | int | nx,
|  | CV_OUT Mat & | dst
| ) |  |

replicates the input matrix the specified number of times in the horizontal and/or vertical direction

Mat cv::repeat | ( | const Mat & | src,
|  | int | ny,
|  | int | nx
| ) |  |

CV_EXPORTS_W void cv::reprojectImageTo3D | ( | const Mat & | disparity,
|  | CV_OUT Mat & | _3dImage,
|  | const Mat & | Q,
|  | bool | handleMissingValues = `false`
| ) |  |

reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify

CV_EXPORTS_W void cv::resize | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | Size | dsize,
|  | double | fx = `0`,
|  | double | fy = `0`,
|  | int | interpolation = `INTER_LINEAR`
| ) |  |

resizes the image

CV_EXPORTS_W void cv::Rodrigues | ( | const Mat & | src,
|  | CV_OUT Mat & | dst
| ) |  |

converts rotation vector to rotation matrix or vice versa using Rodrigues transformation

void cv::RQDecomp3x3 | ( | const Mat & | M,
|  | Mat & | R,
|  | Mat & | Q
| ) |  |

Computes RQ decomposition of 3x3 matrix.

CV_EXPORTS_W Vec3d cv::RQDecomp3x3 | ( | const Mat & | M,
|  | Mat & | R,
|  | Mat & | Q,
|  | CV_OUT Mat & | Qx,
|  | CV_OUT Mat & | Qy,
|  | CV_OUT Mat & | Qz
| ) |  |

Computes RQ decomposition of 3x3 matrix. Also, decomposes the output orthogonal matrix into the 3 primitive rotation matrices.

template<>

int cv::saturate_cast< int > | ( | double | v ) | `[inline]`

template<>

int cv::saturate_cast< int > | ( | float | v ) | `[inline]`

template<>

schar cv::saturate_cast< schar > | ( | double | v ) | `[inline]`

template<>

schar cv::saturate_cast< schar > | ( | int | v ) | `[inline]`

template<>

schar cv::saturate_cast< schar > | ( | short | v ) | `[inline]`

template<>

schar cv::saturate_cast< schar > | ( | unsigned | v ) | `[inline]`

template<>

schar cv::saturate_cast< schar > | ( | float | v ) | `[inline]`

template<>

schar cv::saturate_cast< schar > | ( | ushort | v ) | `[inline]`

template<>

schar cv::saturate_cast< schar > | ( | uchar | v ) | `[inline]`

template<>

short cv::saturate_cast< short > | ( | int | v ) | `[inline]`

template<>

short cv::saturate_cast< short > | ( | double | v ) | `[inline]`

template<>

short cv::saturate_cast< short > | ( | ushort | v ) | `[inline]`

template<>

short cv::saturate_cast< short > | ( | unsigned | v ) | `[inline]`

template<>

short cv::saturate_cast< short > | ( | float | v ) | `[inline]`

template<>

uchar cv::saturate_cast< uchar > | ( | schar | v ) | `[inline]`

template<>

uchar cv::saturate_cast< uchar > | ( | float | v ) | `[inline]`

template<>

uchar cv::saturate_cast< uchar > | ( | short | v ) | `[inline]`

template<>

uchar cv::saturate_cast< uchar > | ( | unsigned | v ) | `[inline]`

template<>

uchar cv::saturate_cast< uchar > | ( | int | v ) | `[inline]`

template<>

uchar cv::saturate_cast< uchar > | ( | double | v ) | `[inline]`

template<>

uchar cv::saturate_cast< uchar > | ( | ushort | v ) | `[inline]`

template<>

unsigned cv::saturate_cast< unsigned > | ( | float | v ) | `[inline]`

template<>

unsigned cv::saturate_cast< unsigned > | ( | double | v ) | `[inline]`

template<>

ushort cv::saturate_cast< ushort > | ( | short | v ) | `[inline]`

template<>

ushort cv::saturate_cast< ushort > | ( | int | v ) | `[inline]`

template<>

ushort cv::saturate_cast< ushort > | ( | unsigned | v ) | `[inline]`

template<>

ushort cv::saturate_cast< ushort > | ( | double | v ) | `[inline]`

template<>

ushort cv::saturate_cast< ushort > | ( | float | v ) | `[inline]`

template<>

ushort cv::saturate_cast< ushort > | ( | schar | v ) | `[inline]`

void cv::saveWindowParameters | ( | const string & | windowName ) |

void cv::scalarToRawData | ( | const Scalar & | s,
|  | void * | buf,
|  | int | type,
|  | int | unroll_to = `0`
| ) |  |

CV_EXPORTS_W void cv::scaleAdd | ( | const Mat & | src1,
|  | double | alpha,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst
| ) |  |

adds scaled array to another one (dst = alpha*src1 + src2)

CV_EXPORTS_W void cv::sepFilter2D | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | ddepth,
|  | const Mat & | kernelX,
|  | const Mat & | kernelY,
|  | Point | anchor = `Point(-1,-1)`,
|  | double | delta = `0`,
|  | int | borderType = `BORDER_DEFAULT`
| ) |  |

applies separable 2D linear filter to the image

void cv::seqInsertSlice | ( | CvSeq * | seq,
|  | int | before_index,
|  | const CvArr * | from_arr
| ) |  |

void cv::seqPop | ( | CvSeq * | seq,
|  | void * | element = `0`
| ) |  |

void cv::seqPopFront | ( | CvSeq * | seq,
|  | void * | element = `0`
| ) |  |

void cv::seqPopMulti | ( | CvSeq * | seq,
|  | void * | elements,
|  | int | count,
|  | int | in_front = `0`
| ) |  |

schar* cv::seqPush | ( | CvSeq * | seq,
|  | const void * | element = `0`
| ) |  |

schar* cv::seqPushFront | ( | CvSeq * | seq,
|  | const void * | element = `0`
| ) |  |

void cv::seqRemove | ( | CvSeq * | seq,
|  | int | index
| ) |  |

void cv::seqRemoveSlice | ( | CvSeq * | seq,
|  | CvSlice | slice
| ) |  |

bool cv::setBreakOnError | ( | bool | flag ) |

Sets/resets the break-on-error mode.

When the break-on-error mode is set, the default error handler issues a hardware exception, which can make debugging more convenient.

Returns:
  the previous state

CV_EXPORTS_W void cv::setIdentity | ( | Mat & | mtx,
|  | const Scalar & | s = `Scalar(1)`
| ) |  |

initializes scaled identity matrix

void cv::setMouseCallback | ( | const string & | windowName,
|  | MouseCallback | onMouse,
|  | void * | param = `0`
| ) |  |

assigns callback for mouse events

void cv::setNumThreads | ( | int | nthreads ) |

CV_EXPORTS_W void cv::setTrackbarPos | ( | const string & | trackbarname,
|  | const string & | winname,
|  | int | pos
| ) |  |

CV_EXPORTS_W void cv::setUseOptimized | ( | bool | onoff ) |

Turns on/off available optimization

The function turns on or off the optimized code in OpenCV. Some optimization can not be enabled or disabled, but, for example, most of SSE code in OpenCV can be temporarily turned on or off this way.

Note:
  {Since optimization may imply using special data structures, it may be unsafe to call this function anywhere in the code. Instead, call it somewhere at the top level.}

CV_EXPORTS_W void cv::setWindowProperty | ( | const string & | winname,
|  | int | prop_id,
|  | double | prop_value
| ) |  |

CV_EXPORTS_W bool cv::solve | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst,
|  | int | flags = `DECOMP_LU`
| ) |  |

solves linear system or a least-square problem

CV_EXPORTS_W int cv::solveCubic | ( | const Mat & | coeffs,
|  | CV_OUT Mat & | roots
| ) |  |

finds real roots of a cubic polynomial

CV_EXPORTS_W void cv::solvePnP | ( | const Mat & | objectPoints,
|  | const Mat & | imagePoints,
|  | const Mat & | cameraMatrix,
|  | const Mat & | distCoeffs,
|  | CV_OUT Mat & | rvec,
|  | CV_OUT Mat & | tvec,
|  | bool | useExtrinsicGuess = `false`
| ) |  |

computes the camera pose from a few 3D points and the corresponding projections. The outliers are not handled.

CV_EXPORTS_W double cv::solvePoly | ( | const Mat & | coeffs,
|  | CV_OUT Mat & | roots,
|  | int | maxIters = `300`
| ) |  |

finds real and complex roots of a polynomial

template<typename _Tp , class _LT >

void cv::sort | ( | vector< _Tp > & | vec,
|  | _LT | LT = `_LT()`
| ) |  |

CV_EXPORTS_W void cv::sort | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | flags
| ) |  |

sorts independently each matrix row or each matrix column

CV_EXPORTS_W void cv::sortIdx | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | int | flags
| ) |  |

sorts independently each matrix row or each matrix column

CV_EXPORTS_W void cv::split | ( | const Mat & | m,
|  | vector< Mat > & | mv
| ) |  |

copies each plane of a multi-channel array to a dedicated array

void cv::split | ( | const Mat & | src,
|  | Mat * | mvbegin
| ) |  |

copies each plane of a multi-channel array to a dedicated array

template<typename _Tp >

void cv::split | ( | const Mat & | src,
|  | vector< Mat_< _Tp > > & | mv
| ) |  |

CV_EXPORTS_W void cv::sqrt | ( | const Mat & | src,
|  | CV_OUT Mat & | dst
| ) |  |

computes square root of each matrix element (dst = src**0.5)

int cv::startLoop | ( | int(*)(int argc, char *argv[]) | pt2Func,
|  | int | argc,
|  | char * | argv[]
| ) |  |

CV_EXPORTS_W int cv::startWindowThread | ( | ) |

CV_EXPORTS_W double cv::stereoCalibrate | ( | const vector< vector< Point3f > > & | objectPoints,
|  | const vector< vector< Point2f > > & | imagePoints1,
|  | const vector< vector< Point2f > > & | imagePoints2,
|  | CV_IN_OUT Mat & | cameraMatrix1,
|  | CV_IN_OUT Mat & | distCoeffs1,
|  | CV_IN_OUT Mat & | cameraMatrix2,
|  | CV_IN_OUT Mat & | distCoeffs2,
|  | Size | imageSize,
|  | CV_OUT Mat & | R,
|  | CV_OUT Mat & | T,
|  | CV_OUT Mat & | E,
|  | CV_OUT Mat & | F,
|  | TermCriteria | criteria = `TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6)`,
|  | int | flags = `CALIB_FIX_INTRINSIC`
| ) |  |

finds intrinsic and extrinsic parameters of a stereo camera

CV_EXPORTS_W void cv::stereoRectify | ( | const Mat & | cameraMatrix1,
|  | const Mat & | distCoeffs1,
|  | const Mat & | cameraMatrix2,
|  | const Mat & | distCoeffs2,
|  | Size | imageSize,
|  | const Mat & | R,
|  | const Mat & | T,
|  | CV_OUT Mat & | R1,
|  | CV_OUT Mat & | R2,
|  | CV_OUT Mat & | P1,
|  | CV_OUT Mat & | P2,
|  | CV_OUT Mat & | Q,
|  | double | alpha,
|  | Size | newImageSize = `Size()`,
|  | CV_OUT Rect * | validPixROI1 = `0`,
|  | CV_OUT Rect * | validPixROI2 = `0`,
|  | int | flags = `CALIB_ZERO_DISPARITY`
| ) |  |

computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters

void cv::stereoRectify | ( | const Mat & | cameraMatrix1,
|  | const Mat & | distCoeffs1,
|  | const Mat & | cameraMatrix2,
|  | const Mat & | distCoeffs2,
|  | Size | imageSize,
|  | const Mat & | R,
|  | const Mat & | T,
|  | CV_OUT Mat & | R1,
|  | CV_OUT Mat & | R2,
|  | CV_OUT Mat & | P1,
|  | CV_OUT Mat & | P2,
|  | CV_OUT Mat & | Q,
|  | int | flags = `CALIB_ZERO_DISPARITY`
| ) |  |

computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters

CV_EXPORTS_W bool cv::stereoRectifyUncalibrated | ( | const Mat & | points1,
|  | const Mat & | points2,
|  | const Mat & | F,
|  | Size | imgSize,
|  | CV_OUT Mat & | H1,
|  | CV_OUT Mat & | H2,
|  | double | threshold = `5`
| ) |  |

computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)

void cv::stopLoop | ( | ) |

CV_EXPORTS_W void cv::subtract | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat &mask | CV_WRAP_DEFAULTMat()
| ) |  |

subtracts one matrix from another (dst = src1 - src2)

CV_EXPORTS_W void cv::subtract | ( | const Scalar & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

subtracts matrix from scalar (dst = src1 - src2)

CV_EXPORTS_W void cv::subtract | ( | const Mat & | src1,
|  | const Scalar & | src2,
|  | CV_OUT Mat & | dst,
|  | const Mat & | mask = `Mat()`
| ) |  |

subtracts scalar from a matrix (dst = src1 - src2)

void cv::subtract | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | CV_OUT Mat & | dst
| ) |  |

subtracts one matrix from another (dst = src1 - src2)

CV_EXPORTS_W Scalar cv::sum | ( | const Mat & | src ) |

computes sum of array elements

void cv::swap | ( | Mat & | a,
|  | Mat & | b
| ) |  |

swaps two matrices

RNG& cv::theRNG | ( | ) |

returns the thread-local Random number generator

CV_EXPORTS_W double cv::threshold | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | double | thresh,
|  | double | maxval,
|  | int | type
| ) |  |

applies fixed threshold to the image

WString cv::toUtf16 | ( | const string & | str ) |

CV_EXPORTS_W Scalar cv::trace | ( | const Mat & | mtx ) |

computes trace of a matrix

CV_EXPORTS_W void cv::transform | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Mat & | m
| ) |  |

performs affine transformation of each element of multi-channel input matrix

CV_EXPORTS_W void cv::transpose | ( | const Mat & | src,
|  | CV_OUT Mat & | dst
| ) |  |

transposes the matrix

CV_EXPORTS_W void cv::undistort | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Mat & | cameraMatrix,
|  | const Mat & | distCoeffs,
|  | const Mat & | newCameraMatrix = `Mat()`
| ) |  |

corrects lens distortion for the given camera matrix and distortion coefficients

void cv::undistortPoints | ( | const Mat & | src,
|  | CV_OUT vector< Point2f > & | dst,
|  | const Mat & | cameraMatrix,
|  | const Mat & | distCoeffs,
|  | const Mat & | R = `Mat()`,
|  | const Mat & | P = `Mat()`
| ) |  |

returns points' coordinates after lens distortion correction

CV_EXPORTS_W void cv::undistortPoints | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Mat & | cameraMatrix,
|  | const Mat & | distCoeffs,
|  | const Mat & | R = `Mat()`,
|  | const Mat & | P = `Mat()`
| ) |  |

returns points' coordinates after lens distortion correction

CV_EXPORTS_W void cv::updateMotionHistory | ( | const Mat & | silhouette,
|  | Mat & | mhi,
|  | double | timestamp,
|  | double | duration
| ) |  |

updates motion history image using the current silhouette

CV_EXPORTS_W bool cv::useOptimized | ( | ) |

Returns the current optimization status

The function returns the current optimization status, which is controlled by cv::setUseOptimized().

CV_EXPORTS_W void cv::validateDisparity | ( | Mat & | disparity,
|  | const Mat & | cost,
|  | int | minDisparity,
|  | int | numberOfDisparities,
|  | int | disp12MaxDisp = `1`
| ) |  |

validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm

void cv::vconcat | ( | const Mat * | src,
|  | size_t | nsrc,
|  | Mat & | dst
| ) |  |

void cv::vconcat | ( | const Mat & | src1,
|  | const Mat & | src2,
|  | Mat & | dst
| ) |  |

CV_EXPORTS_W void cv::vconcat | ( | const vector< Mat > & | src,
|  | CV_OUT Mat & | dst
| ) |  |

CV_EXPORTS_W int cv::waitKey | ( | int | delay = `0` ) |

CV_EXPORTS_W void cv::warpAffine | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Mat & | M,
|  | Size | dsize,
|  | int | flags = `INTER_LINEAR`,
|  | int | borderMode = `BORDER_CONSTANT`,
|  | const Scalar & | borderValue = `Scalar()`
| ) |  |

warps the image using affine transformation

CV_EXPORTS_W void cv::warpPerspective | ( | const Mat & | src,
|  | CV_OUT Mat & | dst,
|  | const Mat & | M,
|  | Size | dsize,
|  | int | flags = `INTER_LINEAR`,
|  | int | borderMode = `BORDER_CONSTANT`,
|  | const Scalar & | borderValue = `Scalar()`
| ) |  |

warps the image using perspective transformation

CV_EXPORTS_W void cv::watershed | ( | const Mat & | image,
|  | Mat & | markers
| ) |  |

segments the image using watershed algorithm

Mat cv::windowedMatchingMask | ( | const vector< KeyPoint > & | keypoints1,
|  | const vector< KeyPoint > & | keypoints2,
|  | float | maxDeltaX,
|  | float | maxDeltaY
| ) |  |

template<>

void cv::write | ( | FileStorage & | fs,
|  | const string & | value
| ) |  | `[inline]`

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const Rect_< _Tp > & | r
| ) |  | `[inline]`

void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const Range & | r
| ) |  | `[inline]`

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const Point_< _Tp > & | pt
| ) |  | `[inline]`

template<>

void cv::write | ( | FileStorage & | fs,
|  | const double & | value
| ) |  | `[inline]`

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const Point_< _Tp > & | pt
| ) |  | `[inline]`

CV_EXPORTS_W void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | double | value
| ) |  |

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const Complex< _Tp > & | c
| ) |  | `[inline]`

CV_EXPORTS_W void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | float | value
| ) |  |

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const Size_< _Tp > & | sz
| ) |  | `[inline]`

CV_EXPORTS_W void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | int | value
| ) |  |

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const Scalar_< _Tp > & | s
| ) |  | `[inline]`

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const Point3_< _Tp > & | pt
| ) |  | `[inline]`

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const Scalar_< _Tp > & | s
| ) |  | `[inline]`

template<typename _Tp , int cn>

void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const Vec< _Tp, cn > & | v
| ) |  | `[inline]`

void cv::write | ( | FileStorage & | fs,
|  | const Range & | r
| ) |  | `[inline]`

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const Rect_< _Tp > & | r
| ) |  | `[inline]`

template<typename _Tp , int cn>

void cv::write | ( | FileStorage & | fs,
|  | const Vec< _Tp, cn > & | v
| ) |  | `[inline]`

void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const vector< KeyPoint > & | keypoints
| ) |  |

writes vector of keypoints to the file storage

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const Size_< _Tp > & | sz
| ) |  | `[inline]`

void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const SparseMat & | value
| ) |  |

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const Point3_< _Tp > & | pt
| ) |  | `[inline]`

template<>

void cv::write | ( | FileStorage & | fs,
|  | const int & | value
| ) |  | `[inline]`

template<>

void cv::write | ( | FileStorage & | fs,
|  | const float & | value
| ) |  | `[inline]`

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const _Tp & | value
| ) |  | `[inline]`

template<typename _Tp >

void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const Complex< _Tp > & | c
| ) |  | `[inline]`

CV_EXPORTS_W void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const Mat & | value
| ) |  |

CV_EXPORTS_W void cv::write | ( | FileStorage & | fs,
|  | const string & | name,
|  | const string & | value
| ) |  |

void cv::writeScalar | ( | FileStorage & | fs,
|  | const string & | value
| ) |  |

void cv::writeScalar | ( | FileStorage & | fs,
|  | double | value
| ) |  |

void cv::writeScalar | ( | FileStorage & | fs,
|  | int | value
| ) |  |

void cv::writeScalar | ( | FileStorage & | fs,
|  | float | value
| ) |  |

## Variable Documentation

CV_OUT Mat double double int cv::apertureSize = 3

const Mat const Mat const Mat const Mat CV_OUT vector<Point2f> CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat double cv::aspectRatio = 0 )

CV_OUT Mat int int double double int cv::borderType = BORDER_DEFAULT )

const Mat const Mat const Mat& cv::cameraMatrix

CV_OUT vector<Vec3f>& cv::circles

CV_OUT Mat int cv::ddepth

CV_OUT Mat int int double double cv::delta = 0

const Mat const Mat const Mat const Mat& cv::distCoeffs

CV_OUT vector<Vec3f> int double cv::dp

const Mat const Mat const Mat const Mat CV_OUT vector<Point2f> CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dpdc

const Mat const Mat const Mat const Mat CV_OUT vector<Point2f> CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dpddist

const Mat const Mat const Mat const Mat CV_OUT vector<Point2f> CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dpdf

const Mat const Mat const Mat const Mat CV_OUT vector<Point2f> CV_OUT Mat& cv::dpdrot

const Mat const Mat const Mat const Mat CV_OUT vector<Point2f> CV_OUT Mat CV_OUT Mat& cv::dpdt

const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dr3dr1

const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dr3dr2

const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dr3dt1

const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dr3dt2

CV_OUT Mat & cv::dst

const Mat& cv::dstPoints

const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dt3dr1

const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dt3dr2

const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dt3dt1

const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::dt3dt2

CV_OUT Mat int int cv::dx

CV_OUT Mat int int int cv::dy

CV_OUT Mat& cv::edges

Mat Point Scalar CV_OUT Rect Scalar Scalar int cv::flags = 4 )

const Mat const Mat const Mat const Mat CV_OUT vector<Point2f>& cv::imagePoints

CV_OUT Mat CV_OUT Mat& cv::jacobian

CV_OUT Mat int int cv::ksize = 3

CV_OUT Mat double double int bool cv::L2gradient = false )

CV_OUT vector< Vec4i > & cv::lines

Mat Point Scalar CV_OUT Rect Scalar cv::loDiff = Scalar()

const Mat vector< uchar > & cv::mask

CV_OUT vector<Vec4i> double double int double double cv::maxLineGap = 0 )

CV_OUT vector<Vec3f> int double double double double int int cv::maxRadius = 0 )

const Mat vector< uchar > int cv::method = 0

CV_OUT vector<Vec3f> int double double cv::minDist

CV_OUT vector<Vec4i> double double int double cv::minLineLength = 0

CV_OUT vector<Vec3f> int double double double double int cv::minRadius = 0

Mat Point Scalar cv::newVal

CV_OUT vector<Vec3f> int double double double cv::param1 = 100

CV_OUT vector<Vec3f> int double double double double cv::param2 = 100

const Mat vector<uchar> int double cv::ransacReprojThreshold = 3 )

Mat Point Scalar CV_OUT Rect* cv::rect = 0

CV_OUT vector< Vec4i > double cv::rho

const Mat& cv::rvec

const Mat const Mat& cv::rvec2

const Mat const Mat const Mat CV_OUT Mat& cv::rvec3

CV_OUT Mat int int double cv::scale = 1

CV_OUT Mat CV_OUT Mat CV_OUT Mat int cv::sdepth = -1 )

Mat Point cv::seedPoint

CV_OUT Mat Size double cv::sigma1

CV_OUT Mat Size double double cv::sigma2 = 0

CV_OUT Mat CV_OUT Mat & cv::sqsum

CV_OUT vector<Vec2f> double double int double cv::srn = 0

CV_OUT vector<Vec2f> double double int double double cv::stn = 0 )

CV_OUT Mat & cv::sum

CV_OUT vector< Vec4i > double double cv::theta

CV_OUT vector< Vec4i > double double int cv::threshold

CV_OUT Mat double cv::threshold1

CV_OUT Mat double double cv::threshold2

CV_OUT Mat CV_OUT Mat CV_OUT Mat& cv::tilted

const Mat const Mat& cv::tvec

const Mat& cv::tvec1

const Mat const Mat const Mat& cv::tvec2

const Mat const Mat const Mat CV_OUT Mat CV_OUT Mat& cv::tvec3

Mat Point Scalar CV_OUT Rect Scalar Scalar cv::upDiff = Scalar()

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines