opencv 2.2.0
|
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 | cv::MatAllocator |
class | cv::MatCommaInitializer_< _Tp > |
class | cv::MatConstIterator |
class | cv::MatConstIterator_< _Tp > |
class | cv::MatIterator_< _Tp > |
class | cv::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 | cv::Ptr< _Tp > |
class | cv::Range |
class | cv::Allocator< _Tp >::rebind< U > |
class | cv::Rect_< _Tp > |
class | cv::RNG |
class | cv::RotatedRect |
class | cv::Scalar_< _Tp > |
class | cv::Seq< _Tp > |
class | cv::SeqIterator< _Tp > |
class | cv::Size_< _Tp > |
class | cv::SparseMat |
class | cv::SparseMat_< _Tp > |
class | cv::SparseMatConstIterator |
class | cv::SparseMatConstIterator_< _Tp > |
class | cv::SparseMatIterator |
class | cv::SparseMatIterator_< _Tp > |
class | cv::SVD |
class | cv::TermCriteria |
class | cv::Vec< _Tp, cn > |
class | cv::VecCommaInitializer< _Tp, m > |
Namespaces | |
namespace | cv |
Defines | |
#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) | |
CV_EXPORTS_W void | cv::add (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat()) |
adds scalar to a matrix (dst = src1 + src2) | |
void | cv::add (const Mat &src1, const Mat &src2, CV_OUT Mat &dst) |
adds one matrix to another (dst = src1 + src2) | |
CV_EXPORTS_W void | cv::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, double s, CV_OUT Mat &dst, int cmpop) |
compares elements of array with scalar (dst = src1 <cmpop> src2) | |
CV_EXPORTS_W void | cv::compare (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, int cmpop) |
compares elements of two arrays (dst = src1 <cmpop> src2) | |
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()) |
void | cv::minMaxLoc (const SparseMat &a, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0) |
finds global minimum and maximum sparse array elements and returns their values and their locations | |
CV_EXPORTS_W void | cv::minMaxLoc (const Mat &src, CV_OUT double *minVal, CV_OUT double *maxVal=0, CV_OUT Point *minLoc=0, CV_OUT Point *maxLoc=0, const Mat &mask=Mat()) |
finds global minimum and maximum array elements and returns their values and their locations | |
void | cv::mixChannels (const vector< Mat > &src, vector< Mat > &dst, const int *fromTo, int npairs) |
void | cv::mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs) |
copies selected channels from the input arrays to the selected channels of the output arrays | |
CV_EXPORTS_W 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 SparseMat &src, int normType) |
computes norm of a sparse matrix | |
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, const Mat &src2, int normType, const Mat &mask CV_WRAP_DEFAULT(Mat())) |
computes norm of selected part of the difference between two arrays | |
CV_EXPORTS_W double | cv::norm (const Mat &src1, int normType, const Mat &mask CV_WRAP_DEFAULT(Mat())) |
computes norm of the selected array part | |
void | cv::normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType) |
scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values | |
CV_EXPORTS_W void | cv::normalize (const Mat &src, CV_OUT Mat &dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int rtype=-1, const Mat &mask=Mat()) |
scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values | |
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 | |
CV_EXPORTS_W void | cv::split (const Mat &m, vector< Mat > &mv) |
copies each plane of a multi-channel array to a dedicated array | |
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::sqrt (const Mat &src, CV_OUT Mat &dst) |
computes square root of each matrix element (dst = src**0.5) | |
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 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) | |
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 &src1, const Mat &src2, Mat &dst) |
void | cv::vconcat (const Mat *src, size_t nsrc, Mat &dst) |
CV_EXPORTS_W void | cv::vconcat (const vector< Mat > &src, CV_OUT Mat &dst) |
The Core Functionality.
#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__) ) |