Classes | Namespaces | Typedefs | Enumerations | Functions | Variables
include/opencv2/core/core.hpp File Reference

The Core Functionality. More...

Go to the source code of this file.

Classes

class  cv::Exception
 The standard OpenCV exception class. More...
class  cv::Allocator< _Tp >
 The STL-compilant memory Allocator based on cv::fastMalloc() and cv::fastFree() More...
class  cv::Allocator< _Tp >::rebind< U >
class  cv::DataDepth< _Tp >
 A helper class for cv::DataType. More...
class  cv::DataDepth< bool >
class  cv::DataDepth< uchar >
class  cv::DataDepth< schar >
class  cv::DataDepth< char >
class  cv::DataDepth< ushort >
class  cv::DataDepth< short >
class  cv::DataDepth< int >
class  cv::DataDepth< unsigned >
class  cv::DataDepth< float >
class  cv::DataDepth< double >
class  cv::DataDepth< _Tp * >
struct  cv::Matx_AddOp
 A short numerical vector. More...
struct  cv::Matx_SubOp
struct  cv::Matx_ScaleOp
struct  cv::Matx_MulOp
struct  cv::Matx_MatMulOp
struct  cv::Matx_TOp
class  cv::Matx< _Tp, m, n >
class  cv::Vec< _Tp, cn >
 A short numerical vector. More...
class  cv::Complex< _Tp >
 A complex number class. More...
class  cv::Point_< _Tp >
 template 2D point class. More...
class  cv::Point3_< _Tp >
 template 3D point class. More...
class  cv::Size_< _Tp >
 The 2D size class. More...
class  cv::Rect_< _Tp >
 The 2D up-right rectangle class. More...
class  cv::RotatedRect
 The rotated 2D rectangle. More...
class  cv::Scalar_< _Tp >
 The template scalar class. More...
class  cv::Range
 The 2D range class. More...
class  cv::DataType< _Tp >
 Informative template class for OpenCV "scalars". More...
class  cv::DataType< bool >
class  cv::DataType< uchar >
class  cv::DataType< schar >
class  cv::DataType< char >
class  cv::DataType< ushort >
class  cv::DataType< short >
class  cv::DataType< int >
class  cv::DataType< float >
class  cv::DataType< double >
class  cv::DataType< Matx< _Tp, m, n > >
class  cv::DataType< Vec< _Tp, cn > >
class  cv::DataType< std::complex< _Tp > >
class  cv::DataType< Complex< _Tp > >
class  cv::DataType< Point_< _Tp > >
class  cv::DataType< Point3_< _Tp > >
class  cv::DataType< Size_< _Tp > >
class  cv::DataType< Rect_< _Tp > >
class  cv::DataType< Scalar_< _Tp > >
class  cv::DataType< Range >
class  cv::Ptr< _Tp >
 Smart pointer to dynamically allocated objects. More...
class  cv::_InputArray
 Proxy datatype for passing Mat's and vector<>'s as input parameters. More...
class  cv::_OutputArray
 Proxy datatype for passing Mat's and vector<>'s as input parameters. More...
class  cv::MatAllocator
 Custom array allocator. More...
class  cv::Mat
 The n-dimensional matrix class. More...
struct  cv::Mat::MSize
struct  cv::Mat::MStep
class  cv::RNG
 Random Number Generator. More...
class  cv::TermCriteria
 Termination criteria in iterative algorithms. More...
class  cv::PCA
 Principal Component Analysis. More...
class  cv::SVD
 Singular Value Decomposition class. More...
class  cv::LineIterator
 Line iterator class. More...
class  cv::Mat_< _Tp >
 Template matrix class derived from Mat. More...
class  cv::MatConstIterator
class  cv::MatConstIterator_< _Tp >
 Matrix read-only iterator. More...
class  cv::MatIterator_< _Tp >
 Matrix read-write iterator. More...
class  cv::MatCommaInitializer_< _Tp >
 Comma-separated Matrix Initializer. More...
class  cv::MatxCommaInitializer< _Tp, m, n >
class  cv::VecCommaInitializer< _Tp, m >
class  cv::AutoBuffer< _Tp, fixed_size >
 Automatically Allocated Buffer Class. More...
class  cv::NAryMatIterator
 n-Dimensional Dense Matrix Iterator Class. More...
class  cv::SparseMat
 Sparse matrix class. More...
struct  cv::SparseMat::Hdr
 the sparse matrix header More...
struct  cv::SparseMat::Node
 sparse matrix node - element of a hash table More...
class  cv::SparseMatConstIterator
 Read-Only Sparse Matrix Iterator. More...
class  cv::SparseMatIterator
 Read-write Sparse Matrix Iterator. More...
