OpenCV  2.4.13
Open Source Computer Vision
cv Namespace Reference

Namespaces

 detail
 
 fisheye
 
 flann
 
 gpu
 
 linemod
 
 ocl
 
 of2
 
 ogl
 
 RenderMode
 render mode
 
 superres
 
 videostab
 

Classes

class  _InputArray
 
class  _OutputArray
 
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  Affine3
 
class  Algorithm
 
class  AlgorithmInfo
 
class  Allocator
 
class  AutoBuffer
 
class  AutoLock
 
class  BackgroundSubtractor
 
class  BackgroundSubtractorGMG
 
class  BackgroundSubtractorMOG
 
class  BackgroundSubtractorMOG2
 
class  BaseColumnFilter
 
class  BaseFilter
 
struct  BaseKeypoint
 
class  BaseRowFilter
 
class  BFMatcher
 
class  BlockedRange
 
class  BOWImgDescriptorExtractor
 
class  BOWKMeansTrainer
 
class  BOWTrainer
 
class  BriefDescriptorExtractor
 
class  BRISK
 
class  BruteForceMatcher
 
class  CalonderDescriptorExtractor
 
class  CascadeClassifier
 
class  CLAHE
 
class  CommandLineParser
 
class  Complex
 
class  CompressedRectilinearPortraitWarper
 
class  CompressedRectilinearWarper
 
class  CvAffinePose
 
class  CvFeatureTracker
 
struct  CvFeatureTrackerParams
 
class  CvHybridTracker
 
struct  CvHybridTrackerParams
 
class  CvMeanShiftTracker
 
struct  CvMeanShiftTrackerParams
 
struct  CvMotionModel
 
class  CylindricalWarper
 
class  CylindricalWarperGpu
 
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< Affine3< _Tp > >
 
class  DataType< bool >
 
class  DataType< char >
 
class  DataType< Complex< _Tp > >
 
class  DataType< double >
 
class  DataType< float >
 
class  DataType< int >
 
class  DataType< Matx< _Tp, m, n > >
 
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 > >
 
class  DenseFeatureDetector
 
class  DenseOpticalFlow
 
class  DescriptorExtractor
 
class  DescriptorMatcher
 
struct  DetectionROI
 
class  Directory
 
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  EM
 
class  Exception
 
class  FaceRecognizer
 
class  FastAdjuster
 an adjust for the FAST detector. This will basically decrement or increment the threshold by 1 More...
 
class  FastFeatureDetector
 
class  Feature2D
 
class  FeatureDetector
 
class  FeatureEvaluator
 
class  FernClassifier
 
class  FernDescriptorMatcher
 
class  FileNode
 
class  FileNodeIterator
 
class  FileStorage
 
class  FilterEngine
 
class  FisheyeWarper
 
class  FlannBasedMatcher
 
struct  Formatted
 
class  Formatter
 
class  FREAK
 
class  GeneralizedHough
 
class  GenericDescriptorMatcher
 
class  GFTTDetector
 
class  GlArrays
 OpenGL Arrays. More...
 
class  GlBuffer
 Smart pointer for OpenGL buffer memory with reference counting. More...
 
class  GlCamera
 OpenGL camera. More...
 
class  GlFont
 OpenGL Font. More...
 
class  GlTexture
 Smart pointer for OpenGL 2d texture memory with reference counting. More...
 
class  GreaterEq
 
class  GreaterEqIdx
 
class  GridAdaptedFeatureDetector
 
struct  Hamming
 
struct  HammingMultilevel
 
struct  HOGDescriptor
 
class  KalmanFilter
 
class  KDTree
 
class  KeyPoint
 
class  KeyPointsFilter
 
struct  L1
 
struct  L2
 
class  LatentSvmDetector
 
class  LDA
 
class  LDetector
 
class  LessThan
 
class  LessThanIdx
 
class  LevMarqSparse
 
class  LineIterator
 
class  LogPolar_Adjacent
 
class  LogPolar_Interp
 
class  LogPolar_Overlapping
 
class  Mat
 
class  Mat_
 
class  MatAllocator
 
class  MatCommaInitializer_
 
class  MatConstIterator
 
class  MatConstIterator_
 
class  MatExpr
 
class  MatIterator_
 
class  MatOp
 
class  MatOp_Iter_
 
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  MercatorWarper
 
class  Mesh3D
 
class  Moments
 raster image moments More...
 
class  MSER
 
class  Mutex
 
class  NAryMatIterator
 
class  Octree
 
class  OneWayDescriptor
 
class  OneWayDescriptorBase
 
class  OneWayDescriptorMatcher
 
class  OneWayDescriptorObject
 
class  OpponentColorDescriptorExtractor
 
class  ORB
 
class  PaniniPortraitWarper
 
class  PaniniWarper
 
class  ParallelLoopBody
 
struct  Param
 
struct  ParamType
 
struct  ParamType< Algorithm >
 
struct  ParamType< bool >
 
struct  ParamType< double >
 
struct  ParamType< float >
 
struct  ParamType< int >
 
struct  ParamType< Mat >
 
struct  ParamType< short >
 
struct  ParamType< string >
 
struct  ParamType< uchar >
 
struct  ParamType< uint64 >
 
struct  ParamType< unsigned >
 
struct  ParamType< vector< Mat > >
 
class  PatchGenerator
 
class  PCA
 
class  PlanarObjectDetector
 
class  PlaneWarper
 
class  PlaneWarperGpu
 
class  Point3_
 
class  Point_
 
class  Ptr
 
class  PyramidAdaptedFeatureDetector
 
class  RandomizedTree
 
class  Range
 
class  Rect_
 
class  Retina
 
class  RNG
 
class  RNG_MT19937
 
class  RotatedRect
 
class  RTreeClassifier
 
struct  RTreeNode
 
struct  RTTIImpl
 
class  Scalar_
 
class  SelfSimDescriptor
 
class  Seq
 
class  SeqIterator
 
class  SIFT
 
class  SimilarRects
 
class  SimpleBlobDetector
 
class  Size_
 
struct  SL2
 
class  SparseMat
 
class  SparseMat_
 
class  SparseMatConstIterator
 
class  SparseMatConstIterator_
 
class  SparseMatIterator
 
class  SparseMatIterator_
 
class  SphericalWarper
 
class  SphericalWarperGpu
 
class  SpinImageModel
 
class  Split
 
class  StarAdjuster
 
class  StarDetector
 
class  StereoBM
 
class  StereographicWarper
 
class  StereoSGBM
 
class  StereoVar
 
class  Stitcher
 
class  Subdiv2D
 
class  SURF
 
class  SurfAdjuster
 
class  SVD
 
class  TermCriteria
 
class  TickMeter
 
class  TLSData
 
class  TLSDataContainer
 
class  TransverseMercatorWarper
 
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  WarperCreator
 
class  WImage
 
class  WImageBuffer
 
class  WImageBufferC
 
class  WImageC
 
class  WImageView
 
class  WImageViewC
 
class  WriteStructContext
 

Typedefs

typedef Affine3< float > Affine3f
 
typedef Affine3< double > Affine3d
 
typedef std::string String
 
typedef Mat MatND
 
typedef std::basic_string< wchar_t > WString
 
typedef int(CV_CDECLErrorCallback) (int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata)
 
typedef Matx< float, 1, 2 > Matx12f
 
typedef Matx< double, 1, 2 > Matx12d
 
typedef Matx< float, 1, 3 > Matx13f
 
typedef Matx< double, 1, 3 > Matx13d
 
typedef Matx< float, 1, 4 > Matx14f
 
typedef Matx< double, 1, 4 > Matx14d
 
typedef Matx< float, 1, 6 > Matx16f
 
typedef Matx< double, 1, 6 > Matx16d
 
typedef Matx< float, 2, 1 > Matx21f
 
typedef Matx< double, 2, 1 > Matx21d
 
typedef Matx< float, 3, 1 > Matx31f
 
typedef Matx< double, 3, 1 > Matx31d
 
typedef Matx< float, 4, 1 > Matx41f
 
typedef Matx< double, 4, 1 > Matx41d
 
typedef Matx< float, 6, 1 > Matx61f
 
typedef Matx< double, 6, 1 > Matx61d
 
typedef Matx< float, 2, 2 > Matx22f
 
typedef Matx< double, 2, 2 > Matx22d
 
typedef Matx< float, 2, 3 > Matx23f
 
typedef Matx< double, 2, 3 > Matx23d
 
typedef Matx< float, 3, 2 > Matx32f
 
typedef Matx< double, 3, 2 > Matx32d
 
typedef Matx< float, 3, 3 > Matx33f
 
typedef Matx< double, 3, 3 > Matx33d
 
typedef Matx< float, 3, 4 > Matx34f
 
typedef Matx< double, 3, 4 > Matx34d
 
typedef Matx< float, 4, 3 > Matx43f
 
typedef Matx< double, 4, 3 > Matx43d
 
typedef Matx< float, 4, 4 > Matx44f
 
typedef Matx< double, 4, 4 > Matx44d
 
typedef Matx< float, 6, 6 > Matx66f
 
typedef Matx< double, 6, 6 > Matx66d
 
typedef Vec< uchar, 2 > Vec2b
 
typedef Vec< uchar, 3 > Vec3b
 
typedef Vec< uchar, 4 > Vec4b
 
typedef Vec< short, 2 > Vec2s
 
typedef Vec< short, 3 > Vec3s
 
typedef Vec< short, 4 > Vec4s
 
typedef Vec< ushort, 2 > Vec2w
 
typedef Vec< ushort, 3 > Vec3w
 
typedef Vec< ushort, 4 > Vec4w
 
typedef Vec< int, 2 > Vec2i
 
typedef Vec< int, 3 > Vec3i
 
typedef Vec< int, 4 > Vec4i
 
typedef Vec< int, 6 > Vec6i
 
typedef Vec< int, 8 > Vec8i
 
typedef Vec< float, 2 > Vec2f
 
typedef Vec< float, 3 > Vec3f
 
typedef Vec< float, 4 > Vec4f
 
typedef Vec< float, 6 > Vec6f
 
typedef Vec< double, 2 > Vec2d
 
typedef Vec< double, 3 > Vec3d
 
typedef Vec< double, 4 > Vec4d
 
typedef Vec< double, 6 > Vec6d
 
typedef Complex< float > Complexf
 
typedef Complex< double > Complexd
 
typedef Point_< intPoint2i
 
typedef Point2i Point
 
typedef Size_< intSize2i
 
typedef Size_< double > Size2d
 
typedef Size2i Size
 
typedef Rect_< intRect
 
typedef Point_< float > Point2f
 
typedef Point_< double > Point2d
 
typedef Size_< float > Size2f
 
typedef Point3_< intPoint3i
 
typedef Point3_< float > Point3f
 
typedef Point3_< double > Point3d
 
typedef Scalar_< double > Scalar
 
typedef const _InputArrayInputArray
 
typedef InputArray InputArrayOfArrays
 
typedef const _OutputArrayOutputArray
 
typedef OutputArray OutputArrayOfArrays
 
typedef OutputArray InputOutputArray
 
typedef OutputArray InputOutputArrayOfArrays
 
typedef void(* BinaryFunc) (const uchar *src1, size_t step1, const uchar *src2, size_t step2, uchar *dst, size_t step, Size sz, void *)
 
typedef Mat_< ucharMat1b
 
typedef Mat_< Vec2bMat2b
 
typedef Mat_< Vec3bMat3b
 
typedef Mat_< Vec4bMat4b
 
typedef Mat_< short > Mat1s
 
typedef Mat_< Vec2sMat2s
 
typedef Mat_< Vec3sMat3s
 
typedef Mat_< Vec4sMat4s
 
typedef Mat_< ushortMat1w
 
typedef Mat_< Vec2wMat2w
 
typedef Mat_< Vec3wMat3w
 
typedef Mat_< Vec4wMat4w
 
typedef Mat_< intMat1i
 
typedef Mat_< Vec2iMat2i
 
typedef Mat_< Vec3iMat3i
 
typedef Mat_< Vec4iMat4i
 
typedef Mat_< float > Mat1f
 
typedef Mat_< Vec2fMat2f
 
typedef Mat_< Vec3fMat3f
 
typedef Mat_< Vec4fMat4f
 
typedef Mat_< double > Mat1d
 
typedef Mat_< Vec2dMat2d
 
typedef Mat_< Vec3dMat3d
 
typedef Mat_< Vec4dMat4d
 
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 Ptr< CvMemStorageMemStorage
 
typedef std::vector< RectConcurrentRectVector
 
typedef std::vector< double > ConcurrentDoubleVector
 
typedef WImage< ucharWImage_b
 
typedef WImageView< ucharWImageView_b
 
typedef WImageBuffer< ucharWImageBuffer_b
 
typedef WImageC< uchar, 1 > WImage1_b
 
typedef WImageViewC< uchar, 1 > WImageView1_b
 
typedef WImageBufferC< uchar, 1 > WImageBuffer1_b
 
typedef WImageC< uchar, 3 > WImage3_b
 
typedef WImageViewC< uchar, 3 > WImageView3_b
 
typedef WImageBufferC< uchar, 3 > WImageBuffer3_b
 
typedef WImage< float > WImage_f
 
typedef WImageView< float > WImageView_f
 
typedef WImageBuffer< float > WImageBuffer_f
 
typedef WImageC< float, 1 > WImage1_f
 
typedef WImageViewC< float, 1 > WImageView1_f
 
typedef WImageBufferC< float, 1 > WImageBuffer1_f
 
typedef WImageC< float, 3 > WImage3_f
 
typedef WImageViewC< float, 3 > WImageView3_f
 
typedef WImageBufferC< float, 3 > WImageBuffer3_f
 
typedef WImage< short > WImage_16s
 
typedef WImageView< short > WImageView_16s
 
typedef WImageBuffer< short > WImageBuffer_16s
 
typedef WImageC< short, 1 > WImage1_16s
 
typedef WImageViewC< short, 1 > WImageView1_16s
 
typedef WImageBufferC< short, 1 > WImageBuffer1_16s
 
typedef WImageC< short, 3 > WImage3_16s
 
typedef WImageViewC< short, 3 > WImageView3_16s
 
typedef WImageBufferC< short, 3 > WImageBuffer3_16s
 
typedef WImage< ushortWImage_16u
 
typedef WImageView< ushortWImageView_16u
 
typedef WImageBuffer< ushortWImageBuffer_16u
 
typedef WImageC< ushort, 1 > WImage1_16u
 
typedef WImageViewC< ushort, 1 > WImageView1_16u
 
typedef WImageBufferC< ushort, 1 > WImageBuffer1_16u
 
typedef WImageC< ushort, 3 > WImage3_16u
 
typedef WImageViewC< ushort, 3 > WImageView3_16u
 
typedef WImageBufferC< ushort, 3 > WImageBuffer3_16u
 
typedef void(* MouseCallback) (int event, int x, int y, int flags, void *userdata)
 
typedef void(CV_CDECLTrackbarCallback) (int pos, void *userdata)
 
typedef void(* OpenGlDrawCallback) (void *userdata)
 
typedef void(CV_CDECLButtonCallback) (int state, void *userdata)
 
typedef ORB OrbFeatureDetector
 
typedef ORB OrbDescriptorExtractor
 
typedef MSER MserFeatureDetector
 
typedef GFTTDetector GoodFeaturesToTrackDetector
 
typedef StarDetector StarFeatureDetector
 
typedef Hamming HammingLUT
 
typedef GenericDescriptorMatcher GenericDescriptorMatch
 
typedef VectorDescriptorMatcher VectorDescriptorMatch
 
typedef CvStatModel StatModel
 
typedef CvParamGrid ParamGrid
 
typedef CvNormalBayesClassifier NormalBayesClassifier
 
typedef CvKNearest KNearest
 
typedef CvSVMParams SVMParams
 
typedef CvSVMKernel SVMKernel
 
typedef CvSVMSolver SVMSolver
 
typedef CvSVM SVM
 
typedef CvDTreeParams DTreeParams
 
typedef CvMLData TrainData
 
typedef CvDTree DecisionTree
 
typedef CvForestTree ForestTree
 
typedef CvRTParams RandomTreeParams
 
typedef CvRTrees RandomTrees
 
typedef CvERTreeTrainData ERTreeTRainData
 
typedef CvForestERTree ERTree
 
typedef CvERTrees ERTrees
 
typedef CvBoostParams BoostParams
 
typedef CvBoostTree BoostTree
 
typedef CvBoost Boost
 
typedef CvANN_MLP_TrainParams ANN_MLP_TrainParams
 
typedef CvANN_MLP NeuralNet_MLP
 
typedef CvGBTreesParams GradientBoostingTreeParams
 
typedef CvGBTrees GradientBoostingTrees
 
typedef SIFT SiftFeatureDetector
 
typedef SIFT SiftDescriptorExtractor
 
typedef SURF SurfFeatureDetector
 
typedef SURF SurfDescriptorExtractor
 
typedef bool(* BundleAdjustCallback) (int iteration, double norm_error, void *user_data)
 
typedef CvMotionModel MotionModel
 
typedef CvMeanShiftTrackerParams MeanShiftTrackerParams
 
typedef CvFeatureTrackerParams FeatureTrackerParams
 
typedef CvHybridTrackerParams HybridTrackerParams
 
typedef CvMeanShiftTracker MeanShiftTracker
 
typedef CvFeatureTracker FeatureTracker
 
typedef CvHybridTracker HybridTracker
 
typedef CvEMParams EMParams
 
typedef CvEM ExpectationMaximization
 
typedef LDetector YAPE
 
typedef OneWayDescriptorMatcher OneWayDescriptorMatch
 
typedef FernDescriptorMatcher FernDescriptorMatch
 

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_L2SQR =5,
  NORM_HAMMING =6, NORM_HAMMING2 =7, NORM_TYPE_MASK =7, NORM_RELATIVE =8,
  NORM_MINMAX =32
}
 
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  {
  DEPTH_MASK_8U = 1 << CV_8U, DEPTH_MASK_8S = 1 << CV_8S, DEPTH_MASK_16U = 1 << CV_16U, DEPTH_MASK_16S = 1 << CV_16S,
  DEPTH_MASK_32S = 1 << CV_32S, DEPTH_MASK_32F = 1 << CV_32F, DEPTH_MASK_64F = 1 << CV_64F, DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
  DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S, DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
}
 
enum  { MAGIC_MASK =0xFFFF0000, TYPE_MASK =0x00000FFF, DEPTH_MASK =7 }
 
enum  { SORT_EVERY_ROW =0, SORT_EVERY_COLUMN =1, SORT_ASCENDING =0, SORT_DESCENDING =16 }
 
enum  {
  COVAR_SCRAMBLED =0, COVAR_NORMAL =1, COVAR_USE_AVG =2, COVAR_SCALE =4,
  COVAR_ROWS =8, COVAR_COLS =16
}
 
enum  { KMEANS_RANDOM_CENTERS =0, KMEANS_PP_CENTERS =2, KMEANS_USE_INITIAL_LABELS =1 }
 
enum  MarkerTypes {
  MARKER_CROSS = 0, MARKER_TILTED_CROSS = 1, MARKER_STAR = 2, MARKER_DIAMOND = 3,
  MARKER_SQUARE = 4, MARKER_TRIANGLE_UP = 5, MARKER_TRIANGLE_DOWN = 6
}
 Possible set of marker types used for the drawMarker function. 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  {
  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, MORPH_HITMISS
}
 type of morphological operation More...
 
enum  { MORPH_RECT =0, MORPH_CROSS =1, MORPH_ELLIPSE =2 }
 shape of the structuring element More...
 
enum  { GHT_POSITION = 0, GHT_SCALE = 1, GHT_ROTATION = 2 }
 
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  { GC_INIT_WITH_RECT = 0, GC_INIT_WITH_MASK = 1, GC_EVAL = 2 }
 GrabCut algorithm flags. More...
 
enum  { DIST_LABEL_CCOMP = 0, DIST_LABEL_PIXEL = 1 }
 
enum  { FLOODFILL_FIXED_RANGE = 1 << 16, FLOODFILL_MASK_ONLY = 1 << 17 }
 
