cv Namespace Reference

Namespace where all the C++ OpenCV functionality resides. More...

Namespaces

namespace  flann
namespace  gpu

Classes

class  StereoBM
 Block Matching Stereo Correspondence Algorithm. More...
class  StereoSGBM
 Semi-Global Block Matching Stereo Correspondence Algorithm. More...
class  Octree
class  Mesh3D
class  SpinImageModel
class  TickMeter
class  SelfSimDescriptor
class  LevMarqSparse
class  StereoVar
class  Exception
 The standard OpenCV exception class. More...
class  Allocator
 The STL-compilant memory Allocator based on cv::fastMalloc() and cv::fastFree(). More...
class  DataDepth
 A helper class for cv::DataType. More...
class  DataDepth< bool >
class  DataDepth< uchar >
class  DataDepth< schar >
class  DataDepth< char >
class  DataDepth< ushort >
class  DataDepth< short >
class  DataDepth< int >
class  DataDepth< unsigned >
class  DataDepth< float >
class  DataDepth< double >
class  DataDepth< _Tp * >
struct  Matx_AddOp
 A short numerical vector. More...
struct  Matx_SubOp
struct  Matx_ScaleOp
struct  Matx_MulOp
struct  Matx_MatMulOp
struct  Matx_TOp
class  Matx
class  Vec
 A short numerical vector. More...
class  Complex
 A complex number class. More...
class  Point_
 template 2D point class. More...
class  Point3_
 template 3D point class. More...
class  Size_
 The 2D size class. More...
class  Rect_
 The 2D up-right rectangle class. More...
class  RotatedRect
 The rotated 2D rectangle. More...
class  Scalar_
 The template scalar class. More...
class  Range
 The 2D range class. More...
class  DataType
 Informative template class for OpenCV "scalars". More...
class  DataType< bool >
class  DataType< uchar >
class  DataType< schar >
class  DataType< char >
class  DataType< ushort >
class  DataType< short >
class  DataType< int >
class  DataType< float >
class  DataType< double >
class  DataType< Vec< _Tp, cn > >
class  DataType< std::complex< _Tp > >
class  DataType< Complex< _Tp > >
class  DataType< Point_< _Tp > >
class  DataType< Point3_< _Tp > >
class  DataType< Size_< _Tp > >
class  DataType< Rect_< _Tp > >
class  DataType< Scalar_< _Tp > >
class  DataType< Range >
class  Ptr
 Smart pointer to dynamically allocated objects. More...
class  _InputArray
 Proxy datatype for passing Mat's and vector<>'s as input parameters. More...
class  _OutputArray
 Proxy datatype for passing Mat's and vector<>'s as input parameters. More...
class  MatAllocator
 Custom array allocator. More...
class  Mat
 The n-dimensional matrix class. More...
class  RNG
 Random Number Generator. More...
class  TermCriteria
 Termination criteria in iterative algorithms. More...
class  PCA
 Principal Component Analysis. More...
class  SVD
 Singular Value Decomposition class. More...
class  LineIterator
 Line iterator class. More...
class  Mat_
 Template matrix class derived from Mat. More...
class  MatConstIterator
class  MatConstIterator_
 Matrix read-only iterator. More...
class  MatIterator_
 Matrix read-write iterator. More...
class  MatCommaInitializer_
 Comma-separated Matrix Initializer. More...
class  MatxCommaInitializer
class  VecCommaInitializer
class  AutoBuffer
 Automatically Allocated Buffer Class. More...
class  NAryMatIterator
 n-Dimensional Dense Matrix Iterator Class. More...
class  SparseMat
 Sparse matrix class. More...
class  SparseMatConstIterator
 Read-Only Sparse Matrix Iterator. More...
class  SparseMatIterator
 Read-write Sparse Matrix Iterator. More...
class  SparseMat_
 The Template Sparse Matrix class derived from cv::SparseMat. More...
class  SparseMatConstIterator_
 Template Read-Only Sparse Matrix Iterator Class. More...
class  SparseMatIterator_
 Template Read-Write Sparse Matrix Iterator Class. More...
class  KDTree
 Fast Nearest Neighbor Search Class. More...
class  FileStorage
 XML/YAML File Storage Class. More...
class  FileNode
 File Storage Node class. More...
class  FileNodeIterator
 File Node Iterator. More...
class  Seq
 Template Sequence Class derived from CvSeq. More...
class  SeqIterator
 STL-style Sequence Iterator inherited from the CvSeqReader structure. More...
class  Algorithm
 Base class for high-level OpenCV algorithms. More...
class  CommandLineParser
 Command Line Parser. More...
class  BlockedRange
class  Split
class  MatOp
class  MatExpr
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 >
class  Vector
class  WriteStructContext
class  VecWriterProxy
class  VecWriterProxy< _Tp, 1 >
class  VecReaderProxy
class  VecReaderProxy< _Tp, 1 >
class  LessThan
class  GreaterEq
class  LessThanIdx
class  GreaterEqIdx
struct  RTTIImpl
class  Formatter
struct  Formatted
class  WImage
class  WImageC
class  WImageBuffer
class  WImageBufferC
class  WImageView
class  WImageViewC
struct  DefaultRngAuto
class  CvAffinePose
class  KeyPoint
 The Keypoint Class. More...
class  KeyPointsFilter
class  SIFT
 SIFT implementation. More...
class  SURF
 SURF implementation. More...
class  ORB
 ORB implementation. More...
class  MSER
 Maximal Stable Extremal Regions class. More...
class  StarDetector
 The "Star" Detector. More...
class  PatchGenerator
 The Patch Generator class. More...
class  LDetector
class  FernClassifier
struct  BaseKeypoint
class  RandomizedTree
struct  RTreeNode
class  RTreeClassifier
class  OneWayDescriptor
class  OneWayDescriptorBase
class  OneWayDescriptorObject
class  FeatureDetector
class  FastFeatureDetector
class  GoodFeaturesToTrackDetector
class  MserFeatureDetector
class  StarFeatureDetector
class  SiftFeatureDetector
class  SurfFeatureDetector
class  OrbFeatureDetector
class  SimpleBlobDetector
class  DenseFeatureDetector
class  GridAdaptedFeatureDetector
class  PyramidAdaptedFeatureDetector
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  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  FastAdjuster
 an adjust for the FAST detector. This will basically decrement or increment the threshold by 1 More...
class  StarAdjuster
class  SurfAdjuster
class  DescriptorExtractor
class  SiftDescriptorExtractor
class  SurfDescriptorExtractor
class  OrbDescriptorExtractor
class  CalonderDescriptorExtractor
class  OpponentColorDescriptorExtractor
class  BriefDescriptorExtractor
struct  Accumulator
struct  Accumulator< unsigned char >
struct  Accumulator< unsigned short >
struct  Accumulator< char >
struct  Accumulator< short >
struct  L2
struct  L1
struct  HammingLUT
struct  Hamming
struct  DMatch
class  DescriptorMatcher
class  BruteForceMatcher
class  FlannBasedMatcher
class  GenericDescriptorMatcher
class  OneWayDescriptorMatcher
class  FernDescriptorMatcher
class  VectorDescriptorMatcher
struct  DrawMatchesFlags
class  BOWTrainer
class  BOWKMeansTrainer
class  BOWImgDescriptorExtractor
class  VideoCapture
class  VideoWriter
class  BaseRowFilter
 The Base Class for 1D or Row-wise Filters. More...
class  BaseColumnFilter
 The Base Class for Column-wise Filters. More...
class  BaseFilter
 The Base Class for Non-Separable 2D Filters. More...
class  FilterEngine
 The Main Class for Image Filtering. More...
class  Moments
 raster image moments More...
class  FeatureEvaluator
class  CascadeClassifier
struct  HOGDescriptor
class  PlanarObjectDetector
struct  DataMatrixCode
class  BackgroundSubtractor
 The Base Class for Background/Foreground Segmentation. More...
class  BackgroundSubtractorMOG
 Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm. More...
class  BackgroundSubtractorMOG2
class  KalmanFilter
 Kalman filter. More...

Typedefs

typedef bool(* BundleAdjustCallback )(int iteration, double norm_error, void *user_data)
typedef std::string String
typedef std::basic_string
< wchar_t > 
WString
typedef Mat MatND
typedef int(CV_CDECL * ErrorCallback )(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_< int > Point2i
typedef Point2i Point
typedef Size_< int > Size2i
typedef Size2i Size
typedef Rect_< int > Rect
typedef Point_< float > Point2f
typedef Point_< double > Point2d
typedef Size_< float > Size2f
typedef Point3_< int > Point3i
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 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_< int > Mat1i
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 tbb::blocked_range< int > BlockedRange
typedef tbb::split Split
typedef tbb::concurrent_vector
< Rect
ConcurrentRectVector
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 LDetector YAPE
typedef GenericDescriptorMatcher GenericDescriptorMatch
typedef OneWayDescriptorMatcher OneWayDescriptorMatch
typedef FernDescriptorMatcher FernDescriptorMatch
typedef VectorDescriptorMatcher VectorDescriptorMatch
typedef void(CV_CDECL * OpenGLCallback )(void *userdata)
typedef void(CV_CDECL * ButtonCallback )(int state, void *userdata)
typedef void(CV_CDECL * TrackbarCallback )(int pos, void *userdata)
typedef void(* MouseCallback )(int event, int x, int y, int flags, void *param)
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 CvEMParams EMParams
typedef CvEM ExpectationMaximization
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

Enumerations

enum  { LMEDS = CV_LMEDS, RANSAC = CV_RANSAC }
 

type of the robust estimation algorithm

More...
enum  { CALIB_CB_ADAPTIVE_THRESH = 1, CALIB_CB_NORMALIZE_IMAGE = 2, CALIB_CB_FILTER_QUADS = 4, CALIB_CB_FAST_CHECK = 8 }
enum  { CALIB_CB_SYMMETRIC_GRID = 1, CALIB_CB_ASYMMETRIC_GRID = 2, CALIB_CB_CLUSTERING = 4 }
enum  {
  CALIB_USE_INTRINSIC_GUESS = CV_CALIB_USE_INTRINSIC_GUESS, CALIB_FIX_ASPECT_RATIO = CV_CALIB_FIX_ASPECT_RATIO, CALIB_FIX_PRINCIPAL_POINT = CV_CALIB_FIX_PRINCIPAL_POINT, CALIB_ZERO_TANGENT_DIST = CV_CALIB_ZERO_TANGENT_DIST,
  CALIB_FIX_FOCAL_LENGTH = CV_CALIB_FIX_FOCAL_LENGTH, CALIB_FIX_K1 = CV_CALIB_FIX_K1, CALIB_FIX_K2 = CV_CALIB_FIX_K2, CALIB_FIX_K3 = CV_CALIB_FIX_K3,
  CALIB_FIX_K4 = CV_CALIB_FIX_K4, CALIB_FIX_K5 = CV_CALIB_FIX_K5, CALIB_FIX_K6 = CV_CALIB_FIX_K6, CALIB_RATIONAL_MODEL = CV_CALIB_RATIONAL_MODEL,
  CALIB_FIX_INTRINSIC = CV_CALIB_FIX_INTRINSIC, CALIB_SAME_FOCAL_LENGTH = CV_CALIB_SAME_FOCAL_LENGTH, CALIB_ZERO_DISPARITY = CV_CALIB_ZERO_DISPARITY
}
enum  { FM_7POINT = CV_FM_7POINT, FM_8POINT = CV_FM_8POINT, FM_LMEDS = CV_FM_LMEDS, FM_RANSAC = CV_FM_RANSAC }
 

the algorithm for finding fundamental matrix

More...
enum  {
  DECOMP_LU = 0, DECOMP_SVD = 1, DECOMP_EIG = 2, DECOMP_CHOLESKY = 3,
  DECOMP_QR = 4, DECOMP_NORMAL = 16
}
enum  {
  NORM_INF = 1, NORM_L1 = 2, NORM_L2 = 4, NORM_TYPE_MASK = 7,
  NORM_RELATIVE = 8, NORM_MINMAX = 32
}
enum  {
  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  { KMEANS_RANDOM_CENTERS = 0, KMEANS_PP_CENTERS = 2, KMEANS_USE_INITIAL_LABELS = 1 }
 

Various k-Means flags.

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  { WINDOW_AUTOSIZE = 1 }
enum  {
  BORDER_REPLICATE = IPL_BORDER_REPLICATE, BORDER_CONSTANT = IPL_BORDER_CONSTANT, BORDER_REFLECT = IPL_BORDER_REFLECT, BORDER_WRAP = IPL_BORDER_WRAP,
  BORDER_REFLECT_101 = IPL_BORDER_REFLECT_101, BORDER_REFLECT101 = BORDER_REFLECT_101, BORDER_TRANSPARENT = IPL_BORDER_TRANSPARENT, BORDER_DEFAULT = BORDER_REFLECT_101,
  BORDER_ISOLATED = 16
}
 

various border interpolation methods

More...
enum  {
  KERNEL_GENERAL = 0, KERNEL_SYMMETRICAL = 1, KERNEL_ASYMMETRICAL = 2, KERNEL_SMOOTH = 4,
  KERNEL_INTEGER = 8
}
 

type of the kernel

More...
enum  {
  MORPH_ERODE = CV_MOP_ERODE, MORPH_DILATE = CV_MOP_DILATE, MORPH_OPEN = CV_MOP_OPEN, MORPH_CLOSE = CV_MOP_CLOSE,
  MORPH_GRADIENT = CV_MOP_GRADIENT, MORPH_TOPHAT = CV_MOP_TOPHAT, MORPH_BLACKHAT = CV_MOP_BLACKHAT
}
 

type of morphological operation

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

shape of the structuring element

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

interpolation algorithm

More...
enum  { INTER_BITS = 5, INTER_BITS2 = INTER_BITS*2, INTER_TAB_SIZE = (1<<INTER_BITS), INTER_TAB_SIZE2 = INTER_TAB_SIZE*INTER_TAB_SIZE }
enum  {
  THRESH_BINARY = CV_THRESH_BINARY, THRESH_BINARY_INV = CV_THRESH_BINARY_INV, THRESH_TRUNC = CV_THRESH_TRUNC, THRESH_TOZERO = CV_THRESH_TOZERO,
  THRESH_TOZERO_INV = CV_THRESH_TOZERO_INV, THRESH_MASK = CV_THRESH_MASK, THRESH_OTSU = CV_THRESH_OTSU
}
 

type of the threshold operation

More...
enum  { ADAPTIVE_THRESH_MEAN_C = 0, ADAPTIVE_THRESH_GAUSSIAN_C = 1 }
 

adaptive threshold algorithm

More...
enum  { PROJ_SPHERICAL_ORTHO = 0, PROJ_SPHERICAL_EQRECT = 1 }
enum  { GC_BGD = 0, GC_FGD = 1, GC_PR_BGD = 2, GC_PR_FGD = 3 }
 

class of the pixel in GrabCut algorithm

More...
enum  { GC_INIT_WITH_RECT = 0, GC_INIT_WITH_MASK = 1, GC_EVAL = 2 }
 

GrabCut algorithm flags.

More...
enum  { INPAINT_NS = CV_INPAINT_NS, INPAINT_TELEA = CV_INPAINT_TELEA }
 

the inpainting algorithm

More...
enum  { FLOODFILL_FIXED_RANGE = 1 << 16, FLOODFILL_MASK_ONLY = 1 << 17 }
enum  {
  TM_SQDIFF = 0, TM_SQDIFF_NORMED = 1, TM_CCORR = 2, TM_CCORR_NORMED = 3,
  TM_CCOEFF = 4, TM_CCOEFF_NORMED = 5
}
 

type of the template matching operation

More...
enum  { RETR_EXTERNAL = CV_RETR_EXTERNAL, RETR_LIST = CV_RETR_LIST, RETR_CCOMP = CV_RETR_CCOMP, RETR_TREE = CV_RETR_TREE }
 

mode of the contour retrieval algorithm

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

the contour approximation algorithm

More...
enum  { OPTFLOW_USE_INITIAL_FLOW = 4, OPTFLOW_FARNEBACK_GAUSSIAN = 256 }

Functions

CV_EXPORTS_W void Rodrigues (InputArray src, OutputArray dst, OutputArray jacobian=noArray())
 converts rotation vector to rotation matrix or vice versa using Rodrigues transformation
CV_EXPORTS_W 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.
CV_EXPORTS Mat findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, int method=0, double ransacReprojThreshold=3)
 variant of findHomography for backward compatibility
CV_EXPORTS_W Vec3d RQDecomp3x3 (InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray())
 Computes RQ decomposition of 3x3 matrix.
CV_EXPORTS_W 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.
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W void solvePnP (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false)
 computes the camera pose from a few 3D points and the corresponding projections. The outliers are not handled.
CV_EXPORTS_W 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())
 computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.
