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< RectConcurrentRectVector
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_< ucharMat1b
typedef Mat_< double > Mat1d
typedef Mat_< float > Mat1f
typedef Mat_< int > Mat1i
typedef Mat_< short > Mat1s
typedef Mat_< ushortMat1w
typedef Mat_< Vec2bMat2b
typedef Mat_< Vec2dMat2d
typedef Mat_< Vec2fMat2f
typedef Mat_< Vec2iMat2i
typedef Mat_< Vec2sMat2s
typedef Mat_< Vec2wMat2w
typedef Mat_< Vec3bMat3b
typedef Mat_< Vec3dMat3d
typedef Mat_< Vec3fMat3f
typedef Mat_< Vec3iMat3i
typedef Mat_< Vec3sMat3s
typedef Mat_< Vec3wMat3w
typedef Mat_< Vec4bMat4b
typedef Mat_< Vec4dMat4d
typedef Mat_< Vec4fMat4f
typedef Mat_< Vec4iMat4i
typedef Mat_< Vec4sMat4s
typedef Mat_< Vec4wMat4w
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< CvMemStorageMemStorage
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< ushortWImage_16u
typedef WImage< ucharWImage_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< ushortWImageBuffer_16u
typedef WImageBuffer< ucharWImageBuffer_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< ushortWImageView_16u
typedef WImageView< ucharWImageView_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 = CV_MOP_ERODE, MORPH_DILATE = CV_MOP_DILATE, MORPH_OPEN = CV_MOP_OPEN, MORPH_CLOSE = CV_MOP_CLOSE,
  MORPH_GRADIENT = CV_MOP_GRADIENT, MORPH_TOPHAT = CV_MOP_TOPHAT, MORPH_BLACKHAT = CV_MOP_BLACKHAT
}
 

type of morphological operation

More...
enum  { MORPH_RECT = 0, MORPH_CROSS = 1, MORPH_ELLIPSE = 2 }
 

shape of the structuring element

More...
enum  {
  INTER_NEAREST = CV_INTER_NN, INTER_LINEAR = CV_INTER_LINEAR, INTER_CUBIC = CV_INTER_CUBIC, INTER_AREA = CV_INTER_AREA,
  INTER_LANCZOS4 = CV_INTER_LANCZOS4, INTER_MAX = 7, WARP_INVERSE_MAP = CV_WARP_INVERSE_MAP
}
 

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 = CV_THRESH_BINARY, THRESH_BINARY_INV = CV_THRESH_BINARY_INV, THRESH_TRUNC = CV_THRESH_TRUNC, THRESH_TOZERO = CV_THRESH_TOZERO,
  THRESH_TOZERO_INV = CV_THRESH_TOZERO_INV, THRESH_MASK = CV_THRESH_MASK, THRESH_OTSU = CV_THRESH_OTSU
}
 

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 = CV_INPAINT_NS, INPAINT_TELEA = CV_INPAINT_TELEA }
 

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 = CV_RETR_EXTERNAL, RETR_LIST = CV_RETR_LIST, RETR_CCOMP = CV_RETR_CCOMP, RETR_TREE = CV_RETR_TREE }
 

mode of the contour retrieval algorithm

More...
enum  { CHAIN_APPROX_NONE = CV_CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE = CV_CHAIN_APPROX_SIMPLE, CHAIN_APPROX_TC89_L1 = CV_CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS = CV_CHAIN_APPROX_TC89_KCOS }
 

the contour approximation algorithm

More...

Functions

MatExpr abs (const MatExpr &e)
MatExpr abs (const Mat &m)
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 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)
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)
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 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_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_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 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_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_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 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 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 SparseMat &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 Mat &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 (double *A, int m, double *b, int n)
bool Cholesky (float *A, int m, float *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)
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
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 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)
double compareHist (const SparseMat &H1, const SparseMat &H2, int method)
 compares two histograms stored in sparse arrays