class  cv::SparseMat_< _Tp >
 The Template Sparse Matrix class derived from cv::SparseMat. More...
class  cv::SparseMatConstIterator_< _Tp >
 Template Read-Only Sparse Matrix Iterator Class. More...
class  cv::SparseMatIterator_< _Tp >
 Template Read-Write Sparse Matrix Iterator Class. More...
class  cv::KDTree
 Fast Nearest Neighbor Search Class. More...
struct  cv::KDTree::Node
 The node of the search tree. More...
class  cv::FileStorage
 XML/YAML File Storage Class. More...
class  cv::FileNode
 File Storage Node class. More...
class  cv::FileNodeIterator
 File Node Iterator. More...
class  cv::Seq< _Tp >
 Template Sequence Class derived from CvSeq. More...
class  cv::SeqIterator< _Tp >
 STL-style Sequence Iterator inherited from the CvSeqReader structure. More...
struct  cv::ParamType< _Tp >
class  cv::Algorithm
 Base class for high-level OpenCV algorithms. More...
class  cv::AlgorithmInfo
struct  cv::Param
struct  cv::ParamType< bool >
struct  cv::ParamType< int >
struct  cv::ParamType< short >
struct  cv::ParamType< double >
struct  cv::ParamType< string >
struct  cv::ParamType< Mat >
struct  cv::ParamType< vector< Mat > >
struct  cv::ParamType< Algorithm >
struct  cv::ParamType< float >
struct  cv::ParamType< unsigned >
struct  cv::ParamType< uint64 >
class  cv::CommandLineParser
 "\nThe CommandLineParser class is designed for command line arguments parsing\n" "Keys map: \n" "Before you start to work with CommandLineParser you have to create a map for keys.\n" " It will look like this\n" " const char* keys =\n" " {\n" " { s| string| 123asd |string parameter}\n" " { d| digit | 100 |digit parameter }\n" " { c|noCamera|false |without camera }\n" " { 1| |some text|help }\n" " { 2| |333 |another help }\n" " };\n" "Usage syntax: \n" " \"{" - start of parameter string.
" " "}" - end of parameter string
" " "|" - separator between short name, full name, default value and help
" "Supported syntax:
" " --key1=arg1 <If a key with '--' must has an argument
" " you have to assign it through '=' sign.>
" "<If the key with '--' doesn't have any argument, it means that it is a bool key>
" " -key2=arg2 <If a key with '-' must has an argument
" " you have to assign it through '=' sign.>
" "If the key with '-' doesn't have any argument, it means that it is a bool key
" " key3 <This key can't has any parameter>
" "Usage:
" " Imagine that the input parameters are next:
" " -s=string_value --digit=250 --noCamera lena.jpg 10000
" " CommandLineParser parser(argc, argv, keys) - create a parser object
" " parser.get<string>("s" or "string") will return you first parameter value
" " parser.get<string>("s", false or "string", false) will return you first parameter value
" " without spaces in end and begin
" " parser.get<int>("d" or "digit") will return you second parameter value.
" " It also works with 'unsigned int', 'double', and 'float' types>
" " parser.get<bool>("c" or "noCamera") will return you true .
" " If you enter this key in commandline>
" " It return you false otherwise.
" " parser.get<string>("1") will return you the first argument without parameter (lena.jpg)
" " parser.get<int>("2") will return you the second argument without parameter (10000)
" " It also works with 'unsigned int', 'double', and 'float' types
" More...
class  cv::ParallelLoopBody
class  cv::Mutex
class  cv::AutoLock

Namespaces

namespace  cv
 Namespace where all the C++ OpenCV functionality resides.
namespace  cv::gpu

Typedefs

typedef std::string cv::String
typedef Mat cv::MatND
typedef std::basic_string
< wchar_t > 		cv::WString
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 InputArray cv::InputArrayOfArrays
typedef const _OutputArray & cv::OutputArray
typedef OutputArray cv::OutputArrayOfArrays
typedef OutputArray cv::InputOutputArray
typedef OutputArray cv::InputOutputArrayOfArrays
typedef void(* cv::BinaryFunc )(const uchar *src1, size_t step1, const uchar *src2, size_t step2, uchar *dst, size_t step, Size sz, void *)
typedef 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 Ptr< CvMemStorage > cv::MemStorage

Enumerations