enum  {
  COLOR_BGR2BGRA =0, COLOR_RGB2RGBA =COLOR_BGR2BGRA, COLOR_BGRA2BGR =1, COLOR_RGBA2RGB =COLOR_BGRA2BGR,
  COLOR_BGR2RGBA =2, COLOR_RGB2BGRA =COLOR_BGR2RGBA, COLOR_RGBA2BGR =3, COLOR_BGRA2RGB =COLOR_RGBA2BGR,
  COLOR_BGR2RGB =4, COLOR_RGB2BGR =COLOR_BGR2RGB, COLOR_BGRA2RGBA =5, COLOR_RGBA2BGRA =COLOR_BGRA2RGBA,
  COLOR_BGR2GRAY =6, COLOR_RGB2GRAY =7, COLOR_GRAY2BGR =8, COLOR_GRAY2RGB =COLOR_GRAY2BGR,
  COLOR_GRAY2BGRA =9, COLOR_GRAY2RGBA =COLOR_GRAY2BGRA, COLOR_BGRA2GRAY =10, COLOR_RGBA2GRAY =11,
  COLOR_BGR2BGR565 =12, COLOR_RGB2BGR565 =13, COLOR_BGR5652BGR =14, COLOR_BGR5652RGB =15,
  COLOR_BGRA2BGR565 =16, COLOR_RGBA2BGR565 =17, COLOR_BGR5652BGRA =18, COLOR_BGR5652RGBA =19,
  COLOR_GRAY2BGR565 =20, COLOR_BGR5652GRAY =21, COLOR_BGR2BGR555 =22, COLOR_RGB2BGR555 =23,
  COLOR_BGR5552BGR =24, COLOR_BGR5552RGB =25, COLOR_BGRA2BGR555 =26, COLOR_RGBA2BGR555 =27,
  COLOR_BGR5552BGRA =28, COLOR_BGR5552RGBA =29, COLOR_GRAY2BGR555 =30, COLOR_BGR5552GRAY =31,
  COLOR_BGR2XYZ =32, COLOR_RGB2XYZ =33, COLOR_XYZ2BGR =34, COLOR_XYZ2RGB =35,
  COLOR_BGR2YCrCb =36, COLOR_RGB2YCrCb =37, COLOR_YCrCb2BGR =38, COLOR_YCrCb2RGB =39,
  COLOR_BGR2HSV =40, COLOR_RGB2HSV =41, COLOR_BGR2Lab =44, COLOR_RGB2Lab =45,
  COLOR_BayerBG2BGR =46, COLOR_BayerGB2BGR =47, COLOR_BayerRG2BGR =48, COLOR_BayerGR2BGR =49,
  COLOR_BayerBG2RGB =COLOR_BayerRG2BGR, COLOR_BayerGB2RGB =COLOR_BayerGR2BGR, COLOR_BayerRG2RGB =COLOR_BayerBG2BGR, COLOR_BayerGR2RGB =COLOR_BayerGB2BGR,
  COLOR_BGR2Luv =50, COLOR_RGB2Luv =51, COLOR_BGR2HLS =52, COLOR_RGB2HLS =53,
  COLOR_HSV2BGR =54, COLOR_HSV2RGB =55, COLOR_Lab2BGR =56, COLOR_Lab2RGB =57,
  COLOR_Luv2BGR =58, COLOR_Luv2RGB =59, COLOR_HLS2BGR =60, COLOR_HLS2RGB =61,
  COLOR_BayerBG2BGR_VNG =62, COLOR_BayerGB2BGR_VNG =63, COLOR_BayerRG2BGR_VNG =64, COLOR_BayerGR2BGR_VNG =65,
  COLOR_BayerBG2RGB_VNG =COLOR_BayerRG2BGR_VNG, COLOR_BayerGB2RGB_VNG =COLOR_BayerGR2BGR_VNG, COLOR_BayerRG2RGB_VNG =COLOR_BayerBG2BGR_VNG, COLOR_BayerGR2RGB_VNG =COLOR_BayerGB2BGR_VNG,
  COLOR_BGR2HSV_FULL = 66, COLOR_RGB2HSV_FULL = 67, COLOR_BGR2HLS_FULL = 68, COLOR_RGB2HLS_FULL = 69,
  COLOR_HSV2BGR_FULL = 70, COLOR_HSV2RGB_FULL = 71, COLOR_HLS2BGR_FULL = 72, COLOR_HLS2RGB_FULL = 73,
  COLOR_LBGR2Lab = 74, COLOR_LRGB2Lab = 75, COLOR_LBGR2Luv = 76, COLOR_LRGB2Luv = 77,
  COLOR_Lab2LBGR = 78, COLOR_Lab2LRGB = 79, COLOR_Luv2LBGR = 80, COLOR_Luv2LRGB = 81,
  COLOR_BGR2YUV = 82, COLOR_RGB2YUV = 83, COLOR_YUV2BGR = 84, COLOR_YUV2RGB = 85,
  COLOR_BayerBG2GRAY = 86, COLOR_BayerGB2GRAY = 87, COLOR_BayerRG2GRAY = 88, COLOR_BayerGR2GRAY = 89,
  COLOR_YUV2RGB_NV12 = 90, COLOR_YUV2BGR_NV12 = 91, COLOR_YUV2RGB_NV21 = 92, COLOR_YUV2BGR_NV21 = 93,
  COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21, COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21, COLOR_YUV2RGBA_NV12 = 94, COLOR_YUV2BGRA_NV12 = 95,
  COLOR_YUV2RGBA_NV21 = 96, COLOR_YUV2BGRA_NV21 = 97, COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21, COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21,
  COLOR_YUV2RGB_YV12 = 98, COLOR_YUV2BGR_YV12 = 99, COLOR_YUV2RGB_IYUV = 100, COLOR_YUV2BGR_IYUV = 101,
  COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV, COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV, COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12, COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12,
  COLOR_YUV2RGBA_YV12 = 102, COLOR_YUV2BGRA_YV12 = 103, COLOR_YUV2RGBA_IYUV = 104, COLOR_YUV2BGRA_IYUV = 105,
  COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV, COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV, COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12, COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12,
  COLOR_YUV2GRAY_420 = 106, COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420, COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420, COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420,
  COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420, COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420, COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420, COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420,
  COLOR_YUV2RGB_UYVY = 107, COLOR_YUV2BGR_UYVY = 108, COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY, COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY,
  COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY, COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY, COLOR_YUV2RGBA_UYVY = 111, COLOR_YUV2BGRA_UYVY = 112,
  COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY, COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY, COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY, COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY,
  COLOR_YUV2RGB_YUY2 = 115, COLOR_YUV2BGR_YUY2 = 116, COLOR_YUV2RGB_YVYU = 117, COLOR_YUV2BGR_YVYU = 118,
  COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2, COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2, COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2, COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2,
  COLOR_YUV2RGBA_YUY2 = 119, COLOR_YUV2BGRA_YUY2 = 120, COLOR_YUV2RGBA_YVYU = 121, COLOR_YUV2BGRA_YVYU = 122,
  COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2, COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2, COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2, COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2,
  COLOR_YUV2GRAY_UYVY = 123, COLOR_YUV2GRAY_YUY2 = 124, COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY, COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY,
  COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2, COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2, COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2, COLOR_RGBA2mRGBA = 125,
  COLOR_mRGBA2RGBA = 126, COLOR_RGB2YUV_I420 = 127, COLOR_BGR2YUV_I420 = 128, COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420,
  COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420, COLOR_RGBA2YUV_I420 = 129, COLOR_BGRA2YUV_I420 = 130, COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420,
  COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420, COLOR_RGB2YUV_YV12 = 131, COLOR_BGR2YUV_YV12 = 132, COLOR_RGBA2YUV_YV12 = 133,
  COLOR_BGRA2YUV_YV12 = 134, COLOR_COLORCVT_MAX = 135
}
 
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,
  RETR_FLOODFILL =CV_RETR_FLOODFILL
}
 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...
 
enum  {
  WINDOW_NORMAL = CV_WINDOW_NORMAL, WINDOW_AUTOSIZE = CV_WINDOW_AUTOSIZE, WINDOW_OPENGL = CV_WINDOW_OPENGL, WND_PROP_FULLSCREEN = CV_WND_PROP_FULLSCREEN,
  WND_PROP_AUTOSIZE = CV_WND_PROP_AUTOSIZE, WND_PROP_ASPECT_RATIO = CV_WND_PROP_ASPECTRATIO, WND_PROP_OPENGL = CV_WND_PROP_OPENGL
}
 
enum  {
  EVENT_MOUSEMOVE =0, EVENT_LBUTTONDOWN =1, EVENT_RBUTTONDOWN =2, EVENT_MBUTTONDOWN =3,
  EVENT_LBUTTONUP =4, EVENT_RBUTTONUP =5, EVENT_MBUTTONUP =6, EVENT_LBUTTONDBLCLK =7,
  EVENT_RBUTTONDBLCLK =8, EVENT_MBUTTONDBLCLK =9
}
 
enum  {
  EVENT_FLAG_LBUTTON =1, EVENT_FLAG_RBUTTON =2, EVENT_FLAG_MBUTTON =4, EVENT_FLAG_CTRLKEY =8,
  EVENT_FLAG_SHIFTKEY =16, EVENT_FLAG_ALTKEY =32
}
 
enum  {
  IMREAD_UNCHANGED =-1, IMREAD_GRAYSCALE =0, IMREAD_COLOR =1, IMREAD_ANYDEPTH =2,
  IMREAD_ANYCOLOR =4
}
 
enum  {
  IMWRITE_JPEG_QUALITY =1, IMWRITE_PNG_COMPRESSION =16, IMWRITE_PNG_STRATEGY =17, IMWRITE_PNG_BILEVEL =18,
  IMWRITE_PNG_STRATEGY_DEFAULT =0, IMWRITE_PNG_STRATEGY_FILTERED =1, IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY =2, IMWRITE_PNG_STRATEGY_RLE =3,
  IMWRITE_PNG_STRATEGY_FIXED =4, IMWRITE_PXM_BINARY =32
}
 
enum  { OPTFLOW_USE_INITIAL_FLOW = 4, OPTFLOW_LK_GET_MIN_EIGENVALS = 8, OPTFLOW_FARNEBACK_GAUSSIAN = 256 }
 
enum  { LMEDS = 4, RANSAC = 8 }
 type of the robust estimation algorithm More...
 
enum  { ITERATIVE =CV_ITERATIVE, EPNP =CV_EPNP, P3P =CV_P3P }
 computes the camera pose from a few 3D points and the corresponding projections. The outliers are not handled. More...
 
enum  { CALIB_CB_ADAPTIVE_THRESH = 1, CALIB_CB_NORMALIZE_IMAGE = 2, CALIB_CB_FILTER_QUADS = 4, CALIB_CB_FAST_CHECK = 8 }
 
enum  { CALIB_CB_SYMMETRIC_GRID = 1, CALIB_CB_ASYMMETRIC_GRID = 2, CALIB_CB_CLUSTERING = 4 }
 
enum  {
  CALIB_USE_INTRINSIC_GUESS = 1, CALIB_FIX_ASPECT_RATIO = 2, CALIB_FIX_PRINCIPAL_POINT = 4, CALIB_ZERO_TANGENT_DIST = 8,
  CALIB_FIX_FOCAL_LENGTH = 16, CALIB_FIX_K1 = 32, CALIB_FIX_K2 = 64, CALIB_FIX_K3 = 128,
  CALIB_FIX_K4 = 2048, CALIB_FIX_K5 = 4096, CALIB_FIX_K6 = 8192, CALIB_RATIONAL_MODEL = 16384,
  CALIB_FIX_INTRINSIC = 256, CALIB_SAME_FOCAL_LENGTH = 512, CALIB_ZERO_DISPARITY = 1024
}
 
enum  { FM_7POINT = 1, FM_8POINT = 2, FM_LMEDS = 4, FM_RANSAC = 8 }
 the algorithm for finding fundamental matrix More...
 
enum  { CASCADE_DO_CANNY_PRUNING =1, CASCADE_SCALE_IMAGE =2, CASCADE_FIND_BIGGEST_OBJECT =4, CASCADE_DO_ROUGH_SEARCH =8 }
 
enum  { INPAINT_NS =CV_INPAINT_NS, INPAINT_TELEA =CV_INPAINT_TELEA }
 the inpainting algorithm More...
 
enum  { ROTATION = 1, TRANSLATION = 2, RIGID_BODY_MOTION = 4 }
 
enum  {
  COLORMAP_AUTUMN = 0, COLORMAP_BONE = 1, COLORMAP_JET = 2, COLORMAP_WINTER = 3,
  COLORMAP_RAINBOW = 4, COLORMAP_OCEAN = 5, COLORMAP_SUMMER = 6, COLORMAP_SPRING = 7,
  COLORMAP_COOL = 8, COLORMAP_HSV = 9, COLORMAP_PINK = 10, COLORMAP_HOT = 11
}
 
enum  RETINA_COLORSAMPLINGMETHOD { RETINA_COLOR_RANDOM, RETINA_COLOR_DIAGONAL, RETINA_COLOR_BAYER }
 

Functions

string fromUtf16 (const WString &str)
 
WString toUtf16 (const string &str)
 
string format (const char *fmt,...)
 
string tempfile (const char *suffix CV_DEFAULT(0))
 
void error (const Exception &exc)
 Signals an error and raises the exception. More...
 
bool setBreakOnError (bool flag)
 Sets/resets the break-on-error mode. More...
 
ErrorCallback redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0)
 Sets the new error handler and the optional user data. More...
 
void glob (String pattern, std::vector< String > &result, bool recursive=false)
 
void setNumThreads (int nthreads)
 
int getNumThreads ()
 
int getThreadNum ()
 
const string & getBuildInformation ()
 
int64 getTickCount ()
 Returns the number of ticks. More...
 
double getTickFrequency ()
 
int64 getCPUTickCount ()
 
bool checkHardwareSupport (int feature)
 
int getNumberOfCPUs ()
 returns the number of CPUs (including hyper-threading) More...
 
voidfastMalloc (size_t bufSize)
 
void fastFree (void *ptr)
 
void setUseOptimized (bool onoff)
 
bool useOptimized ()
 
void scalarToRawData (const Scalar &s, void *buf, int type, int unroll_to=0)
 
template<typename T >
Ptr< T > makePtr ()
 
template<typename T , typename A1 >
Ptr< T > makePtr (const A1 &a1)
 
template<typename T , typename A1 , typename A2 >
Ptr< T > makePtr (const A1 &a1, const A2 &a2)
 
template<typename T , typename A1 , typename A2 , typename A3 >
Ptr< T > makePtr (const A1 &a1, const A2 &a2, const A3 &a3)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 >
Ptr< T > makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >
Ptr< T > makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 >
Ptr< T > makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 >
Ptr< T > makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 >
Ptr< T > makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 >
Ptr< T > makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 >
Ptr< T > makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10)
 
OutputArray noArray ()
 
BinaryFunc getConvertFunc (int sdepth, int ddepth)
 
BinaryFunc getConvertScaleFunc (int sdepth, int ddepth)
 
BinaryFunc getCopyMaskFunc (size_t esz)
 
void swap (Mat &a, Mat &b)
 swaps two matrices More...
 
Mat cvarrToMat (const CvArr *arr, bool copyData=false, bool allowND=true, int coiMode=0)
 converts array (CvMat or IplImage) to cv::Mat More...
 
void extractImageCOI (const CvArr *arr, OutputArray coiimg, int coi=-1)
 extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it. More...
 
void insertImageCOI (InputArray coiimg, CvArr *arr, int coi=-1)
 inserts single-channel cv::Mat into a multi-channel CvMat or IplImage More...
 
void add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
 adds one matrix to another (dst = src1 + src2) More...
 
void subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
 subtracts one matrix from another (dst = src1 - src2) More...
 
void multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
 computes element-wise weighted product of the two arrays (dst = scale*src1*src2) More...
 
void divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
 computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2) More...
 
void divide (double scale, InputArray src2, OutputArray dst, int dtype=-1)
 computes element-wise weighted reciprocal of an array (dst = scale/src2) More...
 
void scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst)
 adds scaled array to another one (dst = alpha*src1 + src2) More...
 
void addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1)
 computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma) More...
 
void convertScaleAbs (InputArray src, OutputArray 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) More...
 
void LUT (InputArray src, InputArray lut, OutputArray dst, int interpolation=0)
 transforms array of numbers using a lookup table: dst(i)=lut(src(i)) More...
 
 CV_EXPORTS_AS (sumElems) Scalar sum(InputArray src)
 computes sum of array elements More...
 
int countNonZero (InputArray src)
 computes the number of nonzero array elements More...
 
void findNonZero (InputArray src, OutputArray idx)
 returns the list of locations of non-zero pixels More...
 
Scalar mean (InputArray src, InputArray mask=noArray())
 computes mean value of selected array elements More...
 
void meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
 computes mean value and standard deviation of all or selected array elements More...
 
double norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
 computes norm of the selected array part More...
 
double norm (InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray())
 computes norm of selected part of the difference between two arrays More...
 
void batchDistance (InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, int normType=NORM_L2, int K=0, InputArray mask=noArray(), int update=0, bool crosscheck=false)
 naive nearest neighbor finder More...
 
void normalize (InputArray src, OutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
 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 More...
 
void minMaxLoc (InputArray src, CV_OUT double *minVal, CV_OUT double *maxVal=0, CV_OUT Point *minLoc=0, CV_OUT Point *maxLoc=0, InputArray mask=noArray())
 finds global minimum and maximum array elements and returns their values and their locations More...
 
void minMaxIdx (InputArray src, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray())
 
void reduce (InputArray src, OutputArray 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 More...
 
void merge (const Mat *mv, size_t count, OutputArray dst)
 makes multi-channel array out of several single-channel arrays More...
 
void merge (const vector< Mat > &mv, OutputArray dst)
 
void merge (InputArrayOfArrays mv, OutputArray dst)
 makes multi-channel array out of several single-channel arrays More...
 
void split (const Mat &src, Mat *mvbegin)
 copies each plane of a multi-channel array to a dedicated array More...
 
void split (const Mat &m, vector< Mat > &mv)
 
void split (InputArray m, OutputArrayOfArrays mv)
 copies each plane of a multi-channel array to a dedicated array More...
 
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 More...
 
void mixChannels (const vector< Mat > &src, vector< Mat > &dst, const int *fromTo, size_t npairs)
 
void mixChannels (InputArrayOfArrays src, InputArrayOfArrays dst, const vector< int > &fromTo)
 
void extractChannel (InputArray src, OutputArray dst, int coi)
 extracts a single channel from src (coi is 0-based index) More...
 
void insertChannel (InputArray src, InputOutputArray dst, int coi)
 inserts a single channel to dst (coi is 0-based index) More...
 
void flip (InputArray src, OutputArray dst, int flipCode)
 reverses the order of the rows, columns or both in a matrix More...
 
void repeat (InputArray src, int ny, int nx, OutputArray dst)
 replicates the input matrix the specified number of times in the horizontal and/or vertical direction More...
 
Mat repeat (const Mat &src, int ny, int nx)
 
void hconcat (const Mat *src, size_t nsrc, OutputArray dst)
 
void hconcat (InputArray src1, InputArray src2, OutputArray dst)
 
void hconcat (InputArrayOfArrays src, OutputArray dst)
 
void vconcat (const Mat *src, size_t nsrc, OutputArray dst)
 
void vconcat (InputArray src1, InputArray src2, OutputArray dst)
 
void vconcat (InputArrayOfArrays src, OutputArray dst)
 
void bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 computes bitwise conjunction of the two arrays (dst = src1 & src2) More...
 
void bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 computes bitwise disjunction of the two arrays (dst = src1 | src2) More...
 
void bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2) More...
 
void bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray())
 inverts each bit of array (dst = ~src) More...
 
void absdiff (InputArray src1, InputArray src2, OutputArray dst)
 computes element-wise absolute difference of two arrays (dst = abs(src1 - src2)) More...
 
void inRange (InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)
 set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb) More...
 
void compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop)
 compares elements of two arrays (dst = src1 <cmpop> src2) More...
 
void min (InputArray src1, InputArray src2, OutputArray dst)
 computes per-element minimum of two arrays (dst = min(src1, src2)) More...
 
void max (InputArray src1, InputArray src2, OutputArray dst)
 computes per-element maximum of two arrays (dst = max(src1, src2)) More...
 
void min (const Mat &src1, const Mat &src2, Mat &dst)
 computes per-element minimum of two arrays (dst = min(src1, src2)) More...
 
void min (const Mat &src1, double src2, Mat &dst)
 computes per-element minimum of array and scalar (dst = min(src1, src2)) More...
 
void max (const Mat &src1, const Mat &src2, Mat &dst)
 computes per-element maximum of two arrays (dst = max(src1, src2)) More...
 
void max (const Mat &src1, double src2, Mat &dst)
 computes per-element maximum of array and scalar (dst = max(src1, src2)) More...
 
void sqrt (InputArray src, OutputArray dst)
 computes square root of each matrix element (dst = src**0.5) More...
 
void pow (InputArray src, double power, OutputArray dst)
 raises the input matrix elements to the specified power (b = a**power) More...
 
void exp (InputArray src, OutputArray dst)
 computes exponent of each matrix element (dst = e**src) More...
 
void log (InputArray src, OutputArray dst)
 computes natural logarithm of absolute value of each matrix element: dst = log(abs(src)) More...
 
float cubeRoot (float val)
 computes cube root of the argument More...
 
float fastAtan2 (float y, float x)
 computes the angle in degrees (0..360) of the vector (x,y) More...
 
void exp (const float *src, float *dst, int n)
 
void log (const float *src, float *dst, int n)
 
void fastAtan2 (const float *y, const float *x, float *dst, int n, bool angleInDegrees)
 
void magnitude (const float *x, const float *y, float *dst, int n)
 
void polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
 converts polar coordinates to Cartesian More...
 
void cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
 converts Cartesian coordinates to polar More...
 
void phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
 computes angle (angle(i)) of each (x(i), y(i)) vector More...
 
void magnitude (InputArray x, InputArray y, OutputArray magnitude)
 computes magnitude (magnitude(i)) of each (x(i), y(i)) vector More...
 
bool checkRange (InputArray a, bool quiet=true, CV_OUT Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
 checks that each matrix element is within the specified range. More...
 
void patchNaNs (InputOutputArray a, double val=0)
 converts NaN's to the given number More...
 
void gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0)
 implements generalized matrix product algorithm GEMM from BLAS More...
 
void mulTransposed (InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1)
 multiplies matrix by its transposition from the left or from the right More...
 
void transpose (InputArray src, OutputArray dst)
 transposes the matrix More...
 
void transform (InputArray src, OutputArray dst, InputArray m)
 performs affine transformation of each element of multi-channel input matrix More...
 
void perspectiveTransform (InputArray src, OutputArray dst, InputArray m)
 performs perspective transformation of each element of multi-channel input matrix More...
 
void completeSymm (InputOutputArray mtx, bool lowerToUpper=false)
 extends the symmetrical matrix from the lower half or from the upper half More...
 
void setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1))
 initializes scaled identity matrix More...
 
double determinant (InputArray mtx)
 computes determinant of a square matrix More...
 
Scalar trace (InputArray mtx)
 computes trace of a matrix More...
 
double invert (InputArray src, OutputArray dst, int flags=DECOMP_LU)
 computes inverse or pseudo-inverse matrix More...
 
bool solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
 solves linear system or a least-square problem More...
 
void sort (InputArray src, OutputArray dst, int flags)
 sorts independently each matrix row or each matrix column More...
 
void sortIdx (InputArray src, OutputArray dst, int flags)
 sorts independently each matrix row or each matrix column More...
 
int solveCubic (InputArray coeffs, OutputArray roots)
 finds real roots of a cubic polynomial More...
 
double solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300)
 finds real and complex roots of a polynomial More...
 