CV_EXPORTS_W Mat initCameraMatrix2D (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.)
 initializes camera matrix from a few 3D points and the corresponding projections.
CV_EXPORTS_W 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
CV_EXPORTS bool find4QuadCornerSubpix (InputArray img, InputOutputArray corners, Size region_size)
 finds subpixel-accurate positions of the chessboard corners
CV_EXPORTS_W void drawChessboardCorners (InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound)
 draws the checkerboard pattern (found or partly found) in the image
CV_EXPORTS 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
CV_EXPORTS_W double calibrateCamera (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, CV_IN_OUT InputOutputArray cameraMatrix, CV_IN_OUT InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0)
 finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
CV_EXPORTS_W 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.
CV_EXPORTS_W double stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, CV_IN_OUT InputOutputArray cameraMatrix1, CV_IN_OUT InputOutputArray distCoeffs1, CV_IN_OUT InputOutputArray cameraMatrix2, CV_IN_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
CV_EXPORTS 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
CV_EXPORTS_W 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)
CV_EXPORTS_W 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.
CV_EXPORTS_W Mat getOptimalNewCameraMatrix (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize=Size(), CV_OUT Rect *validPixROI=0)
 returns the optimal new camera matrix
CV_EXPORTS_W void convertPointsToHomogeneous (InputArray src, OutputArray dst)
 converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
CV_EXPORTS_W void convertPointsFromHomogeneous (InputArray src, OutputArray dst)
 converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
CV_EXPORTS void convertPointsHomogeneous (InputArray src, OutputArray dst)
 for backward compatibility
CV_EXPORTS_W 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
CV_EXPORTS 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
CV_EXPORTS void computeCorrespondEpilines (InputArray points1, int whichImage, InputArray F, OutputArray lines)
 finds coordinates of epipolar lines corresponding the specified points
CV_EXPORTS_W void filterSpeckles (InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray())
 filters off speckles (small regions of incorrectly computed disparity)
CV_EXPORTS_W Rect getValidDisparityROI (Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)
 computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W int estimateAffine3D (InputArray _from, InputArray _to, OutputArray _out, OutputArray _inliers, double param1=3, double param2=0.99)
CV_EXPORTS std::ostream & operator<< (std::ostream &out, const TickMeter &tm)
CV_EXPORTS int chamerMatching (Mat &img, Mat &templ, vector< vector< Point > > &results, vector< float > &cost, double templScale=1, int maxMatches=20, double minMatchDistance=1.0, int padX=3, int padY=3, int scales=5, double minScale=0.6, double maxScale=1.6, double orientationWeight=0.5, double truncate=20)
CV_EXPORTS void polyfit (const Mat &srcx, const Mat &srcy, Mat &dst, int order)
CV_EXPORTS string fromUtf16 (const WString &str)
CV_EXPORTS WString toUtf16 (const string &str)
CV_EXPORTS string format (const char *fmt,...)
CV_EXPORTS string tempfile (const char *suffix CV_DEFAULT(0))
CV_EXPORTS void error (const Exception &exc)
 Signals an error and raises the exception.
CV_EXPORTS bool setBreakOnError (bool flag)
 Sets/resets the break-on-error mode.
CV_EXPORTS ErrorCallback redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0)
 Sets the new error handler and the optional user data.
CV_EXPORTS void setNumThreads (int nthreads)
CV_EXPORTS int getNumThreads ()
CV_EXPORTS int getThreadNum ()
CV_EXPORTS int64 getTickCount ()
 Returns the number of ticks.
CV_EXPORTS_W double getTickFrequency ()
 Returns the number of ticks per seconds.
CV_EXPORTS int64 getCPUTickCount ()
 Returns the number of CPU ticks.
CV_EXPORTS_W bool checkHardwareSupport (int feature)
 Returns SSE etc.
CV_EXPORTS void * fastMalloc (size_t bufSize)
 Allocates memory buffer.
CV_EXPORTS void fastFree (void *ptr)
 Frees the memory allocated with cv::fastMalloc.
CV_EXPORTS_W void setUseOptimized (bool onoff)
 Turns on/off available optimization.
CV_EXPORTS_W bool useOptimized ()
 Returns the current optimization status.
CV_EXPORTS void scalarToRawData (const Scalar &s, void *buf, int type, int unroll_to=0)
CV_EXPORTS OutputArray noArray ()
CV_EXPORTS void swap (Mat &a, Mat &b)
 swaps two matrices
CV_EXPORTS Mat cvarrToMat (const CvArr *arr, bool copyData=false, bool allowND=true, int coiMode=0)
 converts array (CvMat or IplImage) to cv::Mat
CV_EXPORTS 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.
CV_EXPORTS void insertImageCOI (InputArray coiimg, CvArr *arr, int coi=-1)
 inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
CV_EXPORTS_W void add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
 adds one matrix to another (dst = src1 + src2)
CV_EXPORTS_W void subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
 subtracts one matrix from another (dst = src1 - src2)
CV_EXPORTS_W 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)
CV_EXPORTS_W 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)
CV_EXPORTS_W void divide (double scale, InputArray src2, OutputArray dst, int dtype=-1)
 computes element-wise weighted reciprocal of an array (dst = scale/src2)
CV_EXPORTS_W void scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst)
 adds scaled array to another one (dst = alpha*src1 + src2)
CV_EXPORTS_W 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)
CV_EXPORTS_W 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)
CV_EXPORTS_W void LUT (InputArray src, InputArray lut, OutputArray dst, int interpolation=0)
 transforms array of numbers using a lookup table: dst(i)=lut(src(i))
 CV_EXPORTS_AS (sumElems) Scalar sum(InputArray src)
 computes sum of array elements
CV_EXPORTS_W int countNonZero (InputArray src)
 computes the number of nonzero array elements
CV_EXPORTS_W Scalar mean (InputArray src, InputArray mask=noArray())
 computes mean value of selected array elements
CV_EXPORTS_W void meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
 computes mean value and standard deviation of all or selected array elements
CV_EXPORTS_W double norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
 computes norm of the selected array part
CV_EXPORTS_W double norm (InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray())
 computes norm of selected part of the difference between two arrays
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS void minMaxIdx (InputArray src, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray())
CV_EXPORTS_W 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
CV_EXPORTS void merge (const Mat *mv, size_t count, OutputArray dst)
 makes multi-channel array out of several single-channel arrays
CV_EXPORTS_W void merge (const vector< Mat > &mv, OutputArray dst)
 makes multi-channel array out of several single-channel arrays
CV_EXPORTS void split (const Mat &src, Mat *mvbegin)
 copies each plane of a multi-channel array to a dedicated array
CV_EXPORTS_W void split (const Mat &m, vector< Mat > &mv)
 copies each plane of a multi-channel array to a dedicated array
CV_EXPORTS void mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs)
 copies selected channels from the input arrays to the selected channels of the output arrays
CV_EXPORTS void mixChannels (const vector< Mat > &src, vector< Mat > &dst, const int *fromTo, size_t npairs)
CV_EXPORTS_W void extractChannel (InputArray src, OutputArray dst, int coi)
 extracts a single channel from src (coi is 0-based index)
CV_EXPORTS_W void insertChannel (InputArray src, InputOutputArray dst, int coi)
 inserts a single channel to dst (coi is 0-based index)
CV_EXPORTS_W void flip (InputArray src, OutputArray dst, int flipCode)
 reverses the order of the rows, columns or both in a matrix
CV_EXPORTS_W 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
CV_EXPORTS Mat repeat (const Mat &src, int ny, int nx)
CV_EXPORTS void hconcat (const Mat *src, size_t nsrc, OutputArray dst)
CV_EXPORTS void hconcat (InputArray src1, InputArray src2, OutputArray dst)
CV_EXPORTS_W void hconcat (InputArray src, OutputArray dst)
CV_EXPORTS void vconcat (const Mat *src, size_t nsrc, OutputArray dst)
CV_EXPORTS void vconcat (InputArray src1, InputArray src2, OutputArray dst)
CV_EXPORTS_W void vconcat (InputArray src, OutputArray dst)
CV_EXPORTS_W void bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 computes bitwise conjunction of the two arrays (dst = src1 & src2)
CV_EXPORTS_W void bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 computes bitwise disjunction of the two arrays (dst = src1 | src2)
CV_EXPORTS_W void bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
CV_EXPORTS_W void bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray())
 inverts each bit of array (dst = ~src)
CV_EXPORTS_W void absdiff (InputArray src1, InputArray src2, OutputArray dst)
 computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
CV_EXPORTS_W 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)
CV_EXPORTS_W void compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop)
 compares elements of two arrays (dst = src1 <cmpop> src2)
CV_EXPORTS_W void min (InputArray src1, InputArray src2, OutputArray dst)
 computes per-element minimum of two arrays (dst = min(src1, src2))
CV_EXPORTS_W void max (InputArray src1, InputArray src2, OutputArray dst)
 computes per-element maximum of two arrays (dst = max(src1, src2))
CV_EXPORTS void min (const Mat &src1, const Mat &src2, Mat &dst)
 computes per-element minimum of two arrays (dst = min(src1, src2))
CV_EXPORTS void min (const Mat &src1, double src2, Mat &dst)
 computes per-element minimum of array and scalar (dst = min(src1, src2))
CV_EXPORTS void max (const Mat &src1, const Mat &src2, Mat &dst)
 computes per-element maximum of two arrays (dst = max(src1, src2))
CV_EXPORTS void max (const Mat &src1, double src2, Mat &dst)
 computes per-element maximum of array and scalar (dst = max(src1, src2))
CV_EXPORTS_W void sqrt (InputArray src, OutputArray dst)
 computes square root of each matrix element (dst = src**0.5)
CV_EXPORTS_W void pow (InputArray src, double power, OutputArray dst)
 raises the input matrix elements to the specified power (b = a**power)
CV_EXPORTS_W void exp (InputArray src, OutputArray dst)
 computes exponent of each matrix element (dst = e**src)
CV_EXPORTS_W void log (InputArray src, OutputArray dst)
 computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
CV_EXPORTS_W float cubeRoot (float val)
 computes cube root of the argument
CV_EXPORTS_W float fastAtan2 (float y, float x)
 computes the angle in degrees (0..360) of the vector (x,y)
CV_EXPORTS_W void polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
 converts polar coordinates to Cartesian
CV_EXPORTS_W void cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
 converts Cartesian coordinates to polar
CV_EXPORTS_W void phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
 computes angle (angle(i)) of each (x(i), y(i)) vector
CV_EXPORTS_W void magnitude (InputArray x, InputArray y, OutputArray magnitude)
 computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
CV_EXPORTS_W bool checkRange (InputArray a, bool quiet=true, CV_OUT Point *pt=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
 checks that each matrix element is within the specified range.
CV_EXPORTS_W void gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double gamma, OutputArray dst, int flags=0)
 implements generalized matrix product algorithm GEMM from BLAS
CV_EXPORTS_W 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
CV_EXPORTS_W void transpose (InputArray src, OutputArray dst)
 transposes the matrix
