/home/grier/opencv/opencv/modules/core/include/opencv2/core/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  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_< ucharcv::Mat1b
typedef Mat_< double > cv::Mat1d
typedef Mat_< float > cv::Mat1f
typedef Mat_< int > cv::Mat1i
typedef Mat_< short > cv::Mat1s
typedef Mat_< ushortcv::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< CvMemStoragecv::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 Scalar &src2, CV_OUT Mat &dst)
 computes element-wise absolute difference of array and scalar (dst = abs(src1 - src2))
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::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::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::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 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_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_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 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_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_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)
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::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
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::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
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
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 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 (double scale, const Mat &src2, CV_OUT Mat &dst)
 computes element-wise weighted reciprocal of an array (dst = scale/src2)
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)
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
bool cv::eigen (const Mat &src, CV_OUT Mat &eigenvalues, int lowindex=-1, int highindex=-1)
 finds eigenvalues of a symmetric matrix
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::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::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 ()
CV_EXPORTS_W void cv::hconcat (const vector< Mat > &src, CV_OUT Mat &dst)
void cv::hconcat (const Mat &src1, const Mat &src2, Mat &dst)
void cv::hconcat (const Mat *src, size_t nsrc, 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 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)
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)
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, double src2, CV_OUT Mat &dst)
 computes per-element maximum of array and scalar (dst = max(src1, src2))
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 Scalar cv::mean (const Mat &src, const Mat &mask CV_WRAP_DEFAULT(Mat()))
 computes mean value of selected array elements
Scalar cv::mean (const Mat &src)
 computes mean value of 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
CV_EXPORTS_W void cv::merge (const vector< Mat > &mv, Mat &dst)
 makes multi-channel array out of several single-channel arrays
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::min (const Mat &src1, double src2, CV_OUT Mat &dst)
 computes per-element minimum of array and scalar (dst = min(src1, src2))
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))
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
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
double cv::norm (const Mat &src1, const Mat &src2, int normType=NORM_L2)
 computes norm of the difference between two arrays
double cv::norm (const Mat &src1, int normType=NORM_L2)
 computes norm of array
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)
void cv::rectangle (Mat &img, Rect rec, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 draws the rectangle outline or a solid rectangle covering rec in the image
CV_EXPORTS_W void cv::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
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
Mat cv::repeat (const Mat &src, int ny, int nx)
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
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)
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 Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat())
 subtracts scalar from a matrix (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 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 ()
CV_EXPORTS_W void cv::vconcat (const vector< Mat > &src, CV_OUT Mat &dst)
void cv::vconcat (const Mat &src1, const Mat &src2, Mat &dst)
void cv::vconcat (const Mat *src, size_t nsrc, Mat &dst)

Detailed Description

The Core Functionality.


Define 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__) )
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Thu Dec 23 11:40:54 2010 for opencv by  doxygen 1.6.3