bool eigen (InputArray src, OutputArray eigenvalues, int lowindex=-1, int highindex=-1)
 finds eigenvalues of a symmetric matrix More...
 
bool eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors, int lowindex=-1, int highindex=-1)
 finds eigenvalues and eigenvectors of a symmetric matrix More...
 
bool eigen (InputArray src, bool computeEigenvectors, OutputArray eigenvalues, OutputArray eigenvectors)
 
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 More...
 
void calcCovarMatrix (InputArray samples, OutputArray covar, OutputArray mean, int flags, int ctype=CV_64F)
 computes covariation matrix of a set of samples More...
 
void PCACompute (InputArray data, CV_OUT InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0)
 
void PCAComputeVar (InputArray data, CV_OUT InputOutputArray mean, OutputArray eigenvectors, double retainedVariance)
 
void PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
 
void PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
 
void SVDecomp (InputArray src, CV_OUT OutputArray w, CV_OUT OutputArray u, CV_OUT OutputArray vt, int flags=0)
 computes SVD of src More...
 
void SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, CV_OUT OutputArray dst)
 performs back substitution for the previously computed SVD More...
 
double Mahalanobis (InputArray v1, InputArray v2, InputArray icovar)
 computes Mahalanobis distance between two vectors: sqrt((v1-v2)'icovar(v1-v2)), where icovar is the inverse covariation matrix More...
 
double Mahalonobis (InputArray v1, InputArray v2, InputArray icovar)
 a synonym for Mahalanobis More...
 
void dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
 performs forward or inverse 1D or 2D Discrete Fourier Transformation More...
 
void idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
 performs inverse 1D or 2D Discrete Fourier Transformation More...
 
void dct (InputArray src, OutputArray dst, int flags=0)
 performs forward or inverse 1D or 2D Discrete Cosine Transformation More...
 
void idct (InputArray src, OutputArray dst, int flags=0)
 performs inverse 1D or 2D Discrete Cosine Transformation More...
 
void mulSpectrums (InputArray a, InputArray b, OutputArray 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 More...
 
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 More...
 
double kmeans (InputArray data, int K, CV_OUT InputOutputArray bestLabels, TermCriteria criteria, int attempts, int flags, OutputArray centers=noArray())
 clusters the input data using k-Means algorithm More...
 
RNGtheRNG ()
 returns the thread-local Random number generator More...
 
void setRNGSeed (int seed)
 sets state of the thread-local Random number generator More...
 
void randu (InputOutputArray dst, InputArray low, InputArray high)
 fills array with uniformly-distributed random numbers from the range [low, high) More...
 
void randn (InputOutputArray dst, InputArray mean, InputArray stddev)
 fills array with normally-distributed random numbers with the specified mean and the standard deviation More...
 
void randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0)
 shuffles the input array elements More...
 
 CV_EXPORTS_AS (randShuffle) void randShuffle_(InputOutputArray dst
 
void line (CV_IN_OUT 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 More...
 
void arrowedLine (CV_IN_OUT Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int line_type=8, int shift=0, double tipLength=0.1)
 draws an arrow from pt1 to pt2 in the image More...
 
void rectangle (CV_IN_OUT 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 More...
 
void rectangle (CV_IN_OUT 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 More...
 
void circle (CV_IN_OUT 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 More...
 
void ellipse (CV_IN_OUT 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 More...
 
void ellipse (CV_IN_OUT Mat &img, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=8)
 draws a rotated ellipse in the image More...
 
void drawMarker (CV_IN_OUT Mat &img, Point position, const Scalar &color, int markerType=MARKER_CROSS, int markerSize=20, int thickness=1, int line_type=8)
 Draws a marker on a predefined position in an image. More...
 
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 More...
 
void fillConvexPoly (InputOutputArray img, InputArray points, const Scalar &color, int lineType=8, int shift=0)
 
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 More...
 
void fillPoly (InputOutputArray img, InputArrayOfArrays pts, const Scalar &color, int lineType=8, int shift=0, Point offset=Point())
 
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 More...
 
void polylines (InputOutputArray img, InputArrayOfArrays pts, bool isClosed, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 
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) More...
 
bool clipLine (Rect imgRect, CV_OUT CV_IN_OUT Point &pt1, CV_OUT CV_IN_OUT Point &pt2)
 clips the line segment by the rectangle imgRect More...
 
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 More...
 
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 More...
 
Size getTextSize (const string &text, int fontFace, double fontScale, int thickness, CV_OUT int *baseLine)
 returns bounding box of the text string More...
 
ConvertData getConvertElem (int fromType, int toType)
 returns the function for converting pixels from one data type to another More...
 
ConvertScaleData getConvertScaleElem (int fromType, int toType)
 returns the function for converting pixels from one data type to another with the optional scaling More...
 
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 More...
 
double norm (const SparseMat &src, int normType)
 computes norm of a sparse matrix More...
 
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 More...
 
template<>
std::string CommandLineParser::analyzeValue< std::string > (const std::string &str, bool space_delete)
 
void parallel_for_ (const Range &range, const ParallelLoopBody &body, double nstripes=-1.)
 
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)
 
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst)
 
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
void cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst)
 
template<typename _Tp >
void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst)
 
template<typename _Tp , int _rows, int _cols>
void cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst)
 
template<typename _Tp >
void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst)
 
template<typename _Tp , int _rows>
void cv2eigen (const Matx< _Tp, _rows, 1 > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst)
 
template<typename _Tp >
void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst)
 
template<typename _Tp , int _cols>
void cv2eigen (const Matx< _Tp, 1, _cols > &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst)
 
const char * currentParallelFramework ()
 
template<typename T1 , typename T2 , typename Op >
void process (const Mat_< T1 > &m1, Mat_< T2 > &m2, Op op)
 
template<typename T1 , typename T2 , typename T3 , typename Op >
void process (const Mat_< T1 > &m1, const Mat_< T2 > &m2, Mat_< T3 > &m3, Op op)
 
MatExpr operator+ (const Mat &a, const Mat &b)
 
MatExpr operator+ (const Mat &a, const Scalar &s)
 
MatExpr operator+ (const Scalar &s, const Mat &a)
 
MatExpr operator+ (const MatExpr &e, const Mat &m)
 
MatExpr operator+ (const Mat &m, const MatExpr &e)
 
MatExpr operator+ (const MatExpr &e, const Scalar &s)
 
MatExpr operator+ (const Scalar &s, const MatExpr &e)
 
MatExpr operator+ (const MatExpr &e1, const MatExpr &e2)
 
MatExpr operator- (const Mat &a, const Mat &b)
 
MatExpr operator- (const Mat &a, const Scalar &s)
 
MatExpr operator- (const Scalar &s, const Mat &a)
 
MatExpr operator- (const MatExpr &e, const Mat &m)
 
MatExpr operator- (const Mat &m, const MatExpr &e)
 
MatExpr operator- (const MatExpr &e, const Scalar &s)
 
MatExpr operator- (const Scalar &s, const MatExpr &e)
 
MatExpr operator- (const MatExpr &e1, const MatExpr &e2)
 
MatExpr operator- (const Mat &m)
 
MatExpr operator- (const MatExpr &e)
 
MatExpr operator* (const Mat &a, const Mat &b)
 
MatExpr operator* (const Mat &a, double s)
 
MatExpr operator* (double s, const Mat &a)
 
MatExpr operator* (const MatExpr &e, const Mat &m)
 
MatExpr operator* (const Mat &m, const MatExpr &e)
 
MatExpr operator* (const MatExpr &e, double s)
 
MatExpr operator* (double s, const MatExpr &e)
 
MatExpr operator* (const MatExpr &e1, const MatExpr &e2)
 
MatExpr operator/ (const Mat &a, const Mat &b)
 
MatExpr operator/ (const Mat &a, double s)
 
MatExpr operator/ (double s, const Mat &a)
 
MatExpr operator/ (const MatExpr &e, const Mat &m)
 
MatExpr operator/ (const Mat &m, const MatExpr &e)
 
MatExpr operator/ (const MatExpr &e, double s)
 
MatExpr operator/ (double s, const MatExpr &e)
 
MatExpr operator/ (const MatExpr &e1, const MatExpr &e2)
 
MatExpr operator< (const Mat &a, const Mat &b)
 
MatExpr operator< (const Mat &a, double s)
 
MatExpr operator< (double s, const Mat &a)
 
MatExpr operator<= (const Mat &a, const Mat &b)
 
MatExpr operator<= (const Mat &a, double s)
 
MatExpr operator<= (double s, const Mat &a)
 
MatExpr operator== (const Mat &a, const Mat &b)
 
MatExpr operator== (const Mat &a, double s)
 
MatExpr operator== (double s, const Mat &a)
 
MatExpr operator!= (const Mat &a, const Mat &b)
 
MatExpr operator!= (const Mat &a, double s)
 
MatExpr operator!= (double s, const Mat &a)
 
MatExpr operator>= (const Mat &a, const Mat &b)
 
MatExpr operator>= (const Mat &a, double s)
 
MatExpr operator>= (double s, const Mat &a)
 
MatExpr operator> (const Mat &a, const Mat &b)
 
MatExpr operator> (const Mat &a, double s)
 
MatExpr operator> (double s, const Mat &a)
 
MatExpr min (const Mat &a, const Mat &b)
 
MatExpr min (const Mat &a, double s)
 
MatExpr min (double s, const Mat &a)
 
MatExpr max (const Mat &a, const Mat &b)
 
MatExpr max (const Mat &a, double s)
 
MatExpr max (double s, const Mat &a)
 
MatExpr operator& (const Mat &a, const Mat &b)
 
MatExpr operator& (const Mat &a, const Scalar &s)
 
MatExpr operator& (const Scalar &s, const Mat &a)
 
MatExpr operator| (const Mat &a, const Mat &b)
 
MatExpr operator| (const Mat &a, const Scalar &s)
 
MatExpr operator| (const Scalar &s, const Mat &a)
 
MatExpr operator^ (const Mat &a, const Mat &b)
 
MatExpr operator^ (const Mat &a, const Scalar &s)
 
MatExpr operator^ (const Scalar &s, const Mat &a)
 
MatExpr operator~ (const Mat &m)
 
MatExpr abs (const Mat &m)
 
MatExpr abs (const MatExpr &e)
 
template<typename _Tp >
void split (const Mat &src, vector< Mat_< _Tp > > &mv)
 
ptrdiff_t operator- (const MatConstIterator &b, const MatConstIterator &a)
 
void render (const GlTexture &tex, Rect_< double > wndRect=Rect_< double >(0.0, 0.0, 1.0, 1.0), Rect_< double > texRect=Rect_< double >(0.0, 0.0, 1.0, 1.0))
 render functions More...
 
void render (const GlArrays &arr, int mode=RenderMode::POINTS, Scalar color=Scalar::all(255))
 render OpenGL arrays More...
 
void render (const std::string &str, const Ptr< GlFont > &font, Scalar color, Point2d pos)
 
template<>
uchar saturate_cast< uchar > (schar v)
 
template<>
uchar saturate_cast< uchar > (ushort v)
 
template<>
uchar saturate_cast< uchar > (int v)
 
template<>
uchar saturate_cast< uchar > (short v)
 
template<>
uchar saturate_cast< uchar > (unsigned v)
 
template<>
uchar saturate_cast< uchar > (float v)
 
template<>
uchar saturate_cast< uchar > (double v)
 
template<>
schar saturate_cast< schar > (uchar v)
 
template<>
schar saturate_cast< schar > (ushort v)
 
template<>
schar saturate_cast< schar > (int v)
 
template<>
schar saturate_cast< schar > (short v)
 
template<>
schar saturate_cast< schar > (unsigned v)
 
template<>
schar saturate_cast< schar > (float v)
 
template<>
schar saturate_cast< schar > (double v)
 
template<>
ushort saturate_cast< ushort > (schar v)
 
template<>
ushort saturate_cast< ushort > (short v)
 
template<>
ushort saturate_cast< ushort > (int v)
 
template<>
ushort saturate_cast< ushort > (unsigned v)
 
template<>
ushort saturate_cast< ushort > (float v)
 
template<>
ushort saturate_cast< ushort > (double v)
 
template<>
short saturate_cast< short > (ushort v)
 
template<>
short saturate_cast< short > (int v)
 
template<>
short saturate_cast< short > (unsigned v)
 
template<>
short saturate_cast< short > (float v)
 
template<>
short saturate_cast< short > (double v)
 
template<>
int saturate_cast< int > (float v)
 
template<>
int saturate_cast< int > (double v)
 
template<>
unsigned saturate_cast< unsigned > (float v)
 
template<>
unsigned saturate_cast< unsigned > (double v)
 
int fast_abs (uchar v)
 
int fast_abs (schar v)
 
int fast_abs (ushort v)
 
int fast_abs (short v)
 
int fast_abs (int v)
 
float fast_abs (float v)
 
double fast_abs (double v)
 
int LU (float *A, size_t astep, int m, float *b, size_t bstep, int n)
 
int LU (double *A, size_t astep, int m, double *b, size_t bstep, int n)
 
bool Cholesky (float *A, size_t astep, int m, float *b, size_t bstep, int n)
 
bool Cholesky (double *A, size_t astep, int m, double *b, size_t bstep, int n)
 
float normL2Sqr_ (const float *a, const float *b, int n)
 
float normL1_ (const float *a, const float *b, int n)
 
int normL1_ (const uchar *a, const uchar *b, int n)
 
int normHamming (const uchar *a, const uchar *b, int n)
 
int normHamming (const uchar *a, const uchar *b, int n, int cellSize)
 
template<>
float normL2Sqr (const float *a, const float *b, int n)
 
template<>
float normL1 (const float *a, const float *b, int n)
 
template<>
int normL1 (const uchar *a, const uchar *b, int n)
 
template<typename _Tp >
Vec< _Tp, 2 > conjugate (const Vec< _Tp, 2 > &v)
 
template<typename _Tp >
Vec< _Tp, 4 > conjugate (const Vec< _Tp, 4 > &v)
 
template<typename _Tp >
Vec< _Tp, 4 > operator* (const Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2)
 
template<typename _Tp >
Vec< _Tp, 4 > & operator*= (Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2)
 
template<typename _Tp , int cn>
Vec< _Tp, cn > normalize (const Vec< _Tp, cn > &v)
 
template<typename _Tp >
DataType< _Tp >::work_type dot (const Vector< _Tp > &v1, const Vector< _Tp > &v2)
 
void write (FileStorage &fs, const string &name, int value)
 
void write (FileStorage &fs, const string &name, float value)
 
void write (FileStorage &fs, const string &name, double value)
 
void write (FileStorage &fs, const string &name, const string &value)
 
template<typename _Tp >
void write (FileStorage &fs, const _Tp &value)
 
void writeScalar (FileStorage &fs, int value)
 
void writeScalar (FileStorage &fs, float value)
 
void writeScalar (FileStorage &fs, double value)
 
void writeScalar (FileStorage &fs, const string &value)
 
template<>
void write (FileStorage &fs, const int &value)
 
template<>
void write (FileStorage &fs, const float &value)
 
template<>
void write (FileStorage &fs, const double &value)
 
template<>
void write (FileStorage &fs, const string &value)
 
template<typename _Tp >
void write (FileStorage &fs, const Point_< _Tp > &pt)
 
template<typename _Tp >
void write (FileStorage &fs, const Point3_< _Tp > &pt)
 
template<typename _Tp >
void write (FileStorage &fs, const Size_< _Tp > &sz)
 
template<typename _Tp >
void write (FileStorage &fs, const Complex< _Tp > &c)
 
template<typename _Tp >
void write (FileStorage &fs, const Rect_< _Tp > &r)
 
template<typename _Tp , int cn>
void write (FileStorage &fs, const Vec< _Tp, cn > &v)
 
template<typename _Tp >
void write (FileStorage &fs, const Scalar_< _Tp > &s)
 
void write (FileStorage &fs, const Range &r)
 
template<typename _Tp >
void write (FileStorage &fs, const string &name, const Point_< _Tp > &pt)
 
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 Size_< _Tp > &sz)
 
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 Rect_< _Tp > &r)
 
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 Scalar_< _Tp > &s)
 
void write (FileStorage &fs, const string &name, const Range &r)
 
void write (FileStorage &fs, const string &name, const Mat &value)
 
void write (FileStorage &fs, const string &name, const SparseMat &value)
 
FileStorageoperator<< (FileStorage &fs, const string &str)
 
void read (const FileNode &node, Mat &mat, const Mat &default_mat=Mat())
 
void read (const FileNode &node, SparseMat &mat, const SparseMat &default_mat=SparseMat())
 
template<typename _Tp , class _LT >
void sort (vector< _Tp > &vec, _LT LT=_LT())
 
template<typename _Tp , class _EqPredicate >
int partition (const vector< _Tp > &_vec, vector< int > &labels, _EqPredicate predicate=_EqPredicate())
 
scharseqPush (CvSeq *seq, const void *element=0)
 
scharseqPushFront (CvSeq *seq, const void *element=0)
 
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)
 
void seqRemove (CvSeq *seq, int index)
 
void clearSeq (CvSeq *seq)
 
schargetSeqElem (const CvSeq *seq, int index)
 
void seqRemoveSlice (CvSeq *seq, CvSlice slice)
 
void seqInsertSlice (CvSeq *seq, int before_index, const CvArr *from_arr)
 
template<typename _Tp >
ptrdiff_t operator- (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b)
 
template<typename _Tp >
bool operator== (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b)
 
template<typename _Tp >
bool operator!= (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b)
 
template<typename _Tp , int m, int n>
std::ostream & operator<< (std::ostream &out, const Matx< _Tp, m, n > &matx)
 
template<typename _Tp >
std::ostream & operator<< (std::ostream &out, const Point_< _Tp > &p)
 
template<typename _Tp >
std::ostream & operator<< (std::ostream &out, const Point3_< _Tp > &p)
 
template<typename _Tp , int n>
std::ostream & operator<< (std::ostream &out, const Vec< _Tp, n > &vec)
 
template<typename _Tp >
std::ostream & operator<< (std::ostream &out, const Size_< _Tp > &size)
 
template<typename _Tp >
std::ostream & operator<< (std::ostream &out, const Rect_< _Tp > &rect)
 
int borderInterpolate (int p, int len, int borderType)
 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p. More...
 
int getKernelType (InputArray kernel, Point anchor)
 returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients. More...
 
Ptr< BaseRowFiltergetLinearRowFilter (int srcType, int bufType, InputArray kernel, int anchor, int symmetryType)
 returns the primitive row filter with the specified kernel More...
 
Ptr< BaseColumnFiltergetLinearColumnFilter (int bufType, int dstType, InputArray kernel, int anchor, int symmetryType, double delta=0, int bits=0)
 returns the primitive column filter with the specified kernel More...
 
Ptr< BaseFiltergetLinearFilter (int srcType, int dstType, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0)
 returns 2D filter with the specified kernel More...
 