CV_EXPORTS_W void transform (InputArray src, OutputArray dst, InputArray m)
 performs affine transformation of each element of multi-channel input matrix
CV_EXPORTS_W void perspectiveTransform (InputArray src, OutputArray dst, InputArray m)
 performs perspective transformation of each element of multi-channel input matrix
CV_EXPORTS_W void completeSymm (InputOutputArray mtx, bool lowerToUpper=false)
 extends the symmetrical matrix from the lower half or from the upper half
CV_EXPORTS_W void setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1))
 initializes scaled identity matrix
CV_EXPORTS_W double determinant (InputArray mtx)
 computes determinant of a square matrix
CV_EXPORTS_W Scalar trace (InputArray mtx)
 computes trace of a matrix
CV_EXPORTS_W double invert (InputArray src, OutputArray dst, int flags=DECOMP_LU)
 computes inverse or pseudo-inverse matrix
CV_EXPORTS_W bool solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
 solves linear system or a least-square problem
CV_EXPORTS_W void sort (InputArray src, OutputArray dst, int flags)
 sorts independently each matrix row or each matrix column
CV_EXPORTS_W void sortIdx (InputArray src, OutputArray dst, int flags)
 sorts independently each matrix row or each matrix column
CV_EXPORTS_W int solveCubic (InputArray coeffs, OutputArray roots)
 finds real roots of a cubic polynomial
CV_EXPORTS_W double solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300)
 finds real and complex roots of a polynomial
CV_EXPORTS bool eigen (InputArray src, OutputArray eigenvalues, int lowindex=-1, int highindex=-1)
 finds eigenvalues of a symmetric matrix
CV_EXPORTS bool eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors, int lowindex=-1, int highindex=-1)
 finds eigenvalues and eigenvectors of a symmetric matrix
CV_EXPORTS void calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=CV_64F)
 computes covariation matrix of a set of samples
CV_EXPORTS_W void calcCovarMatrix (InputArray samples, OutputArray covar, OutputArray mean, int flags, int ctype=CV_64F)
 computes covariation matrix of a set of samples
CV_EXPORTS_W 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
CV_EXPORTS double Mahalonobis (InputArray v1, InputArray v2, InputArray icovar)
 a synonym for Mahalanobis
CV_EXPORTS_W void dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
 performs forward or inverse 1D or 2D Discrete Fourier Transformation
CV_EXPORTS_W void idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
 performs inverse 1D or 2D Discrete Fourier Transformation
CV_EXPORTS_W void dct (InputArray src, OutputArray dst, int flags=0)
 performs forward or inverse 1D or 2D Discrete Cosine Transformation
CV_EXPORTS_W void idct (InputArray src, OutputArray dst, int flags=0)
 performs inverse 1D or 2D Discrete Cosine Transformation
CV_EXPORTS_W 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
CV_EXPORTS_W int getOptimalDFTSize (int vecsize)
 computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently
CV_EXPORTS_W 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
CV_EXPORTS RNGtheRNG ()
 returns the thread-local Random number generator
CV_EXPORTS_W void randu (InputOutputArray dst, InputArray low, InputArray high)
 fills array with uniformly-distributed random numbers from the range [low, high)
CV_EXPORTS_W void randn (InputOutputArray dst, InputArray mean, InputArray stddev)
 fills array with normally-distributed random numbers with the specified mean and the standard deviation
CV_EXPORTS void randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0)
 shuffles the input array elements
