opencv 2.2.0

- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions
core.hpp File Reference

The Core Functionality. More...

Go to the source code of this file.

## Classes
class | cv::Allocator< _Tp >
class | cv::AutoBuffer< _Tp, fixed_size >
class | cv::Complex< _Tp >
class | cv::DataDepth< _Tp >
class | cv::DataDepth< _Tp * >
class | cv::DataDepth< bool >
class | cv::DataDepth< char >
class | cv::DataDepth< double >
class | cv::DataDepth< float >
class | cv::DataDepth< int >
class | cv::DataDepth< schar >
class | cv::DataDepth< short >
class | cv::DataDepth< uchar >
class | cv::DataDepth< unsigned >
class | cv::DataDepth< ushort >
class | cv::DataType< _Tp >
class | cv::DataType< bool >
class | cv::DataType< char >
class | cv::DataType< Complex< _Tp > >
class | cv::DataType< double >
class | cv::DataType< float >
class | cv::DataType< int >
class | cv::DataType< Point3_< _Tp > >
class | cv::DataType< Point_< _Tp > >
class | cv::DataType< Range >
class | cv::DataType< Rect_< _Tp > >
class | cv::DataType< Scalar_< _Tp > >
class | cv::DataType< schar >
class | cv::DataType< short >
class | cv::DataType< Size_< _Tp > >
class | cv::DataType< std::complex< _Tp > >
class | cv::DataType< uchar >
class | cv::DataType< ushort >
class | cv::DataType< Vec< _Tp, cn > >
class | cv::Exception
class | cv::FileNode
class | cv::FileNodeIterator
class | cv::FileStorage
struct | cv::SparseMat::Hdr
| the sparse matrix header More...
class | cv::KDTree
class | cv::LineIterator
class | cv::Mat
class | cv::Mat_< _Tp >
class | Mat_< _Tp >
class | cv::MatAllocator
class | cv::MatCommaInitializer_< _Tp >
class | MatCommaInitializer_< _Tp >
class | cv::MatConstIterator
class | cv::MatConstIterator_< _Tp >
class | MatConstIterator_< _Tp >
class | cv::MatIterator_< _Tp >
class | MatIterator_< _Tp >
class | MatOp_Iter_< _Tp >
class | cv::Matx< _Tp, m, n >
class | Matx< _Tp, m, n >
struct | cv::Matx_AddOp
struct | cv::Matx_MatMulOp
struct | cv::Matx_MulOp
struct | cv::Matx_ScaleOp
struct | cv::Matx_SubOp
struct | cv::Matx_TOp
class | cv::MatxCommaInitializer< _Tp, m, n >
struct | cv::Mat::MSize
struct | cv::Mat::MStep
class | cv::NAryMatIterator
struct | cv::KDTree::Node
struct | cv::SparseMat::Node
| sparse matrix node - element of a hash table More...
class | cv::PCA
class | cv::Point3_< _Tp >
class | cv::Point_< _Tp >
class | Point_< _Tp >
class | cv::Ptr< _Tp >
class | cv::Range
class | cv::Allocator< _Tp >::rebind< U >
class | cv::Rect_< _Tp >
class | Rect_< _Tp >
class | cv::RNG
class | cv::RotatedRect
class | cv::Scalar_< _Tp >
class | cv::Seq< _Tp >
class | cv::SeqIterator< _Tp >
class | SeqIterator< _Tp >
class | cv::Size_< _Tp >
class | Size_< _Tp >
class | cv::SparseMat
class | cv::SparseMat_< _Tp >
class | cv::SparseMatConstIterator
class | cv::SparseMatConstIterator_< _Tp >
class | SparseMatConstIterator_< _Tp >
class | cv::SparseMatIterator
class | cv::SparseMatIterator_< _Tp >
class | SparseMatIterator_< _Tp >
class | cv::SVD
class | cv::TermCriteria
class | cv::Vec< _Tp, cn >
class | Vec< _Tp, cn >
class | cv::VecCommaInitializer< _Tp, m >

## Namespaces
namespace | cv

## Macros
#define | CV_Assert(expr) if((expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, "", __FILE__, __LINE__) )
#define | CV_DbgAssert(expr)
#define | CV_Error(code, msg) cv::error( cv::Exception(code, msg, "", __FILE__, __LINE__) )
#define | CV_Error_(code, args) cv::error( cv::Exception(code, cv::format args, "", __FILE__, __LINE__) )