CV_EXPORTS_W double compareHist (const Mat &H1, const Mat &H2, int method)
 compares two histograms stored in dense 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< Point2f > &dst)
 converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
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))
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< Point > &hull, bool clockwise=false)
 computes convex hull for a set of 2D points.
void convexHull (const Mat &points, CV_OUT vector< int > &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< FilterEnginecreateBoxFilter (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< FilterEnginecreateDerivFilter (int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT)
 returns filter engine for the generalized Sobel operator
Ptr< FilterEnginecreateGaussianFilter (int type, Size ksize, double sigma1, double sigma2=0, int borderType=BORDER_DEFAULT)
 returns the Gaussian filter engine
Ptr< FilterEnginecreateLinearFilter (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< FilterEnginecreateMorphologyFilter (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< FilterEnginecreateSeparableLinearFilter (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 >
void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, 1, 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, Eigen::Dynamic, Eigen::Dynamic > &dst)
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)
 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
 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 (findHomographyAndOutliers) Mat findHomography(const Mat &srcPoints
 computes the best-fit perspective transformation mapping srcPoints to dstPoints.
 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 (floodFillMask) int floodFill(Mat &image
 fills the semi-uniform image region and/or the mask starting from the specified seed point
 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 (integral2) void integral(const Mat &src
 computes the integral image and integral for the squared image
 CV_EXPORTS_AS (houghCircles) void HoughCircles(const Mat &image
 finds circles in the grayscale image using 2+1 gradient 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 (houghLines) void HoughLines(const Mat &image
 finds lines in the black-n-white image using the standard or pyramid Hough transform
 CV_EXPORTS_AS (canny) void Canny(const Mat &image
 applies Canny edge detector and produces the edge map.
 CV_EXPORTS_AS (laplacian) void Laplacian(const Mat &src
 applies Laplacian 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 (sobel) void Sobel(const Mat &src
 applies generalized Sobel operator to the image
 CV_EXPORTS_AS (gaussianBlur) void GaussianBlur(const Mat &src
 smooths the image using Gaussian filter.
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
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.
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 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)
CV_EXPORTS_W void distanceTransform (const Mat &src, CV_OUT Mat &dst, int distanceType, int maskSize)
 computes the distance transform map
void distanceTransform (const Mat &src, CV_OUT Mat &dst, Mat &labels, int distanceType, int maskSize)
 builds the discrete Voronoi diagram
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)
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)
template<typename _Tp >
DataType< _Tp >::work_type dot (const Vector< _Tp > &v1, const Vector< _Tp > &v2)
void drawChessboardCorners (Mat &image, Size patternSize, const vector< Point2f > &corners, bool patternWasFound)
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 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, CV_OUT Mat &eigenvectors, int lowindex=-1, int highindex=-1)
 finds eigenvalues and eigenvectors of a symmetric matrix
bool eigen (const Mat &src, CV_OUT Mat &eigenvalues, int lowindex=-1, int highindex=-1)
 finds eigenvalues 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, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=8)
 draws a rotated ellipse in the image
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 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
CV_EXPORTS_W bool findCirclesGrid (const Mat &image, Size patternSize, CV_OUT vector< Point2f > &centers, int flags=0)
 finds circles' grid 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.
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
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 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< BaseColumnFiltergetColumnSumFilter (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 ()
uchargetData (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< BaseColumnFiltergetLinearColumnFilter (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< BaseFiltergetLinearFilter (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< BaseRowFiltergetLinearRowFilter (int srcType, int bufType, const Mat &kernel, int anchor, int symmetryType)
 returns the primitive row filter with the specified kernel
Ptr< BaseColumnFiltergetMorphologyColumnFilter (int op, int type, int ksize, int anchor=-1)
 returns vertical 1D morphological filter
Ptr< BaseFiltergetMorphologyFilter (int op, int type, const Mat &kernel, Point anchor=Point(-1,-1))
 returns 2D morphological filter
Ptr< BaseRowFiltergetMorphologyRowFilter (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< BaseRowFiltergetRowSumFilter (int srcType, int sumType, int ksize, int anchor=-1)
 returns horizontal 1D box filter
schargetSeqElem (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)
CV_EXPORTS_W void hconcat (const vector< Mat > &src, CV_OUT Mat &dst)
void hconcat (const Mat &src1, const Mat &src2, Mat &dst)
void hconcat (const Mat *src, size_t nsrc, 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 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)
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)
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 (double *A, int m, double *b, int n)
int LU (float *A, int m, float *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
MatExpr max (double s, const Mat &a)
MatExpr max (const Mat &a, double s)
MatExpr max (const Mat &a, const Mat &b)
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))
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 Scalar mean (const Mat &src, const Mat &mask CV_WRAP_DEFAULT(Mat()))
 computes mean value of selected array elements
Scalar mean (const Mat &src)
 computes mean value of 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.
CV_EXPORTS_W void merge (const vector< Mat > &mv, Mat &dst)
 makes multi-channel array out of several single-channel arrays
void merge (const Mat *mv, size_t count, CV_OUT Mat &dst)
 makes multi-channel array out of several single-channel arrays
MatExpr min (double s, const Mat &a)
MatExpr min (const Mat &a, double s)
MatExpr min (const Mat &a, const Mat &b)
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))
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 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 vector< Mat > &src, vector< Mat > &dst, const int *fromTo, int npairs)
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
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
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
CV_EXPORTS_W double norm (const Mat &src1, int normType, const Mat &mask CV_WRAP_DEFAULT(Mat()))
 computes norm of the selected array part
double norm (const Mat &src1, const Mat &src2, int normType=NORM_L2)
 computes norm of the difference between two arrays
double norm (const Mat &src1, int normType=NORM_L2)
 computes norm of array
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!= (double s, const Mat &a)
MatExpr operator!= (const Mat &a, double s)
MatExpr operator!= (const Mat &a, const Mat &b)
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 MatExpr &e1, const MatExpr &e2)
MatExpr operator* (double s, const MatExpr &e)
MatExpr operator* (const MatExpr &e, double s)
MatExpr operator* (const Mat &m, const MatExpr &e)
MatExpr operator* (const MatExpr &e, const Mat &m)
MatExpr operator* (double s, const Mat &a)
MatExpr operator* (const Mat &a, double s)
MatExpr operator* (const Mat &a, const Mat &b)
MatExpr operator+ (const MatExpr &e1, const MatExpr &e2)
MatExpr operator+ (const Scalar &s, const MatExpr &e)
MatExpr operator+ (const MatExpr &e, const Scalar &s)
MatExpr operator+ (const Mat &m, const MatExpr &e)
MatExpr operator+ (const MatExpr &e, const Mat &m)
MatExpr operator+ (const Scalar &s, const Mat &a)
MatExpr operator+ (const Mat &a, const Scalar &s)
MatExpr operator+ (const Mat &a, const Mat &b)
template<typename _Tp >
ptrdiff_t operator- (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b)
ptrdiff_t operator- (const MatConstIterator &b, const MatConstIterator &a)
MatExpr operator- (const MatExpr &e)
MatExpr operator- (const Mat &m)
MatExpr operator- (const MatExpr &e1, const MatExpr &e2)
MatExpr operator- (const Scalar &s, const MatExpr &e)
MatExpr operator- (const MatExpr &e, const Scalar &s)
MatExpr operator- (const Mat &m, const MatExpr &e)
MatExpr operator- (const MatExpr &e, const Mat &m)
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 MatExpr &e1, const MatExpr &e2)
MatExpr operator/ (double s, const MatExpr &e)
MatExpr operator/ (const MatExpr &e, double s)
MatExpr operator/ (const Mat &m, const MatExpr &e)
MatExpr operator/ (const MatExpr &e, const Mat &m)
MatExpr operator/ (double s, const Mat &a)
MatExpr operator/ (const Mat &a, double s)
MatExpr operator/ (const Mat &a, const Mat &b)
MatExpr operator< (double s, const Mat &a)
MatExpr operator< (const Mat &a, double s)
MatExpr operator< (const Mat &a, const Mat &b)
std::ostream & operator<< (std::ostream &out, const TickMeter &tm)
template<typename _Tp >
std::ostream & operator<< (std::ostream &out, const Point3_< _Tp > &p)
template<typename _Tp >
std::ostream & operator<< (std::ostream &out, const Point_< _Tp > &p)
FileStorageoperator<< (FileStorage &fs, const string &str)
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 >
bool operator== (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b)
MatExpr operator== (double s, const Mat &a)
MatExpr operator== (const Mat &a, double s)
MatExpr operator== (const Mat &a, const Mat &b)
MatExpr operator> (double s, const Mat &a)
MatExpr operator> (const Mat &a, double s)
MatExpr operator> (const Mat &a, const Mat &b)
MatExpr operator>= (double s, const Mat &a)
MatExpr operator>= (const Mat &a, double s)
MatExpr operator>= (const Mat &a, const Mat &b)
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 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 T3 , typename Op >
void process (const Mat_< T1 > &m1, const Mat_< T2 > &m2, Mat_< T3 > &m3, Op op)
template<typename T1 , typename T2 , typename Op >
void process (const Mat_< T1 > &m1, Mat_< T2 > &m2, 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, CV_OUT vector< KeyPoint > &keypoints)
 reads vector of keypoints from the specified file storage node
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 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
Mat repeat (const Mat &src, int ny, int nx)
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
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
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.
void RQDecomp3x3 (const Mat &M, Mat &R, Mat &Q)
 Computes RQ decomposition of 3x3 matrix.
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 > (float v)
template<>
schar saturate_cast< schar > (unsigned v)
template<>
schar saturate_cast< schar > (short v)
template<>
schar saturate_cast< schar > (int v)
template<>
schar saturate_cast< schar > (ushort v)
template<>
schar saturate_cast< schar > (uchar v)
template<>
short saturate_cast< short > (double v)
template<>
short saturate_cast< short > (float v)
template<>
short saturate_cast< short > (unsigned v)
template<>
short saturate_cast< short > (int v)
template<>
short saturate_cast< short > (ushort v)
template<>
uchar saturate_cast< uchar > (double v)
template<>
uchar saturate_cast< uchar > (float v)
template<>
uchar saturate_cast< uchar > (unsigned v)
template<>
uchar saturate_cast< uchar > (short v)
template<>
uchar saturate_cast< uchar > (int v)
template<>
uchar saturate_cast< uchar > (ushort v)
template<>
uchar saturate_cast< uchar > (schar v)
template<>
unsigned saturate_cast< unsigned > (double v)
template<>
unsigned saturate_cast< unsigned > (float v)
template<>
ushort saturate_cast< ushort > (double v)
template<>
ushort saturate_cast< ushort > (float v)
template<>
ushort saturate_cast< ushort > (unsigned v)
template<>
ushort saturate_cast< ushort > (int v)
template<>
ushort saturate_cast< ushort > (short 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)
scharseqPush (CvSeq *seq, const void *element=0)
scharseqPushFront (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
template<typename _Tp >
void split (const Mat &src, vector< Mat_< _Tp > > &mv)
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
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 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 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 Scalar sum (const Mat &src)
 computes sum of array elements
void swap (Mat &a, Mat &b)
 swaps two matrices
RNGtheRNG ()
 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
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
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 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
CV_EXPORTS_W void vconcat (const vector< Mat > &src, CV_OUT Mat &dst)
void vconcat (const Mat &src1, const Mat &src2, Mat &dst)
void vconcat (const Mat *src, size_t nsrc, 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)
void write (FileStorage &fs, const string &name, const vector< KeyPoint > &keypoints)
 writes vector of keypoints to the file storage
void write (FileStorage &fs, const string &name, const SparseMat &value)
CV_EXPORTS_W void write (FileStorage &fs, const string &name, const Mat &value)
void write (FileStorage &fs, const string &name, const Range &r)
template<typename _Tp >
void write (FileStorage &fs, const string &name, const Scalar_< _Tp > &s)
template<typename _Tp , int cn>
void write (FileStorage &fs, const string &name, const Vec< _Tp, cn > &v)
template<typename _Tp >
void write (FileStorage &fs, const string &name, const Rect_< _Tp > &r)
template<typename _Tp >
void write (FileStorage &fs, const string &name, const Complex< _Tp > &c)
template<typename _Tp >
void write (FileStorage &fs, const string &name, const Size_< _Tp > &sz)
template<typename _Tp >
void write (FileStorage &fs, const string &name, const Point3_< _Tp > &pt)
template<typename _Tp >
void write (FileStorage &fs, const string &name, const Point_< _Tp > &pt)
void write (FileStorage &fs, const Range &r)
template<typename _Tp >
void write (FileStorage &fs, const Scalar_< _Tp > &s)
template<typename _Tp , int cn>
void write (FileStorage &fs, const Vec< _Tp, cn > &v)
template<typename _Tp >
void write (FileStorage &fs, const Rect_< _Tp > &r)
template<typename _Tp >
void write (FileStorage &fs, const Complex< _Tp > &c)
template<typename _Tp >
void write (FileStorage &fs, const Size_< _Tp > &sz)
template<typename _Tp >
void write (FileStorage &fs, const Point3_< _Tp > &pt)
template<typename _Tp >
void write (FileStorage &fs, const Point_< _Tp > &pt)
template<>
void write (FileStorage &fs, const string &value)
template<>
void write (FileStorage &fs, const double &value)
template<>
void write (FileStorage &fs, const float &value)
template<>
void write (FileStorage &fs, const int &value)
template<typename _Tp >
void write (FileStorage &fs, const _Tp &value)
CV_EXPORTS_W void write (FileStorage &fs, const string &name, const string &value)
CV_EXPORTS_W void write (FileStorage &fs, const string &name, double value)
CV_EXPORTS_W void write (FileStorage &fs, const string &name, float value)
CV_EXPORTS_W void write (FileStorage &fs, const string &name, int value)
void writeScalar (FileStorage &fs, const string &value)
void writeScalar (FileStorage &fs, double value)
void writeScalar (FileStorage &fs, float value)
void writeScalar (FileStorage &fs, int 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 MatcameraMatrix
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 Matdst
const MatdstPoints
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 Matedges
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 Matjacobian
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()
Matmask
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 Rectrect = 0
CV_OUT vector< Vec2f > double rho
const Matrvec
const Mat const Matrvec2
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 Matsqsum
CV_OUT vector< Vec2f > double
double int double 
srn = 0
CV_OUT vector< Vec2f > double
double int double double 
stn = 0 )
CV_OUT Matsum
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 Mattilted
const Mat const Mattvec
const Mattvec1
const Mat const Mat const Mattvec2
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 CvBoost cv::Boost
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 int(CV_CDECL * cv::ErrorCallback)(int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata)
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 void(* cv::MouseCallback)(int event, int x, int y, int flags, void *param)
typedef void(CV_CDECL * cv::OpenGLCallback)(void *userdata)
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 Rect_<int> cv::Rect
typedef Scalar_<double> cv::Scalar
typedef Size2i cv::Size
typedef Size_<float> cv::Size2f
typedef Size_<int> cv::Size2i
typedef std::string cv::String
typedef CvSVM cv::SVM
typedef void(CV_CDECL * cv::TrackbarCallback)(int pos, void *userdata)
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 WImageC<short, 1> cv::WImage1_16s
typedef WImageC<float, 1> cv::WImage1_f
typedef WImageC<short, 3> cv::WImage3_16s
typedef WImageC<float, 3> cv::WImage3_f
typedef WImage<short> cv::WImage_16s
typedef WImage<float> cv::WImage_f
typedef WImageViewC<short, 1> cv::WImageView1_16s
typedef WImageViewC<float, 1> cv::WImageView1_f
typedef WImageViewC<short, 3> cv::WImageView3_16s
typedef WImageViewC<float, 3> cv::WImageView3_f
typedef WImageView<float> cv::WImageView_f
typedef std::basic_string<wchar_t> cv::WString

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 MatExpr &  e  ) 
MatExpr cv::abs ( const Mat &  m  ) 
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 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)

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)

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 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_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_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 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_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_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::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::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 SparseMat &  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 Mat &  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 ( double *  A,
int  m,
double *  b,
int  n 
)
bool cv::Cholesky ( float *  A,
int  m,
float *  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  ) 
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

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

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

compares two histograms stored in sparse arrays

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

compares two histograms stored in dense 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< Point2f > &  dst 
)

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

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

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< Point > &  hull,
bool  clockwise = false 
)

computes convex hull for a set of 2D points.

void cv::convexHull ( const Mat &  points,
CV_OUT vector< int > &  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 >
void cv::cv2eigen ( const Mat &  src,
Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &  dst 
) [inline]
template<typename _Tp >
void cv::cv2eigen ( const Mat &  src,
Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &  dst 
) [inline]
template<typename _Tp >
void cv::cv2eigen ( const Mat &  src,
Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &  dst 
) [inline]
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 
) [inline]
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

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 ( findHomographyAndOutliers   )  const

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

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 ( floodFillMask   ) 

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

cv::CV_EXPORTS_AS ( integral3   )  const

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

cv::CV_EXPORTS_AS ( integral2   )  const

computes the integral image and integral for the squared image

cv::CV_EXPORTS_AS ( houghCircles   )  const

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

cv::CV_EXPORTS_AS ( houghLinesP   ) 

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

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 ( canny   )  const

applies Canny edge detector and produces the edge map.

cv::CV_EXPORTS_AS ( laplacian   )  const

applies Laplacian operator to the image

cv::CV_EXPORTS_AS ( scharr   )  const

applies the vertical or horizontal Scharr operator to the image

cv::CV_EXPORTS_AS ( sobel   )  const

applies generalized Sobel operator to the image

cv::CV_EXPORTS_AS ( gaussianBlur   )  const

smooths the image using Gaussian filter.

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

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.

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::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 
)
CV_EXPORTS_W void cv::distanceTransform ( const Mat &  src,
CV_OUT Mat &  dst,
int  distanceType,
int  maskSize 
)