CV_EXPORTS_W void line (Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws the line segment (pt1, pt2) in the image
CV_EXPORTS_W void rectangle (Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image
CV_EXPORTS void rectangle (Mat &img, Rect rec, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws the rectangle outline or a solid rectangle covering rec in the image
CV_EXPORTS_W void circle (Mat &img, Point center, int radius, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws the circle outline or a solid circle in the image
CV_EXPORTS_W void ellipse (Mat &img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws an elliptic arc, ellipse sector or a rotated ellipse in the image
CV_EXPORTS_W void ellipse (Mat &img, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=8)
 draws a rotated ellipse in the image
CV_EXPORTS 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
CV_EXPORTS void fillPoly (Mat &img, const Point **pts, const int *npts, int ncontours, const Scalar &color, int lineType=8, int shift=0, Point offset=Point())
 fills an area bounded by one or more polygons
CV_EXPORTS void polylines (Mat &img, const Point **pts, const int *npts, int ncontours, bool isClosed, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws one or more polygonal curves
CV_EXPORTS bool clipLine (Size imgSize, CV_IN_OUT Point &pt1, CV_IN_OUT Point &pt2)
 clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
CV_EXPORTS_W bool clipLine (Rect imgRect, CV_IN_OUT Point &pt1, CV_IN_OUT Point &pt2)
 clips the line segment by the rectangle imgRect
CV_EXPORTS_W void ellipse2Poly (Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, CV_OUT vector< Point > &pts)
 converts elliptic arc to a polygonal curve
CV_EXPORTS_W void putText (Mat &img, const string &text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int linetype=8, bool bottomLeftOrigin=false)
 renders text string in the image
CV_EXPORTS_W Size getTextSize (const string &text, int fontFace, double fontScale, int thickness, CV_OUT int *baseLine)
 returns bounding box of the text string
CV_EXPORTS ConvertData getConvertElem (int fromType, int toType)
 returns the function for converting pixels from one data type to another
CV_EXPORTS ConvertScaleData getConvertScaleElem (int fromType, int toType)
 returns the function for converting pixels from one data type to another with the optional scaling
CV_EXPORTS void minMaxLoc (const SparseMat &a, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0)
 finds global minimum and maximum sparse array elements and returns their values and their locations
CV_EXPORTS double norm (const SparseMat &src, int normType)
 computes norm of a sparse matrix
CV_EXPORTS 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
template<>
CV_EXPORTS std::string CommandLineParser::analyzeValue< std::string > (const std::string &str)
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 >
void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst)
template<typename _Tp >
void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst)
template<typename _Tp >
void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst)
template<typename T1 , typename T2 , typename Op >
void process (const Mat_< T1 > &m1, Mat_< T2 > &m2, Op op)
template<typename T1 , typename T2 , typename T3 , typename Op >
void process (const Mat_< T1 > &m1, const Mat_< T2 > &m2, Mat_< T3 > &m3, Op op)
CV_EXPORTS MatExpr operator+ (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator+ (const Mat &a, const Scalar &s)
CV_EXPORTS MatExpr operator+ (const Scalar &s, const Mat &a)
CV_EXPORTS MatExpr operator+ (const MatExpr &e, const Mat &m)
CV_EXPORTS MatExpr operator+ (const Mat &m, const MatExpr &e)
CV_EXPORTS MatExpr operator+ (const MatExpr &e, const Scalar &s)
CV_EXPORTS MatExpr operator+ (const Scalar &s, const MatExpr &e)
CV_EXPORTS MatExpr operator+ (const MatExpr &e1, const MatExpr &e2)
CV_EXPORTS MatExpr operator- (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator- (const Mat &a, const Scalar &s)
CV_EXPORTS MatExpr operator- (const Scalar &s, const Mat &a)
CV_EXPORTS MatExpr operator- (const MatExpr &e, const Mat &m)
CV_EXPORTS MatExpr operator- (const Mat &m, const MatExpr &e)
CV_EXPORTS MatExpr operator- (const MatExpr &e, const Scalar &s)
CV_EXPORTS MatExpr operator- (const Scalar &s, const MatExpr &e)
CV_EXPORTS MatExpr operator- (const MatExpr &e1, const MatExpr &e2)
CV_EXPORTS MatExpr operator- (const Mat &m)
CV_EXPORTS MatExpr operator- (const MatExpr &e)
CV_EXPORTS MatExpr operator* (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator* (const Mat &a, double s)
CV_EXPORTS MatExpr operator* (double s, const Mat &a)
CV_EXPORTS MatExpr operator* (const MatExpr &e, const Mat &m)
CV_EXPORTS MatExpr operator* (const Mat &m, const MatExpr &e)
CV_EXPORTS MatExpr operator* (const MatExpr &e, double s)
CV_EXPORTS MatExpr operator* (double s, const MatExpr &e)
CV_EXPORTS MatExpr operator* (const MatExpr &e1, const MatExpr &e2)
CV_EXPORTS MatExpr operator/ (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator/ (const Mat &a, double s)
CV_EXPORTS MatExpr operator/ (double s, const Mat &a)
CV_EXPORTS MatExpr operator/ (const MatExpr &e, const Mat &m)
CV_EXPORTS MatExpr operator/ (const Mat &m, const MatExpr &e)
CV_EXPORTS MatExpr operator/ (const MatExpr &e, double s)
CV_EXPORTS MatExpr operator/ (double s, const MatExpr &e)
CV_EXPORTS MatExpr operator/ (const MatExpr &e1, const MatExpr &e2)
CV_EXPORTS MatExpr operator< (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator< (const Mat &a, double s)
CV_EXPORTS MatExpr operator< (double s, const Mat &a)
CV_EXPORTS MatExpr operator<= (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator<= (const Mat &a, double s)
CV_EXPORTS MatExpr operator<= (double s, const Mat &a)
CV_EXPORTS MatExpr operator== (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator== (const Mat &a, double s)
CV_EXPORTS MatExpr operator== (double s, const Mat &a)
CV_EXPORTS MatExpr operator!= (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator!= (const Mat &a, double s)
CV_EXPORTS MatExpr operator!= (double s, const Mat &a)
CV_EXPORTS MatExpr operator>= (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator>= (const Mat &a, double s)
CV_EXPORTS MatExpr operator>= (double s, const Mat &a)
CV_EXPORTS MatExpr operator> (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator> (const Mat &a, double s)
CV_EXPORTS MatExpr operator> (double s, const Mat &a)
CV_EXPORTS MatExpr min (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr min (const Mat &a, double s)
CV_EXPORTS MatExpr min (double s, const Mat &a)
CV_EXPORTS MatExpr max (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr max (const Mat &a, double s)
CV_EXPORTS MatExpr max (double s, const Mat &a)
CV_EXPORTS MatExpr operator& (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator& (const Mat &a, const Scalar &s)
CV_EXPORTS MatExpr operator& (const Scalar &s, const Mat &a)
CV_EXPORTS MatExpr operator| (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator| (const Mat &a, const Scalar &s)
CV_EXPORTS MatExpr operator| (const Scalar &s, const Mat &a)
CV_EXPORTS MatExpr operator^ (const Mat &a, const Mat &b)
CV_EXPORTS MatExpr operator^ (const Mat &a, const Scalar &s)
CV_EXPORTS MatExpr operator^ (const Scalar &s, const Mat &a)
CV_EXPORTS MatExpr operator~ (const Mat &m)
CV_EXPORTS MatExpr abs (const Mat &m)
CV_EXPORTS MatExpr abs (const MatExpr &e)
template<typename _Tp >
void split (const Mat &src, vector< Mat_< _Tp > > &mv)
CV_EXPORTS ptrdiff_t operator- (const MatConstIterator &b, const MatConstIterator &a)
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)
CV_EXPORTS int LU (float *A, size_t astep, int m, float *b, size_t bstep, int n)
CV_EXPORTS int LU (double *A, size_t astep, int m, double *b, size_t bstep, int n)
CV_EXPORTS bool Cholesky (float *A, size_t astep, int m, float *b, size_t bstep, int n)
CV_EXPORTS bool Cholesky (double *A, size_t astep, int m, double *b, size_t bstep, int n)
template<typename _Tp >
DataType< _Tp >::work_type dot (const Vector< _Tp > &v1, const Vector< _Tp > &v2)
CV_EXPORTS_W void write (FileStorage &fs, const string &name, int value)
CV_EXPORTS_W void write (FileStorage &fs, const string &name, float value)
CV_EXPORTS_W void write (FileStorage &fs, const string &name, double value)
CV_EXPORTS_W void write (FileStorage &fs, const string &name, const string &value)
template<typename _Tp >
void write (FileStorage &fs, const _Tp &value)
CV_EXPORTS void writeScalar (FileStorage &fs, int value)
CV_EXPORTS void writeScalar (FileStorage &fs, float value)
CV_EXPORTS void writeScalar (FileStorage &fs, double value)
CV_EXPORTS 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)
CV_EXPORTS_W void write (FileStorage &fs, const string &name, const Mat &value)
CV_EXPORTS void write (FileStorage &fs, const string &name, const SparseMat &value)
CV_EXPORTS FileStorageoperator<< (FileStorage &fs, const string &str)
CV_EXPORTS_W void read (const FileNode &node, Mat &mat, const Mat &default_mat=Mat())
CV_EXPORTS 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())
CV_EXPORTS scharseqPush (CvSeq *seq, const void *element=0)
CV_EXPORTS scharseqPushFront (CvSeq *seq, const void *element=0)
CV_EXPORTS void seqPop (CvSeq *seq, void *element=0)
CV_EXPORTS void seqPopFront (CvSeq *seq, void *element=0)
CV_EXPORTS void seqPopMulti (CvSeq *seq, void *elements, int count, int in_front=0)
CV_EXPORTS void seqRemove (CvSeq *seq, int index)
CV_EXPORTS void clearSeq (CvSeq *seq)
CV_EXPORTS schargetSeqElem (const CvSeq *seq, int index)
CV_EXPORTS void seqRemoveSlice (CvSeq *seq, CvSlice slice)
CV_EXPORTS 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 >
std::ostream & operator<< (std::ostream &out, const Point_< _Tp > &p)
template<typename _Tp >
std::ostream & operator<< (std::ostream &out, const Point3_< _Tp > &p)
CV_EXPORTS void write (FileStorage &fs, const string &name, const vector< KeyPoint > &keypoints)
 writes vector of keypoints to the file storage
CV_EXPORTS void read (const FileNode &node, CV_OUT vector< KeyPoint > &keypoints)
 reads vector of keypoints from the specified file storage node
CV_EXPORTS void FAST (const Mat &image, CV_OUT vector< KeyPoint > &keypoints, int threshold, bool nonmaxSupression=true)
 detects corners using FAST algorithm by E. Rosten
uchargetData (IplImage *image)
CV_EXPORTS Mat windowedMatchingMask (const vector< KeyPoint > &keypoints1, const vector< KeyPoint > &keypoints2, float maxDeltaX, float maxDeltaY)
CV_EXPORTS void drawKeypoints (const Mat &image, const vector< KeyPoint > &keypoints, Mat &outImage, const Scalar &color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT)
CV_EXPORTS 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)
CV_EXPORTS 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)
CV_EXPORTS 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 >())
CV_EXPORTS void computeRecallPrecisionCurve (const vector< vector< DMatch > > &matches1to2, const vector< vector< uchar > > &correctMatches1to2Mask, vector< Point2f > &recallPrecisionCurve)
CV_EXPORTS float getRecall (const vector< Point2f > &recallPrecisionCurve, float l_precision)
CV_EXPORTS int getNearestPoint (const vector< Point2f > &recallPrecisionCurve, float l_precision)
CV_EXPORTS void evaluateGenericDescriptorMatcher (const Mat &img1, const Mat &img2, const Mat &H1to2, vector< KeyPoint > &keypoints1, vector< KeyPoint > &keypoints2, vector< vector< DMatch > > *matches1to2, vector< vector< uchar > > *correctMatches1to2Mask, vector< Point2f > &recallPrecisionCurve, const Ptr< GenericDescriptorMatcher > &dmatch=Ptr< GenericDescriptorMatcher >())
CV_EXPORTS void filterSpeckles (Mat &img, uchar newVal, int maxSpeckleSize, uchar diffThreshold, Mat &buf)
CV_EXPORTS_W void namedWindow (const string &winname, int flags=WINDOW_AUTOSIZE)
CV_EXPORTS_W void destroyWindow (const string &winname)
CV_EXPORTS_W void destroyAllWindows ()
CV_EXPORTS_W int startWindowThread ()
CV_EXPORTS_W void setWindowProperty (const string &winname, int prop_id, double prop_value)
CV_EXPORTS_W double getWindowProperty (const string &winname, int prop_id)
CV_EXPORTS 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)
CV_EXPORTS void addText (const Mat &img, const string &text, Point org, CvFont font)
CV_EXPORTS void displayOverlay (const string &winname, const string &text, int delayms)
CV_EXPORTS void displayStatusBar (const string &winname, const string &text, int delayms)
CV_EXPORTS void createOpenGLCallback (const string &winname, CvOpenGLCallback callbackOpenGL, void *userdata=0)
CV_EXPORTS void saveWindowParameters (const string &windowName)
CV_EXPORTS void loadWindowParameters (const string &windowName)
CV_EXPORTS int startLoop (int(*pt2Func)(int argc, char *argv[]), int argc, char *argv[])
CV_EXPORTS void stopLoop ()
CV_EXPORTS int createButton (const string &bar_name, ButtonCallback on_change, void *userdata=NULL, int type=CV_PUSH_BUTTON, bool initial_button_state=0)
CV_EXPORTS_W void imshow (const string &winname, InputArray mat)
CV_EXPORTS int createTrackbar (const string &trackbarname, const string &winname, int *value, int count, TrackbarCallback onChange=0, void *userdata=0)
CV_EXPORTS_W int getTrackbarPos (const string &trackbarname, const string &winname)
CV_EXPORTS_W void setTrackbarPos (const string &trackbarname, const string &winname, int pos)
CV_EXPORTS void setMouseCallback (const string &windowName, MouseCallback onMouse, void *param=0)
 assigns callback for mouse events
CV_EXPORTS_W Mat imread (const string &filename, int flags=1)
CV_EXPORTS_W bool imwrite (const string &filename, InputArray img, const vector< int > &params=vector< int >())
CV_EXPORTS_W Mat imdecode (InputArray buf, int flags)
CV_EXPORTS_W bool imencode (const string &ext, InputArray img, vector< uchar > &buf, const vector< int > &params=vector< int >())
CV_EXPORTS_W int waitKey (int delay=0)
CV_EXPORTS_W int borderInterpolate (int p, int len, int borderType)
 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.
CV_EXPORTS int getKernelType (InputArray kernel, Point anchor)
 returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients.
CV_EXPORTS Ptr< BaseRowFiltergetLinearRowFilter (int srcType, int bufType, InputArray kernel, int anchor, int symmetryType)
 returns the primitive row filter with the specified kernel
CV_EXPORTS 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
CV_EXPORTS 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
CV_EXPORTS 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
CV_EXPORTS 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
CV_EXPORTS_W Mat getGaussianKernel (int ksize, double sigma, int ktype=CV_64F)
 returns the Gaussian kernel with the specified parameters
CV_EXPORTS Ptr< FilterEnginecreateGaussianFilter (int type, Size ksize, double sigma1, double sigma2=0, int borderType=BORDER_DEFAULT)
 returns the Gaussian filter engine
CV_EXPORTS_W 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
CV_EXPORTS Ptr< FilterEnginecreateDerivFilter (int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT)
 returns filter engine for the generalized Sobel operator
CV_EXPORTS Ptr< BaseRowFiltergetRowSumFilter (int srcType, int sumType, int ksize, int anchor=-1)
 returns horizontal 1D box filter
CV_EXPORTS Ptr< BaseColumnFiltergetColumnSumFilter (int sumType, int dstType, int ksize, int anchor=-1, double scale=1)
 returns vertical 1D box filter
CV_EXPORTS Ptr< FilterEnginecreateBoxFilter (int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
 returns box filter engine
CV_EXPORTS Ptr< BaseRowFiltergetMorphologyRowFilter (int op, int type, int ksize, int anchor=-1)
 returns horizontal 1D morphological filter
CV_EXPORTS Ptr< BaseColumnFiltergetMorphologyColumnFilter (int op, int type, int ksize, int anchor=-1)
 returns vertical 1D morphological filter
CV_EXPORTS Ptr< BaseFiltergetMorphologyFilter (int op, int type, InputArray kernel, Point anchor=Point(-1,-1))
 returns 2D morphological filter
CV_EXPORTS 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.
CV_EXPORTS_W Mat getStructuringElement (int shape, Size ksize, Point anchor=Point(-1,-1))
 returns structuring element of the specified shape and size
CV_EXPORTS_W 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
CV_EXPORTS_W void medianBlur (InputArray src, OutputArray dst, int ksize)
 smooths the image using median filter.
CV_EXPORTS_W void GaussianBlur (InputArray src, OutputArray dst, Size ksize, double sigma1, double sigma2=0, int borderType=BORDER_DEFAULT)
 smooths the image using Gaussian filter.
CV_EXPORTS_W void bilateralFilter (InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)
 smooths the image using bilateral filter
CV_EXPORTS_W 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
CV_EXPORTS_W void blur (InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)
 a synonym for normalized box filter
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W 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.
CV_EXPORTS_W 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
CV_EXPORTS_W void cornerHarris (InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT)
 computes Harris cornerness criteria at each image pixel
CV_EXPORTS_W 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.
CV_EXPORTS_W void preCornerDetect (InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT)
 computes another complex cornerness criteria at each pixel
CV_EXPORTS 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
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W 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 probabalistic Hough transform
CV_EXPORTS_W 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
CV_EXPORTS_W 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)
CV_EXPORTS_W 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)
CV_EXPORTS_W 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
CV_EXPORTS_W void resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
 resizes the image
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W Mat getRotationMatrix2D (Point2f center, double angle, double scale)
 returns 2x3 affine transformation matrix for the planar rotation.
CV_EXPORTS Mat getPerspectiveTransform (const Point2f src[], const Point2f dst[])
 returns 3x3 perspective transformation for the corresponding 4 point pairs.
CV_EXPORTS Mat getAffineTransform (const Point2f src[], const Point2f dst[])
 returns 2x3 affine transformation for the corresponding 3 point pairs.
CV_EXPORTS_W void invertAffineTransform (InputArray M, OutputArray iM)
 computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.
CV_EXPORTS_W void getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1)
 extracts rectangle from the image at sub-pixel location
CV_EXPORTS_W void integral (InputArray src, OutputArray sum, int sdepth=-1)
 computes the integral image
 CV_EXPORTS_AS (integral2) void integral(InputArray src
 computes the integral image and integral for the squared image
 CV_EXPORTS_AS (integral3) void integral(InputArray src
 computes the integral image, integral for the squared image and the tilted integral image
CV_EXPORTS_W void accumulate (InputArray src, CV_IN_OUT InputOutputArray dst, InputArray mask=noArray())
 adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.
CV_EXPORTS_W void accumulateSquare (InputArray src, CV_IN_OUT InputOutputArray dst, InputArray mask=noArray())
 adds squared src image to the accumulator (dst += src*src).
CV_EXPORTS_W void accumulateProduct (InputArray src1, InputArray src2, CV_IN_OUT InputOutputArray dst, InputArray mask=noArray())
 adds product of the 2 images to the accumulator (dst += src1*src2).
CV_EXPORTS_W void accumulateWeighted (InputArray src, CV_IN_OUT InputOutputArray dst, double alpha, InputArray mask=noArray())
 updates the running average (dst = dst*(1-alpha) + src*alpha)
CV_EXPORTS_W double threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type)
 applies fixed threshold to the image
CV_EXPORTS_W void adaptiveThreshold (InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
 applies variable (adaptive) threshold to the image
CV_EXPORTS_W void pyrDown (InputArray src, OutputArray dst, const Size &dstsize=Size())
 smooths and downsamples the image
CV_EXPORTS_W void pyrUp (InputArray src, OutputArray dst, const Size &dstsize=Size())
 upsamples and smoothes the image
CV_EXPORTS void buildPyramid (InputArray src, OutputArrayOfArrays dst, int maxlevel)
 builds the gaussian pyramid using pyrDown() as a basic operation
CV_EXPORTS_W void undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray())
 corrects lens distortion for the given camera matrix and distortion coefficients
CV_EXPORTS_W 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
CV_EXPORTS_W 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
CV_EXPORTS_W 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)
CV_EXPORTS void undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray())
 returns points' coordinates after lens distortion correction
CV_EXPORTS 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.
CV_EXPORTS 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.
CV_EXPORTS 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
CV_EXPORTS 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
CV_EXPORTS_W double compareHist (InputArray H1, InputArray H2, int method)
 compares two histograms stored in dense arrays
CV_EXPORTS double compareHist (const SparseMat &H1, const SparseMat &H2, int method)
 compares two histograms stored in sparse arrays
CV_EXPORTS_W void equalizeHist (InputArray src, OutputArray dst)
 normalizes the grayscale image brightness and contrast by normalizing its histogram
CV_EXPORTS float EMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float *lowerBound=0, OutputArray flow=noArray())
CV_EXPORTS_W void watershed (InputArray image, InputOutputArray markers)
 segments the image using watershed algorithm
CV_EXPORTS_W 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
CV_EXPORTS_W void grabCut (InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode=GC_EVAL)
 segments the image using GrabCut algorithm
CV_EXPORTS_W void inpaint (InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRange, int flags)
 restores the damaged image areas using one of the available intpainting algorithms
CV_EXPORTS_W void distanceTransform (InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize)
 builds the discrete Voronoi diagram
CV_EXPORTS void distanceTransform (InputArray src, OutputArray dst, int distanceType, int maskSize)
 computes the distance transform map
CV_EXPORTS 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
CV_EXPORTS_W 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
CV_EXPORTS_W void cvtColor (InputArray src, OutputArray dst, int code, int dstCn=0)
 converts image from one color space to another
CV_EXPORTS_W Moments moments (InputArray array, bool binaryImage=false)
 computes moments of the rasterized shape or a vector of points
CV_EXPORTS void HuMoments (const Moments &moments, double hu[7])
 computes 7 Hu invariants from the moments
CV_EXPORTS_W 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
CV_EXPORTS 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.
CV_EXPORTS void findContours (InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())
 retrieves contours from black-n-white image.
CV_EXPORTS 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
CV_EXPORTS void approxPolyDP (InputArray curve, OutputArray approxCurve, double epsilon, bool closed)
 approximates contour or a curve using Douglas-Peucker algorithm
CV_EXPORTS_W double arcLength (InputArray curve, bool closed)
 computes the contour perimeter (closed=true) or a curve length
CV_EXPORTS_W Rect boundingRect (InputArray points)
 computes the bounding rectangle for a contour
CV_EXPORTS_W double contourArea (InputArray contour, bool oriented=false)
 computes the contour area
CV_EXPORTS_W RotatedRect minAreaRect (InputArray points)
 computes the minimal rotated rectangle for a set of points
CV_EXPORTS_W void minEnclosingCircle (InputArray points, Point2f &center, float &radius)
 computes the minimal enclosing circle for a set of points
CV_EXPORTS_W double matchShapes (InputArray contour1, InputArray contour2, int method, double parameter)
 matches two contours using one of the available algorithms
CV_EXPORTS void convexHull (InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true)
 computes convex hull for a set of 2D points.
CV_EXPORTS_W bool isContourConvex (InputArray contour)
 returns true iff the contour is convex. Does not support contours with self-intersection
CV_EXPORTS_W RotatedRect fitEllipse (InputArray points)
 fits ellipse to the set of 2D points
CV_EXPORTS 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
CV_EXPORTS_W 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
CV_EXPORTS_W void groupRectangles (vector< Rect > &rectList, int groupThreshold, double eps=0.2)
CV_EXPORTS_W void groupRectangles (vector< Rect > &rectList, CV_OUT vector< int > &weights, int groupThreshold, double eps=0.2)
CV_EXPORTS void groupRectangles (vector< Rect > &rectList, vector< int > &rejectLevels, vector< double > &levelWeights, int groupThreshold, double eps=0.2)
CV_EXPORTS void groupRectangles_meanshift (vector< Rect > &rectList, vector< double > &foundWeights, vector< double > &foundScales, double detectThreshold=0.0, Size winDetSize=Size(64, 128))
void CV_EXPORTS_W groupRectangles (vector< Rect > &rectList, int groupThreshold, double eps, vector< int > *weights, vector< double > *levelWeights)
CV_EXPORTS void findDataMatrix (const Mat &image, std::vector< DataMatrixCode > &codes)
CV_EXPORTS void drawDataMatrixCodes (const std::vector< DataMatrixCode > &codes, Mat &drawImage)
CV_EXPORTS_W void updateMotionHistory (InputArray silhouette, InputOutputArray mhi, double timestamp, double duration)
 updates motion history image using the current silhouette
CV_EXPORTS_W 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
CV_EXPORTS_W double calcGlobalOrientation (InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration)
 computes the global orientation of the selected motion history image part
CV_EXPORTS_W void segmentMotion (InputArray mhi, OutputArray segmask, vector< Rect > &boundingRects, double timestamp, double segThresh)
CV_EXPORTS_W RotatedRect CamShift (InputArray probImage, CV_IN_OUT Rect &window, TermCriteria criteria)
 updates the object tracking window using CAMSHIFT algorithm
CV_EXPORTS_W int meanShift (InputArray probImage, CV_IN_OUT Rect &window, TermCriteria criteria)
 updates the object tracking window using meanshift algorithm
CV_EXPORTS_W void calcOpticalFlowPyrLK (InputArray prevImg, InputArray nextImg, InputArray prevPts, CV_OUT InputOutputArray nextPts, OutputArray status, OutputArray err, Size winSize=Size(15, 15), int maxLevel=3, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), double derivLambda=0.5, int flags=0)
 computes sparse optical flow using multi-scale Lucas-Kanade algorithm
CV_EXPORTS_W 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
CV_EXPORTS_W Mat estimateRigidTransform (InputArray src, InputArray dst, bool fullAffine)
 estimates the best-fit Euqcidean, similarity, affine or perspective transformation

Variables

class CV_EXPORTS Size_
class CV_EXPORTS Point_
class CV_EXPORTS Rect_
class CV_EXPORTS Vec
class CV_EXPORTS Matx
class CV_EXPORTS MatExpr
class CV_EXPORTS MatOp_Base
class CV_EXPORTS MatArg
class CV_EXPORTS MatConstIterator
class CV_EXPORTS Mat_
class CV_EXPORTS MatIterator_
class CV_EXPORTS MatConstIterator_
class CV_EXPORTS MatCommaInitializer_
class CV_EXPORTS MatOp_Iter_
class CV_EXPORTS FileNode
class CV_EXPORTS FileNodeIterator
class CV_EXPORTS AlgorithmImpl
OutputArray sum
OutputArray OutputArray sqsum
OutputArray OutputArray int sdepth = -1 )
OutputArray OutputArray OutputArray tilted

Detailed Description

Namespace where all the C++ OpenCV functionality resides.


Typedef Documentation

typedef bool(* cv::BundleAdjustCallback)(int iteration, double norm_error, void *user_data)
typedef std::string cv::String
typedef std::basic_string<wchar_t> cv::WString
typedef Mat cv::MatND
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 Matx<float, 1, 2> cv::Matx12f
typedef Matx<double, 1, 2> cv::Matx12d
typedef Matx<float, 1, 3> cv::Matx13f
typedef Matx<double, 1, 3> cv::Matx13d
typedef Matx<float, 1, 4> cv::Matx14f
typedef Matx<double, 1, 4> cv::Matx14d
typedef Matx<float, 1, 6> cv::Matx16f
typedef Matx<double, 1, 6> cv::Matx16d
typedef Matx<float, 2, 1> cv::Matx21f
typedef Matx<double, 2, 1> cv::Matx21d
typedef Matx<float, 3, 1> cv::Matx31f
typedef Matx<double, 3, 1> cv::Matx31d
typedef Matx<float, 4, 1> cv::Matx41f
typedef Matx<double, 4, 1> cv::Matx41d
typedef Matx<float, 6, 1> cv::Matx61f
typedef Matx<double, 6, 1> cv::Matx61d
typedef Matx<float, 2, 2> cv::Matx22f
typedef Matx<double, 2, 2> cv::Matx22d
typedef Matx<float, 2, 3> cv::Matx23f
typedef Matx<double, 2, 3> cv::Matx23d
typedef Matx<float, 3, 2> cv::Matx32f
typedef Matx<double, 3, 2> cv::Matx32d
typedef Matx<float, 3, 3> cv::Matx33f
typedef Matx<double, 3, 3> cv::Matx33d
typedef Matx<float, 3, 4> cv::Matx34f
typedef Matx<double, 3, 4> cv::Matx34d
typedef Matx<float, 4, 3> cv::Matx43f
typedef Matx<double, 4, 3> cv::Matx43d
typedef Matx<float, 4, 4> cv::Matx44f
typedef Matx<double, 4, 4> cv::Matx44d
typedef Matx<float, 6, 6> cv::Matx66f
typedef Matx<double, 6, 6> cv::Matx66d
typedef Vec<uchar, 2> cv::Vec2b
typedef Vec<uchar, 3> cv::Vec3b
typedef Vec<uchar, 4> cv::Vec4b
typedef Vec<short, 2> cv::Vec2s
typedef Vec<short, 3> cv::Vec3s
typedef Vec<short, 4> cv::Vec4s
typedef Vec<ushort, 2> cv::Vec2w
typedef Vec<ushort, 3> cv::Vec3w
typedef Vec<ushort, 4> cv::Vec4w
typedef Vec<int, 2> cv::Vec2i
typedef Vec<int, 3> cv::Vec3i
typedef Vec<int, 4> cv::Vec4i
typedef Vec<int, 6> cv::Vec6i
typedef Vec<int, 8> cv::Vec8i
typedef Vec<float, 2> cv::Vec2f
typedef Vec<float, 3> cv::Vec3f
typedef Vec<float, 4> cv::Vec4f
typedef Vec<float, 6> cv::Vec6f
typedef Vec<double, 2> cv::Vec2d
typedef Vec<double, 3> cv::Vec3d
typedef Vec<double, 4> cv::Vec4d
typedef Vec<double, 6> cv::Vec6d
typedef Complex<float> cv::Complexf
typedef Complex<double> cv::Complexd
typedef Point_<int> cv::Point2i
typedef Point2i cv::Point
typedef Size_<int> cv::Size2i
typedef Size2i cv::Size
typedef Rect_<int> cv::Rect
typedef Point_<float> cv::Point2f
typedef Point_<double> cv::Point2d
typedef Size_<float> cv::Size2f
typedef Point3_<int> cv::Point3i
typedef Point3_<float> cv::Point3f
typedef Point3_<double> cv::Point3d
typedef Scalar_<double> cv::Scalar
typedef const _InputArray& cv::InputArray
typedef const _OutputArray& cv::OutputArray
typedef Mat_<uchar> cv::Mat1b
typedef Mat_<Vec2b> cv::Mat2b
typedef Mat_<Vec3b> cv::Mat3b
typedef Mat_<Vec4b> cv::Mat4b
typedef Mat_<short> cv::Mat1s
typedef Mat_<Vec2s> cv::Mat2s
typedef Mat_<Vec3s> cv::Mat3s
typedef Mat_<Vec4s> cv::Mat4s
typedef Mat_<ushort> cv::Mat1w
typedef Mat_<Vec2w> cv::Mat2w
typedef Mat_<Vec3w> cv::Mat3w
typedef Mat_<Vec4w> cv::Mat4w
typedef Mat_<int> cv::Mat1i
typedef Mat_<Vec2i> cv::Mat2i
typedef Mat_<Vec3i> cv::Mat3i
typedef Mat_<Vec4i> cv::Mat4i
typedef Mat_<float> cv::Mat1f
typedef Mat_<Vec2f> cv::Mat2f
typedef Mat_<Vec3f> cv::Mat3f
typedef Mat_<Vec4f> cv::Mat4f
typedef Mat_<double> cv::Mat1d
typedef Mat_<Vec2d> cv::Mat2d
typedef Mat_<Vec3d> cv::Mat3d
typedef Mat_<Vec4d> cv::Mat4d
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 tbb::blocked_range<int> cv::BlockedRange
typedef tbb::split cv::Split
typedef std::vector< Rect > cv::ConcurrentRectVector
typedef WImage<float> cv::WImage_f
typedef WImageView<float> cv::WImageView_f
typedef WImageC<float, 1> cv::WImage1_f
typedef WImageViewC<float, 1> cv::WImageView1_f
typedef WImageC<float, 3> cv::WImage3_f
typedef WImageViewC<float, 3> cv::WImageView3_f
typedef WImage<short> cv::WImage_16s
typedef WImageC<short, 1> cv::WImage1_16s
typedef WImageViewC<short, 1> cv::WImageView1_16s
typedef WImageC<short, 3> cv::WImage3_16s
typedef WImageViewC<short, 3> cv::WImageView3_16s
typedef void(CV_CDECL * cv::OpenGLCallback)(void *userdata)
typedef void(CV_CDECL * cv::ButtonCallback)(int state, void *userdata)
typedef void(CV_CDECL * cv::TrackbarCallback)(int pos, void *userdata)
typedef void(* cv::MouseCallback)(int event, int x, int y, int flags, void *param)
typedef CvSVM cv::SVM
typedef CvBoost cv::Boost

Enumeration Type Documentation

anonymous enum

type of the robust estimation algorithm

Enumerator:
LMEDS 

least-median algorithm

RANSAC 

RANSAC algorithm.

anonymous enum
Enumerator:
CALIB_CB_ADAPTIVE_THRESH 
CALIB_CB_NORMALIZE_IMAGE 
CALIB_CB_FILTER_QUADS 
CALIB_CB_FAST_CHECK 
anonymous enum
Enumerator:
CALIB_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:
DECOMP_LU 
DECOMP_SVD 
DECOMP_EIG 
DECOMP_CHOLESKY 
DECOMP_QR 
DECOMP_NORMAL 
anonymous enum
Enumerator:
NORM_INF 
NORM_L1 
NORM_L2 
NORM_TYPE_MASK 
NORM_RELATIVE 
NORM_MINMAX 
anonymous enum
Enumerator:
CMP_EQ 
CMP_GT 
CMP_GE 
CMP_LT 
CMP_LE 
CMP_NE 
anonymous enum
Enumerator:
GEMM_1_T 
GEMM_2_T 
GEMM_3_T 
anonymous enum
Enumerator:
DFT_INVERSE 
DFT_SCALE 
DFT_ROWS 
DFT_COMPLEX_OUTPUT 
DFT_REAL_OUTPUT 
DCT_INVERSE 
DCT_ROWS 
anonymous enum
Enumerator:
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

Various k-Means flags.

Enumerator:
KMEANS_RANDOM_CENTERS 
KMEANS_PP_CENTERS 
KMEANS_USE_INITIAL_LABELS 
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_AUTOSIZE 
anonymous enum

various border interpolation methods

Enumerator:
BORDER_REPLICATE 
BORDER_CONSTANT 
BORDER_REFLECT 
BORDER_WRAP 
BORDER_REFLECT_101 
BORDER_REFLECT101 
BORDER_TRANSPARENT 
BORDER_DEFAULT 
BORDER_ISOLATED 
anonymous enum

type of the kernel

Enumerator:
KERNEL_GENERAL 
KERNEL_SYMMETRICAL 
KERNEL_ASYMMETRICAL 
KERNEL_SMOOTH 
KERNEL_INTEGER 
anonymous enum

type of morphological operation

Enumerator:
MORPH_ERODE 
MORPH_DILATE 
MORPH_OPEN 
MORPH_CLOSE 
MORPH_GRADIENT 
MORPH_TOPHAT 
MORPH_BLACKHAT 
anonymous enum

shape of the structuring element

Enumerator:
MORPH_RECT 
MORPH_CROSS 
MORPH_ELLIPSE 
anonymous enum

interpolation algorithm

Enumerator:
INTER_NEAREST 

nearest neighbor interpolation

INTER_LINEAR 

bilinear interpolation

INTER_CUBIC 

bicubic interpolation

INTER_AREA 

area-based (or super) interpolation

INTER_LANCZOS4 

Lanczos interpolation over 8x8 neighborhood.

INTER_MAX 
WARP_INVERSE_MAP 
anonymous enum
Enumerator:
INTER_BITS 
INTER_BITS2 
INTER_TAB_SIZE 
INTER_TAB_SIZE2 
anonymous enum

type of the threshold operation

Enumerator:
THRESH_BINARY 
THRESH_BINARY_INV 
THRESH_TRUNC 
THRESH_TOZERO 
THRESH_TOZERO_INV 
THRESH_MASK 
THRESH_OTSU 
anonymous enum

adaptive threshold algorithm

Enumerator:
ADAPTIVE_THRESH_MEAN_C 
ADAPTIVE_THRESH_GAUSSIAN_C 
anonymous enum
Enumerator:
PROJ_SPHERICAL_ORTHO 
PROJ_SPHERICAL_EQRECT 
anonymous enum

class of the pixel in GrabCut algorithm

Enumerator:
GC_BGD 

background

GC_FGD 

foreground

GC_PR_BGD 

most probably background

GC_PR_FGD 

most probably foreground

anonymous enum

GrabCut algorithm flags.

Enumerator:
GC_INIT_WITH_RECT 
GC_INIT_WITH_MASK 
GC_EVAL 
anonymous enum

the inpainting algorithm

Enumerator:
INPAINT_NS 
INPAINT_TELEA 
anonymous enum
Enumerator:
FLOODFILL_FIXED_RANGE 
FLOODFILL_MASK_ONLY 
anonymous enum

type of the template matching operation

Enumerator:
TM_SQDIFF 
TM_SQDIFF_NORMED 
TM_CCORR 
TM_CCORR_NORMED 
TM_CCOEFF 
TM_CCOEFF_NORMED 
anonymous enum

mode of the contour retrieval algorithm

Enumerator:
RETR_EXTERNAL 

retrieve only the most external (top-level) contours

RETR_LIST 

retrieve all the contours without any hierarchical information

RETR_CCOMP 

retrieve the connected components (that can possibly be nested)

RETR_TREE 

retrieve all the contours and the whole hierarchy

anonymous enum

the contour approximation algorithm

Enumerator:
CHAIN_APPROX_NONE 
CHAIN_APPROX_SIMPLE 
CHAIN_APPROX_TC89_L1 
CHAIN_APPROX_TC89_KCOS 
anonymous enum
Enumerator:
OPTFLOW_USE_INITIAL_FLOW 
OPTFLOW_FARNEBACK_GAUSSIAN 

Function Documentation

CV_EXPORTS_W void cv::Rodrigues ( InputArray  src,
OutputArray  dst,
OutputArray  jacobian = noArray() 
)

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

CV_EXPORTS_W 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.

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

variant of findHomography for backward compatibility

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

Computes RQ decomposition of 3x3 matrix.

CV_EXPORTS_W 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.

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W void cv::solvePnP ( InputArray  objectPoints,
InputArray  imagePoints,
InputArray  cameraMatrix,
InputArray  distCoeffs,
OutputArray  rvec,
OutputArray  tvec,
bool  useExtrinsicGuess = false 
)

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

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

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

CV_EXPORTS_W Mat cv::initCameraMatrix2D ( InputArrayOfArrays  objectPoints,
InputArrayOfArrays  imagePoints,
Size  imageSize,
double  aspectRatio = 1. 
)

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

CV_EXPORTS_W 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

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

finds subpixel-accurate positions of the chessboard corners

CV_EXPORTS_W void cv::drawChessboardCorners ( InputOutputArray  image,
Size  patternSize,
InputArray  corners,
bool  patternWasFound 
)

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

CV_EXPORTS 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

CV_EXPORTS_W double cv::calibrateCamera ( InputArrayOfArrays  objectPoints,
InputArrayOfArrays  imagePoints,
Size  imageSize,
CV_IN_OUT InputOutputArray  cameraMatrix,
CV_IN_OUT InputOutputArray  distCoeffs,
OutputArrayOfArrays  rvecs,
OutputArrayOfArrays  tvecs,
int  flags = 0 
)

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

CV_EXPORTS_W 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.

CV_EXPORTS_W double cv::stereoCalibrate ( InputArrayOfArrays  objectPoints,
InputArrayOfArrays  imagePoints1,
InputArrayOfArrays  imagePoints2,
CV_IN_OUT InputOutputArray  cameraMatrix1,
CV_IN_OUT InputOutputArray  distCoeffs1,
CV_IN_OUT InputOutputArray  cameraMatrix2,
CV_IN_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

CV_EXPORTS 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

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

CV_EXPORTS_W 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.

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

returns the optimal new camera matrix

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

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

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

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

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

for backward compatibility

CV_EXPORTS_W 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

CV_EXPORTS 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

CV_EXPORTS void cv::computeCorrespondEpilines ( InputArray  points1,
int  whichImage,
InputArray  F,
OutputArray  lines 
)

finds coordinates of epipolar lines corresponding the specified points

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

filters off speckles (small regions of incorrectly computed disparity)

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

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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W int cv::estimateAffine3D ( InputArray  _from,
InputArray  _to,
OutputArray  _out,
OutputArray  _inliers,
double  param1 = 3,
double  param2 = 0.99 
)
CV_EXPORTS std::ostream& cv::operator<< ( std::ostream &  out,
const TickMeter &  tm 
)
CV_EXPORTS int cv::chamerMatching ( Mat &  img,
Mat &  templ,
vector< vector< Point > > &  results,
vector< float > &  cost,
double  templScale = 1,
int  maxMatches = 20,
double  minMatchDistance = 1.0,
int  padX = 3,
int  padY = 3,
int  scales = 5,
double  minScale = 0.6,
double  maxScale = 1.6,
double  orientationWeight = 0.5,
double  truncate = 20 
)
CV_EXPORTS void cv::polyfit ( const Mat &  srcx,
const Mat &  srcy,
Mat &  dst,
int  order 
)
CV_EXPORTS string cv::fromUtf16 ( const WString &  str  ) 
CV_EXPORTS WString cv::toUtf16 ( const string &  str  ) 
CV_EXPORTS string cv::format ( const char *  fmt,
  ... 
)
CV_EXPORTS string cv::tempfile ( const char *suffix   CV_DEFAULT0  ) 
CV_EXPORTS void cv::error ( const Exception &  exc  ) 

Signals an error and raises the exception.

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

Parameters:
exc the exception raisen.
CV_EXPORTS bool cv::setBreakOnError ( bool  flag  ) 

Sets/resets the break-on-error mode.

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

Returns:
the previous state
CV_EXPORTS ErrorCallback cv::redirectError ( ErrorCallback  errCallback,
void *  userdata = 0,
void **  prevUserdata = 0 
)

Sets the new error handler and the optional user data.

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

Parameters:
errCallback the new error handler. If NULL, the default error handler is used.
userdata the optional user data pointer, passed to the callback.
prevUserdata the optional output parameter where the previous user data pointer is stored
Returns:
the previous error handler
CV_EXPORTS void cv::setNumThreads ( int  nthreads  ) 
CV_EXPORTS int cv::getNumThreads (  ) 
CV_EXPORTS int cv::getThreadNum (  ) 
CV_EXPORTS int64 cv::getTickCount (  ) 

Returns the number of ticks.

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

CV_EXPORTS_W double cv::getTickFrequency (  ) 

Returns the number of ticks per seconds.

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

  double exec_time = (double)getTickCount();
  // do something ...
  exec_time = ((double)getTickCount() - exec_time)*1000./getTickFrequency();
CV_EXPORTS 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.

CV_EXPORTS_W bool cv::checkHardwareSupport ( int  feature  ) 

Returns SSE etc.

support status

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

  • CV_CPU_MMX - MMX
  • CV_CPU_SSE - SSE
  • CV_CPU_SSE2 - SSE 2
  • CV_CPU_SSE3 - SSE 3
  • CV_CPU_SSSE3 - SSSE 3
  • CV_CPU_SSE4_1 - SSE 4.1
  • CV_CPU_SSE4_2 - SSE 4.2
  • CV_CPU_POPCNT - POPCOUNT
  • CV_CPU_AVX - AVX
Note:
{Note that the function output is not static. Once you called cv::useOptimized(false), most of the hardware acceleration is disabled and thus the function will returns false, until you call cv::useOptimized(true)}
CV_EXPORTS void* cv::fastMalloc ( size_t  bufSize  ) 

Allocates memory buffer.

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

Parameters:
bufSize buffer size in bytes
Returns:
the allocated memory buffer.
CV_EXPORTS 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.

CV_EXPORTS_W void cv::setUseOptimized ( bool  onoff  ) 

Turns on/off available optimization.

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

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

Returns the current optimization status.

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

CV_EXPORTS void cv::scalarToRawData ( const Scalar &  s,
void *  buf,
int  type,
int  unroll_to = 0 
)
CV_EXPORTS OutputArray cv::noArray (  ) 
CV_EXPORTS void cv::swap ( Mat &  a,
Mat &  b 
)

swaps two matrices

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

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

CV_EXPORTS 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.

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

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

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

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

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

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

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

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

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

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

CV_EXPORTS_W void cv::scaleAdd ( InputArray  src1,
double  alpha,
InputArray  src2,
OutputArray  dst 
)

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

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

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

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

cv::CV_EXPORTS_AS ( sumElems   ) 

computes sum of array elements

CV_EXPORTS_W int cv::countNonZero ( InputArray  src  ) 

computes the number of nonzero array elements

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

computes mean value of selected array elements

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

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

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

computes norm of the selected array part

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS void cv::minMaxIdx ( InputArray  src,
double *  minVal,
double *  maxVal,
int *  minIdx = 0,
int *  maxIdx = 0,
InputArray  mask = noArray() 
)
CV_EXPORTS_W 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

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

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

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

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

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

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

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

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

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

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

CV_EXPORTS void cv::mixChannels ( const vector< Mat > &  src,
vector< Mat > &  dst,
const int *  fromTo,
size_t  npairs 
)
CV_EXPORTS_W void cv::extractChannel ( InputArray  src,
OutputArray  dst,
int  coi 
)

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

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

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

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

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

CV_EXPORTS_W 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

CV_EXPORTS Mat cv::repeat ( const Mat &  src,
int  ny,
int  nx 
)
CV_EXPORTS void cv::hconcat ( const Mat *  src,
size_t  nsrc,
OutputArray  dst 
)
CV_EXPORTS void cv::hconcat ( InputArray  src1,
InputArray  src2,
OutputArray  dst 
)
CV_EXPORTS_W void cv::hconcat ( InputArray  src,
OutputArray  dst 
)
CV_EXPORTS void cv::vconcat ( const Mat *  src,
size_t  nsrc,
OutputArray  dst 
)
CV_EXPORTS void cv::vconcat ( InputArray  src1,
InputArray  src2,
OutputArray  dst 
)
CV_EXPORTS_W void cv::vconcat ( InputArray  src,
OutputArray  dst 
)
CV_EXPORTS_W void cv::bitwise_and ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
InputArray  mask = noArray() 
)

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

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

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

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

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

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

inverts each bit of array (dst = ~src)

CV_EXPORTS_W void cv::absdiff ( InputArray  src1,
InputArray  src2,
OutputArray  dst 
)

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

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

CV_EXPORTS_W void cv::compare ( InputArray  src1,
InputArray  src2,
OutputArray  dst,
int  cmpop 
)

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

CV_EXPORTS_W void cv::min ( InputArray  src1,
InputArray  src2,
OutputArray  dst 
)

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

CV_EXPORTS_W void cv::max ( InputArray  src1,
InputArray  src2,
OutputArray  dst 
)

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

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

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

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

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

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

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

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

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

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

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

CV_EXPORTS_W void cv::pow ( InputArray  src,
double  power,
OutputArray  dst 
)

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

CV_EXPORTS_W void cv::exp ( InputArray  src,
OutputArray  dst 
)

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

CV_EXPORTS_W void cv::log ( InputArray  src,
OutputArray  dst 
)

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

CV_EXPORTS_W float cv::cubeRoot ( float  val  ) 

computes cube root of the argument

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

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

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

converts polar coordinates to Cartesian

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

converts Cartesian coordinates to polar

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

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

CV_EXPORTS_W void cv::magnitude ( InputArray  x,
InputArray  y,
OutputArray  magnitude 
)

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

CV_EXPORTS_W bool cv::checkRange ( InputArray  a,
bool  quiet = true,
CV_OUT Point *  pt = 0,
double  minVal = -DBL_MAX,
double  maxVal = DBL_MAX 
)

checks that each matrix element is within the specified range.

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

implements generalized matrix product algorithm GEMM from BLAS

CV_EXPORTS_W 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

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

transposes the matrix

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

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

CV_EXPORTS_W void cv::perspectiveTransform ( InputArray  src,
OutputArray  dst,
InputArray  m 
)

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

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

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

CV_EXPORTS_W void cv::setIdentity ( InputOutputArray  mtx,
const Scalar &  s = Scalar(1) 
)

initializes scaled identity matrix

CV_EXPORTS_W double cv::determinant ( InputArray  mtx  ) 

computes determinant of a square matrix

CV_EXPORTS_W Scalar cv::trace ( InputArray  mtx  ) 

computes trace of a matrix

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

computes inverse or pseudo-inverse matrix

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

solves linear system or a least-square problem

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

sorts independently each matrix row or each matrix column

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

sorts independently each matrix row or each matrix column

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

finds real roots of a cubic polynomial

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

finds real and complex roots of a polynomial

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

finds eigenvalues of a symmetric matrix

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

finds eigenvalues and eigenvectors of a symmetric matrix

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

computes covariation matrix of a set of samples

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

computes covariation matrix of a set of samples

CV_EXPORTS_W 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

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

a synonym for Mahalanobis

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

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

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

performs inverse 1D or 2D Discrete Fourier Transformation

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

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

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

performs inverse 1D or 2D Discrete Cosine Transformation

CV_EXPORTS_W 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

CV_EXPORTS_W int cv::getOptimalDFTSize ( int  vecsize  ) 

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

CV_EXPORTS_W 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

CV_EXPORTS RNG& cv::theRNG (  ) 

returns the thread-local Random number generator

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

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

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

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

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

shuffles the input array elements

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

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

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

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

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

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

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

draws the circle outline or a solid circle in the image

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

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

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

draws a rotated ellipse in the image

CV_EXPORTS 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

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

fills an area bounded by one or more polygons

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

draws one or more polygonal curves

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

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

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

clips the line segment by the rectangle imgRect

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

converts elliptic arc to a polygonal curve

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

renders text string in the image

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

returns bounding box of the text string

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

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

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

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

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

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

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

computes norm of a sparse matrix

CV_EXPORTS 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

template<>
CV_EXPORTS std::string cv::CommandLineParser::analyzeValue< std::string > ( const std::string &  str  ) 
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 
)
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
void cv::cv2eigen ( const Mat &  src,
Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &  dst 
)
template<typename _Tp >
void cv::cv2eigen ( const Mat &  src,
Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &  dst 
)
template<typename _Tp >
void cv::cv2eigen ( const Mat &  src,
Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &  dst 
)
template<typename _Tp >
void cv::cv2eigen ( const Mat &  src,
Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &  dst 
)
template<typename T1 , typename T2 , typename Op >
void cv::process ( const Mat_< T1 > &  m1,
Mat_< T2 > &  m2,
Op  op 
)
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 
)
CV_EXPORTS MatExpr cv::operator+ ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator+ ( const Mat &  a,
const Scalar &  s 
)
CV_EXPORTS MatExpr cv::operator+ ( const Scalar &  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator+ ( const MatExpr &  e,
const Mat &  m 
)
CV_EXPORTS MatExpr cv::operator+ ( const Mat &  m,
const MatExpr &  e 
)
CV_EXPORTS MatExpr cv::operator+ ( const MatExpr &  e,
const Scalar &  s 
)
CV_EXPORTS MatExpr cv::operator+ ( const Scalar &  s,
const MatExpr &  e 
)
CV_EXPORTS MatExpr cv::operator+ ( const MatExpr &  e1,
const MatExpr &  e2 
)
CV_EXPORTS MatExpr cv::operator- ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator- ( const Mat &  a,
const Scalar &  s 
)
CV_EXPORTS MatExpr cv::operator- ( const Scalar &  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator- ( const MatExpr &  e,
const Mat &  m 
)
CV_EXPORTS MatExpr cv::operator- ( const Mat &  m,
const MatExpr &  e 
)
CV_EXPORTS MatExpr cv::operator- ( const MatExpr &  e,
const Scalar &  s 
)
CV_EXPORTS MatExpr cv::operator- ( const Scalar &  s,
const MatExpr &  e 
)
CV_EXPORTS MatExpr cv::operator- ( const MatExpr &  e1,
const MatExpr &  e2 
)
CV_EXPORTS MatExpr cv::operator- ( const Mat &  m  ) 
CV_EXPORTS MatExpr cv::operator- ( const MatExpr &  e  ) 
CV_EXPORTS MatExpr cv::operator* ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator* ( const Mat &  a,
double  s 
)
CV_EXPORTS MatExpr cv::operator* ( double  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator* ( const MatExpr &  e,
const Mat &  m 
)
CV_EXPORTS MatExpr cv::operator* ( const Mat &  m,
const MatExpr &  e 
)
CV_EXPORTS MatExpr cv::operator* ( const MatExpr &  e,
double  s 
)
CV_EXPORTS MatExpr cv::operator* ( double  s,
const MatExpr &  e 
)
CV_EXPORTS MatExpr cv::operator* ( const MatExpr &  e1,
const MatExpr &  e2 
)
CV_EXPORTS MatExpr cv::operator/ ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator/ ( const Mat &  a,
double  s 
)
CV_EXPORTS MatExpr cv::operator/ ( double  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator/ ( const MatExpr &  e,
const Mat &  m 
)
CV_EXPORTS MatExpr cv::operator/ ( const Mat &  m,
const MatExpr &  e 
)
CV_EXPORTS MatExpr cv::operator/ ( const MatExpr &  e,
double  s 
)
CV_EXPORTS MatExpr cv::operator/ ( double  s,
const MatExpr &  e 
)
CV_EXPORTS MatExpr cv::operator/ ( const MatExpr &  e1,
const MatExpr &  e2 
)
CV_EXPORTS MatExpr cv::operator< ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator< ( const Mat &  a,
double  s 
)
CV_EXPORTS MatExpr cv::operator< ( double  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator<= ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator<= ( const Mat &  a,
double  s 
)
CV_EXPORTS MatExpr cv::operator<= ( double  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator== ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator== ( const Mat &  a,
double  s 
)
CV_EXPORTS MatExpr cv::operator== ( double  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator!= ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator!= ( const Mat &  a,
double  s 
)
CV_EXPORTS MatExpr cv::operator!= ( double  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator>= ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator>= ( const Mat &  a,
double  s 
)
CV_EXPORTS MatExpr cv::operator>= ( double  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator> ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator> ( const Mat &  a,
double  s 
)
CV_EXPORTS MatExpr cv::operator> ( double  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::min ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::min ( const Mat &  a,
double  s 
)
CV_EXPORTS MatExpr cv::min ( double  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::max ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::max ( const Mat &  a,
double  s 
)
CV_EXPORTS MatExpr cv::max ( double  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator& ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator& ( const Mat &  a,
const Scalar &  s 
)
CV_EXPORTS MatExpr cv::operator& ( const Scalar &  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator| ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator| ( const Mat &  a,
const Scalar &  s 
)
CV_EXPORTS MatExpr cv::operator| ( const Scalar &  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator^ ( const Mat &  a,
const Mat &  b 
)
CV_EXPORTS MatExpr cv::operator^ ( const Mat &  a,
const Scalar &  s 
)
CV_EXPORTS MatExpr cv::operator^ ( const Scalar &  s,
const Mat &  a 
)
CV_EXPORTS MatExpr cv::operator~ ( const Mat &  m  ) 
CV_EXPORTS MatExpr cv::abs ( const Mat &  m  ) 
CV_EXPORTS MatExpr cv::abs ( const MatExpr &  e  ) 
template<typename _Tp >
void cv::split ( const Mat &  src,
vector< Mat_< _Tp > > &  mv 
)
CV_EXPORTS ptrdiff_t cv::operator- ( const MatConstIterator &  b,
const MatConstIterator &  a 
)
template<>
uchar cv::saturate_cast< uchar > ( schar  v  ) 
template<>
uchar cv::saturate_cast< uchar > ( ushort  v  ) 
template<>
uchar cv::saturate_cast< uchar > ( int  v  ) 
template<>
uchar cv::saturate_cast< uchar > ( short  v  ) 
template<>
uchar cv::saturate_cast< uchar > ( unsigned  v  ) 
template<>
uchar cv::saturate_cast< uchar > ( float  v  ) 
template<>
uchar cv::saturate_cast< uchar > ( double  v  ) 
template<>
schar cv::saturate_cast< schar > ( uchar  v  ) 
template<>
schar cv::saturate_cast< schar > ( ushort  v  ) 
template<>
schar cv::saturate_cast< schar > ( int  v  ) 
template<>
schar cv::saturate_cast< schar > ( short  v  ) 
template<>
schar cv::saturate_cast< schar > ( unsigned  v  ) 
template<>
schar cv::saturate_cast< schar > ( float  v  ) 
template<>
schar cv::saturate_cast< schar > ( double  v  ) 
template<>
ushort cv::saturate_cast< ushort > ( schar  v  ) 
template<>
ushort cv::saturate_cast< ushort > ( short  v  ) 
template<>
ushort cv::saturate_cast< ushort > ( int  v  ) 
template<>
ushort cv::saturate_cast< ushort > ( unsigned  v  ) 
template<>
ushort cv::saturate_cast< ushort > ( float  v  ) 
template<>
ushort cv::saturate_cast< ushort > ( double  v  ) 
template<>
short cv::saturate_cast< short > ( ushort  v  ) 
template<>
short cv::saturate_cast< short > ( int  v  ) 
template<>
short cv::saturate_cast< short > ( unsigned  v  ) 
template<>
short cv::saturate_cast< short > ( float  v  ) 
template<>
short cv::saturate_cast< short > ( double  v  ) 
template<>
int cv::saturate_cast< int > ( float  v  ) 
template<>
int cv::saturate_cast< int > ( double  v  ) 
template<>
unsigned cv::saturate_cast< unsigned > ( float  v  ) 
template<>
unsigned cv::saturate_cast< unsigned > ( double  v  ) 
CV_EXPORTS int cv::LU ( float *  A,
size_t  astep,
int  m,
float *  b,
size_t  bstep,
int  n 
)
CV_EXPORTS int cv::LU ( double *  A,
size_t  astep,
int  m,
double *  b,
size_t  bstep,
int  n 
)
CV_EXPORTS bool cv::Cholesky ( float *  A,
size_t  astep,
int  m,
float *  b,
size_t  bstep,
int  n 
)
CV_EXPORTS bool cv::Cholesky ( double *  A,
size_t  astep,
int  m,
double *  b,
size_t  bstep,
int  n 
)
template<typename _Tp >
DataType<_Tp>::work_type cv::dot ( const Vector< _Tp > &  v1,
const Vector< _Tp > &  v2 
)
CV_EXPORTS_W void cv::write ( FileStorage &  fs,
const string &  name,
int  value 
)
CV_EXPORTS_W void cv::write ( FileStorage &  fs,
const string &  name,
float  value 
)
CV_EXPORTS_W void cv::write ( FileStorage &  fs,
const string &  name,
double  value 
)
CV_EXPORTS_W void cv::write ( FileStorage &  fs,
const string &  name,
const string &  value 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const _Tp &  value 
)
CV_EXPORTS void cv::writeScalar ( FileStorage &  fs,
int  value 
)
CV_EXPORTS void cv::writeScalar ( FileStorage &  fs,
float  value 
)
CV_EXPORTS void cv::writeScalar ( FileStorage &  fs,
double  value 
)
CV_EXPORTS void cv::writeScalar ( FileStorage &  fs,
const string &  value 
)
template<>
void cv::write ( FileStorage &  fs,
const int &  value 
)
template<>
void cv::write ( FileStorage &  fs,
const float &  value 
)
template<>
void cv::write ( FileStorage &  fs,
const double &  value 
)
template<>
void cv::write ( FileStorage &  fs,
const string &  value 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const Point_< _Tp > &  pt 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const Point3_< _Tp > &  pt 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const Size_< _Tp > &  sz 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const Complex< _Tp > &  c 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const Rect_< _Tp > &  r 
)
template<typename _Tp , int cn>
void cv::write ( FileStorage &  fs,
const Vec< _Tp, cn > &  v 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const Scalar_< _Tp > &  s 
)
void cv::write ( FileStorage &  fs,
const Range &  r 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const string &  name,
const Point_< _Tp > &  pt 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const string &  name,
const Point3_< _Tp > &  pt 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const string &  name,
const Size_< _Tp > &  sz 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const string &  name,
const Complex< _Tp > &  c 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const string &  name,
const Rect_< _Tp > &  r 
)
template<typename _Tp , int cn>
void cv::write ( FileStorage &  fs,
const string &  name,
const Vec< _Tp, cn > &  v 
)
template<typename _Tp >
void cv::write ( FileStorage &  fs,
const string &  name,
const Scalar_< _Tp > &  s 
)
void cv::write ( FileStorage &  fs,
const string &  name,
const Range &  r 
)
CV_EXPORTS_W void cv::write ( FileStorage &  fs,
const string &  name,
const Mat &  value 
)
CV_EXPORTS void cv::write ( FileStorage &  fs,
const string &  name,
const SparseMat &  value 
)
CV_EXPORTS FileStorage& cv::operator<< ( FileStorage &  fs,
const string &  str 
)
CV_EXPORTS_W void cv::read ( const FileNode &  node,
Mat &  mat,
const Mat &  default_mat = Mat() 
)
CV_EXPORTS void cv::read ( const FileNode &  node,
SparseMat &  mat,
const SparseMat &  default_mat = SparseMat() 
)
template<typename _Tp , class _LT >
void cv::sort ( vector< _Tp > &  vec,
_LT  LT = _LT() 
)
template<typename _Tp , class _EqPredicate >
int cv::partition ( const vector< _Tp > &  _vec,
vector< int > &  labels,
_EqPredicate  predicate = _EqPredicate() 
)
CV_EXPORTS schar* cv::seqPush ( CvSeq seq,
const void *  element = 0 
)
CV_EXPORTS schar* cv::seqPushFront ( CvSeq seq,
const void *  element = 0 
)
CV_EXPORTS void cv::seqPop ( CvSeq seq,
void *  element = 0 
)
CV_EXPORTS void cv::seqPopFront ( CvSeq seq,
void *  element = 0 
)
CV_EXPORTS void cv::seqPopMulti ( CvSeq seq,
void *  elements,
int  count,
int  in_front = 0 
)
CV_EXPORTS void cv::seqRemove ( CvSeq seq,
int  index 
)
CV_EXPORTS void cv::clearSeq ( CvSeq seq  ) 
CV_EXPORTS schar* cv::getSeqElem ( const CvSeq seq,
int  index 
)
CV_EXPORTS void cv::seqRemoveSlice ( CvSeq seq,
CvSlice  slice 
)
CV_EXPORTS void cv::seqInsertSlice ( CvSeq seq,
int  before_index,
const CvArr from_arr 
)
template<typename _Tp >
ptrdiff_t cv::operator- ( const SeqIterator< _Tp > &  a,
const SeqIterator< _Tp > &  b 
)
template<typename _Tp >
bool cv::operator== ( const SeqIterator< _Tp > &  a,
const SeqIterator< _Tp > &  b 
)
template<typename _Tp >
bool cv::operator!= ( const SeqIterator< _Tp > &  a,
const SeqIterator< _Tp > &  b 
)
template<typename _Tp >
std::ostream& cv::operator<< ( std::ostream &  out,
const Point_< _Tp > &  p 
)

Writes a point to an output stream in Matlab notation

template<typename _Tp >
std::ostream& cv::operator<< ( std::ostream &  out,
const Point3_< _Tp > &  p 
)

Writes a point to an output stream in Matlab notation

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

writes vector of keypoints to the file storage

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

reads vector of keypoints from the specified file storage node

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

detects corners using FAST algorithm by E. Rosten

uchar* cv::getData ( IplImage image  ) 
CV_EXPORTS Mat cv::windowedMatchingMask ( const vector< KeyPoint > &  keypoints1,
const vector< KeyPoint > &  keypoints2,
float  maxDeltaX,
float  maxDeltaY 
)
CV_EXPORTS void cv::drawKeypoints ( const Mat &  image,
const vector< KeyPoint > &  keypoints,
Mat &  outImage,
const Scalar &  color = Scalar::all(-1),
int  flags = DrawMatchesFlags::DEFAULT 
)
CV_EXPORTS 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 
)
CV_EXPORTS 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 
)
CV_EXPORTS void cv::evaluateFeatureDetector ( const Mat &  img1,
const Mat &  img2,
const Mat &  H1to2,
vector< KeyPoint > *  keypoints1,
vector< KeyPoint > *  keypoints2,
float &  repeatability,
int &  correspCount,
const Ptr< FeatureDetector > &  fdetector = Ptr< FeatureDetector >() 
)
CV_EXPORTS void cv::computeRecallPrecisionCurve ( const vector< vector< DMatch > > &  matches1to2,
const vector< vector< uchar > > &  correctMatches1to2Mask,
vector< Point2f > &  recallPrecisionCurve 
)
CV_EXPORTS float cv::getRecall ( const vector< Point2f > &  recallPrecisionCurve,
float  l_precision 
)
CV_EXPORTS int cv::getNearestPoint ( const vector< Point2f > &  recallPrecisionCurve,
float  l_precision 
)
CV_EXPORTS void cv::evaluateGenericDescriptorMatcher ( const Mat &  img1,
const Mat &  img2,
const Mat &  H1to2,
vector< KeyPoint > &  keypoints1,
vector< KeyPoint > &  keypoints2,
vector< vector< DMatch > > *  matches1to2,
vector< vector< uchar > > *  correctMatches1to2Mask,
vector< Point2f > &  recallPrecisionCurve,
const Ptr< GenericDescriptorMatcher > &  dmatch = Ptr< GenericDescriptorMatcher >() 
)
CV_EXPORTS void cv::filterSpeckles ( Mat &  img,
uchar  newVal,
int  maxSpeckleSize,
uchar  diffThreshold,
Mat &  buf 
)

Speckle filtering - filters small connected components on diparity image. It sets pixel (x,y) to newVal if it coresponds to small CC with size < maxSpeckleSize. Threshold for border between CC is diffThreshold;

CV_EXPORTS_W void cv::namedWindow ( const string &  winname,
int  flags = WINDOW_AUTOSIZE 
)
CV_EXPORTS_W void cv::destroyWindow ( const string &  winname  ) 
CV_EXPORTS_W void cv::destroyAllWindows (  ) 
CV_EXPORTS_W int cv::startWindowThread (  ) 
CV_EXPORTS_W void cv::setWindowProperty ( const string &  winname,
int  prop_id,
double  prop_value 
)
CV_EXPORTS_W double cv::getWindowProperty ( const string &  winname,
int  prop_id 
)
CV_EXPORTS 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 
)
CV_EXPORTS void cv::addText ( const Mat &  img,
const string &  text,
Point  org,
CvFont  font 
)
CV_EXPORTS void cv::displayOverlay ( const string &  winname,
const string &  text,
int  delayms 
)
CV_EXPORTS void cv::displayStatusBar ( const string &  winname,
const string &  text,
int  delayms 
)
CV_EXPORTS void cv::createOpenGLCallback ( const string &  winname,
CvOpenGLCallback  callbackOpenGL,
void *  userdata = 0 
)
CV_EXPORTS void cv::saveWindowParameters ( const string &  windowName  ) 
CV_EXPORTS void cv::loadWindowParameters ( const string &  windowName  ) 
CV_EXPORTS int cv::startLoop ( int(*)(int argc, char *argv[])  pt2Func,
int  argc,
char *  argv[] 
)
CV_EXPORTS void cv::stopLoop (  ) 
CV_EXPORTS int cv::createButton ( const string &  bar_name,
ButtonCallback  on_change,
void *  userdata = NULL,
int  type = CV_PUSH_BUTTON,
bool  initial_button_state = 0 
)
CV_EXPORTS_W void cv::imshow ( const string &  winname,
InputArray  mat 
)
CV_EXPORTS int cv::createTrackbar ( const string &  trackbarname,
const string &  winname,
int *  value,
int  count,
TrackbarCallback  onChange = 0,
void *  userdata = 0 
)
CV_EXPORTS_W int cv::getTrackbarPos ( const string &  trackbarname,
const string &  winname 
)
CV_EXPORTS_W void cv::setTrackbarPos ( const string &  trackbarname,
const string &  winname,
int  pos 
)
CV_EXPORTS void cv::setMouseCallback ( const string &  windowName,
MouseCallback  onMouse,
void *  param = 0 
)

assigns callback for mouse events

CV_EXPORTS_W Mat cv::imread ( const string &  filename,
int  flags = 1 
)
CV_EXPORTS_W bool cv::imwrite ( const string &  filename,
InputArray  img,
const vector< int > &  params = vector< int >() 
)
CV_EXPORTS_W Mat cv::imdecode ( InputArray  buf,
int  flags 
)
CV_EXPORTS_W bool cv::imencode ( const string &  ext,
InputArray  img,
vector< uchar > &  buf,
const vector< int > &  params = vector< int >() 
)
CV_EXPORTS_W int cv::waitKey ( int  delay = 0  ) 
CV_EXPORTS_W int cv::borderInterpolate ( int  p,
int  len,
int  borderType 
)

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

CV_EXPORTS int cv::getKernelType ( InputArray  kernel,
Point  anchor 
)

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

CV_EXPORTS Ptr<BaseRowFilter> cv::getLinearRowFilter ( int  srcType,
int  bufType,
InputArray  kernel,
int  anchor,
int  symmetryType 
)

returns the primitive row filter with the specified kernel

CV_EXPORTS 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

CV_EXPORTS 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

CV_EXPORTS 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

CV_EXPORTS 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

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

returns the Gaussian kernel with the specified parameters

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

returns the Gaussian filter engine

CV_EXPORTS_W 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

CV_EXPORTS 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

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

returns horizontal 1D box filter

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

returns vertical 1D box filter

CV_EXPORTS 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

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

returns horizontal 1D morphological filter

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

returns vertical 1D morphological filter

CV_EXPORTS Ptr<BaseFilter> cv::getMorphologyFilter ( int  op,
int  type,
InputArray  kernel,
Point  anchor = Point(-1,-1) 
)

returns 2D morphological filter

CV_EXPORTS 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.

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

returns structuring element of the specified shape and size

CV_EXPORTS_W 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

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

smooths the image using median filter.

CV_EXPORTS_W void cv::GaussianBlur ( InputArray  src,
OutputArray  dst,
Size  ksize,
double  sigma1,
double  sigma2 = 0,
int  borderType = BORDER_DEFAULT 
)

smooths the image using Gaussian filter.

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

smooths the image using bilateral filter

CV_EXPORTS_W 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

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

a synonym for normalized box filter

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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.

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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.

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

computes another complex cornerness criteria at each pixel

CV_EXPORTS 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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 probabalistic Hough transform

CV_EXPORTS_W 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

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

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

CV_EXPORTS_W 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

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

resizes the image

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

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

returns 2x3 affine transformation matrix for the planar rotation.

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

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

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

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

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

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

CV_EXPORTS_W void cv::getRectSubPix ( InputArray  image,
Size  patchSize,
Point2f  center,
OutputArray  patch,
int  patchType = -1 
)

extracts rectangle from the image at sub-pixel location

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

computes the integral image

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_EXPORTS_W void cv::accumulate ( InputArray  src,
CV_IN_OUT InputOutputArray  dst,
InputArray  mask = noArray() 
)

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

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

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

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

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

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

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

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

applies fixed threshold to the image

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

applies variable (adaptive) threshold to the image

CV_EXPORTS_W void cv::pyrDown ( InputArray  src,
OutputArray  dst,
const Size &  dstsize = Size() 
)

smooths and downsamples the image

CV_EXPORTS_W void cv::pyrUp ( InputArray  src,
OutputArray  dst,
const Size &  dstsize = Size() 
)

upsamples and smoothes the image

CV_EXPORTS void cv::buildPyramid ( InputArray  src,
OutputArrayOfArrays  dst,
int  maxlevel 
)

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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

CV_EXPORTS_W 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

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

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

returns points' coordinates after lens distortion correction

CV_EXPORTS 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.

CV_EXPORTS 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.

CV_EXPORTS 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

CV_EXPORTS 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

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

compares two histograms stored in dense arrays

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

compares two histograms stored in sparse arrays

CV_EXPORTS_W void cv::equalizeHist ( InputArray  src,
OutputArray  dst 
)

normalizes the grayscale image brightness and contrast by normalizing its histogram

CV_EXPORTS float cv::EMD ( InputArray  signature1,
InputArray  signature2,
int  distType,
InputArray  cost = noArray(),
float *  lowerBound = 0,
OutputArray  flow = noArray() 
)
CV_EXPORTS_W void cv::watershed ( InputArray  image,
InputOutputArray  markers 
)

segments the image using watershed algorithm

CV_EXPORTS_W 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

CV_EXPORTS_W 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

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

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

CV_EXPORTS_W void cv::distanceTransform ( InputArray  src,
OutputArray  dst,
OutputArray  labels,
int  distanceType,
int  maskSize 
)

builds the discrete Voronoi diagram

CV_EXPORTS void cv::distanceTransform ( InputArray  src,
OutputArray  dst,
int  distanceType,
int  maskSize 
)

computes the distance transform map

CV_EXPORTS 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

CV_EXPORTS_W 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

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

converts image from one color space to another

CV_EXPORTS_W Moments cv::moments ( InputArray  array,
bool  binaryImage = false 
)

computes moments of the rasterized shape or a vector of points

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

computes 7 Hu invariants from the moments

CV_EXPORTS_W 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

CV_EXPORTS 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.

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

retrieves contours from black-n-white image.

CV_EXPORTS 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

CV_EXPORTS void cv::approxPolyDP ( InputArray  curve,
OutputArray  approxCurve,
double  epsilon,
bool  closed 
)

approximates contour or a curve using Douglas-Peucker algorithm

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

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

CV_EXPORTS_W Rect cv::boundingRect ( InputArray  points  ) 

computes the bounding rectangle for a contour

CV_EXPORTS_W double cv::contourArea ( InputArray  contour,
bool  oriented = false 
)

computes the contour area

CV_EXPORTS_W RotatedRect cv::minAreaRect ( InputArray  points  ) 

computes the minimal rotated rectangle for a set of points

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

computes the minimal enclosing circle for a set of points

CV_EXPORTS_W double cv::matchShapes ( InputArray  contour1,
InputArray  contour2,
int  method,
double  parameter 
)

matches two contours using one of the available algorithms

CV_EXPORTS void cv::convexHull ( InputArray  points,
OutputArray  hull,
bool  clockwise = false,
bool  returnPoints = true 
)

computes convex hull for a set of 2D points.

CV_EXPORTS_W bool cv::isContourConvex ( InputArray  contour  ) 

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

CV_EXPORTS_W RotatedRect cv::fitEllipse ( InputArray  points  ) 

fits ellipse to the set of 2D points

CV_EXPORTS 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

CV_EXPORTS_W 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

CV_EXPORTS_W void cv::groupRectangles ( vector< Rect > &  rectList,
int  groupThreshold,
double  eps = 0.2 
)
CV_EXPORTS_W void cv::groupRectangles ( vector< Rect > &  rectList,
CV_OUT vector< int > &  weights,
int  groupThreshold,
double  eps = 0.2 
)
CV_EXPORTS void cv::groupRectangles ( vector< Rect > &  rectList,
vector< int > &  rejectLevels,
vector< double > &  levelWeights,
int  groupThreshold,
double  eps = 0.2 
)
CV_EXPORTS void cv::groupRectangles_meanshift ( vector< Rect > &  rectList,
vector< double > &  foundWeights,
vector< double > &  foundScales,
double  detectThreshold = 0.0,
Size  winDetSize = Size(64, 128) 
)
void CV_EXPORTS_W cv::groupRectangles ( vector< Rect > &  rectList,
int  groupThreshold,
double  eps,
vector< int > *  weights,
vector< double > *  levelWeights 
)
CV_EXPORTS void cv::findDataMatrix ( const Mat &  image,
std::vector< DataMatrixCode > &  codes 
)
CV_EXPORTS void cv::drawDataMatrixCodes ( const std::vector< DataMatrixCode > &  codes,
Mat &  drawImage 
)
CV_EXPORTS_W void cv::updateMotionHistory ( InputArray  silhouette,
InputOutputArray  mhi,
double  timestamp,
double  duration 
)

updates motion history image using the current silhouette

CV_EXPORTS_W 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

CV_EXPORTS_W double cv::calcGlobalOrientation ( InputArray  orientation,
InputArray  mask,
InputArray  mhi,
double  timestamp,
double  duration 
)

computes the global orientation of the selected motion history image part

CV_EXPORTS_W void cv::segmentMotion ( InputArray  mhi,
OutputArray  segmask,
vector< Rect > &  boundingRects,
double  timestamp,
double  segThresh 
)
CV_EXPORTS_W RotatedRect cv::CamShift ( InputArray  probImage,
CV_IN_OUT Rect &  window,
TermCriteria  criteria 
)

updates the object tracking window using CAMSHIFT algorithm

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

updates the object tracking window using meanshift algorithm

CV_EXPORTS_W void cv::calcOpticalFlowPyrLK ( InputArray  prevImg,
InputArray  nextImg,
InputArray  prevPts,
CV_OUT InputOutputArray  nextPts,
OutputArray  status,
OutputArray  err,
Size  winSize = Size(15, 15),
int  maxLevel = 3,
TermCriteria  criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
double  derivLambda = 0.5,
int  flags = 0 
)

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

CV_EXPORTS_W 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

CV_EXPORTS_W Mat cv::estimateRigidTransform ( InputArray  src,
InputArray  dst,
bool  fullAffine 
)

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


Variable Documentation

class CV_EXPORTS cv::Size_
class CV_EXPORTS cv::Point_
class CV_EXPORTS cv::Rect_
class CV_EXPORTS cv::Vec
class CV_EXPORTS cv::Matx
class CV_EXPORTS cv::MatExpr
class CV_EXPORTS cv::MatOp_Base
class CV_EXPORTS cv::MatArg
class CV_EXPORTS cv::MatConstIterator
class CV_EXPORTS cv::Mat_
class CV_EXPORTS cv::MatIterator_
class CV_EXPORTS cv::MatConstIterator_
class CV_EXPORTS cv::MatCommaInitializer_
class CV_EXPORTS cv::MatOp_Iter_
class CV_EXPORTS cv::FileNode
class CV_EXPORTS cv::FileNodeIterator
class CV_EXPORTS cv::AlgorithmImpl