## Typedefs
typedef Complex< double > | cv::Complexd
typedef Complex< float > | cv::Complexf
typedef void(* | cv::ConvertData )(const void *from, void *to, int cn)
typedef void(* | cv::ConvertScaleData )(const void *from, void *to, int cn, double alpha, double beta)
typedef int(CV_CDECL * | cv::ErrorCallback )(int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata)
typedef Mat_< uchar > | cv::Mat1b
typedef Mat_< double > | cv::Mat1d
typedef Mat_< float > | cv::Mat1f
typedef Mat_< int > | cv::Mat1i
typedef Mat_< short > | cv::Mat1s
typedef Mat_< ushort > | cv::Mat1w
typedef Mat_< Vec2b > | cv::Mat2b
typedef Mat_< Vec2d > | cv::Mat2d
typedef Mat_< Vec2f > | cv::Mat2f
typedef Mat_< Vec2i > | cv::Mat2i
typedef Mat_< Vec2s > | cv::Mat2s
typedef Mat_< Vec2w > | cv::Mat2w
typedef Mat_< Vec3b > | cv::Mat3b
typedef Mat_< Vec3d > | cv::Mat3d
typedef Mat_< Vec3f > | cv::Mat3f
typedef Mat_< Vec3i > | cv::Mat3i
typedef Mat_< Vec3s > | cv::Mat3s
typedef Mat_< Vec3w > | cv::Mat3w
typedef Mat_< Vec4b > | cv::Mat4b
typedef Mat_< Vec4d > | cv::Mat4d
typedef Mat_< Vec4f > | cv::Mat4f
typedef Mat_< Vec4i > | cv::Mat4i
typedef Mat_< Vec4s > | cv::Mat4s
typedef Mat_< Vec4w > | cv::Mat4w
typedef Mat | cv::MatND
typedef Matx< double, 1, 2 > | cv::Matx12d
typedef Matx< float, 1, 2 > | cv::Matx12f
typedef Matx< double, 1, 3 > | cv::Matx13d
typedef Matx< float, 1, 3 > | cv::Matx13f
typedef Matx< double, 1, 4 > | cv::Matx14d
typedef Matx< float, 1, 4 > | cv::Matx14f
typedef Matx< double, 1, 6 > | cv::Matx16d
typedef Matx< float, 1, 6 > | cv::Matx16f
typedef Matx< double, 2, 1 > | cv::Matx21d
typedef Matx< float, 2, 1 > | cv::Matx21f
typedef Matx< double, 2, 2 > | cv::Matx22d
typedef Matx< float, 2, 2 > | cv::Matx22f
typedef Matx< double, 2, 3 > | cv::Matx23d
typedef Matx< float, 2, 3 > | cv::Matx23f
typedef Matx< double, 3, 1 > | cv::Matx31d
typedef Matx< float, 3, 1 > | cv::Matx31f
typedef Matx< double, 3, 2 > | cv::Matx32d
typedef Matx< float, 3, 2 > | cv::Matx32f
typedef Matx< double, 3, 3 > | cv::Matx33d
typedef Matx< float, 3, 3 > | cv::Matx33f
typedef Matx< double, 3, 4 > | cv::Matx34d
typedef Matx< float, 3, 4 > | cv::Matx34f
typedef Matx< double, 4, 1 > | cv::Matx41d
typedef Matx< float, 4, 1 > | cv::Matx41f
typedef Matx< double, 4, 3 > | cv::Matx43d
typedef Matx< float, 4, 3 > | cv::Matx43f
typedef Matx< double, 4, 4 > | cv::Matx44d
typedef Matx< float, 4, 4 > | cv::Matx44f
typedef Matx< double, 6, 1 > | cv::Matx61d
typedef Matx< float, 6, 1 > | cv::Matx61f
typedef Matx< double, 6, 6 > | cv::Matx66d
typedef Matx< float, 6, 6 > | cv::Matx66f
typedef Ptr< CvMemStorage > | cv::MemStorage
typedef Point2i | cv::Point
typedef Point_< double > | cv::Point2d
typedef Point_< float > | cv::Point2f
typedef Point_< int > | cv::Point2i
typedef Point3_< double > | cv::Point3d
typedef Point3_< float > | cv::Point3f
typedef Point3_< int > | cv::Point3i
typedef Rect_< int > | cv::Rect
typedef Scalar_< double > | cv::Scalar
typedef Size2i | cv::Size
typedef Size_< float > | cv::Size2f
typedef Size_< int > | cv::Size2i
typedef std::string | cv::String
typedef Vec< uchar, 2 > | cv::Vec2b
typedef Vec< double, 2 > | cv::Vec2d
typedef Vec< float, 2 > | cv::Vec2f
typedef Vec< int, 2 > | cv::Vec2i
typedef Vec< short, 2 > | cv::Vec2s
typedef Vec< ushort, 2 > | cv::Vec2w
typedef Vec< uchar, 3 > | cv::Vec3b
typedef Vec< double, 3 > | cv::Vec3d
typedef Vec< float, 3 > | cv::Vec3f
typedef Vec< int, 3 > | cv::Vec3i
typedef Vec< short, 3 > | cv::Vec3s
typedef Vec< ushort, 3 > | cv::Vec3w
typedef Vec< uchar, 4 > | cv::Vec4b
typedef Vec< double, 4 > | cv::Vec4d
typedef Vec< float, 4 > | cv::Vec4f
typedef Vec< int, 4 > | cv::Vec4i
typedef Vec< short, 4 > | cv::Vec4s
typedef Vec< ushort, 4 > | cv::Vec4w
typedef Vec< double, 6 > | cv::Vec6d
typedef Vec< float, 6 > | cv::Vec6f
typedef std::basic_string < wchar_t > | cv::WString