computes the distance transform map

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::divide ( double  scale,
const Mat &  src2,
CV_OUT Mat &  dst 
)

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

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)

template<typename _Tp >
DataType<_Tp>::work_type cv::dot ( const Vector< _Tp > &  v1,
const Vector< _Tp > &  v2 
) [inline]
void cv::drawChessboardCorners ( Mat &  image,
Size  patternSize,
const vector< Point2f > &  corners,
bool  patternWasFound 
)
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::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,
CV_OUT Mat &  eigenvectors,
int  lowindex = -1,
int  highindex = -1 
)

finds eigenvalues and eigenvectors of a symmetric matrix

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

finds eigenvalues 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 
) [inline]
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::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::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

CV_EXPORTS_W bool cv::findCirclesGrid ( const Mat &  image,
Size  patternSize,
CV_OUT vector< Point2f > &  centers,
int  flags = 0 
)

finds circles' grid 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.

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

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::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 
)
CV_EXPORTS_W void cv::hconcat ( const vector< Mat > &  src,
CV_OUT Mat &  dst 
)
void cv::hconcat ( const Mat &  src1,
const Mat &  src2,
Mat &  dst 
)
void cv::hconcat ( const Mat *  src,
size_t  nsrc,
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 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)

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)

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 ( double *  A,
int  m,
double *  b,
int  n 
)
int cv::LU ( float *  A,
int  m,
float *  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

MatExpr cv::max ( double  s,
const Mat &  a 
)
MatExpr cv::max ( const Mat &  a,
double  s 
)
MatExpr cv::max ( const Mat &  a,
const Mat &  b 
)
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))

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 Scalar cv::mean ( const Mat &  src,
const Mat &mask   CV_WRAP_DEFAULTMat() 
)