Ptr< FilterEnginecreateSeparableLinearFilter (int srcType, int dstType, InputArray rowKernel, InputArray 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 More...
 
Ptr< FilterEnginecreateLinearFilter (int srcType, int dstType, InputArray 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 More...
 
Mat getGaussianKernel (int ksize, double sigma, int ktype=CV_64F)
 returns the Gaussian kernel with the specified parameters More...
 
Ptr< FilterEnginecreateGaussianFilter (int type, Size ksize, double sigma1, double sigma2=0, int borderType=BORDER_DEFAULT)
 returns the Gaussian filter engine More...
 
void getDerivKernels (OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F)
 initializes kernels of the generalized Sobel operator More...
 
Ptr< FilterEnginecreateDerivFilter (int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT)
 returns filter engine for the generalized Sobel operator More...
 
Ptr< BaseRowFiltergetRowSumFilter (int srcType, int sumType, int ksize, int anchor=-1)
 returns horizontal 1D box filter More...
 
Ptr< BaseColumnFiltergetColumnSumFilter (int sumType, int dstType, int ksize, int anchor=-1, double scale=1)
 returns vertical 1D box filter More...
 
Ptr< FilterEnginecreateBoxFilter (int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
 returns box filter engine More...
 
Mat getGaborKernel (Size ksize, double sigma, double theta, double lambd, double gamma, double psi=CV_PI *0.5, int ktype=CV_64F)
 returns the Gabor kernel with the specified parameters More...
 
Ptr< BaseRowFiltergetMorphologyRowFilter (int op, int type, int ksize, int anchor=-1)
 returns horizontal 1D morphological filter More...
 
Ptr< BaseColumnFiltergetMorphologyColumnFilter (int op, int type, int ksize, int anchor=-1)
 returns vertical 1D morphological filter More...
 
Ptr< BaseFiltergetMorphologyFilter (int op, int type, InputArray kernel, Point anchor=Point(-1,-1))
 returns 2D morphological filter More...
 
Ptr< FilterEnginecreateMorphologyFilter (int op, int type, InputArray 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. More...
 
Mat getStructuringElement (int shape, Size ksize, Point anchor=Point(-1,-1))
 returns structuring element of the specified shape and size More...
 
void copyMakeBorder (InputArray src, OutputArray 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 More...
 
void medianBlur (InputArray src, OutputArray dst, int ksize)
 smooths the image using median filter. More...
 
void GaussianBlur (InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT)
 smooths the image using Gaussian filter. More...
 
void bilateralFilter (InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)
 smooths the image using bilateral filter More...
 
void adaptiveBilateralFilter (InputArray src, OutputArray dst, Size ksize, double sigmaSpace, double maxSigmaColor=20.0, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)
 smooths the image using adaptive bilateral filter More...
 
void boxFilter (InputArray src, OutputArray 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 More...
 
void blur (InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)
 a synonym for normalized box filter More...
 
void filter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)
 applies non-separable 2D linear filter to the image More...
 
void sepFilter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernelX, InputArray kernelY, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)
 applies separable 2D linear filter to the image More...
 
void Sobel (InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
 applies generalized Sobel operator to the image More...
 
void Scharr (InputArray src, OutputArray dst, int ddepth, int dx, int dy, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
 applies the vertical or horizontal Scharr operator to the image More...
 
void Laplacian (InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
 applies Laplacian operator to the image More...
 
void Canny (InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)
 applies Canny edge detector and produces the edge map. More...
 
void cornerMinEigenVal (InputArray src, OutputArray 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 More...
 
void cornerHarris (InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT)
 computes Harris cornerness criteria at each image pixel More...
 
void eigen2x2 (const float *a, float *e, int n)
 
void cornerEigenValsAndVecs (InputArray src, OutputArray 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. More...
 
void preCornerDetect (InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT)
 computes another complex cornerness criteria at each pixel More...
 
void cornerSubPix (InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria)
 adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria More...
 
void goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04)
 finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima More...
 
void HoughLines (InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0)
 finds lines in the black-n-white image using the standard or pyramid Hough transform More...
 
void HoughLinesP (InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0)
 finds line segments in the black-n-white image using probabilistic Hough transform More...
 
void HoughCircles (InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0)
 finds circles in the grayscale image using 2+1 gradient Hough transform More...
 
void erode (InputArray src, OutputArray dst, InputArray 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) More...
 
void dilate (InputArray src, OutputArray dst, InputArray 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) More...
 
void morphologyEx (InputArray src, OutputArray dst, int op, InputArray 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 More...
 
void resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
 resizes the image More...
 
void warpAffine (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
 warps the image using affine transformation More...
 
void warpPerspective (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
 warps the image using perspective transformation More...
 
void remap (InputArray src, OutputArray dst, InputArray map1, InputArray 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 More...
 
void convertMaps (InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false)
 converts maps for remap from floating-point to fixed-point format or backwards More...
 
Mat getRotationMatrix2D (Point2f center, double angle, double scale)
 returns 2x3 affine transformation matrix for the planar rotation. More...
 
Mat getPerspectiveTransform (const Point2f src[], const Point2f dst[])
 returns 3x3 perspective transformation for the corresponding 4 point pairs. More...
 
Mat getAffineTransform (const Point2f src[], const Point2f dst[])
 returns 2x3 affine transformation for the corresponding 3 point pairs. More...
 
void invertAffineTransform (InputArray M, OutputArray iM)
 computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation. More...
 
Mat getPerspectiveTransform (InputArray src, InputArray dst)
 
Mat getAffineTransform (InputArray src, InputArray dst)
 
void getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1)
 extracts rectangle from the image at sub-pixel location More...
 
void integral (InputArray src, OutputArray sum, int sdepth=-1)
 computes the integral image More...
 
 CV_EXPORTS_AS (integral2) void integral(InputArray src
 computes the integral image and integral for the squared image More...
 
 CV_EXPORTS_AS (integral3) void integral(InputArray src
 computes the integral image, integral for the squared image and the tilted integral image More...
 
void accumulate (InputArray src, InputOutputArray dst, InputArray mask=noArray())
 adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types. More...
 
void accumulateSquare (InputArray src, InputOutputArray dst, InputArray mask=noArray())
 adds squared src image to the accumulator (dst += src*src). More...
 
void accumulateProduct (InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray())
 adds product of the 2 images to the accumulator (dst += src1*src2). More...
 
void accumulateWeighted (InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray())
 updates the running average (dst = dst*(1-alpha) + src*alpha) More...
 
double PSNR (InputArray src1, InputArray src2)
 computes PSNR image/video quality metric More...
 
Point2d phaseCorrelate (InputArray src1, InputArray src2, InputArray window=noArray())
 
Point2d phaseCorrelateRes (InputArray src1, InputArray src2, InputArray window, CV_OUT double *response=0)
 
void createHanningWindow (OutputArray dst, Size winSize, int type)
 
double threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type)
 applies fixed threshold to the image More...
 
void adaptiveThreshold (InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
 applies variable (adaptive) threshold to the image More...
 
void pyrDown (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)
 smooths and downsamples the image More...
 
void pyrUp (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)
 upsamples and smoothes the image More...
 
void buildPyramid (InputArray src, OutputArrayOfArrays dst, int maxlevel, int borderType=BORDER_DEFAULT)
 builds the gaussian pyramid using pyrDown() as a basic operation More...
 
void undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray())
 corrects lens distortion for the given camera matrix and distortion coefficients More...
 
void initUndistortRectifyMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2)
 initializes maps for cv::remap() to correct lens distortion and optionally rectify the image More...
 
float initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType=PROJ_SPHERICAL_EQRECT, double alpha=0)
 initializes maps for cv::remap() for wide-angle More...
 
Mat getDefaultNewCameraMatrix (InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false)
 returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true) More...
 
void undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray())
 returns points' coordinates after lens distortion correction More...
 
void calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, OutputArray 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. More...
 
void calcHist (const Mat *images, int nimages, const int *channels, InputArray 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. More...
 
void calcHist (InputArrayOfArrays images, const vector< int > &channels, InputArray mask, OutputArray hist, const vector< int > &histSize, const vector< float > &ranges, bool accumulate=false)
 
void calcBackProject (const Mat *images, int nimages, const int *channels, InputArray hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true)
 computes back projection for the set of images More...
 
void calcBackProject (const Mat *images, int nimages, const int *channels, const SparseMat &hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true)
 computes back projection for the set of images More...
 
void calcBackProject (InputArrayOfArrays images, const vector< int > &channels, InputArray hist, OutputArray dst, const vector< float > &ranges, double scale)
 
double compareHist (InputArray H1, InputArray H2, int method)
 compares two histograms stored in dense arrays More...
 
double compareHist (const SparseMat &H1, const SparseMat &H2, int method)
 compares two histograms stored in sparse arrays More...
 
void equalizeHist (InputArray src, OutputArray dst)
 normalizes the grayscale image brightness and contrast by normalizing its histogram More...
 
Ptr< CLAHEcreateCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8))
 
float EMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float *lowerBound=0, OutputArray flow=noArray())
 
void watershed (InputArray image, InputOutputArray markers)
 segments the image using watershed algorithm More...
 
void pyrMeanShiftFiltering (InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria( TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1))
 filters image using meanshift algorithm More...
 
void grabCut (InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode=GC_EVAL)
 segments the image using GrabCut algorithm More...
 
 CV_EXPORTS_AS (distanceTransformWithLabels) void distanceTransform(InputArray src
 builds the discrete Voronoi diagram More...
 
void distanceTransform (InputArray src, OutputArray dst, int distanceType, int maskSize)
 computes the distance transform map More...
 
int floodFill (InputOutputArray 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 More...
 
int floodFill (InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)
 fills the semi-uniform image region and/or the mask starting from the specified seed point More...
 
void cvtColor (InputArray src, OutputArray dst, int code, int dstCn=0)
 converts image from one color space to another More...
 
Moments moments (InputArray array, bool binaryImage=false)
 computes moments of the rasterized shape or a vector of points More...
 
void HuMoments (const Moments &moments, double hu[7])
 computes 7 Hu invariants from the moments More...
 
void HuMoments (const Moments &m, CV_OUT OutputArray hu)
 
void matchTemplate (InputArray image, InputArray templ, OutputArray result, int method)
 computes the proximity map for the raster template and the image where the template is searched for More...
 
void findContours (InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())
 retrieves contours and the hierarchical information from black-n-white image. More...
 
void findContours (InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())
 retrieves contours from black-n-white image. More...
 
void drawContours (InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar &color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point())
 draws contours in the image More...
 
void approxPolyDP (InputArray curve, OutputArray approxCurve, double epsilon, bool closed)
 approximates contour or a curve using Douglas-Peucker algorithm More...
 
double arcLength (InputArray curve, bool closed)
 computes the contour perimeter (closed=true) or a curve length More...
 
Rect boundingRect (InputArray points)
 computes the bounding rectangle for a contour More...
 
double contourArea (InputArray contour, bool oriented=false)
 computes the contour area More...
 
RotatedRect minAreaRect (InputArray points)
 computes the minimal rotated rectangle for a set of points More...
 
void minEnclosingCircle (InputArray points, CV_OUT Point2f &center, CV_OUT float &radius)
 computes the minimal enclosing circle for a set of points More...
 
double matchShapes (InputArray contour1, InputArray contour2, int method, double parameter)
 matches two contours using one of the available algorithms More...
 
void convexHull (InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true)
 computes convex hull for a set of 2D points. More...
 
void convexityDefects (InputArray contour, InputArray convexhull, OutputArray convexityDefects)
 computes the contour convexity defects More...
 
bool isContourConvex (InputArray contour)
 returns true if the contour is convex. Does not support contours with self-intersection More...
 
float intersectConvexConvex (InputArray _p1, InputArray _p2, OutputArray _p12, bool handleNested=true)
 finds intersection of two convex polygons More...
 
RotatedRect fitEllipse (InputArray points)
 fits ellipse to the set of 2D points More...
 
void fitLine (InputArray points, OutputArray line, int distType, double param, double reps, double aeps)
 fits line to the set of 2D points using M-estimator algorithm More...
 
double pointPolygonTest (InputArray 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 More...
 
void namedWindow (const string &winname, int flags=WINDOW_AUTOSIZE)
 
void destroyWindow (const string &winname)
 
void destroyAllWindows ()
 
int startWindowThread ()
 
int waitKey (int delay=0)
 
void imshow (const string &winname, InputArray mat)
 
void resizeWindow (const string &winname, int width, int height)
 
void moveWindow (const string &winname, int x, int y)
 
void setWindowProperty (const string &winname, int prop_id, double prop_value)
 
double getWindowProperty (const string &winname, int prop_id)
 
void setMouseCallback (const string &winname, MouseCallback onMouse, void *userdata=0)
 assigns callback for mouse events More...
 
int createTrackbar (const string &trackbarname, const string &winname, int *value, int count, TrackbarCallback onChange=0, void *userdata=0)
 
int getTrackbarPos (const string &trackbarname, const string &winname)
 
void setTrackbarPos (const string &trackbarname, const string &winname, int pos)
 
void setOpenGlDrawCallback (const string &winname, OpenGlDrawCallback onOpenGlDraw, void *userdata=0)
 
void setOpenGlContext (const string &winname)
 
void updateWindow (const string &winname)
 
void pointCloudShow (const string &winname, const GlCamera &camera, const GlArrays &arr)
 
void pointCloudShow (const string &winname, const GlCamera &camera, InputArray points, InputArray colors=noArray())
 
CvFont fontQt (const string &nameFont, int pointSize=-1, Scalar color=Scalar::all(0), int weight=CV_FONT_NORMAL, int style=CV_STYLE_NORMAL, int spacing=0)
 
void addText (const Mat &img, const string &text, Point org, CvFont font)
 
void displayOverlay (const string &winname, const string &text, int delayms CV_DEFAULT(0))
 
void displayStatusBar (const string &winname, const string &text, int delayms CV_DEFAULT(0))
 
void saveWindowParameters (const string &windowName)
 
void loadWindowParameters (const string &windowName)
 
int startLoop (int(*pt2Func)(int argc, char *argv[]), int argc, char *argv[])
 
void stopLoop ()
 
int createButton (const string &bar_name, ButtonCallback on_change, void *userdata=NULL, int type=CV_PUSH_BUTTON, bool initial_button_state=0)
 
Mat imread (const string &filename, int flags=1)
 
bool imwrite (const string &filename, InputArray img, const vector< int > &params=vector< int >())
 
Mat imdecode (InputArray buf, int flags)
 
Mat imdecode (InputArray buf, int flags, Mat *dst)
 
bool imencode (const string &ext, InputArray img, CV_OUT vector< uchar > &buf, const vector< int > &params=vector< int >())
 
void updateMotionHistory (InputArray silhouette, InputOutputArray mhi, double timestamp, double duration)
 updates motion history image using the current silhouette More...
 
void calcMotionGradient (InputArray mhi, OutputArray mask, OutputArray orientation, double delta1, double delta2, int apertureSize=3)
 computes the motion gradient orientation image from the motion history image More...
 
double calcGlobalOrientation (InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration)
 computes the global orientation of the selected motion history image part More...
 
void segmentMotion (InputArray mhi, OutputArray segmask, CV_OUT vector< Rect > &boundingRects, double timestamp, double segThresh)
 
RotatedRect CamShift (InputArray probImage, CV_OUT CV_IN_OUT Rect &window, TermCriteria criteria)
 updates the object tracking window using CAMSHIFT algorithm More...
 
int meanShift (InputArray probImage, CV_OUT CV_IN_OUT Rect &window, TermCriteria criteria)
 updates the object tracking window using meanshift algorithm More...
 
int buildOpticalFlowPyramid (InputArray img, OutputArrayOfArrays pyramid, Size winSize, int maxLevel, bool withDerivatives=true, int pyrBorder=BORDER_REFLECT_101, int derivBorder=BORDER_CONSTANT, bool tryReuseInputImage=true)
 constructs a pyramid which can be used as input for calcOpticalFlowPyrLK More...
 
void calcOpticalFlowPyrLK (InputArray prevImg, InputArray nextImg, InputArray prevPts, CV_OUT InputOutputArray nextPts, OutputArray status, OutputArray err, Size winSize=Size(21, 21), int maxLevel=3, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags=0, double minEigThreshold=1e-4)
 computes sparse optical flow using multi-scale Lucas-Kanade algorithm More...
 
void calcOpticalFlowFarneback (InputArray prev, InputArray next, CV_OUT InputOutputArray 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 More...
 
Mat estimateRigidTransform (InputArray src, InputArray dst, bool fullAffine)
 estimates the best-fit Euqcidean, similarity, affine or perspective transformation More...
 
void calcOpticalFlowSF (Mat &from, Mat &to, Mat &flow, int layers, int averaging_block_size, int max_flow)
 computes dense optical flow using Simple Flow algorithm More...
 
void calcOpticalFlowSF (Mat &from, Mat &to, Mat &flow, int layers, int averaging_block_size, int max_flow, double sigma_dist, double sigma_color, int postprocess_window, double sigma_dist_fix, double sigma_color_fix, double occ_thr, int upscale_averaging_radius, double upscale_sigma_dist, double upscale_sigma_color, double speed_up_thr)
 
Ptr< DenseOpticalFlowcreateOptFlow_DualTVL1 ()
 
bool initModule_video (void)
 
void Rodrigues (InputArray src, OutputArray dst, OutputArray jacobian=noArray())
 converts rotation vector to rotation matrix or vice versa using Rodrigues transformation More...
 
Mat findHomography (InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray())
 computes the best-fit perspective transformation mapping srcPoints to dstPoints. More...
 
Mat findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, int method=0, double ransacReprojThreshold=3)
 variant of findHomography for backward compatibility More...
 
Vec3d RQDecomp3x3 (InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray())
 Computes RQ decomposition of 3x3 matrix. More...
 
void decomposeProjectionMatrix (InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray())
 Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector. More...
 
void matMulDeriv (InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB)
 computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients More...
 
void composeRT (InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray())
 composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments More...
 
void projectPoints (InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0)
 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 More...
 
bool solvePnP (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int flags=ITERATIVE)
 
void solvePnPRansac (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount=100, float reprojectionError=8.0, int minInliersCount=100, OutputArray inliers=noArray(), int flags=ITERATIVE)
 computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible. More...
 
Mat initCameraMatrix2D (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.)
 initializes camera matrix from a few 3D points and the corresponding projections. More...
 
bool findChessboardCorners (InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE)
 finds checkerboard pattern of the specified size in the image More...
 
bool find4QuadCornerSubpix (InputArray img, InputOutputArray corners, Size region_size)
 finds subpixel-accurate positions of the chessboard corners More...
 
void drawChessboardCorners (InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound)
 draws the checkerboard pattern (found or partly found) in the image More...
 
bool findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr< FeatureDetector > &blobDetector=new SimpleBlobDetector())
 finds circles' grid pattern of the specified size in the image More...
 
bool findCirclesGridDefault (InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID)
 the deprecated function. Use findCirclesGrid() instead of it. More...
 
double calibrateCamera (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, CV_OUT InputOutputArray cameraMatrix, CV_OUT InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0, TermCriteria criteria=TermCriteria( TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
 finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern. More...
 
void calibrationMatrixValues (InputArray 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. More...
 
double stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, CV_OUT InputOutputArray cameraMatrix1, CV_OUT InputOutputArray distCoeffs1, CV_OUT InputOutputArray cameraMatrix2, CV_OUT InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray 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 More...
 
void stereoRectify (InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags=CALIB_ZERO_DISPARITY, double alpha=-1, Size newImageSize=Size(), CV_OUT Rect *validPixROI1=0, CV_OUT Rect *validPixROI2=0)
 computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters More...
 
bool stereoRectifyUncalibrated (InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5)
 computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed) More...
 
float rectify3Collinear (InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, InputArray cameraMatrix3, InputArray distCoeffs3, InputArrayOfArrays imgpt1, InputArrayOfArrays imgpt3, Size imageSize, InputArray R12, InputArray T12, InputArray R13, InputArray T13, OutputArray R1, OutputArray R2, OutputArray R3, OutputArray P1, OutputArray P2, OutputArray P3, OutputArray 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. More...
 
Mat getOptimalNewCameraMatrix (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize=Size(), CV_OUT Rect *validPixROI=0, bool centerPrincipalPoint=false)
 returns the optimal new camera matrix More...
 
void convertPointsToHomogeneous (InputArray src, OutputArray dst)
 converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1)) More...
 
void convertPointsFromHomogeneous (InputArray src, OutputArray dst)
 converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z)) More...
 
void convertPointsHomogeneous (InputArray src, OutputArray dst)
 for backward compatibility More...
 
Mat findFundamentalMat (InputArray points1, InputArray points2, int method=FM_RANSAC, double param1=3., double param2=0.99, OutputArray mask=noArray())
 finds fundamental matrix from a set of corresponding 2D points More...
 
Mat findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, int method=FM_RANSAC, double param1=3., double param2=0.99)
 variant of findFundamentalMat for backward compatibility More...
 
void computeCorrespondEpilines (InputArray points, int whichImage, InputArray F, OutputArray lines)
 finds coordinates of epipolar lines corresponding the specified points More...
 
void triangulatePoints (InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, OutputArray points4D)
 
void correctMatches (InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2)
 
void filterSpeckles (InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray())
 filters off speckles (small regions of incorrectly computed disparity) More...
 
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()) More...
 
void validateDisparity (InputOutputArray disparity, InputArray 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 More...
 
void reprojectImageTo3D (InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int ddepth=-1)
 reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify More...
 
int estimateAffine3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
 
bool initModule_features2d ()
 
void write (FileStorage &fs, const string &name, const vector< KeyPoint > &keypoints)
 writes vector of keypoints to the file storage More...
 
void read (const FileNode &node, CV_OUT vector< KeyPoint > &keypoints)
 reads vector of keypoints from the specified file storage node More...
 
void FAST (InputArray image, CV_OUT vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression=true)
 detects corners using FAST algorithm by E. Rosten More...
 
void FASTX (InputArray image, CV_OUT vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression, int type)
 
Mat windowedMatchingMask (const vector< KeyPoint > &keypoints1, const vector< KeyPoint > &keypoints2, float maxDeltaX, float maxDeltaY)
 
void drawKeypoints (const Mat &image, const vector< KeyPoint > &keypoints, CV_OUT Mat &outImage, 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< 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)
 
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 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 computeRecallPrecisionCurve (const vector< vector< DMatch > > &matches1to2, const vector< vector< uchar > > &correctMatches1to2Mask, vector< Point2f > &recallPrecisionCurve)
 
float getRecall (const vector< Point2f > &recallPrecisionCurve, float l_precision)
 
int getNearestPoint (const vector< Point2f > &recallPrecisionCurve, float l_precision)
 
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 >())
 
void groupRectangles (CV_OUT CV_IN_OUT vector< Rect > &rectList, int groupThreshold, double eps=0.2)
 
void groupRectangles (CV_OUT CV_IN_OUT vector< Rect > &rectList, CV_OUT vector< int > &weights, int groupThreshold, double eps=0.2)
 
void groupRectangles (vector< Rect > &rectList, int groupThreshold, double eps, vector< int > *weights, vector< double > *levelWeights)
 
void groupRectangles (vector< Rect > &rectList, vector< int > &rejectLevels, vector< double > &levelWeights, int groupThreshold, double eps=0.2)
 
void groupRectangles_meanshift (vector< Rect > &rectList, vector< double > &foundWeights, vector< double > &foundScales, double detectThreshold=0.0, Size winDetSize=Size(64, 128))
 
void findDataMatrix (InputArray image, CV_OUT vector< string > &codes, OutputArray corners=noArray(), OutputArrayOfArrays dmtx=noArray())
 
void drawDataMatrixCodes (InputOutputArray image, const vector< string > &codes, InputArray corners)
 
bool initModule_ml (void)
 
void inpaint (InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRadius, int flags)
 restores the damaged image areas using one of the available intpainting algorithms More...
 
void fastNlMeansDenoising (InputArray src, OutputArray dst, float h=3, int templateWindowSize=7, int searchWindowSize=21)
 
void fastNlMeansDenoisingColored (InputArray src, OutputArray dst, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21)
 
void fastNlMeansDenoisingMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, int templateWindowSize=7, int searchWindowSize=21)
 
void fastNlMeansDenoisingColoredMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21)
 
bool initModule_nonfree ()
 
std::ostream & operator<< (std::ostream &out, const TickMeter &tm)
 
int chamerMatching (Mat &img, Mat &templ, CV_OUT vector< vector< Point > > &results, CV_OUT 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)
 
void polyfit (const Mat &srcx, const Mat &srcy, Mat &dst, int order)
 
void generateColors (std::vector< Scalar > &colors, size_t count, size_t factor=100)
 
bool RGBDOdometry (Mat &Rt, const Mat &initRt, const Mat &image0, const Mat &depth0, const Mat &mask0, const Mat &image1, const Mat &depth1, const Mat &mask1, const Mat &cameraMatrix, float minDepth=0.f, float maxDepth=4.f, float maxDepthDiff=0.07f, const std::vector< int > &iterCounts=std::vector< int >(), const std::vector< float > &minGradientMagnitudes=std::vector< float >(), int transformType=RIGID_BODY_MOTION)
 
Mat subspaceProject (InputArray W, InputArray mean, InputArray src)
 
Mat subspaceReconstruct (InputArray W, InputArray mean, InputArray src)
 
Ptr< FaceRecognizercreateEigenFaceRecognizer (int num_components=0, double threshold=DBL_MAX)
 
Ptr< FaceRecognizercreateFisherFaceRecognizer (int num_components=0, double threshold=DBL_MAX)
 
Ptr< FaceRecognizercreateLBPHFaceRecognizer (int radius=1, int neighbors=8, int grid_x=8, int grid_y=8, double threshold=DBL_MAX)
 
void applyColorMap (InputArray src, OutputArray dst, int colormap)
 
bool initModule_contrib ()
 
uchargetData (IplImage *image)
 

Variables

double iterFactor =1.)
 
OutputArray sum
 
OutputArray OutputArray sqsum
 
OutputArray OutputArray int sdepth =-1 )
 
OutputArray OutputArray OutputArray tilted
 
OutputArray dst
 
OutputArray OutputArray labels
 
OutputArray OutputArray int distanceType
 
OutputArray OutputArray int int maskSize
 
OutputArray OutputArray int int int labelType =DIST_LABEL_CCOMP )
 