## 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_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::MAGIC_MASK =0xFFFF0000, cv::TYPE_MASK =0x00000FFF, cv::DEPTH_MASK =7 }
enum | { cv::KMEANS_RANDOM_CENTERS =0, cv::KMEANS_PP_CENTERS =2, cv::KMEANS_USE_INITIAL_LABELS =1 }
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_W void | cv::absdiff (const Mat &src1, const Mat &src2, CV_OUT Mat &dst)
| computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
CV_EXPORTS_W void | cv::absdiff (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst)
| computes element-wise absolute difference of array and scalar (dst = abs(src1 - src2))
CV_EXPORTS_W void | cv::add (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask CV_WRAP_DEFAULT(Mat()))
| adds one matrix to another (dst = src1 + src2)
void | cv::add (const Mat &src1, const Mat &src2, CV_OUT Mat &dst)
| adds one matrix to another (dst = src1 + src2)
CV_EXPORTS_W void | cv::add (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| adds scalar to a matrix (dst = src1 + src2)
CV_EXPORTS_W void | cv::addWeighted (const Mat &src1, double alpha, const Mat &src2, double beta, double gamma, CV_OUT Mat &dst)
| computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
CV_EXPORTS_W void | cv::bitwise_and (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise conjunction of the two arrays (dst = src1 & src2)
CV_EXPORTS_W void | cv::bitwise_and (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise conjunction of an array and scalar (dst = src1 & src2)
CV_EXPORTS_W void | cv::bitwise_not (const Mat &src, CV_OUT Mat &dst)
| inverts each bit of array (dst = ~src)
CV_EXPORTS_W void | cv::bitwise_or (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise disjunction of the two arrays (dst = src1 | src2)
CV_EXPORTS_W void | cv::bitwise_or (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise disjunction of an array and scalar (dst = src1 | src2)
CV_EXPORTS_W void | cv::bitwise_xor (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
CV_EXPORTS_W void | cv::bitwise_xor (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| computes bitwise exclusive-or of an array and scalar (dst = src1 ^ src2)
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 (const Mat &samples, CV_OUT Mat &covar, CV_OUT Mat &mean, int flags, int ctype=CV_64F)
| computes covariation matrix of a set of samples
CV_EXPORTS_W void | cv::cartToPolar (const Mat &x, const Mat &y, CV_OUT Mat &magnitude, CV_OUT Mat &angle, bool angleInDegrees=false)
| converts Cartesian coordinates to polar
CV_EXPORTS_W bool | cv::checkHardwareSupport (int feature)
CV_EXPORTS_W bool | cv::checkRange (const Mat &a, bool quiet=true, CV_OUT Point *pt=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
| checks that each matrix element is within the specified range.
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
bool | cv::clipLine (Size imgSize, CV_IN_OUT Point &pt1, CV_IN_OUT Point &pt2)
| clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
CV_EXPORTS_W bool | cv::clipLine (Rect imgRect, CV_IN_OUT Point &pt1, CV_IN_OUT Point &pt2)
| clips the line segment by the rectangle imgRect
CV_EXPORTS_W void | cv::compare (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, int cmpop)
| compares elements of two arrays (dst = src1 <cmpop> src2)
CV_EXPORTS_W void | cv::compare (const Mat &src1, double s, CV_OUT Mat &dst, int cmpop)
| compares elements of array with scalar (dst = src1 <cmpop> src2)
CV_EXPORTS_W void | cv::completeSymm (Mat &mtx, bool lowerToUpper=false)
| extends the symmetrical matrix from the lower half or from the upper half
CV_EXPORTS_W void | cv::convertScaleAbs (const Mat &src, CV_OUT Mat &dst, double alpha=1, double beta=0)
| scales array elements, computes absolute values and converts the results to 8-bit unsigned integers: dst(i)=saturate_cast<uchar>abs(src(i)*alpha+beta)
CV_EXPORTS_W int | cv::countNonZero (const Mat &src)
| computes the number of nonzero array elements
CV_EXPORTS_W float | cv::cubeRoot (float val)
| computes cube root of the argument
Mat | cv::cvarrToMat (const CvArr *arr, bool copyData=false, bool allowND=true, int coiMode=0)
| converts array (CvMat or IplImage) to cv::Mat
CV_EXPORTS_W void | cv::dct (const Mat &src, CV_OUT Mat &dst, int flags=0)
| performs forward or inverse 1D or 2D Discrete Cosine Transformation
CV_EXPORTS_W double | cv::determinant (const Mat &mtx)
| computes determinant of a square matrix
CV_EXPORTS_W void | cv::dft (const Mat &src, CV_OUT Mat &dst, int flags=0, int nonzeroRows=0)
| performs forward or inverse 1D or 2D Discrete Fourier Transformation
CV_EXPORTS_W void | cv::divide (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, double scale=1)
| computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2)
CV_EXPORTS_W void | cv::divide (double scale, const Mat &src2, CV_OUT Mat &dst)
| computes element-wise weighted reciprocal of an array (dst = scale/src2)
bool | cv::eigen (const Mat &src, CV_OUT Mat &eigenvalues, int lowindex=-1, int highindex=-1)
| finds eigenvalues of a symmetric matrix
bool | cv::eigen (const Mat &src, CV_OUT Mat &eigenvalues, CV_OUT Mat &eigenvectors, int lowindex=-1, int highindex=-1)
| finds eigenvalues and eigenvectors of a symmetric matrix
CV_EXPORTS_W void | cv::ellipse (Mat &img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
| draws an elliptic arc, ellipse sector or a rotated ellipse in the image
CV_EXPORTS_W void | cv::ellipse (Mat &img, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=8)
| draws a rotated ellipse in the image
CV_EXPORTS_W void | cv::ellipse2Poly (Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, CV_OUT vector< Point > &pts)
| converts elliptic arc to a polygonal curve
void | cv::error (const Exception &exc)
| Signals an error and raises the exception.
CV_EXPORTS_W void | cv::exp (const Mat &src, CV_OUT Mat &dst)
| computes exponent of each matrix element (dst = e**src)
void | cv::extractImageCOI (const CvArr *arr, CV_OUT Mat &coiimg, int coi=-1)
| extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
CV_EXPORTS_W float | cv::fastAtan2 (float y, float x)
| computes the angle in degrees (0..360) of the vector (x,y)
void | cv::fastFree (void *ptr)
void * | cv::fastMalloc (size_t bufSize)
void | cv::fillConvexPoly (Mat &img, const Point *pts, int npts, const Scalar &color, int lineType=8, int shift=0)
| draws a filled convex polygon in the image
void | cv::fillPoly (Mat &img, const Point **pts, const int *npts, int ncontours, const Scalar &color, int lineType=8, int shift=0, Point offset=Point())
| fills an area bounded by one or more polygons
CV_EXPORTS_W void | cv::flip (const Mat &src, CV_OUT Mat &dst, int flipCode)
| reverses the order of the rows, columns or both in a matrix
string | cv::format (const char *fmt,...)
string | cv::fromUtf16 (const WString &str)
CV_EXPORTS_W void | cv::gemm (const Mat &src1, const Mat &src2, double alpha, const Mat &src3, double gamma, CV_OUT Mat &dst, int flags=0)
| implements generalized matrix product algorithm GEMM from BLAS
ConvertData | cv::getConvertElem (int fromType, int toType)
| returns the function for converting pixels from one data type to another
ConvertScaleData | cv::getConvertScaleElem (int fromType, int toType)
| returns the function for converting pixels from one data type to another with the optional scaling
int64 | cv::getCPUTickCount ()
int | cv::getNumThreads ()
CV_EXPORTS_W int | cv::getOptimalDFTSize (int vecsize)
| computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently
CV_EXPORTS_W Size | cv::getTextSize (const string &text, int fontFace, double fontScale, int thickness, CV_OUT int *baseLine)
| returns bounding box of the text string
int | cv::getThreadNum ()
int64 | cv::getTickCount ()
| Returns the number of ticks.
CV_EXPORTS_W double | cv::getTickFrequency ()
void | cv::hconcat (const Mat *src, size_t nsrc, Mat &dst)
void | cv::hconcat (const Mat &src1, const Mat &src2, Mat &dst)
CV_EXPORTS_W void | cv::hconcat (const vector< Mat > &src, CV_OUT Mat &dst)
CV_EXPORTS_W void | cv::idct (const Mat &src, CV_OUT Mat &dst, int flags=0)
| performs inverse 1D or 2D Discrete Cosine Transformation
CV_EXPORTS_W void | cv::idft (const Mat &src, CV_OUT Mat &dst, int flags=0, int nonzeroRows=0)
| performs inverse 1D or 2D Discrete Fourier Transformation
CV_EXPORTS_W void | cv::inRange (const Mat &src, const Mat &lowerb, const Mat &upperb, CV_OUT Mat &dst)
| set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
CV_EXPORTS_W void | cv::inRange (const Mat &src, const Scalar &lowerb, const Scalar &upperb, CV_OUT Mat &dst)
| set mask elements for those array elements which are within the fixed bounding box (dst = lowerb <= src && src < upperb)
void | cv::insertImageCOI (const Mat &coiimg, CvArr *arr, int coi=-1)
| inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
CV_EXPORTS_W double | cv::invert (const Mat &src, CV_OUT Mat &dst, int flags=DECOMP_LU)
| computes inverse or pseudo-inverse matrix
CV_EXPORTS_W double | cv::kmeans (const Mat &data, int K, CV_OUT Mat &bestLabels, TermCriteria criteria, int attempts, int flags, CV_OUT Mat *centers=0)
| clusters the input data using k-Means algorithm
CV_EXPORTS_W void | cv::line (Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
| draws the line segment (pt1, pt2) in the image
CV_EXPORTS_W void | cv::log (const Mat &src, CV_OUT Mat &dst)
| computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
CV_EXPORTS_W void | cv::LUT (const Mat &src, const Mat &lut, CV_OUT Mat &dst)
| transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
CV_EXPORTS_W void | cv::magnitude (const Mat &x, const Mat &y, CV_OUT Mat &magnitude)
| computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
CV_EXPORTS_W double | cv::Mahalanobis (const Mat &v1, const Mat &v2, const Mat &icovar)
| computes Mahalanobis distance between two vectors: sqrt((v1-v2)'icovar(v1-v2)), where icovar is the inverse covariation matrix
double | cv::Mahalonobis (const Mat &v1, const Mat &v2, const Mat &icovar)
| a synonym for Mahalanobis
CV_EXPORTS_W void | cv::max (const Mat &src1, const Mat &src2, CV_OUT Mat &dst)
| computes per-element maximum of two arrays (dst = max(src1, src2))
CV_EXPORTS_W void | cv::max (const Mat &src1, double src2, CV_OUT Mat &dst)
| computes per-element maximum of array and scalar (dst = max(src1, src2))
Scalar | cv::mean (const Mat &src)
| computes mean value of array elements
CV_EXPORTS_W Scalar | cv::mean (const Mat &src, const Mat &mask CV_WRAP_DEFAULT(Mat()))
| computes mean value of selected array elements
CV_EXPORTS_W void | cv::meanStdDev (const Mat &src, CV_OUT Scalar &mean, CV_OUT Scalar &stddev, const Mat &mask=Mat())
| computes mean value and standard deviation of all or selected array elements
void | cv::merge (const Mat *mv, size_t count, CV_OUT Mat &dst)
| makes multi-channel array out of several single-channel arrays
CV_EXPORTS_W void | cv::merge (const vector< Mat > &mv, Mat &dst)
| makes multi-channel array out of several single-channel arrays
CV_EXPORTS_W void | cv::min (const Mat &src1, const Mat &src2, CV_OUT Mat &dst)
| computes per-element minimum of two arrays (dst = min(src1, src2))
CV_EXPORTS_W void | cv::min (const Mat &src1, double src2, CV_OUT Mat &dst)
| computes per-element minimum of array and scalar (dst = min(src1, src2))
void | cv::minMaxIdx (const Mat &src, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0, const Mat &mask=Mat())
CV_EXPORTS_W void | cv::minMaxLoc (const Mat &src, CV_OUT double *minVal, CV_OUT double *maxVal=0, CV_OUT Point *minLoc=0, CV_OUT Point *maxLoc=0, const Mat &mask=Mat())
| finds global minimum and maximum array elements and returns their values and their locations
void | cv::minMaxLoc (const SparseMat &a, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0)
| finds global minimum and maximum sparse array elements and returns their values and their locations
void | cv::mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs)
| copies selected channels from the input arrays to the selected channels of the output arrays
void | cv::mixChannels (const vector< Mat > &src, vector< Mat > &dst, const int *fromTo, int npairs)
CV_EXPORTS_W void | cv::mulSpectrums (const Mat &a, const Mat &b, CV_OUT Mat &c, int flags, bool conjB=false)
| computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication
CV_EXPORTS_W void | cv::multiply (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, double scale=1)
| computes element-wise weighted product of the two arrays (dst = scale*src1*src2)
CV_EXPORTS_W void | cv::mulTransposed (const Mat &src, CV_OUT Mat &dst, bool aTa, const Mat &delta=Mat(), double scale=1, int rtype=-1)
| multiplies matrix by its transposition from the left or from the right
double | cv::norm (const Mat &src1, int normType=NORM_L2)
| computes norm of array
double | cv::norm (const Mat &src1, const Mat &src2, int normType=NORM_L2)
| computes norm of the difference between two arrays
CV_EXPORTS_W double | cv::norm (const Mat &src1, int normType, const Mat &mask CV_WRAP_DEFAULT(Mat()))
| computes norm of the selected array part
CV_EXPORTS_W double | cv::norm (const Mat &src1, const Mat &src2, int normType, const Mat &mask CV_WRAP_DEFAULT(Mat()))
| computes norm of selected part of the difference between two arrays
double | cv::norm (const SparseMat &src, int normType)
| computes norm of a sparse matrix
CV_EXPORTS_W void | cv::normalize (const Mat &src, CV_OUT Mat &dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int rtype=-1, const Mat &mask=Mat())
| scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
void | cv::normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType)
| scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
CV_EXPORTS_W void | cv::perspectiveTransform (const Mat &src, CV_OUT Mat &dst, const Mat &m)
| performs perspective transformation of each element of multi-channel input matrix
CV_EXPORTS_W void | cv::phase (const Mat &x, const Mat &y, CV_OUT Mat &angle, bool angleInDegrees=false)
| computes angle (angle(i)) of each (x(i), y(i)) vector
CV_EXPORTS_W void | cv::polarToCart (const Mat &magnitude, const Mat &angle, CV_OUT Mat &x, CV_OUT Mat &y, bool angleInDegrees=false)
| converts polar coordinates to Cartesian
void | cv::polylines (Mat &img, const Point **pts, const int *npts, int ncontours, bool isClosed, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
| draws one or more polygonal curves
CV_EXPORTS_W void | cv::pow (const Mat &src, double power, CV_OUT Mat &dst)
| raises the input matrix elements to the specified power (b = a**power)
CV_EXPORTS_W void | cv::putText (Mat &img, const string &text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int linetype=8, bool bottomLeftOrigin=false)
| renders text string in the image
CV_EXPORTS_W void | cv::randn (CV_OUT Mat &dst, const Scalar &mean, const Scalar &stddev)
| fills array with normally-distributed random numbers with the specified mean and the standard deviation
void | cv::randShuffle (Mat &dst, double iterFactor=1., RNG *rng=0)
| shuffles the input array elements
CV_EXPORTS_W void | cv::randu (CV_OUT Mat &dst, const Scalar &low, const Scalar &high)
| fills array with uniformly-distributed random numbers from the range [low, high)
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
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
ErrorCallback | cv::redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0)
| Sets the new error handler and the optional user data.
CV_EXPORTS_W void | cv::reduce (const Mat &src, CV_OUT Mat &dst, int dim, int rtype, int dtype=-1)
| transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows
CV_EXPORTS_W void | cv::repeat (const Mat &src, int ny, int nx, CV_OUT Mat &dst)
| replicates the input matrix the specified number of times in the horizontal and/or vertical direction
Mat | cv::repeat (const Mat &src, int ny, int nx)
void | cv::scalarToRawData (const Scalar &s, void *buf, int type, int unroll_to=0)
CV_EXPORTS_W void | cv::scaleAdd (const Mat &src1, double alpha, const Mat &src2, CV_OUT Mat &dst)
| adds scaled array to another one (dst = alpha*src1 + src2)
bool | cv::setBreakOnError (bool flag)
| Sets/resets the break-on-error mode.
CV_EXPORTS_W void | cv::setIdentity (Mat &mtx, const Scalar &s=Scalar(1))
| initializes scaled identity matrix
void | cv::setNumThreads (int nthreads)
CV_EXPORTS_W void | cv::setUseOptimized (bool onoff)
CV_EXPORTS_W bool | cv::solve (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, int flags=DECOMP_LU)
| solves linear system or a least-square problem
CV_EXPORTS_W int | cv::solveCubic (const Mat &coeffs, CV_OUT Mat &roots)
| finds real roots of a cubic polynomial
CV_EXPORTS_W double | cv::solvePoly (const Mat &coeffs, CV_OUT Mat &roots, int maxIters=300)
| finds real and complex roots of a polynomial
CV_EXPORTS_W void | cv::sort (const Mat &src, CV_OUT Mat &dst, int flags)
| sorts independently each matrix row or each matrix column
CV_EXPORTS_W void | cv::sortIdx (const Mat &src, CV_OUT Mat &dst, int flags)
| sorts independently each matrix row or each matrix column
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_W void | cv::sqrt (const Mat &src, CV_OUT Mat &dst)
| computes square root of each matrix element (dst = src**0.5)
CV_EXPORTS_W void | cv::subtract (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask CV_WRAP_DEFAULT(Mat()))
| subtracts one matrix from another (dst = src1 - src2)
void | cv::subtract (const Mat &src1, const Mat &src2, CV_OUT Mat &dst)
| subtracts one matrix from another (dst = src1 - src2)
CV_EXPORTS_W void | cv::subtract (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| subtracts scalar from a matrix (dst = src1 - src2)
CV_EXPORTS_W void | cv::subtract (const Scalar &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
| subtracts matrix from scalar (dst = src1 - src2)
CV_EXPORTS_W Scalar | cv::sum (const Mat &src)
| computes sum of array elements
void | cv::swap (Mat &a, Mat &b)
| swaps two matrices
RNG & | cv::theRNG ()
| returns the thread-local Random number generator
WString | cv::toUtf16 (const string &str)
CV_EXPORTS_W Scalar | cv::trace (const Mat &mtx)
| computes trace of a matrix
CV_EXPORTS_W void | cv::transform (const Mat &src, CV_OUT Mat &dst, const Mat &m)
| performs affine transformation of each element of multi-channel input matrix
CV_EXPORTS_W void | cv::transpose (const Mat &src, CV_OUT Mat &dst)
| transposes the matrix
CV_EXPORTS_W bool | cv::useOptimized ()
void | cv::vconcat (const Mat *src, size_t nsrc, Mat &dst)
void | cv::vconcat (const Mat &src1, const Mat &src2, Mat &dst)
CV_EXPORTS_W void | cv::vconcat (const vector< Mat > &src, CV_OUT Mat &dst)

## Detailed Description

The Core Functionality.

## Macro Definition Documentation

#define CV_Assert | ( |  | expr | ) | if((expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, "", __FILE__, __LINE__) )

#define CV_DbgAssert | ( |  | expr | ) |

#define CV_Error | ( |  | code,
|  |  | msg
| ) |  | cv::error( cv::Exception(code, msg, "", __FILE__, __LINE__) )

#define CV_Error_ | ( |  | code,
|  |  | args
| ) |  | cv::error( cv::Exception(code, cv::format args, "", __FILE__, __LINE__) )