enum  {
  cv::DECOMP_LU = 0, cv::DECOMP_SVD = 1, cv::DECOMP_EIG = 2, cv::DECOMP_CHOLESKY = 3,
  cv::DECOMP_QR = 4, cv::DECOMP_NORMAL = 16
}
enum  {
  cv::NORM_INF = 1, cv::NORM_L1 = 2, cv::NORM_L2 = 4, cv::NORM_L2SQR = 5,
  cv::NORM_HAMMING = 6, cv::NORM_HAMMING2 = 7, cv::NORM_TYPE_MASK = 7, cv::NORM_RELATIVE = 8,
  cv::NORM_MINMAX = 32
}
enum  {
  cv::CMP_EQ = 0, cv::CMP_GT = 1, cv::CMP_GE = 2, cv::CMP_LT = 3,
  cv::CMP_LE = 4, cv::CMP_NE = 5
}
enum  { cv::GEMM_1_T = 1, cv::GEMM_2_T = 2, cv::GEMM_3_T = 4 }
enum  {
  cv::DFT_INVERSE = 1, cv::DFT_SCALE = 2, cv::DFT_ROWS = 4, cv::DFT_COMPLEX_OUTPUT = 16,
  cv::DFT_REAL_OUTPUT = 32, cv::DCT_INVERSE = DFT_INVERSE, cv::DCT_ROWS = DFT_ROWS
}
enum  {
  cv::DEPTH_MASK_8U = 1 << CV_8U, cv::DEPTH_MASK_8S = 1 << CV_8S, cv::DEPTH_MASK_16U = 1 << CV_16U, cv::DEPTH_MASK_16S = 1 << CV_16S,
  cv::DEPTH_MASK_32S = 1 << CV_32S, cv::DEPTH_MASK_32F = 1 << CV_32F, cv::DEPTH_MASK_64F = 1 << CV_64F, cv::DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
  cv::DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S, cv::DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
}
enum  { cv::MAGIC_MASK = 0xFFFF0000, cv::TYPE_MASK = 0x00000FFF, cv::DEPTH_MASK = 7 }
enum  { cv::SORT_EVERY_ROW = 0, cv::SORT_EVERY_COLUMN = 1, cv::SORT_ASCENDING = 0, cv::SORT_DESCENDING = 16 }
enum  {
  cv::COVAR_SCRAMBLED = 0, cv::COVAR_NORMAL = 1, cv::COVAR_USE_AVG = 2, cv::COVAR_SCALE = 4,
  cv::COVAR_ROWS = 8, cv::COVAR_COLS = 16
}
enum  { cv::KMEANS_RANDOM_CENTERS = 0, cv::KMEANS_PP_CENTERS = 2, cv::KMEANS_USE_INITIAL_LABELS = 1 }
 Various k-Means flags. More...
enum  {
  cv::FONT_HERSHEY_SIMPLEX = 0, cv::FONT_HERSHEY_PLAIN = 1, cv::FONT_HERSHEY_DUPLEX = 2, cv::FONT_HERSHEY_COMPLEX = 3,
  cv::FONT_HERSHEY_TRIPLEX = 4, cv::FONT_HERSHEY_COMPLEX_SMALL = 5, cv::FONT_HERSHEY_SCRIPT_SIMPLEX = 6, cv::FONT_HERSHEY_SCRIPT_COMPLEX = 7,
  cv::FONT_ITALIC = 16
}

Functions

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_DEFAULT(0))
CV_EXPORTS void cv::error (const Exception &exc)
 Signals an error and raises the exception.
CV_EXPORTS bool cv::setBreakOnError (bool flag)
 Sets/resets the break-on-error mode.
CV_EXPORTS ErrorCallback cv::redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0)
 Sets the new error handler and the optional user data.
CV_EXPORTS void cv::setNumThreads (int nthreads)
CV_EXPORTS int cv::getNumThreads ()
CV_EXPORTS int cv::getThreadNum ()
CV_EXPORTS_W const string & cv::getBuildInformation ()
CV_EXPORTS_W int64 cv::getTickCount ()
 Returns the number of ticks.
CV_EXPORTS_W double cv::getTickFrequency ()
 Returns the number of ticks per seconds.
CV_EXPORTS_W int64 cv::getCPUTickCount ()
 Returns the number of CPU ticks.
CV_EXPORTS_W bool cv::checkHardwareSupport (int feature)
 Returns SSE etc.
CV_EXPORTS_W int cv::getNumberOfCPUs ()
 returns the number of CPUs (including hyper-threading)
CV_EXPORTS void * cv::fastMalloc (size_t bufSize)
 Allocates memory buffer.
CV_EXPORTS void cv::fastFree (void *ptr)
 Frees the memory allocated with cv::fastMalloc.
CV_EXPORTS_W void cv::setUseOptimized (bool onoff)
 Turns on/off available optimization.
CV_EXPORTS_W bool cv::useOptimized ()
 Returns the current optimization status.