Detailed Description

Namespace where all the C++ OpenCV functionality resides

Typedef Documentation

typedef Affine3<double> cv::Affine3d
typedef Affine3<float> cv::Affine3f
typedef void(* cv::BinaryFunc) (const uchar *src1, size_t step1, const uchar *src2, size_t step2, uchar *dst, size_t step, Size sz, void *)
typedef CvBoost cv::Boost
typedef bool(* cv::BundleAdjustCallback) (int iteration, double norm_error, void *user_data)
typedef void(CV_CDECL * cv::ButtonCallback) (int state, void *userdata)
typedef Complex<double> cv::Complexd
typedef Complex<float> cv::Complexf
typedef std::vector<double> cv::ConcurrentDoubleVector
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 const _InputArray& cv::InputArray
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 *userdata)
typedef void(* cv::OpenGlDrawCallback) (void *userdata)
typedef const _OutputArray& cv::OutputArray
typedef Point2i cv::Point
typedef Point_<double> cv::Point2d
typedef Point_<float> cv::Point2f
typedef Point3_<double> cv::Point3d
typedef Point3_<float> cv::Point3f
typedef Rect_<int> cv::Rect
typedef Scalar_<double> cv::Scalar
typedef Size2i cv::Size
typedef Size_<double> cv::Size2d
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 Vec<int, 6> cv::Vec6i
typedef Vec<int, 8> cv::Vec8i
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

Various k-Means flags

Enumerator
KMEANS_RANDOM_CENTERS 
KMEANS_PP_CENTERS 
KMEANS_USE_INITIAL_LABELS 
anonymous enum

the contour approximation algorithm

Enumerator
CHAIN_APPROX_NONE 
CHAIN_APPROX_SIMPLE 
CHAIN_APPROX_TC89_L1 
CHAIN_APPROX_TC89_KCOS 
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
Enumerator
WINDOW_NORMAL 
WINDOW_AUTOSIZE 
WINDOW_OPENGL 
WND_PROP_FULLSCREEN 
WND_PROP_AUTOSIZE 
WND_PROP_ASPECT_RATIO 
WND_PROP_OPENGL 
anonymous enum
Enumerator
EVENT_MOUSEMOVE 
EVENT_LBUTTONDOWN 
EVENT_RBUTTONDOWN 
EVENT_MBUTTONDOWN 
EVENT_LBUTTONUP 
EVENT_RBUTTONUP 
EVENT_MBUTTONUP 
EVENT_LBUTTONDBLCLK 
EVENT_RBUTTONDBLCLK 
EVENT_MBUTTONDBLCLK 
anonymous enum
Enumerator
EVENT_FLAG_LBUTTON 
EVENT_FLAG_RBUTTON 
EVENT_FLAG_MBUTTON 
EVENT_FLAG_CTRLKEY 
EVENT_FLAG_SHIFTKEY 
EVENT_FLAG_ALTKEY 
anonymous enum
Enumerator
IMREAD_UNCHANGED 
IMREAD_GRAYSCALE 
IMREAD_COLOR 
IMREAD_ANYDEPTH 
IMREAD_ANYCOLOR 
anonymous enum
Enumerator
IMWRITE_JPEG_QUALITY 
IMWRITE_PNG_COMPRESSION 
IMWRITE_PNG_STRATEGY 
IMWRITE_PNG_BILEVEL 
IMWRITE_PNG_STRATEGY_DEFAULT 
IMWRITE_PNG_STRATEGY_FILTERED 
IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY 
IMWRITE_PNG_STRATEGY_RLE 
IMWRITE_PNG_STRATEGY_FIXED 
IMWRITE_PXM_BINARY 
anonymous enum
Enumerator
OPTFLOW_USE_INITIAL_FLOW 
OPTFLOW_LK_GET_MIN_EIGENVALS 
OPTFLOW_FARNEBACK_GAUSSIAN 
anonymous enum

type of the robust estimation algorithm

Enumerator
LMEDS 

least-median algorithm

RANSAC 

RANSAC algorithm.

anonymous enum

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

Enumerator
ITERATIVE 
EPNP 
P3P 
anonymous enum
Enumerator
CALIB_CB_ADAPTIVE_THRESH 
CALIB_CB_NORMALIZE_IMAGE 
CALIB_CB_FILTER_QUADS 
CALIB_CB_FAST_CHECK 
anonymous enum
Enumerator
CALIB_CB_SYMMETRIC_GRID 
CALIB_CB_ASYMMETRIC_GRID 
CALIB_CB_CLUSTERING 
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
CASCADE_DO_CANNY_PRUNING 
CASCADE_SCALE_IMAGE 
CASCADE_FIND_BIGGEST_OBJECT 
CASCADE_DO_ROUGH_SEARCH 
anonymous enum
Enumerator
NORM_INF 
NORM_L1 
NORM_L2 
NORM_L2SQR 
NORM_HAMMING 
NORM_HAMMING2 
NORM_TYPE_MASK 
NORM_RELATIVE 
NORM_MINMAX 
anonymous enum
Enumerator
CMP_EQ 
CMP_GT 
CMP_GE 
CMP_LT 
CMP_LE 
CMP_NE 
anonymous enum

the inpainting algorithm

Enumerator
INPAINT_NS 
INPAINT_TELEA 
anonymous enum
Enumerator
ROTATION 
TRANSLATION 
RIGID_BODY_MOTION 
anonymous enum
Enumerator
COLORMAP_AUTUMN 
COLORMAP_BONE 
COLORMAP_JET 
COLORMAP_WINTER 
COLORMAP_RAINBOW 
COLORMAP_OCEAN 
COLORMAP_SUMMER 
COLORMAP_SPRING 
COLORMAP_COOL 
COLORMAP_HSV 
COLORMAP_PINK 
COLORMAP_HOT 
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
DEPTH_MASK_8U 
DEPTH_MASK_8S 
DEPTH_MASK_16U 
DEPTH_MASK_16S 
DEPTH_MASK_32S 
DEPTH_MASK_32F 
DEPTH_MASK_64F 
DEPTH_MASK_ALL 
DEPTH_MASK_ALL_BUT_8S 
DEPTH_MASK_FLT 
anonymous enum
Enumerator
MAGIC_MASK 
TYPE_MASK 
DEPTH_MASK 
anonymous enum
Enumerator
SORT_EVERY_ROW 
SORT_EVERY_COLUMN 
SORT_ASCENDING 
SORT_DESCENDING 
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 
MORPH_HITMISS 
anonymous enum

shape of the structuring element

Enumerator
MORPH_RECT 
MORPH_CROSS 
MORPH_ELLIPSE 
anonymous enum
Enumerator
GHT_POSITION 
GHT_SCALE 
GHT_ROTATION 
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
Enumerator
COVAR_SCRAMBLED 
COVAR_NORMAL 
COVAR_USE_AVG 
COVAR_SCALE 
COVAR_ROWS 
COVAR_COLS 
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

GrabCut algorithm flags.

Enumerator
GC_INIT_WITH_RECT 
GC_INIT_WITH_MASK 
GC_EVAL 
anonymous enum
Enumerator
DIST_LABEL_CCOMP 
DIST_LABEL_PIXEL 
anonymous enum
Enumerator
FLOODFILL_FIXED_RANGE 
FLOODFILL_MASK_ONLY 
anonymous enum
Enumerator
COLOR_BGR2BGRA 
COLOR_RGB2RGBA 
COLOR_BGRA2BGR 
COLOR_RGBA2RGB 
COLOR_BGR2RGBA 
COLOR_RGB2BGRA 
COLOR_RGBA2BGR 
COLOR_BGRA2RGB 
COLOR_BGR2RGB 
COLOR_RGB2BGR 
COLOR_BGRA2RGBA 
COLOR_RGBA2BGRA 
COLOR_BGR2GRAY 
COLOR_RGB2GRAY 
COLOR_GRAY2BGR 
COLOR_GRAY2RGB 
COLOR_GRAY2BGRA 
COLOR_GRAY2RGBA 
COLOR_BGRA2GRAY 
COLOR_RGBA2GRAY 
COLOR_BGR2BGR565 
COLOR_RGB2BGR565 
COLOR_BGR5652BGR 
COLOR_BGR5652RGB 
COLOR_BGRA2BGR565 
COLOR_RGBA2BGR565 
COLOR_BGR5652BGRA 
COLOR_BGR5652RGBA 
COLOR_GRAY2BGR565 
COLOR_BGR5652GRAY 
COLOR_BGR2BGR555 
COLOR_RGB2BGR555 
COLOR_BGR5552BGR 
COLOR_BGR5552RGB 
COLOR_BGRA2BGR555 
COLOR_RGBA2BGR555 
COLOR_BGR5552BGRA 
COLOR_BGR5552RGBA 
COLOR_GRAY2BGR555 
COLOR_BGR5552GRAY 
COLOR_BGR2XYZ 
COLOR_RGB2XYZ 
COLOR_XYZ2BGR 
COLOR_XYZ2RGB 
COLOR_BGR2YCrCb 
COLOR_RGB2YCrCb 
COLOR_YCrCb2BGR 
COLOR_YCrCb2RGB 
COLOR_BGR2HSV 
COLOR_RGB2HSV 
COLOR_BGR2Lab 
COLOR_RGB2Lab 
COLOR_BayerBG2BGR 
COLOR_BayerGB2BGR 
COLOR_BayerRG2BGR 
COLOR_BayerGR2BGR 
COLOR_BayerBG2RGB 
COLOR_BayerGB2RGB 
COLOR_BayerRG2RGB 
COLOR_BayerGR2RGB 
COLOR_BGR2Luv 
COLOR_RGB2Luv 
COLOR_BGR2HLS 
COLOR_RGB2HLS 
COLOR_HSV2BGR 
COLOR_HSV2RGB 
COLOR_Lab2BGR 
COLOR_Lab2RGB 
COLOR_Luv2BGR 
COLOR_Luv2RGB 
COLOR_HLS2BGR 
COLOR_HLS2RGB 
COLOR_BayerBG2BGR_VNG 
COLOR_BayerGB2BGR_VNG 
COLOR_BayerRG2BGR_VNG 
COLOR_BayerGR2BGR_VNG 
COLOR_BayerBG2RGB_VNG 
COLOR_BayerGB2RGB_VNG 
COLOR_BayerRG2RGB_VNG 
COLOR_BayerGR2RGB_VNG 
COLOR_BGR2HSV_FULL 
COLOR_RGB2HSV_FULL 
COLOR_BGR2HLS_FULL 
COLOR_RGB2HLS_FULL 
COLOR_HSV2BGR_FULL 
COLOR_HSV2RGB_FULL 
COLOR_HLS2BGR_FULL 
COLOR_HLS2RGB_FULL 
COLOR_LBGR2Lab 
COLOR_LRGB2Lab 
COLOR_LBGR2Luv 
COLOR_LRGB2Luv 
COLOR_Lab2LBGR 
COLOR_Lab2LRGB 
COLOR_Luv2LBGR 
COLOR_Luv2LRGB 
COLOR_BGR2YUV 
COLOR_RGB2YUV 
COLOR_YUV2BGR 
COLOR_YUV2RGB 
COLOR_BayerBG2GRAY 
COLOR_BayerGB2GRAY 
COLOR_BayerRG2GRAY 
COLOR_BayerGR2GRAY 
COLOR_YUV2RGB_NV12 
COLOR_YUV2BGR_NV12 
COLOR_YUV2RGB_NV21 
COLOR_YUV2BGR_NV21 
COLOR_YUV420sp2RGB 
COLOR_YUV420sp2BGR 
COLOR_YUV2RGBA_NV12 
COLOR_YUV2BGRA_NV12 
COLOR_YUV2RGBA_NV21 
COLOR_YUV2BGRA_NV21 
COLOR_YUV420sp2RGBA 
COLOR_YUV420sp2BGRA 
COLOR_YUV2RGB_YV12 
COLOR_YUV2BGR_YV12 
COLOR_YUV2RGB_IYUV 
COLOR_YUV2BGR_IYUV 
COLOR_YUV2RGB_I420 
COLOR_YUV2BGR_I420 
COLOR_YUV420p2RGB 
COLOR_YUV420p2BGR 
COLOR_YUV2RGBA_YV12 
COLOR_YUV2BGRA_YV12 
COLOR_YUV2RGBA_IYUV 
COLOR_YUV2BGRA_IYUV 
COLOR_YUV2RGBA_I420 
COLOR_YUV2BGRA_I420 
COLOR_YUV420p2RGBA 
COLOR_YUV420p2BGRA 
COLOR_YUV2GRAY_420 
COLOR_YUV2GRAY_NV21 
COLOR_YUV2GRAY_NV12 
COLOR_YUV2GRAY_YV12 
COLOR_YUV2GRAY_IYUV 
COLOR_YUV2GRAY_I420 
COLOR_YUV420sp2GRAY 
COLOR_YUV420p2GRAY 
COLOR_YUV2RGB_UYVY 
COLOR_YUV2BGR_UYVY 
COLOR_YUV2RGB_Y422 
COLOR_YUV2BGR_Y422 
COLOR_YUV2RGB_UYNV 
COLOR_YUV2BGR_UYNV 
COLOR_YUV2RGBA_UYVY 
COLOR_YUV2BGRA_UYVY 
COLOR_YUV2RGBA_Y422 
COLOR_YUV2BGRA_Y422 
COLOR_YUV2RGBA_UYNV 
COLOR_YUV2BGRA_UYNV 
COLOR_YUV2RGB_YUY2 
COLOR_YUV2BGR_YUY2 
COLOR_YUV2RGB_YVYU 
COLOR_YUV2BGR_YVYU 
COLOR_YUV2RGB_YUYV 
COLOR_YUV2BGR_YUYV 
COLOR_YUV2RGB_YUNV 
COLOR_YUV2BGR_YUNV 
COLOR_YUV2RGBA_YUY2 
COLOR_YUV2BGRA_YUY2 
COLOR_YUV2RGBA_YVYU 
COLOR_YUV2BGRA_YVYU 
COLOR_YUV2RGBA_YUYV 
COLOR_YUV2BGRA_YUYV 
COLOR_YUV2RGBA_YUNV 
COLOR_YUV2BGRA_YUNV 
COLOR_YUV2GRAY_UYVY 
COLOR_YUV2GRAY_YUY2 
COLOR_YUV2GRAY_Y422 
COLOR_YUV2GRAY_UYNV 
COLOR_YUV2GRAY_YVYU 
COLOR_YUV2GRAY_YUYV 
COLOR_YUV2GRAY_YUNV 
COLOR_RGBA2mRGBA 
COLOR_mRGBA2RGBA 
COLOR_RGB2YUV_I420 
COLOR_BGR2YUV_I420 
COLOR_RGB2YUV_IYUV 
COLOR_BGR2YUV_IYUV 
COLOR_RGBA2YUV_I420 
COLOR_BGRA2YUV_I420 
COLOR_RGBA2YUV_IYUV 
COLOR_BGRA2YUV_IYUV 
COLOR_RGB2YUV_YV12 
COLOR_BGR2YUV_YV12 
COLOR_RGBA2YUV_YV12 
COLOR_BGRA2YUV_YV12 
COLOR_COLORCVT_MAX 
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

RETR_FLOODFILL 

Possible set of marker types used for the drawMarker function.

Enumerator
MARKER_CROSS 
MARKER_TILTED_CROSS 
MARKER_STAR 
MARKER_DIAMOND 
MARKER_SQUARE 
MARKER_TRIANGLE_UP 
MARKER_TRIANGLE_DOWN 
Enumerator
RETINA_COLOR_RANDOM 

each pixel position is either R, G or B in a random choice

RETINA_COLOR_DIAGONAL 

color sampling is RGBRGBRGB..., line 2 BRGBRGBRG..., line 3, GBRGBRGBR...

RETINA_COLOR_BAYER 

standard bayer sampling

Function Documentation

MatExpr cv::abs ( const Mat m)
MatExpr cv::abs ( const MatExpr e)
void cv::absdiff ( InputArray  src1,
InputArray  src2,
OutputArray  dst 
)

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

void cv::accumulate ( InputArray  src,
InputOutputArray  dst,
InputArray  mask = noArray() 
)

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

void cv::accumulateProduct ( InputArray  src1,
InputArray  src2,
InputOutputArray  dst,
InputArray  mask = noArray() 
)

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

void cv::accumulateSquare ( InputArray  src,
InputOutputArray  dst,
InputArray  mask = noArray() 
)

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

void cv::accumulateWeighted ( InputArray  src,
InputOutputArray  dst,
double  alpha,
InputArray  mask = noArray() 
)

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

void cv::adaptiveBilateralFilter ( InputArray  src,
OutputArray  dst,
Size  ksize,
double  sigmaSpace,
double  maxSigmaColor = 20.0,
Point  anchor = Point(-1,-1),
int  borderType = BORDER_DEFAULT 
)

smooths the image using adaptive bilateral filter

void cv::adaptiveThreshold ( InputArray  src,
OutputArray  dst,
double  maxValue,
int  adaptiveMethod,
int  thresholdType,
int  blockSize,
double  C 
)

applies variable (adaptive) threshold to the image

void cv::add ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
InputArray  mask = noArray(),
int  dtype = -1 
)

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

void cv::addText ( const Mat img,
const string &  text,
Point  org,
CvFont  font 
)
void cv::addWeighted ( InputArray  src1,
double  alpha,
InputArray  src2,
double  beta,
double  gamma,
OutputArray  dst,
int  dtype = -1 
)

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

void cv::applyColorMap ( InputArray  src,
OutputArray  dst,
int  colormap 
)
void cv::approxPolyDP ( InputArray  curve,
OutputArray  approxCurve,
double  epsilon,
bool  closed 
)

approximates contour or a curve using Douglas-Peucker algorithm

double cv::arcLength ( InputArray  curve,
bool  closed 
)

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

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

draws an arrow from pt1 to pt2 in the image

void cv::batchDistance ( InputArray  src1,
InputArray  src2,
OutputArray  dist,
int  dtype,
OutputArray  nidx,
int  normType = NORM_L2,
int  K = 0,
InputArray  mask = noArray(),
int  update = 0,
bool  crosscheck = false 
)

naive nearest neighbor finder

void cv::bilateralFilter ( InputArray  src,
OutputArray  dst,
int  d,
double  sigmaColor,
double  sigmaSpace,
int  borderType = BORDER_DEFAULT 
)

smooths the image using bilateral filter

void cv::bitwise_and ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
InputArray  mask = noArray() 
)

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

void cv::bitwise_not ( InputArray  src,
OutputArray  dst,
InputArray  mask = noArray() 
)

inverts each bit of array (dst = ~src)

void cv::bitwise_or ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
InputArray  mask = noArray() 
)

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

void cv::bitwise_xor ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
InputArray  mask = noArray() 
)

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

void cv::blur ( InputArray  src,
OutputArray  dst,
Size  ksize,
Point  anchor = Point(-1,-1),
int  borderType = BORDER_DEFAULT 
)

a synonym for normalized box filter

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

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

Rect cv::boundingRect ( InputArray  points)

computes the bounding rectangle for a contour