computes mean value of selected array elements

Scalar cv::mean ( const Mat &  src  ) 

computes mean value of 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.

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

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

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

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

MatExpr cv::min ( double  s,
const Mat &  a 
)
MatExpr cv::min ( const Mat &  a,
double  s 
)
MatExpr cv::min ( const Mat &  a,
const Mat &  b 
)
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))

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 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 vector< Mat > &  src,
vector< Mat > &  dst,
const int *  fromTo,
int  npairs 
)
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

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

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

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

computes norm of the selected array part

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

computes norm of the difference between two arrays

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

computes norm of array

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!= ( double  s,
const Mat &  a 
)
MatExpr cv::operator!= ( const Mat &  a,
double  s 
)
MatExpr cv::operator!= ( const Mat &  a,
const Mat &  b 
)
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 MatExpr &  e1,
const MatExpr &  e2 
)
MatExpr cv::operator* ( double  s,
const MatExpr &  e 
)
MatExpr cv::operator* ( const MatExpr &  e,
double  s 
)
MatExpr cv::operator* ( const Mat &  m,
const MatExpr &  e 
)
MatExpr cv::operator* ( const MatExpr &  e,
const Mat &  m 
)
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 
)
MatExpr cv::operator+ ( const MatExpr &  e1,
const MatExpr &  e2 
)
MatExpr cv::operator+ ( const Scalar &  s,
const MatExpr &  e 
)
MatExpr cv::operator+ ( const MatExpr &  e,
const Scalar &  s 
)
MatExpr cv::operator+ ( const Mat &  m,
const MatExpr &  e 
)
MatExpr cv::operator+ ( const MatExpr &  e,
const Mat &  m 
)
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 
)
template<typename _Tp >
ptrdiff_t cv::operator- ( const SeqIterator< _Tp > &  a,
const SeqIterator< _Tp > &  b 
) [inline]
ptrdiff_t cv::operator- ( const MatConstIterator &  b,
const MatConstIterator &  a 
)
MatExpr cv::operator- ( const MatExpr &  e  ) 
MatExpr cv::operator- ( const Mat &  m  ) 
MatExpr cv::operator- ( const MatExpr &  e1,
const MatExpr &  e2 
)
MatExpr cv::operator- ( const Scalar &  s,
const MatExpr &  e 
)
MatExpr cv::operator- ( const MatExpr &  e,
const Scalar &  s 
)
MatExpr cv::operator- ( const Mat &  m,
const MatExpr &  e 
)
MatExpr cv::operator- ( const MatExpr &  e,
const Mat &  m 
)
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 MatExpr &  e1,
const MatExpr &  e2 
)
MatExpr cv::operator/ ( double  s,
const MatExpr &  e 
)
MatExpr cv::operator/ ( const MatExpr &  e,
double  s 
)
MatExpr cv::operator/ ( const Mat &  m,
const MatExpr &  e 
)
MatExpr cv::operator/ ( const MatExpr &  e,
const Mat &  m 
)
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 
)
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 
)
std::ostream& cv::operator<< ( std::ostream &  out,
const TickMeter &  tm 
)
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

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

FileStorage& cv::operator<< ( FileStorage &  fs,
const string &  str 
)
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 >
bool cv::operator== ( const SeqIterator< _Tp > &  a,
const SeqIterator< _Tp > &  b 
) [inline]
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 
)
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 
)
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 
)
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 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() 
) [inline]
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 T3 , typename Op >
void cv::process ( const Mat_< T1 > &  m1,
const Mat_< T2 > &  m2,
Mat_< T3 > &  m3,
Op  op 
) [inline]
template<typename T1 , typename T2 , typename Op >
void cv::process ( const Mat_< T1 > &  m1,
Mat_< T2 > &  m2,
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