CV_EXPORTS void cv::scalarToRawData (const Scalar &s, void *buf, int type, int unroll_to=0)
CV_EXPORTS OutputArray cv::noArray ()
CV_EXPORTS BinaryFunc cv::getConvertFunc (int sdepth, int ddepth)
CV_EXPORTS BinaryFunc cv::getConvertScaleFunc (int sdepth, int ddepth)
CV_EXPORTS BinaryFunc cv::getCopyMaskFunc (size_t esz)
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) Scalar sum(InputArray src)
 computes sum of array elements
CV_EXPORTS_W int cv::countNonZero (InputArray src)
 computes the number of nonzero array elements
CV_EXPORTS_W void cv::findNonZero (InputArray src, OutputArray idx)
 returns the list of locations of non-zero pixels
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::batchDistance (InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, int normType=NORM_L2, int K=0, InputArray mask=noArray(), int update=0, bool crosscheck=false)
 naive nearest neighbor finder
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 void cv::merge (const vector< Mat > &mv, OutputArray dst)
CV_EXPORTS_W void cv::merge (InputArrayOfArrays 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 void cv::split (const Mat &m, vector< Mat > &mv)
CV_EXPORTS_W void cv::split (InputArray m, OutputArrayOfArrays 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::mixChannels (InputArrayOfArrays src, InputArrayOfArrays dst, const vector< int > &fromTo)
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 (InputArrayOfArrays 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 (InputArrayOfArrays 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 void cv::exp (const float *src, float *dst, int n)
CV_EXPORTS void cv::log (const float *src, float *dst, int n)
CV_EXPORTS void cv::fastAtan2 (const float *y, const float *x, float *dst, int n, bool angleInDegrees)
CV_EXPORTS void cv::magnitude (const float *x, const float *y, float *dst, int n)
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 *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
 checks that each matrix element is within the specified range.
CV_EXPORTS_W void cv::patchNaNs (InputOutputArray a, double val=0)
 converts NaN's to the given number
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_W bool cv::eigen (InputArray src, bool computeEigenvectors, OutputArray eigenvalues, OutputArray eigenvectors)
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 void cv::PCACompute (InputArray data, CV_OUT InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0)
CV_EXPORTS_W void cv::PCAComputeVar (InputArray data, CV_OUT InputOutputArray mean, OutputArray eigenvectors, double retainedVariance)
CV_EXPORTS_W void cv::PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
CV_EXPORTS_W void cv::PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
CV_EXPORTS_W void cv::SVDecomp (InputArray src, CV_OUT OutputArray w, CV_OUT OutputArray u, CV_OUT OutputArray vt, int flags=0)
 computes SVD of src
CV_EXPORTS_W void cv::SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, CV_OUT OutputArray dst)
 performs back substitution for the previously computed SVD
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::CV_EXPORTS_AS (randShuffle) void randShuffle_(InputOutputArray dst
CV_EXPORTS_W void cv::line (CV_IN_OUT Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws the line segment (pt1, pt2) in the image
CV_EXPORTS_W void cv::rectangle (CV_IN_OUT Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image
CV_EXPORTS void cv::rectangle (CV_IN_OUT Mat &img, Rect rec, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws the rectangle outline or a solid rectangle covering rec in the image
CV_EXPORTS_W void cv::circle (CV_IN_OUT Mat &img, Point center, int radius, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws the circle outline or a solid circle in the image
CV_EXPORTS_W void cv::ellipse (CV_IN_OUT Mat &img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws an elliptic arc, ellipse sector or a rotated ellipse in the image
CV_EXPORTS_W void cv::ellipse (CV_IN_OUT Mat &img, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=8)
 draws a rotated ellipse in the image
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_W void cv::fillConvexPoly (InputOutputArray img, InputArray points, const Scalar &color, int lineType=8, int shift=0)
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_W void cv::fillPoly (InputOutputArray img, InputArrayOfArrays pts, const Scalar &color, int lineType=8, int shift=0, Point offset=Point())
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_W void cv::polylines (InputOutputArray img, InputArrayOfArrays pts, bool isClosed, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
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_OUT CV_IN_OUT Point &pt1, CV_OUT 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, bool space_delete)
CV_EXPORTS void cv::parallel_for_ (const Range &range, const ParallelLoopBody &body, double nstripes=-1.)

Variables

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_
double cv::iterFactor = 1.)
class CV_EXPORTS cv::MatOp_Iter_
class CV_EXPORTS cv::FileNode
class CV_EXPORTS cv::FileNodeIterator
class CV_EXPORTS cv::Algorithm
class CV_EXPORTS cv::AlgorithmInfo
struct CV_EXPORTS cv::AlgorithmInfoData

Detailed Description

The Core Functionality.