void cv::boxFilter ( InputArray  src,
OutputArray  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

int cv::buildOpticalFlowPyramid ( InputArray  img,
OutputArrayOfArrays  pyramid,
Size  winSize,
int  maxLevel,
bool  withDerivatives = true,
int  pyrBorder = BORDER_REFLECT_101,
int  derivBorder = BORDER_CONSTANT,
bool  tryReuseInputImage = true 
)

constructs a pyramid which can be used as input for calcOpticalFlowPyrLK

void cv::buildPyramid ( InputArray  src,
OutputArrayOfArrays  dst,
int  maxlevel,
int  borderType = BORDER_DEFAULT 
)

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

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

computes back projection for the set of images

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

computes back projection for the set of images

void cv::calcBackProject ( InputArrayOfArrays  images,
const vector< int > &  channels,
InputArray  hist,
OutputArray  dst,
const vector< float > &  ranges,
double  scale 
)
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

void cv::calcCovarMatrix ( InputArray  samples,
OutputArray  covar,
OutputArray  mean,
int  flags,
int  ctype = CV_64F 
)

computes covariation matrix of a set of samples

double cv::calcGlobalOrientation ( InputArray  orientation,
InputArray  mask,
InputArray  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,
InputArray  mask,
OutputArray  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.

void cv::calcHist ( const Mat images,
int  nimages,
const int channels,
InputArray  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 ( InputArrayOfArrays  images,
const vector< int > &  channels,
InputArray  mask,
OutputArray  hist,
const vector< int > &  histSize,
const vector< float > &  ranges,
bool  accumulate = false 
)
void cv::calcMotionGradient ( InputArray  mhi,
OutputArray  mask,
OutputArray  orientation,
double  delta1,
double  delta2,
int  apertureSize = 3 
)

computes the motion gradient orientation image from the motion history image

void cv::calcOpticalFlowFarneback ( InputArray  prev,
InputArray  next,
CV_OUT InputOutputArray  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

void cv::calcOpticalFlowPyrLK ( InputArray  prevImg,
InputArray  nextImg,
InputArray  prevPts,
CV_OUT InputOutputArray  nextPts,
OutputArray  status,
OutputArray  err,
Size  winSize = Size(21, 21),
int  maxLevel = 3,
TermCriteria  criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
int  flags = 0,
double  minEigThreshold = 1e-4 
)

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

void cv::calcOpticalFlowSF ( Mat from,
Mat to,
Mat flow,
int  layers,
int  averaging_block_size,
int  max_flow 
)

computes dense optical flow using Simple Flow algorithm

void cv::calcOpticalFlowSF ( Mat from,
Mat to,
Mat flow,
int  layers,
int  averaging_block_size,
int  max_flow,
double  sigma_dist,
double  sigma_color,
int  postprocess_window,
double  sigma_dist_fix,
double  sigma_color_fix,
double  occ_thr,
int  upscale_averaging_radius,
double  upscale_sigma_dist,
double  upscale_sigma_color,
double  speed_up_thr 
)
double cv::calibrateCamera ( InputArrayOfArrays  objectPoints,
InputArrayOfArrays  imagePoints,
Size  imageSize,
CV_OUT InputOutputArray  cameraMatrix,
CV_OUT InputOutputArray  distCoeffs,
OutputArrayOfArrays  rvecs,
OutputArrayOfArrays  tvecs,
int  flags = 0,
TermCriteria  criteria = TermCriteria(                                                                                                                                                           TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON) 
)

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

void cv::calibrationMatrixValues ( InputArray  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.

RotatedRect cv::CamShift ( InputArray  probImage,
CV_OUT CV_IN_OUT Rect window,
TermCriteria  criteria 
)

updates the object tracking window using CAMSHIFT algorithm

void cv::Canny ( InputArray  image,
OutputArray  edges,
double  threshold1,
double  threshold2,
int  apertureSize = 3,
bool  L2gradient = false 
)

applies Canny edge detector and produces the edge map.

void cv::cartToPolar ( InputArray  x,
InputArray  y,
OutputArray  magnitude,
OutputArray  angle,
bool  angleInDegrees = false 
)

converts Cartesian coordinates to polar

int cv::chamerMatching ( Mat img,
Mat templ,
CV_OUT vector< vector< Point > > &  results,
CV_OUT 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 
)
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_POPCNT - POPCOUNT
  • CV_CPU_AVX - AVX
  • CV_CPU_AVX2 - AVX2
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)}
bool cv::checkRange ( InputArray  a,
bool  quiet = true,
CV_OUT Point pos = 0,
double  minVal = -DBL_MAX,
double  maxVal = DBL_MAX 
)

checks that each matrix element is within the specified range.

bool cv::Cholesky ( float *  A,
size_t  astep,
int  m,
float *  b,
size_t  bstep,
int  n 
)
bool cv::Cholesky ( double *  A,
size_t  astep,
int  m,
double *  b,
size_t  bstep,
int  n 
)
void cv::circle ( CV_IN_OUT Mat img,
Point  center,
int  radius,
const Scalar color,
int  thickness = 1,
int  lineType = 8,
int  shift = 0 
)

draws the circle outline or a solid circle in the image

void cv::clearSeq ( CvSeq seq)
bool cv::clipLine ( Size  imgSize,
CV_IN_OUT Point pt1,
CV_IN_OUT Point pt2 
)

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

bool cv::clipLine ( Rect  imgRect,
CV_OUT CV_IN_OUT Point pt1,
CV_OUT CV_IN_OUT Point pt2 
)

clips the line segment by the rectangle imgRect

template<>
std::string cv::CommandLineParser::analyzeValue< std::string > ( const std::string &  str,
bool  space_delete 
)
void cv::compare ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
int  cmpop 
)

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

double cv::compareHist ( InputArray  H1,
InputArray  H2,
int  method 
)

compares two histograms stored in dense arrays

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

compares two histograms stored in sparse arrays

void cv::completeSymm ( InputOutputArray  mtx,
bool  lowerToUpper = false 
)

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

void cv::composeRT ( InputArray  rvec1,
InputArray  tvec1,
InputArray  rvec2,
InputArray  tvec2,
OutputArray  rvec3,
OutputArray  tvec3,
OutputArray  dr3dr1 = noArray(),
OutputArray  dr3dt1 = noArray(),
OutputArray  dr3dr2 = noArray(),
OutputArray  dr3dt2 = noArray(),
OutputArray  dt3dr1 = noArray(),
OutputArray  dt3dt1 = noArray(),
OutputArray  dt3dr2 = noArray(),
OutputArray  dt3dt2 = noArray() 
)

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

void cv::computeCorrespondEpilines ( InputArray  points,
int  whichImage,
InputArray  F,
OutputArray  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 
)
template<typename _Tp >
Vec<_Tp, 2> cv::conjugate ( const Vec< _Tp, 2 > &  v)
template<typename _Tp >
Vec<_Tp, 4> cv::conjugate ( const Vec< _Tp, 4 > &  v)
double cv::contourArea ( InputArray  contour,
bool  oriented = false 
)

computes the contour area

void cv::convertMaps ( InputArray  map1,
InputArray  map2,
OutputArray  dstmap1,
OutputArray  dstmap2,
int  dstmap1type,
bool  nninterpolation = false 
)

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

void cv::convertPointsFromHomogeneous ( InputArray  src,
OutputArray  dst 
)

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

void cv::convertPointsHomogeneous ( InputArray  src,
OutputArray  dst 
)

for backward compatibility

void cv::convertPointsToHomogeneous ( InputArray  src,
OutputArray  dst 
)

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

void cv::convertScaleAbs ( InputArray  src,
OutputArray  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 ( InputArray  points,
OutputArray  hull,
bool  clockwise = false,
bool  returnPoints = true 
)

computes convex hull for a set of 2D points.

void cv::convexityDefects ( InputArray  contour,
InputArray  convexhull,
OutputArray  convexityDefects 
)

computes the contour convexity defects

void cv::copyMakeBorder ( InputArray  src,
OutputArray  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

void cv::cornerEigenValsAndVecs ( InputArray  src,
OutputArray  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.

void cv::cornerHarris ( InputArray  src,
OutputArray  dst,
int  blockSize,
int  ksize,
double  k,
int  borderType = BORDER_DEFAULT 
)

computes Harris cornerness criteria at each image pixel

void cv::cornerMinEigenVal ( InputArray  src,
OutputArray  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 ( InputArray  image,
InputOutputArray  corners,
Size  winSize,
Size  zeroZone,
TermCriteria  criteria 
)

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

void cv::correctMatches ( InputArray  F,
InputArray  points1,
InputArray  points2,
OutputArray  newPoints1,
OutputArray  newPoints2 
)
int cv::countNonZero ( InputArray  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 = NULL,
int  type = CV_PUSH_BUTTON,
bool  initial_button_state = 0 
)
Ptr<CLAHE> cv::createCLAHE ( double  clipLimit = 40.0,
Size  tileGridSize = Size(8, 8) 
)
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<FaceRecognizer> cv::createEigenFaceRecognizer ( int  num_components = 0,
double  threshold = DBL_MAX 
)
Ptr<FaceRecognizer> cv::createFisherFaceRecognizer ( int  num_components = 0,
double  threshold = DBL_MAX 
)
Ptr<FilterEngine> cv::createGaussianFilter ( int  type,
Size  ksize,
double  sigma1,
double  sigma2 = 0,
int  borderType = BORDER_DEFAULT 
)

returns the Gaussian filter engine

void cv::createHanningWindow ( OutputArray  dst,
Size  winSize,
int  type 
)
Ptr<FaceRecognizer> cv::createLBPHFaceRecognizer ( int  radius = 1,
int  neighbors = 8,
int  grid_x = 8,
int  grid_y = 8,
double  threshold = DBL_MAX 
)
Ptr<FilterEngine> cv::createLinearFilter ( int  srcType,
int  dstType,
InputArray  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,
InputArray  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.

Ptr<DenseOpticalFlow> cv::createOptFlow_DualTVL1 ( )
Ptr<FilterEngine> cv::createSeparableLinearFilter ( int  srcType,
int  dstType,
InputArray  rowKernel,
InputArray  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 = 0,
void userdata = 0 
)
float cv::cubeRoot ( float  val)

computes cube root of the argument

const char* cv::currentParallelFramework ( )
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
void cv::cv2eigen ( const Mat src,
Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &  dst 
)
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
void cv::cv2eigen ( const Matx< _Tp, _rows, _cols > &  src,
Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &  dst 
)
template<typename _Tp >
void cv::cv2eigen ( const Mat src,
Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &  dst 
)
template<typename _Tp , int _rows, int _cols>
void cv::cv2eigen ( const Matx< _Tp, _rows, _cols > &  src,
Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &  dst 
)
template<typename _Tp >
void cv::cv2eigen ( const Mat src,
Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &  dst 
)
template<typename _Tp , int _rows>
void cv::cv2eigen ( const Matx< _Tp, _rows, 1 > &  src,
Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &  dst 
)
template<typename _Tp >
void cv::cv2eigen ( const Mat src,
Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &  dst 
)
template<typename _Tp , int _cols>
void cv::cv2eigen ( const Matx< _Tp, 1, _cols > &  src,
Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &  dst 
)
cv::CV_EXPORTS_AS ( integral2  )

computes the integral image and integral for the squared image

cv::CV_EXPORTS_AS ( integral3  )

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

cv::CV_EXPORTS_AS ( distanceTransformWithLabels  )

builds the discrete Voronoi diagram

cv::CV_EXPORTS_AS ( sumElems  )

computes sum of array elements

cv::CV_EXPORTS_AS ( randShuffle  )
Mat cv::cvarrToMat ( const CvArr arr,
bool  copyData = false,
bool  allowND = true,
int  coiMode = 0 
)

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

void cv::cvtColor ( InputArray  src,
OutputArray  dst,
int  code,
int  dstCn = 0 
)

converts image from one color space to another

void cv::dct ( InputArray  src,
OutputArray  dst,
int  flags = 0 
)

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

void cv::decomposeProjectionMatrix ( InputArray  projMatrix,
OutputArray  cameraMatrix,
OutputArray  rotMatrix,
OutputArray  transVect,
OutputArray  rotMatrixX = noArray(),
OutputArray  rotMatrixY = noArray(),
OutputArray  rotMatrixZ = noArray(),
OutputArray  eulerAngles = noArray() 
)

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

void cv::destroyAllWindows ( )
void cv::destroyWindow ( const string &  winname)
double cv::determinant ( InputArray  mtx)

computes determinant of a square matrix

void cv::dft ( InputArray  src,
OutputArray  dst,
int  flags = 0,
int  nonzeroRows = 0 
)

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

void cv::dilate ( InputArray  src,
OutputArray  dst,
InputArray  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   CV_DEFAULT
)
void cv::displayStatusBar ( const string &  winname,
const string &  text,
int delayms   CV_DEFAULT
)
void cv::distanceTransform ( InputArray  src,
OutputArray  dst,
int  distanceType,
int  maskSize 
)

computes the distance transform map

void cv::divide ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
double  scale = 1,
int  dtype = -1 
)

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

void cv::divide ( double  scale,
InputArray  src2,
OutputArray  dst,
int  dtype = -1 
)

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

template<typename _Tp >
DataType<_Tp>::work_type cv::dot ( const Vector< _Tp > &  v1,
const Vector< _Tp > &  v2 
)
inline
void cv::drawChessboardCorners ( InputOutputArray  image,
Size  patternSize,
InputArray  corners,
bool  patternWasFound 
)

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

void cv::drawContours ( InputOutputArray  image,
InputArrayOfArrays  contours,
int  contourIdx,
const Scalar color,
int  thickness = 1,
int  lineType = 8,
InputArray  hierarchy = noArray(),
int  maxLevel = INT_MAX,
Point  offset = Point() 
)

draws contours in the image

void cv::drawDataMatrixCodes ( InputOutputArray  image,
const vector< string > &  codes,
InputArray  corners 
)
void cv::drawKeypoints ( const Mat image,
const vector< KeyPoint > &  keypoints,
CV_OUT Mat outImage,
const Scalar color = Scalar::all(-1),
int  flags = DrawMatchesFlags::DEFAULT 
)
void cv::drawMarker ( CV_IN_OUT Mat img,
Point  position,
const Scalar color,
int  markerType = MARKER_CROSS,
int  markerSize = 20,
int  thickness = 1,
int  line_type = 8 
)

Draws a marker on a predefined position in an image.

The function drawMarker draws a marker on a given position in the image. For the moment several marker types are supported (MARKER_CROSS, MARKER_TILTED_CROSS, MARKER_STAR, MARKER_DIAMOND, MARKER_SQUARE, MARKER_TRIANGLE_UP and MARKER_TRIANGLE_DOWN).

Parameters
imgImage.
positionThe point where the crosshair is positioned.
markerTypeThe specific type of marker you want to use, see
colorLine color.
thicknessLine thickness.
line_typeType of the line, see cv::LineTypes
markerSizeThe length of the marker axis [default = 20 pixels]
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 
)
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 
)
bool cv::eigen ( InputArray  src,
OutputArray  eigenvalues,
int  lowindex = -1,
int  highindex = -1 
)

finds eigenvalues of a symmetric matrix

bool cv::eigen ( InputArray  src,
OutputArray  eigenvalues,
OutputArray  eigenvectors,
int  lowindex = -1,
int  highindex = -1 
)

finds eigenvalues and eigenvectors of a symmetric matrix

bool cv::eigen ( InputArray  src,
bool  computeEigenvectors,
OutputArray  eigenvalues,
OutputArray  eigenvectors 
)
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 
)
void cv::eigen2x2 ( const float *  a,
float *  e,
int  n 
)
void cv::ellipse ( CV_IN_OUT 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

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

draws a rotated ellipse in the image

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

float cv::EMD ( InputArray  signature1,
InputArray  signature2,
int  distType,
InputArray  cost = noArray(),
float *  lowerBound = 0,
OutputArray  flow = noArray() 
)
void cv::equalizeHist ( InputArray  src,
OutputArray  dst 
)

normalizes the grayscale image brightness and contrast by normalizing its histogram

void cv::erode ( InputArray  src,
OutputArray  dst,
InputArray  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
excthe exception raisen.
int cv::estimateAffine3D ( InputArray  src,
InputArray  dst,
OutputArray  out,
OutputArray  inliers,
double  ransacThreshold = 3,
double  confidence = 0.99 
)
Mat cv::estimateRigidTransform ( InputArray  src,
InputArray  dst,
bool  fullAffine 
)

estimates the best-fit Euqcidean, similarity, affine or perspective transformation

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 = PtrFeatureDetector >() 
)
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 = PtrGenericDescriptorMatcher >() 
)
void cv::exp ( InputArray  src,
OutputArray  dst 
)

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

void cv::exp ( const float *  src,
float *  dst,
int  n 
)
void cv::extractChannel ( InputArray  src,
OutputArray  dst,
int  coi 
)

extracts a single channel from src (coi is 0-based index)

void cv::extractImageCOI ( const CvArr arr,
OutputArray  coiimg,
int  coi = -1 
)

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

void cv::FAST ( InputArray  image,
CV_OUT vector< KeyPoint > &  keypoints,
int  threshold,
bool  nonmaxSuppression = true 
)

detects corners using FAST algorithm by E. Rosten

int cv::fast_abs ( uchar  v)
inline
int cv::fast_abs ( schar  v)
inline
int cv::fast_abs ( ushort  v)
inline
int cv::fast_abs ( short  v)
inline
int cv::fast_abs ( int  v)
inline
float cv::fast_abs ( float  v)
inline
double cv::fast_abs ( double  v)
inline
float cv::fastAtan2 ( float  y,
float  x 
)

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

void cv::fastAtan2 ( const float *  y,
const float *  x,
float *  dst,
int  n,
bool  angleInDegrees 
)
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
bufSizebuffer size in bytes
Returns
the allocated memory buffer.
void cv::fastNlMeansDenoising ( InputArray  src,
OutputArray  dst,
float  h = 3,
int  templateWindowSize = 7,
int  searchWindowSize = 21 
)
void cv::fastNlMeansDenoisingColored ( InputArray  src,
OutputArray  dst,
float  h = 3,
float  hColor = 3,
int  templateWindowSize = 7,
int  searchWindowSize = 21 
)
void cv::fastNlMeansDenoisingColoredMulti ( InputArrayOfArrays  srcImgs,
OutputArray  dst,
int  imgToDenoiseIndex,
int  temporalWindowSize,
float  h = 3,
float  hColor = 3,
int  templateWindowSize = 7,
int  searchWindowSize = 21 
)
void cv::fastNlMeansDenoisingMulti ( InputArrayOfArrays  srcImgs,
OutputArray  dst,
int  imgToDenoiseIndex,
int  temporalWindowSize,
float  h = 3,
int  templateWindowSize = 7,
int  searchWindowSize = 21 
)
void cv::FASTX ( InputArray  image,
CV_OUT vector< KeyPoint > &  keypoints,
int  threshold,
bool  nonmaxSuppression,
int  type 
)
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::fillConvexPoly ( InputOutputArray  img,
InputArray  points,
const Scalar color,
int  lineType = 8,
int  shift = 0 
)
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

void cv::fillPoly ( InputOutputArray  img,
InputArrayOfArrays  pts,
const Scalar color,
int  lineType = 8,
int  shift = 0,
Point  offset = Point() 
)
void cv::filter2D ( InputArray  src,
OutputArray  dst,
int  ddepth,
InputArray  kernel,
Point  anchor = Point(-1,-1),
double  delta = 0,
int  borderType = BORDER_DEFAULT 
)

applies non-separable 2D linear filter to the image

void cv::filterSpeckles ( InputOutputArray  img,
double  newVal,
int  maxSpeckleSize,
double  maxDiff,
InputOutputArray  buf = noArray() 
)

filters off speckles (small regions of incorrectly computed disparity)

bool cv::find4QuadCornerSubpix ( InputArray  img,
InputOutputArray  corners,
Size  region_size 
)

finds subpixel-accurate positions of the chessboard corners

bool cv::findChessboardCorners ( InputArray  image,
Size  patternSize,
OutputArray  corners,
int  flags = CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE 
)

finds checkerboard pattern of the specified size in the image

bool cv::findCirclesGrid ( InputArray  image,
Size  patternSize,
OutputArray  centers,
int  flags = CALIB_CB_SYMMETRIC_GRID,
const Ptr< FeatureDetector > &  blobDetector = new SimpleBlobDetector() 
)

finds circles' grid pattern of the specified size in the image

bool cv::findCirclesGridDefault ( InputArray  image,
Size  patternSize,
OutputArray  centers,
int  flags = CALIB_CB_SYMMETRIC_GRID 
)

the deprecated function. Use findCirclesGrid() instead of it.

void cv::findContours ( InputOutputArray  image,
OutputArrayOfArrays  contours,
OutputArray  hierarchy,
int  mode,
int  method,
Point  offset = Point() 
)

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

void cv::findContours ( InputOutputArray  image,
OutputArrayOfArrays  contours,
int  mode,
int  method,
Point  offset = Point() 
)

retrieves contours from black-n-white image.

void cv::findDataMatrix ( InputArray  image,
CV_OUT vector< string > &  codes,
OutputArray  corners = noArray(),
OutputArrayOfArrays  dmtx = noArray() 
)
Mat cv::findFundamentalMat ( InputArray  points1,
InputArray  points2,
int  method = FM_RANSAC,
double  param1 = 3.,
double  param2 = 0.99,
OutputArray  mask = noArray() 
)

finds fundamental matrix from a set of corresponding 2D points

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

variant of findFundamentalMat for backward compatibility

Mat cv::findHomography ( InputArray  srcPoints,
InputArray  dstPoints,
int  method = 0,
double  ransacReprojThreshold = 3,
OutputArray  mask = noArray() 
)

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

Mat cv::findHomography ( InputArray  srcPoints,
InputArray  dstPoints,
OutputArray  mask,
int  method = 0,
double  ransacReprojThreshold = 3 
)

variant of findHomography for backward compatibility

void cv::findNonZero ( InputArray  src,
OutputArray  idx 
)

returns the list of locations of non-zero pixels

RotatedRect cv::fitEllipse ( InputArray  points)

fits ellipse to the set of 2D points

void cv::fitLine ( InputArray  points,
OutputArray  line,
int  distType,
double  param,
double  reps,
double  aeps 
)

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

void cv::flip ( InputArray  src,
OutputArray  dst,
int  flipCode 
)

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

int cv::floodFill ( InputOutputArray  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

int cv::floodFill ( InputOutputArray  image,
InputOutputArray  mask,
Point  seedPoint,
Scalar  newVal,
CV_OUT Rect rect = 0,
Scalar  loDiff = Scalar(),
Scalar  upDiff = Scalar(),
int  flags = 4 
)

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

CvFont cv::fontQt ( const string &  nameFont,
int  pointSize = -1,
Scalar  color = Scalar::all(0),
int  weight = CV_FONT_NORMAL,
int  style = CV_STYLE_NORMAL,
int  spacing = 0 
)
string cv::format ( const char *  fmt,
  ... 
)
string cv::fromUtf16 ( const WString str)
void cv::GaussianBlur ( InputArray  src,
OutputArray  dst,
Size  ksize,
double  sigmaX,
double  sigmaY = 0,
int  borderType = BORDER_DEFAULT 
)

smooths the image using Gaussian filter.

void cv::gemm ( InputArray  src1,
InputArray  src2,
double  alpha,
InputArray  src3,
double  beta,
OutputArray  dst,
int  flags = 0 
)

implements generalized matrix product algorithm GEMM from BLAS

void cv::generateColors ( std::vector< Scalar > &  colors,
size_t  count,
size_t  factor = 100 
)
Mat cv::getAffineTransform ( const Point2f  src[],
const Point2f  dst[] 
)

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

Mat cv::getAffineTransform ( InputArray  src,
InputArray  dst 
)
const string& cv::getBuildInformation ( )
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

BinaryFunc cv::getConvertFunc ( int  sdepth,
int  ddepth 
)
ConvertScaleData cv::getConvertScaleElem ( int  fromType,
int  toType 
)

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

BinaryFunc cv::getConvertScaleFunc ( int  sdepth,
int  ddepth 
)
BinaryFunc cv::getCopyMaskFunc ( size_t  esz)
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
Mat cv::getDefaultNewCameraMatrix ( InputArray  cameraMatrix,
Size  imgsize = Size(),
bool  centerPrincipalPoint = false 
)

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

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

initializes kernels of the generalized Sobel operator

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

returns the Gabor kernel with the specified parameters

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

returns the Gaussian kernel with the specified parameters

int cv::getKernelType ( InputArray  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,
InputArray  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,
InputArray  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,
InputArray  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,
InputArray  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::getNearestPoint ( const vector< Point2f > &  recallPrecisionCurve,
float  l_precision 
)
int cv::getNumberOfCPUs ( )

returns the number of CPUs (including hyper-threading)

int cv::getNumThreads ( )
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

Mat cv::getOptimalNewCameraMatrix ( InputArray  cameraMatrix,
InputArray  distCoeffs,
Size  imageSize,
double  alpha,
Size  newImgSize = Size(),
CV_OUT Rect validPixROI = 0,
bool  centerPrincipalPoint = false 
)

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.

Mat cv::getPerspectiveTransform ( InputArray  src,
InputArray  dst 
)
float cv::getRecall ( const vector< Point2f > &  recallPrecisionCurve,
float  l_precision 
)
void cv::getRectSubPix ( InputArray  image,
Size  patchSize,
Point2f  center,
OutputArray  patch,
int  patchType = -1 
)

extracts rectangle from the image at sub-pixel location

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 
)
Mat cv::getStructuringElement ( int  shape,
Size  ksize,
Point  anchor = Point(-1,-1) 
)

returns structuring element of the specified shape and size

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.

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();
int cv::getTrackbarPos ( const string &  trackbarname,
const string &  winname 
)
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())

double cv::getWindowProperty ( const string &  winname,
int  prop_id 
)
void cv::glob ( String  pattern,
std::vector< String > &  result,
bool  recursive = false 
)
void cv::goodFeaturesToTrack ( InputArray  image,
OutputArray  corners,
int  maxCorners,
double  qualityLevel,
double  minDistance,
InputArray  mask = noArray(),
int  blockSize = 3,
bool  useHarrisDetector = false,
double  k = 0.04 
)

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

void cv::grabCut ( InputArray  img,
InputOutputArray  mask,
Rect  rect,
InputOutputArray  bgdModel,
InputOutputArray  fgdModel,
int  iterCount,
int  mode = GC_EVAL 
)

segments the image using GrabCut algorithm

void cv::groupRectangles ( CV_OUT CV_IN_OUT vector< Rect > &  rectList,
int  groupThreshold,
double  eps = 0.2 
)
void cv::groupRectangles ( CV_OUT CV_IN_OUT vector< Rect > &  rectList,
CV_OUT vector< int > &  weights,
int  groupThreshold,
double  eps = 0.2 
)
void cv::groupRectangles ( vector< Rect > &  rectList,
int  groupThreshold,
double  eps,
vector< int > *  weights,
vector< double > *  levelWeights 
)
void cv::groupRectangles ( vector< Rect > &  rectList,
vector< int > &  rejectLevels,
vector< double > &  levelWeights,
int  groupThreshold,
double  eps = 0.2 
)
void cv::groupRectangles_meanshift ( vector< Rect > &  rectList,
vector< double > &  foundWeights,
vector< double > &  foundScales,
double  detectThreshold = 0.0,
Size  winDetSize = Size(64, 128) 
)
void cv::hconcat ( const Mat src,
size_t  nsrc,
OutputArray  dst 
)
void cv::hconcat ( InputArray  src1,
InputArray  src2,
OutputArray  dst 
)
void cv::hconcat ( InputArrayOfArrays  src,
OutputArray  dst 
)
void cv::HoughCircles ( InputArray  image,
OutputArray  circles,
int  method,
double  dp,
double  minDist,
double  param1 = 100,
double  param2 = 100,
int  minRadius = 0,
int  maxRadius = 0 
)

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

void cv::HoughLines ( InputArray  image,
OutputArray  lines,
double  rho,
double  theta,
int  threshold,
double  srn = 0,
double  stn = 0 
)

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

void cv::HoughLinesP ( InputArray  image,
OutputArray  lines,
double  rho,
double  theta,
int  threshold,
double  minLineLength = 0,
double  maxLineGap = 0 
)

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

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

computes 7 Hu invariants from the moments

void cv::HuMoments ( const Moments m,
CV_OUT OutputArray  hu 
)
void cv::idct ( InputArray  src,
OutputArray  dst,
int  flags = 0 
)

performs inverse 1D or 2D Discrete Cosine Transformation

void cv::idft ( InputArray  src,
OutputArray  dst,
int  flags = 0,
int  nonzeroRows = 0 
)

performs inverse 1D or 2D Discrete Fourier Transformation

Mat cv::imdecode ( InputArray  buf,
int  flags 
)
Mat cv::imdecode ( InputArray  buf,
int  flags,
Mat dst 
)
bool cv::imencode ( const string &  ext,
InputArray  img,
CV_OUT vector< uchar > &  buf,
const vector< int > &  params = vector< int >() 
)
Mat cv::imread ( const string &  filename,
int  flags = 1 
)
void cv::imshow ( const string &  winname,
InputArray  mat 
)
bool cv::imwrite ( const string &  filename,
InputArray  img,
const vector< int > &  params = vector< int >() 
)
Mat cv::initCameraMatrix2D ( InputArrayOfArrays  objectPoints,
InputArrayOfArrays  imagePoints,
Size  imageSize,
double  aspectRatio = 1. 
)

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

bool cv::initModule_contrib ( )
bool cv::initModule_features2d ( )
bool cv::initModule_ml ( void  )
bool cv::initModule_nonfree ( )
bool cv::initModule_video ( void  )
void cv::initUndistortRectifyMap ( InputArray  cameraMatrix,
InputArray  distCoeffs,
InputArray  R,
InputArray  newCameraMatrix,
Size  size,
int  m1type,
OutputArray  map1,
OutputArray  map2 
)

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

float cv::initWideAngleProjMap ( InputArray  cameraMatrix,
InputArray  distCoeffs,
Size  imageSize,
int  destImageWidth,
int  m1type,
OutputArray  map1,
OutputArray  map2,
int  projType = PROJ_SPHERICAL_EQRECT,
double  alpha = 0 
)

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

void cv::inpaint ( InputArray  src,
InputArray  inpaintMask,
OutputArray  dst,
double  inpaintRadius,
int  flags 
)

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

void cv::inRange ( InputArray  src,
InputArray  lowerb,
InputArray  upperb,
OutputArray  dst 
)

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

void cv::insertChannel ( InputArray  src,
InputOutputArray  dst,
int  coi 
)

inserts a single channel to dst (coi is 0-based index)

void cv::insertImageCOI ( InputArray  coiimg,
CvArr arr,
int  coi = -1 
)

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

void cv::integral ( InputArray  src,
OutputArray  sum,
int  sdepth = -1 
)

computes the integral image

float cv::intersectConvexConvex ( InputArray  _p1,
InputArray  _p2,
OutputArray  _p12,
bool  handleNested = true 
)

finds intersection of two convex polygons

double cv::invert ( InputArray  src,
OutputArray  dst,
int  flags = DECOMP_LU 
)

computes inverse or pseudo-inverse matrix

void cv::invertAffineTransform ( InputArray  M,
OutputArray  iM 
)

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

bool cv::isContourConvex ( InputArray  contour)

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

double cv::kmeans ( InputArray  data,
int  K,
CV_OUT InputOutputArray  bestLabels,
TermCriteria  criteria,
int  attempts,
int  flags,
OutputArray  centers = noArray() 
)

clusters the input data using k-Means algorithm

void cv::Laplacian ( InputArray  src,
OutputArray  dst,
int  ddepth,
int  ksize = 1,
double  scale = 1,
double  delta = 0,
int  borderType = BORDER_DEFAULT 
)

applies Laplacian operator to the image

void cv::line ( CV_IN_OUT 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)
void cv::log ( InputArray  src,
OutputArray  dst 
)

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

void cv::log ( const float *  src,
float *  dst,
int  n 
)
int cv::LU ( float *  A,
size_t  astep,
int  m,
float *  b,
size_t  bstep,
int  n 
)
int cv::LU ( double *  A,
size_t  astep,
int  m,
double *  b,
size_t  bstep,
int  n 
)
void cv::LUT ( InputArray  src,
InputArray  lut,
OutputArray  dst,
int  interpolation = 0 
)

transforms array of numbers using a lookup table: dst(i)=lut(src(i))

void cv::magnitude ( const float *  x,
const float *  y,
float *  dst,
int  n 
)
void cv::magnitude ( InputArray  x,
InputArray  y,
OutputArray  magnitude 
)

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

double cv::Mahalanobis ( InputArray  v1,
InputArray  v2,
InputArray  icovar 
)

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

double cv::Mahalonobis ( InputArray  v1,
InputArray  v2,
InputArray  icovar 
)

a synonym for Mahalanobis

template<typename T >
Ptr< T > cv::makePtr ( )
template<typename T , typename A1 >
Ptr< T > cv::makePtr ( const A1 &  a1)
template<typename T , typename A1 , typename A2 >
Ptr< T > cv::makePtr ( const A1 &  a1,
const A2 &  a2 
)
template<typename T , typename A1 , typename A2 , typename A3 >
Ptr< T > cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3 
)
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 >
Ptr< T > cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4 
)
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >
Ptr< T > cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5 
)
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 >
Ptr< T > cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5,
const A6 &  a6 
)
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 >
Ptr< T > cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5,
const A6 &  a6,
const A7 &  a7 
)
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 >
Ptr< T > cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5,
const A6 &  a6,
const A7 &  a7,
const A8 &  a8 
)
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 >
Ptr< T > cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5,
const A6 &  a6,
const A7 &  a7,
const A8 &  a8,
const A9 &  a9 
)
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 >
Ptr< T > cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5,
const A6 &  a6,
const A7 &  a7,
const A8 &  a8,
const A9 &  a9,
const A10 &  a10 
)
double cv::matchShapes ( InputArray  contour1,
InputArray  contour2,
int  method,
double  parameter 
)

matches two contours using one of the available algorithms

void cv::matchTemplate ( InputArray  image,
InputArray  templ,
OutputArray  result,
int  method 
)

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

void cv::matMulDeriv ( InputArray  A,
InputArray  B,
OutputArray  dABdA,
OutputArray  dABdB 
)

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

MatExpr cv::max ( const Mat a,
const Mat b 
)
MatExpr cv::max ( const Mat a,
double  s 
)
MatExpr cv::max ( double  s,
const Mat a 
)
void cv::max ( InputArray  src1,
InputArray  src2,
OutputArray  dst 
)

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

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

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

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

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

Scalar cv::mean ( InputArray  src,
InputArray  mask = noArray() 
)

computes mean value of selected array elements

int cv::meanShift ( InputArray  probImage,
CV_OUT CV_IN_OUT Rect window,
TermCriteria  criteria 
)

updates the object tracking window using meanshift algorithm

void cv::meanStdDev ( InputArray  src,
OutputArray  mean,
OutputArray  stddev,
InputArray  mask = noArray() 
)

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

void cv::medianBlur ( InputArray  src,
OutputArray  dst,
int  ksize 
)

smooths the image using median filter.

void cv::merge ( const Mat mv,
size_t  count,
OutputArray  dst 
)

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

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

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

MatExpr cv::min ( const Mat a,
const Mat b 
)
MatExpr cv::min ( const Mat a,
double  s 
)
MatExpr cv::min ( double  s,
const Mat a 
)
void cv::min ( InputArray  src1,
InputArray  src2,
OutputArray  dst 
)

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

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

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

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

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

RotatedRect cv::minAreaRect ( InputArray  points)

computes the minimal rotated rectangle for a set of points

void cv::minEnclosingCircle ( InputArray  points,
CV_OUT Point2f center,
CV_OUT float &  radius 
)

computes the minimal enclosing circle for a set of points

void cv::minMaxIdx ( InputArray  src,
double *  minVal,
double *  maxVal,
int minIdx = 0,
int maxIdx = 0,
InputArray  mask = noArray() 
)
void cv::minMaxLoc ( InputArray  src,
CV_OUT double *  minVal,
CV_OUT double *  maxVal = 0,
CV_OUT Point minLoc = 0,
CV_OUT Point maxLoc = 0,
InputArray  mask = noArray() 
)

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

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

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

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

void cv::mixChannels ( const vector< Mat > &  src,
vector< Mat > &  dst,
const int fromTo,
size_t  npairs 
)
void cv::mixChannels ( InputArrayOfArrays  src,
InputArrayOfArrays  dst,
const vector< int > &  fromTo 
)
Moments cv::moments ( InputArray  array,
bool  binaryImage = false 
)

computes moments of the rasterized shape or a vector of points

void cv::morphologyEx ( InputArray  src,
OutputArray  dst,
int  op,
InputArray  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

void cv::moveWindow ( const string &  winname,
int  x,
int  y 
)
void cv::mulSpectrums ( InputArray  a,
InputArray  b,
OutputArray  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

void cv::multiply ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
double  scale = 1,
int  dtype = -1 
)

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

void cv::mulTransposed ( InputArray  src,
OutputArray  dst,
bool  aTa,
InputArray  delta = noArray(),
double  scale = 1,
int  dtype = -1 
)

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

void cv::namedWindow ( const string &  winname,
int  flags = WINDOW_AUTOSIZE 
)
OutputArray cv::noArray ( )
double cv::norm ( InputArray  src1,
int  normType = NORM_L2,
InputArray  mask = noArray() 
)

computes norm of the selected array part

double cv::norm ( InputArray  src1,
InputArray  src2,
int  normType = NORM_L2,
InputArray  mask = noArray() 
)

computes norm of selected part of the difference between two arrays

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

computes norm of a sparse matrix

template<typename _Tp , int cn>
Vec<_Tp, cn> cv::normalize ( const Vec< _Tp, cn > &  v)
inline
void cv::normalize ( InputArray  src,
OutputArray  dst,
double  alpha = 1,
double  beta = 0,
int  norm_type = NORM_L2,
int  dtype = -1,
InputArray  mask = noArray() 
)

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

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

int cv::normHamming ( const uchar a,
const uchar b,
int  n 
)
int cv::normHamming ( const uchar a,
const uchar b,
int  n,
int  cellSize 
)
template<>
float cv::normL1 ( const float *  a,
const float *  b,
int  n 
)
inline
template<>
int cv::normL1 ( const uchar a,
const uchar b,
int  n 
)
inline
float cv::normL1_ ( const float *  a,
const float *  b,
int  n 
)
int cv::normL1_ ( const uchar a,
const uchar b,
int  n 
)
template<>
float cv::normL2Sqr ( const float *  a,
const float *  b,
int  n 
)
inline
float cv::normL2Sqr_ ( const float *  a,
const float *  b,
int  n 
)
MatExpr cv::operator!= ( const Mat a,
const Mat b 
)
MatExpr cv::operator!= ( const Mat a,
double  s 
)
MatExpr cv::operator!= ( double  s,
const Mat a 
)
template<typename _Tp >
bool cv::operator!= ( const SeqIterator< _Tp > &  a,
const SeqIterator< _Tp > &  b 
)
inline
MatExpr cv::operator& ( const Mat a,
const Mat b 
)
MatExpr cv::operator& ( const Mat a,
const Scalar s 
)
MatExpr cv::operator& ( const Scalar s,
const Mat a 
)
MatExpr cv::operator* ( const Mat a,
const Mat b 
)
MatExpr cv::operator* ( const Mat a,
double  s 
)
MatExpr cv::operator* ( double  s,
const Mat a 
)
MatExpr cv::operator* ( const MatExpr e,
const Mat m 
)
MatExpr cv::operator* ( const Mat m,
const MatExpr e 
)
MatExpr cv::operator* ( const MatExpr e,
double  s 
)
MatExpr cv::operator* ( double  s,
const MatExpr e 
)
MatExpr cv::operator* ( const MatExpr e1,
const MatExpr e2 
)
template<typename _Tp >
Vec<_Tp, 4> cv::operator* ( const Vec< _Tp, 4 > &  v1,
const Vec< _Tp, 4 > &  v2 
)
inline
template<typename _Tp >
Vec<_Tp, 4>& cv::operator*= ( Vec< _Tp, 4 > &  v1,
const Vec< _Tp, 4 > &  v2 
)
inline
MatExpr cv::operator+ ( const Mat a,
const Mat b 
)
MatExpr cv::operator+ ( const Mat a,
const Scalar s 
)
MatExpr cv::operator+ ( const Scalar s,
const Mat a 
)
MatExpr cv::operator+ ( const MatExpr e,
const Mat m 
)
MatExpr cv::operator+ ( const Mat m,
const MatExpr e 
)
MatExpr cv::operator+ ( const MatExpr e,
const Scalar s 
)
MatExpr cv::operator+ ( const Scalar s,
const MatExpr e 
)
MatExpr cv::operator+ ( const MatExpr e1,
const MatExpr e2 
)
MatExpr cv::operator- ( const Mat a,
const Mat b 
)
MatExpr cv::operator- ( const Mat a,
const Scalar s 
)
MatExpr cv::operator- ( const Scalar s,
const Mat a 
)
MatExpr cv::operator- ( const MatExpr e,
const Mat m 
)
MatExpr cv::operator- ( const Mat m,
const MatExpr e 
)
MatExpr cv::operator- ( const MatExpr e,
const Scalar s 
)
MatExpr cv::operator- ( const Scalar s,
const MatExpr e 
)
MatExpr cv::operator- ( const MatExpr e1,
const MatExpr e2 
)
MatExpr cv::operator- ( const Mat m)
MatExpr cv::operator- ( const MatExpr e)
ptrdiff_t cv::operator- ( const MatConstIterator b,
const MatConstIterator a 
)
template<typename _Tp >
ptrdiff_t cv::operator- ( const SeqIterator< _Tp > &  a,
const SeqIterator< _Tp > &  b 
)
inline
MatExpr cv::operator/ ( const Mat a,
const Mat b 
)
MatExpr cv::operator/ ( const Mat a,
double  s 
)
MatExpr cv::operator/ ( double  s,
const Mat a 
)
MatExpr cv::operator/ ( const MatExpr e,
const Mat m 
)
MatExpr cv::operator/ ( const Mat m,
const MatExpr e 
)
MatExpr cv::operator/ ( const MatExpr e,
double  s 
)
MatExpr cv::operator/ ( double  s,
const MatExpr e 
)
MatExpr cv::operator/ ( const MatExpr e1,
const MatExpr e2 
)
MatExpr cv::operator< ( const Mat a,
const Mat b 
)
MatExpr cv::operator< ( const Mat a,
double  s 
)
MatExpr cv::operator< ( double  s,
const Mat a 
)
std::ostream& cv::operator<< ( std::ostream &  out,
const TickMeter tm 
)
FileStorage& cv::operator<< ( FileStorage fs,
const string &  str 
)
template<typename _Tp , int m, int n>
std::ostream& cv::operator<< ( std::ostream &  out,
const Matx< _Tp, m, n > &  matx 
)
inline

Writes a Matx to an output stream.

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

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 , int n>
std::ostream& cv::operator<< ( std::ostream &  out,
const Vec< _Tp, n > &  vec 
)
inline

Writes a Vec to an output stream. Format example : [10, 20, 30]

template<typename _Tp >
std::ostream& cv::operator<< ( std::ostream &  out,
const Size_< _Tp > &  size 
)
inline

Writes a Size_ to an output stream. Format example : [640 x 480]

template<typename _Tp >
std::ostream& cv::operator<< ( std::ostream &  out,
const Rect_< _Tp > &  rect 
)
inline

Writes a Rect_ to an output stream. Format example : [640 x 480 from (10, 20)]

MatExpr cv::operator<= ( const Mat a,
const Mat b 
)
MatExpr cv::operator<= ( const Mat a,
double  s 
)
MatExpr cv::operator<= ( double  s,
const Mat a 
)
MatExpr cv::operator== ( const Mat a,
const Mat b 
)
MatExpr cv::operator== ( const Mat a,
double  s 
)
MatExpr cv::operator== ( double  s,
const Mat a 
)
template<typename _Tp >
bool cv::operator== ( const SeqIterator< _Tp > &  a,
const SeqIterator< _Tp > &  b 
)
inline
MatExpr cv::operator> ( const Mat a,
const Mat b 
)
MatExpr cv::operator> ( const Mat a,
double  s 
)
MatExpr cv::operator> ( double  s,
const Mat a 
)
MatExpr cv::operator>= ( const Mat a,
const Mat b 
)
MatExpr cv::operator>= ( const Mat a,
double  s 
)
MatExpr cv::operator>= ( double  s,
const Mat a 
)
MatExpr cv::operator^ ( const Mat a,
const Mat b 
)
MatExpr cv::operator^ ( const Mat a,
const Scalar s 
)
MatExpr cv::operator^ ( const Scalar s,
const Mat a 
)
MatExpr cv::operator| ( const Mat a,
const Mat b 
)
MatExpr cv::operator| ( const Mat a,
const Scalar s 
)
MatExpr cv::operator| ( const Scalar s,
const Mat a 
)
MatExpr cv::operator~ ( const Mat m)
void cv::parallel_for_ ( const Range range,
const ParallelLoopBody body,
double  nstripes = -1. 
)
template<typename _Tp , class _EqPredicate >
int cv::partition ( const vector< _Tp > &  _vec,
vector< int > &  labels,
_EqPredicate  predicate = _EqPredicate() 
)
void cv::patchNaNs ( InputOutputArray  a,
double  val = 0 
)

converts NaN's to the given number

void cv::PCABackProject ( InputArray  data,
InputArray  mean,
InputArray  eigenvectors,
OutputArray  result 
)
void cv::PCACompute ( InputArray  data,
CV_OUT InputOutputArray  mean,
OutputArray  eigenvectors,
int  maxComponents = 0 
)
void cv::PCAComputeVar ( InputArray  data,
CV_OUT InputOutputArray  mean,
OutputArray  eigenvectors,
double  retainedVariance 
)
void cv::PCAProject ( InputArray  data,
InputArray  mean,
InputArray  eigenvectors,
OutputArray  result 
)
void cv::perspectiveTransform ( InputArray  src,
OutputArray  dst,
InputArray  m 
)

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

void cv::phase ( InputArray  x,
InputArray  y,
OutputArray  angle,
bool  angleInDegrees = false 
)

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

Point2d cv::phaseCorrelate ( InputArray  src1,
InputArray  src2,
InputArray  window = noArray() 
)
Point2d cv::phaseCorrelateRes ( InputArray  src1,
InputArray  src2,
InputArray  window,
CV_OUT double *  response = 0 
)
void cv::pointCloudShow ( const string &  winname,
const GlCamera camera,
const GlArrays arr 
)
void cv::pointCloudShow ( const string &  winname,
const GlCamera camera,
InputArray  points,
InputArray  colors = noArray() 
)
double cv::pointPolygonTest ( InputArray  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

void cv::polarToCart ( InputArray  magnitude,
InputArray  angle,
OutputArray  x,
OutputArray  y,
bool  angleInDegrees = false 
)

converts polar coordinates to Cartesian

void cv::polyfit ( const Mat srcx,
const Mat srcy,
Mat dst,
int  order 
)
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

void cv::polylines ( InputOutputArray  img,
InputArrayOfArrays  pts,
bool  isClosed,
const Scalar color,
int  thickness = 1,
int  lineType = 8,
int  shift = 0 
)
void cv::pow ( InputArray  src,
double  power,
OutputArray  dst 
)

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

void cv::preCornerDetect ( InputArray  src,
OutputArray  dst,
int  ksize,
int  borderType = BORDER_DEFAULT 
)

computes another complex cornerness criteria at each pixel

template<typename T1 , typename T2 , typename Op >
void cv::process ( const Mat_< T1 > &  m1,
Mat_< T2 > &  m2,
Op  op 
)
inline
template<typename T1 , typename T2 , typename T3 , typename Op >
void cv::process ( const Mat_< T1 > &  m1,
const Mat_< T2 > &  m2,
Mat_< T3 > &  m3,
Op  op 
)
inline
void cv::projectPoints ( InputArray  objectPoints,
InputArray  rvec,
InputArray  tvec,
InputArray  cameraMatrix,
InputArray  distCoeffs,
OutputArray  imagePoints,
OutputArray  jacobian = noArray(),
double  aspectRatio = 0 
)

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

double cv::PSNR ( InputArray  src1,
InputArray  src2 
)

computes PSNR image/video quality metric

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

renders text string in the image

void cv::pyrDown ( InputArray  src,
OutputArray  dst,
const Size dstsize = Size(),
int  borderType = BORDER_DEFAULT 
)

smooths and downsamples the image

void cv::pyrMeanShiftFiltering ( InputArray  src,
OutputArray  dst,
double  sp,
double  sr,
int  maxLevel = 1,
TermCriteria  termcrit = TermCriteria(                                                                                                                                                                       TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1) 
)

filters image using meanshift algorithm

void cv::pyrUp ( InputArray  src,
OutputArray  dst,
const Size dstsize = Size(),
int  borderType = BORDER_DEFAULT 
)

upsamples and smoothes the image

void cv::randn ( InputOutputArray  dst,
InputArray  mean,
InputArray  stddev 
)

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

void cv::randShuffle ( InputOutputArray  dst,
double  iterFactor = 1.,
RNG rng = 0 
)

shuffles the input array elements

void cv::randu ( InputOutputArray  dst,
InputArray  low,
InputArray  high 
)

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

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

reads vector of keypoints from the specified file storage node

void cv::read ( const FileNode node,
Mat mat,
const Mat default_mat = Mat() 
)
void cv::read ( const FileNode node,
SparseMat mat,
const SparseMat default_mat = SparseMat() 
)
void cv::rectangle ( CV_IN_OUT 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

void cv::rectangle ( CV_IN_OUT 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

float cv::rectify3Collinear ( InputArray  cameraMatrix1,
InputArray  distCoeffs1,
InputArray  cameraMatrix2,
InputArray  distCoeffs2,
InputArray  cameraMatrix3,
InputArray  distCoeffs3,
InputArrayOfArrays  imgpt1,
InputArrayOfArrays  imgpt3,
Size  imageSize,
InputArray  R12,
InputArray  T12,
InputArray  R13,
InputArray  T13,
OutputArray  R1,
OutputArray  R2,
OutputArray  R3,
OutputArray  P1,
OutputArray  P2,
OutputArray  P3,
OutputArray  Q,
double  alpha,
Size  newImgSize,
CV_OUT Rect roi1,
CV_OUT Rect roi2,
int  flags 
)

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

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

Sets the new error handler and the optional user data.

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

Parameters
errCallbackthe new error handler. If NULL, the default error handler is used.
userdatathe optional user data pointer, passed to the callback.
prevUserdatathe optional output parameter where the previous user data pointer is stored
Returns
the previous error handler
void cv::reduce ( InputArray  src,
OutputArray  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

void cv::remap ( InputArray  src,
OutputArray  dst,
InputArray  map1,
InputArray  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

void cv::render ( const GlTexture tex,
Rect_< double >  wndRect = Rect_< double >(0.0, 0.0, 1.0, 1.0),
Rect_< double >  texRect = Rect_< double >(0.0, 0.0, 1.0, 1.0) 
)

render functions

render texture rectangle in window

void cv::render ( const GlArrays arr,
int  mode = RenderMode::POINTS,
Scalar  color = Scalar::all(255) 
)

render OpenGL arrays

void cv::render ( const std::string &  str,
const Ptr< GlFont > &  font,
Scalar  color,
Point2d  pos 
)
void cv::repeat ( InputArray  src,
int  ny,
int  nx,
OutputArray  dst 
)

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

Mat cv::repeat ( const Mat src,
int  ny,
int  nx 
)
void cv::reprojectImageTo3D ( InputArray  disparity,
OutputArray  _3dImage,
InputArray  Q,
bool  handleMissingValues = false,
int  ddepth = -1 
)

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

void cv::resize ( InputArray  src,
OutputArray  dst,
Size  dsize,
double  fx = 0,
double  fy = 0,
int  interpolation = INTER_LINEAR 
)

resizes the image

void cv::resizeWindow ( const string &  winname,
int  width,
int  height 
)
bool cv::RGBDOdometry ( Mat Rt,
const Mat initRt,
const Mat image0,
const Mat depth0,
const Mat mask0,
const Mat image1,
const Mat depth1,
const Mat mask1,
const Mat cameraMatrix,
float  minDepth = 0.f,
float  maxDepth = 4.f,
float  maxDepthDiff = 0.07f,
const std::vector< int > &  iterCounts = std::vector< int >(),
const std::vector< float > &  minGradientMagnitudes = std::vector< float >(),
int  transformType = RIGID_BODY_MOTION 
)
void cv::Rodrigues ( InputArray  src,
OutputArray  dst,
OutputArray  jacobian = noArray() 
)

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

Vec3d cv::RQDecomp3x3 ( InputArray  src,
OutputArray  mtxR,
OutputArray  mtxQ,
OutputArray  Qx = noArray(),
OutputArray  Qy = noArray(),
OutputArray  Qz = noArray() 
)

Computes RQ decomposition of 3x3 matrix.

template<>
int cv::saturate_cast< int > ( float  v)
inline
template<>
int cv::saturate_cast< int > ( double  v)
inline
template<>
schar cv::saturate_cast< schar > ( uchar  v)
inline
template<>
schar cv::saturate_cast< schar > ( ushort  v)
inline
template<>
schar cv::saturate_cast< schar > ( int  v)
inline
template<>
schar cv::saturate_cast< schar > ( short  v)
inline
template<>
schar cv::saturate_cast< schar > ( unsigned  v)
inline
template<>
schar cv::saturate_cast< schar > ( float  v)
inline
template<>
schar cv::saturate_cast< schar > ( double  v)
inline
template<>
short cv::saturate_cast< short > ( ushort  v)
inline
template<>
short cv::saturate_cast< short > ( int  v)
inline
template<>
short cv::saturate_cast< short > ( unsigned  v)
inline
template<>
short cv::saturate_cast< short > ( float  v)
inline
template<>
short cv::saturate_cast< short > ( double  v)
inline
template<>
uchar cv::saturate_cast< uchar > ( schar  v)
inline
template<>
uchar cv::saturate_cast< uchar > ( ushort  v)
inline
template<>
uchar cv::saturate_cast< uchar > ( int  v)
inline
template<>
uchar cv::saturate_cast< uchar > ( short  v)
inline
template<>
uchar cv::saturate_cast< uchar > ( unsigned  v)
inline
template<>
uchar cv::saturate_cast< uchar > ( float  v)
inline
template<>
uchar cv::saturate_cast< uchar > ( double  v)
inline
template<>
unsigned cv::saturate_cast< unsigned > ( float  v)
inline
template<>
unsigned cv::saturate_cast< unsigned > ( double  v)
inline
template<>
ushort cv::saturate_cast< ushort > ( schar  v)
inline
template<>
ushort cv::saturate_cast< ushort > ( short  v)
inline
template<>
ushort cv::saturate_cast< ushort > ( int  v)
inline
template<>
ushort cv::saturate_cast< ushort > ( unsigned  v)
inline
template<>
ushort cv::saturate_cast< ushort > ( float  v)
inline
template<>
ushort cv::saturate_cast< ushort > ( double  v)
inline
void cv::saveWindowParameters ( const string &  windowName)
void cv::scalarToRawData ( const Scalar s,
void buf,
int  type,
int  unroll_to = 0 
)
void cv::scaleAdd ( InputArray  src1,
double  alpha,
InputArray  src2,
OutputArray  dst 
)

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

void cv::Scharr ( InputArray  src,
OutputArray  dst,
int  ddepth,
int  dx,
int  dy,
double  scale = 1,
double  delta = 0,
int  borderType = BORDER_DEFAULT 
)

applies the vertical or horizontal Scharr operator to the image

void cv::segmentMotion ( InputArray  mhi,
OutputArray  segmask,
CV_OUT vector< Rect > &  boundingRects,
double  timestamp,
double  segThresh 
)
void cv::sepFilter2D ( InputArray  src,
OutputArray  dst,
int  ddepth,
InputArray  kernelX,
InputArray  kernelY,
Point  anchor = Point(-1,-1),
double  delta = 0,
int  borderType = BORDER_DEFAULT 
)

applies separable 2D linear filter to the image

void cv::seqInsertSlice ( CvSeq seq,
int  before_index,
const CvArr from_arr 
)
void cv::seqPop ( CvSeq seq,
void element = 0 
)
void cv::seqPopFront ( CvSeq seq,
void element = 0 
)
void cv::seqPopMulti ( CvSeq seq,
void elements,
int  count,
int  in_front = 0 
)
schar* cv::seqPush ( CvSeq seq,
const void element = 0 
)
schar* cv::seqPushFront ( CvSeq seq,
const void element = 0 
)
void cv::seqRemove ( CvSeq seq,
int  index 
)
void cv::seqRemoveSlice ( CvSeq seq,
CvSlice  slice 
)
bool cv::setBreakOnError ( bool  flag)

Sets/resets the break-on-error mode.

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

Returns
the previous state
void cv::setIdentity ( InputOutputArray  mtx,
const Scalar s = Scalar(1) 
)

initializes scaled identity matrix

void cv::setMouseCallback ( const string &  winname,
MouseCallback  onMouse,
void userdata = 0 
)

assigns callback for mouse events

void cv::setNumThreads ( int  nthreads)
void cv::setOpenGlContext ( const string &  winname)
void cv::setOpenGlDrawCallback ( const string &  winname,
OpenGlDrawCallback  onOpenGlDraw,
void userdata = 0 
)
void cv::setRNGSeed ( int  seed)

sets state of the thread-local Random number generator

void cv::setTrackbarPos ( const string &  trackbarname,
const string &  winname,
int  pos 
)
void cv::setUseOptimized ( bool  onoff)

Turns on/off available optimization

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

Note
{Since optimization may imply using special data structures, it may be unsafe to call this function anywhere in the code. Instead, call it somewhere at the top level.}
void cv::setWindowProperty ( const string &  winname,
int  prop_id,
double  prop_value 
)
void cv::Sobel ( InputArray  src,
OutputArray  dst,
int  ddepth,
int  dx,
int  dy,
int  ksize = 3,
double  scale = 1,
double  delta = 0,
int  borderType = BORDER_DEFAULT 
)

applies generalized Sobel operator to the image

bool cv::solve ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
int  flags = DECOMP_LU 
)

solves linear system or a least-square problem

int cv::solveCubic ( InputArray  coeffs,
OutputArray  roots 
)

finds real roots of a cubic polynomial

bool cv::solvePnP ( InputArray  objectPoints,
InputArray  imagePoints,
InputArray  cameraMatrix,
InputArray  distCoeffs,
OutputArray  rvec,
OutputArray  tvec,
bool  useExtrinsicGuess = false,
int  flags = ITERATIVE 
)
void cv::solvePnPRansac ( InputArray  objectPoints,
InputArray  imagePoints,
InputArray  cameraMatrix,
InputArray  distCoeffs,
OutputArray  rvec,
OutputArray  tvec,
bool  useExtrinsicGuess = false,
int  iterationsCount = 100,
float  reprojectionError = 8.0,
int  minInliersCount = 100,
OutputArray  inliers = noArray(),
int  flags = ITERATIVE 
)

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

double cv::solvePoly ( InputArray  coeffs,
OutputArray  roots,
int  maxIters = 300 
)

finds real and complex roots of a polynomial

void cv::sort ( InputArray  src,
OutputArray  dst,
int  flags 
)

sorts independently each matrix row or each matrix column

template<typename _Tp , class _LT >
void cv::sort ( vector< _Tp > &  vec,
_LT  LT = _LT() 
)
void cv::sortIdx ( InputArray  src,
OutputArray  dst,
int  flags 
)

sorts independently each matrix row or each matrix column

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

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

void cv::split ( const Mat m,
vector< Mat > &  mv 
)
void cv::split ( InputArray  m,
OutputArrayOfArrays  mv 
)

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

void cv::sqrt ( InputArray  src,
OutputArray  dst 
)

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

int cv::startLoop ( int(*)(int argc, char *argv[])  pt2Func,
int  argc,
char *  argv[] 
)
int cv::startWindowThread ( )
double cv::stereoCalibrate ( InputArrayOfArrays  objectPoints,
InputArrayOfArrays  imagePoints1,
InputArrayOfArrays  imagePoints2,
CV_OUT InputOutputArray  cameraMatrix1,
CV_OUT InputOutputArray  distCoeffs1,
CV_OUT InputOutputArray  cameraMatrix2,
CV_OUT InputOutputArray  distCoeffs2,
Size  imageSize,
OutputArray  R,
OutputArray  T,
OutputArray  E,
OutputArray  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

void cv::stereoRectify ( InputArray  cameraMatrix1,
InputArray  distCoeffs1,
InputArray  cameraMatrix2,
InputArray  distCoeffs2,
Size  imageSize,
InputArray  R,
InputArray  T,
OutputArray  R1,
OutputArray  R2,
OutputArray  P1,
OutputArray  P2,
OutputArray  Q,
int  flags = CALIB_ZERO_DISPARITY,
double  alpha = -1,
Size  newImageSize = Size(),
CV_OUT Rect validPixROI1 = 0,
CV_OUT Rect validPixROI2 = 0 
)

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

bool cv::stereoRectifyUncalibrated ( InputArray  points1,
InputArray  points2,
InputArray  F,
Size  imgSize,
OutputArray  H1,
OutputArray  H2,
double  threshold = 5 
)

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

void cv::stopLoop ( )
Mat cv::subspaceProject ( InputArray  W,
InputArray  mean,
InputArray  src 
)
Mat cv::subspaceReconstruct ( InputArray  W,
InputArray  mean,
InputArray  src 
)
void cv::subtract ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
InputArray  mask = noArray(),
int  dtype = -1 
)

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

void cv::SVBackSubst ( InputArray  w,
InputArray  u,
InputArray  vt,
InputArray  rhs,
CV_OUT OutputArray  dst 
)

performs back substitution for the previously computed SVD

void cv::SVDecomp ( InputArray  src,
CV_OUT OutputArray  w,
CV_OUT OutputArray  u,
CV_OUT OutputArray  vt,
int  flags = 0 
)

computes SVD of src

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

swaps two matrices

string cv::tempfile ( const char *suffix   CV_DEFAULT0)
RNG& cv::theRNG ( )

returns the thread-local Random number generator

double cv::threshold ( InputArray  src,
OutputArray  dst,
double  thresh,
double  maxval,
int  type 
)

applies fixed threshold to the image

WString cv::toUtf16 ( const string &  str)
Scalar cv::trace ( InputArray  mtx)

computes trace of a matrix

void cv::transform ( InputArray  src,
OutputArray  dst,
InputArray  m 
)

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

void cv::transpose ( InputArray  src,
OutputArray  dst 
)

transposes the matrix

void cv::triangulatePoints ( InputArray  projMatr1,
InputArray  projMatr2,
InputArray  projPoints1,
InputArray  projPoints2,
OutputArray  points4D 
)
void cv::undistort ( InputArray  src,
OutputArray  dst,
InputArray  cameraMatrix,
InputArray  distCoeffs,
InputArray  newCameraMatrix = noArray() 
)

corrects lens distortion for the given camera matrix and distortion coefficients

void cv::undistortPoints ( InputArray  src,
OutputArray  dst,
InputArray  cameraMatrix,
InputArray  distCoeffs,
InputArray  R = noArray(),
InputArray  P = noArray() 
)

returns points' coordinates after lens distortion correction

void cv::updateMotionHistory ( InputArray  silhouette,
InputOutputArray  mhi,
double  timestamp,
double  duration 
)

updates motion history image using the current silhouette

void cv::updateWindow ( const string &  winname)
bool cv::useOptimized ( )

Returns the current optimization status

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

void cv::validateDisparity ( InputOutputArray  disparity,
InputArray  cost,
int  minDisparity,
int  numberOfDisparities,
int  disp12MaxDisp = 1 
)

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

void cv::vconcat ( const Mat src,
size_t  nsrc,
OutputArray  dst 
)
void cv::vconcat ( InputArray  src1,
InputArray  src2,
OutputArray  dst 
)
void cv::vconcat ( InputArrayOfArrays  src,
OutputArray  dst 
)
int cv::waitKey ( int  delay = 0)
void cv::warpAffine ( InputArray  src,
OutputArray  dst,
InputArray  M,
Size  dsize,
int  flags = INTER_LINEAR,
int  borderMode = BORDER_CONSTANT,
const Scalar borderValue = Scalar() 
)

warps the image using affine transformation

void cv::warpPerspective ( InputArray  src,
OutputArray  dst,
InputArray  M,
Size  dsize,
int  flags = INTER_LINEAR,
int  borderMode = BORDER_CONSTANT,
const Scalar borderValue = Scalar() 
)

warps the image using perspective transformation

void cv::watershed ( InputArray  image,
InputOutputArray  markers 
)

segments the image using watershed algorithm

Mat cv::windowedMatchingMask ( const vector< KeyPoint > &  keypoints1,
const vector< KeyPoint > &  keypoints2,
float  maxDeltaX,
float  maxDeltaY 
)
void cv::write ( FileStorage fs,
const string &  name,
const vector< KeyPoint > &  keypoints 
)

writes vector of keypoints to the file storage

void cv::write ( FileStorage fs,
const string &  name,
int  value 
)
void cv::write ( FileStorage fs,
const string &  name,
float  value 
)
void cv::write ( FileStorage fs,
const string &  name,
double  value 
)
void cv::write ( FileStorage fs,
const string &  name,
const string &  value 
)
template<typename _Tp >
void cv::write ( FileStorage fs,
const _Tp &  value 
)
inline
template<>
void cv::write ( FileStorage fs,
const int value 
)
inline
template<>
void cv::write ( FileStorage fs,
const float &  value 
)
inline
template<>
void cv::write ( FileStorage fs,
const double &  value 
)
inline
template<>
void cv::write ( FileStorage fs,
const string &  value 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const Point_< _Tp > &  pt 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const Point3_< _Tp > &  pt 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const Size_< _Tp > &  sz 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const Complex< _Tp > &  c 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const Rect_< _Tp > &  r 
)
inline
template<typename _Tp , int cn>
void cv::write ( FileStorage fs,
const Vec< _Tp, cn > &  v 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const Scalar_< _Tp > &  s 
)
inline
void cv::write ( FileStorage fs,
const Range r 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const string &  name,
const Point_< _Tp > &  pt 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const string &  name,
const Point3_< _Tp > &  pt 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const string &  name,
const Size_< _Tp > &  sz 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const string &  name,
const Complex< _Tp > &  c 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const string &  name,
const Rect_< _Tp > &  r 
)
inline
template<typename _Tp , int cn>
void cv::write ( FileStorage fs,
const string &  name,
const Vec< _Tp, cn > &  v 
)
inline
template<typename _Tp >
void cv::write ( FileStorage fs,
const string &  name,
const Scalar_< _Tp > &  s 
)
inline
void cv::write ( FileStorage fs,
const string &  name,
const Range r 
)
inline
void cv::write ( FileStorage fs,
const string &  name,
const Mat value 
)
void cv::write ( FileStorage fs,
const string &  name,
const SparseMat value 
)
void cv::writeScalar ( FileStorage fs,
int  value 
)
void cv::writeScalar ( FileStorage fs,
float  value 
)
void cv::writeScalar ( FileStorage fs,
double  value 
)
void cv::writeScalar ( FileStorage fs,
const string &  value 
)

Variable Documentation

OutputArray OutputArray int cv::distanceType
OutputArray cv::dst
double cv::iterFactor =1.)
OutputArray cv::sum