OpenCV  2.4.13.2
Open Source Computer Vision
core/core.hpp File Reference
#include "opencv2/core/types_c.h"
#include "opencv2/core/version.hpp"
#include <limits.h>
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <complex>
#include <map>
#include <new>
#include <string>
#include <vector>
#include <sstream>
#include "opencv2/core/operations.hpp"
#include "opencv2/core/mat.hpp"

Classes

class  cv::Size_< _Tp >
 
class  cv::Point_< _Tp >
 
class  cv::Rect_< _Tp >
 
class  cv::Vec< _Tp, cn >
 
class  cv::Matx< _Tp, m, n >
 
class  cv::Mat_< _Tp >
 
class  cv::MatIterator_< _Tp >
 
class  cv::MatConstIterator_< _Tp >
 
class  cv::MatCommaInitializer_< _Tp >
 
class  cv::Exception
 
class  cv::Allocator< _Tp >
 
class  cv::Allocator< _Tp >::rebind< U >
 
class  cv::DataDepth< _Tp >
 
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
 
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 >
 
class  cv::Complex< _Tp >
 
class  cv::Point_< _Tp >
 
class  cv::Point3_< _Tp >
 
class  cv::Size_< _Tp >
 
class  cv::Rect_< _Tp >
 
class  cv::RotatedRect
 
class  cv::Scalar_< _Tp >
 
class  cv::Range
 
class  cv::DataType< _Tp >
 
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 >
 
class  cv::_InputArray
 
class  cv::_OutputArray
 
class  cv::MatAllocator
 
class  cv::Mat
 
struct  cv::Mat::MSize
 
struct  cv::Mat::MStep
 
class  cv::RNG
 
class  cv::RNG_MT19937
 
class  cv::TermCriteria
 
class  cv::PCA
 
class  cv::SVD
 
class  cv::LineIterator
 
class  cv::Mat_< _Tp >
 
class  cv::MatConstIterator
 
class  cv::MatConstIterator_< _Tp >
 
class  cv::MatIterator_< _Tp >
 
class  cv::MatOp_Iter_< _Tp >
 
class  cv::MatCommaInitializer_< _Tp >
 
class  cv::MatxCommaInitializer< _Tp, m, n >
 
class  cv::VecCommaInitializer< _Tp, m >
 
class  cv::AutoBuffer< _Tp, fixed_size >
 
class  cv::NAryMatIterator
 
class  cv::SparseMatIterator_< _Tp >
 
class  cv::SparseMatConstIterator_< _Tp >
 
class  cv::SparseMat
 
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
 
class  cv::SparseMatIterator
 
class  cv::SparseMat_< _Tp >
 
class  cv::SparseMatConstIterator_< _Tp >
 
class  cv::SparseMatIterator_< _Tp >
 
class  cv::KDTree
 
struct  cv::KDTree::Node
 
class  cv::FileStorage
 
class  cv::FileNode
 
class  cv::FileNodeIterator
 
class  cv::SeqIterator< _Tp >
 
class  cv::Seq< _Tp >
 
class  cv::SeqIterator< _Tp >
 
struct  cv::ParamType< _Tp >
 
class  cv::Algorithm
 
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 >
 
struct  cv::ParamType< uchar >
 
class  cv::CommandLineParser
 
class  cv::ParallelLoopBody
 
class  cv::Mutex
 
class  cv::AutoLock
 
class  cv::TLSDataContainer
 
class  cv::TLSData< T >
 

Namespaces

 cv
 
 cv::ogl
 
 cv::gpu
 

Macros

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

Typedefs

typedef std::string cv::String
 
typedef Mat cv::MatND
 
typedef std::basic_string< wchar_t > cv::WString
 
typedef int(CV_CDECLcv::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_< intcv::Point2i
 
typedef Point2i cv::Point
 
typedef Size_< intcv::Size2i
 
typedef Size_< double > cv::Size2d
 
typedef Size2i cv::Size
 
typedef Rect_< intcv::Rect
 
typedef Point_< float > cv::Point2f
 
typedef Point_< double > cv::Point2d
 
typedef Size_< float > cv::Size2f
 
typedef Point3_< intcv::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_< ucharcv::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_< ushortcv::Mat1w
 
typedef Mat_< Vec2w > cv::Mat2w
 
typedef Mat_< Vec3w > cv::Mat3w
 
typedef Mat_< Vec4w > cv::Mat4w
 
typedef Mat_< intcv::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< CvMemStoragecv::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 }
 
enum  cv::MarkerTypes {
  cv::MARKER_CROSS = 0, cv::MARKER_TILTED_CROSS = 1, cv::MARKER_STAR = 2, cv::MARKER_DIAMOND = 3,
  cv::MARKER_SQUARE = 4, cv::MARKER_TRIANGLE_UP = 5, cv::MARKER_TRIANGLE_DOWN = 6
}
 Possible set of marker types used for the drawMarker function. 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

string cv::fromUtf16 (const WString &str)
 
WString cv::toUtf16 (const string &str)
 
string cv::format (const char *fmt,...)
 
string cv::tempfile (const char *suffix CV_DEFAULT(0))
 
void cv::error (const Exception &exc)
 Signals an error and raises the exception. More...
 
bool cv::setBreakOnError (bool flag)
 Sets/resets the break-on-error mode. More...
 
ErrorCallback cv::redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0)
 Sets the new error handler and the optional user data. More...
 
void cv::glob (String pattern, std::vector< String > &result, bool recursive=false)
 
void cv::setNumThreads (int nthreads)
 
int cv::getNumThreads ()
 
int cv::getThreadNum ()
 
const string & cv::getBuildInformation ()
 
int64 cv::getTickCount ()
 Returns the number of ticks. More...
 
double cv::getTickFrequency ()
 
int64 cv::getCPUTickCount ()
 
bool cv::checkHardwareSupport (int feature)
 
int cv::getNumberOfCPUs ()
 returns the number of CPUs (including hyper-threading) More...
 
voidcv::fastMalloc (size_t bufSize)
 
void cv::fastFree (void *ptr)
 
void cv::setUseOptimized (bool onoff)
 
bool cv::useOptimized ()
 
void cv::scalarToRawData (const Scalar &s, void *buf, int type, int unroll_to=0)
 
template<typename T >
Ptr< T > cv::makePtr ()
 
template<typename T , typename A1 >
Ptr< T > cv::makePtr (const A1 &a1)
 
template<typename T , typename A1 , typename A2 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2)
 
template<typename T , typename A1 , typename A2 , typename A3 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10)
 
OutputArray cv::noArray ()
 
BinaryFunc cv::getConvertFunc (int sdepth, int ddepth)
 
BinaryFunc cv::getConvertScaleFunc (int sdepth, int ddepth)
 
BinaryFunc cv::getCopyMaskFunc (size_t esz)
 
void cv::swap (Mat &a, Mat &b)
 swaps two matrices More...
 
Mat cv::cvarrToMat (const CvArr *arr, bool copyData=false, bool allowND=true, int coiMode=0)
 converts array (CvMat or IplImage) to cv::Mat More...
 
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. More...
 
void cv::insertImageCOI (InputArray coiimg, CvArr *arr, int coi=-1)
 inserts single-channel cv::Mat into a multi-channel CvMat or IplImage More...
 
void cv::add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
 adds one matrix to another (dst = src1 + src2) More...
 
void cv::subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
 subtracts one matrix from another (dst = src1 - src2) More...
 
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) More...
 
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) More...
 
void cv::divide (double scale, InputArray src2, OutputArray dst, int dtype=-1)
 computes element-wise weighted reciprocal of an array (dst = scale/src2) More...
 
void cv::scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst)
 adds scaled array to another one (dst = alpha*src1 + src2) More...
 
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) More...
 
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) More...
 
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)) More...
 
 cv::CV_EXPORTS_AS (sumElems) Scalar sum(InputArray src)
 computes sum of array elements More...
 
int cv::countNonZero (InputArray src)
 computes the number of nonzero array elements More...
 
void cv::findNonZero (InputArray src, OutputArray idx)
 returns the list of locations of non-zero pixels More...
 
Scalar cv::mean (InputArray src, InputArray mask=noArray())
 computes mean value of selected array elements More...
 
void cv::meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
 computes mean value and standard deviation of all or selected array elements More...
 
double cv::norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
 computes norm of the selected array part More...
 
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 More...
 
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 More...
 
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 More...
 
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 More...
 
void cv::minMaxIdx (InputArray src, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray())
 
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 More...
 
void cv::merge (const Mat *mv, size_t count, OutputArray dst)
 makes multi-channel array out of several single-channel arrays More...
 
void cv::merge (const vector< Mat > &mv, OutputArray dst)
 
void cv::merge (InputArrayOfArrays mv, OutputArray dst)
 makes multi-channel array out of several single-channel arrays More...
 
void cv::split (const Mat &src, Mat *mvbegin)
 copies each plane of a multi-channel array to a dedicated array More...
 
void cv::split (const Mat &m, vector< Mat > &mv)
 
void cv::split (InputArray m, OutputArrayOfArrays mv)
 copies each plane of a multi-channel array to a dedicated array More...
 
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 More...
 
void cv::mixChannels (const vector< Mat > &src, vector< Mat > &dst, const int *fromTo, size_t npairs)
 
void cv::mixChannels (InputArrayOfArrays src, InputArrayOfArrays dst, const vector< int > &fromTo)
 
void cv::extractChannel (InputArray src, OutputArray dst, int coi)
 extracts a single channel from src (coi is 0-based index) More...
 
void cv::insertChannel (InputArray src, InputOutputArray dst, int coi)
 inserts a single channel to dst (coi is 0-based index) More...
 
void cv::flip (InputArray src, OutputArray dst, int flipCode)
 reverses the order of the rows, columns or both in a matrix More...
 
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 More...
 
Mat cv::repeat (const Mat &src, int ny, int nx)
 
void cv::hconcat (const Mat *src, size_t nsrc, OutputArray dst)
 
void cv::hconcat (InputArray src1, InputArray src2, OutputArray dst)
 
void cv::hconcat (InputArrayOfArrays src, OutputArray dst)
 
void cv::vconcat (const Mat *src, size_t nsrc, OutputArray dst)
 
void cv::vconcat (InputArray src1, InputArray src2, OutputArray dst)
 
void cv::vconcat (InputArrayOfArrays src, OutputArray dst)
 
void cv::bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 computes bitwise conjunction of the two arrays (dst = src1 & src2) More...
 
void cv::bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 computes bitwise disjunction of the two arrays (dst = src1 | src2) More...
 
void cv::bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2) More...
 
void cv::bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray())
 inverts each bit of array (dst = ~src) More...
 
void cv::absdiff (InputArray src1, InputArray src2, OutputArray dst)
 computes element-wise absolute difference of two arrays (dst = abs(src1 - src2)) More...
 
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) More...
 
void cv::compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop)
 compares elements of two arrays (dst = src1 <cmpop> src2) More...
 
void cv::min (InputArray src1, InputArray src2, OutputArray dst)
 computes per-element minimum of two arrays (dst = min(src1, src2)) More...
 
void cv::max (InputArray src1, InputArray src2, OutputArray dst)
 computes per-element maximum of two arrays (dst = max(src1, src2)) More...
 
void cv::min (const Mat &src1, const Mat &src2, Mat &dst)
 computes per-element minimum of two arrays (dst = min(src1, src2)) More...
 
void cv::min (const Mat &src1, double src2, Mat &dst)
 computes per-element minimum of array and scalar (dst = min(src1, src2)) More...
 
void cv::max (const Mat &src1, const Mat &src2, Mat &dst)
 computes per-element maximum of two arrays (dst = max(src1, src2)) More...
 
void cv::max (const Mat &src1, double src2, Mat &dst)
 computes per-element maximum of array and scalar (dst = max(src1, src2)) More...
 
void cv::sqrt (InputArray src, OutputArray dst)
 computes square root of each matrix element (dst = src**0.5) More...
 
void cv::pow (InputArray src, double power, OutputArray dst)
 raises the input matrix elements to the specified power (b = a**power) More...
 
void cv::exp (InputArray src, OutputArray dst)
 computes exponent of each matrix element (dst = e**src) More...
 
void cv::log (InputArray src, OutputArray dst)
 computes natural logarithm of absolute value of each matrix element: dst = log(abs(src)) More...
 
float cv::cubeRoot (float val)
 computes cube root of the argument More...
 
float cv::fastAtan2 (float y, float x)
 computes the angle in degrees (0..360) of the vector (x,y) More...
 
void cv::exp (const float *src, float *dst, int n)
 
void cv::log (const float *src, float *dst, int n)
 
void cv::fastAtan2 (const float *y, const float *x, float *dst, int n, bool angleInDegrees)
 
void cv::magnitude (const float *x, const float *y, float *dst, int n)
 
void cv::polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
 converts polar coordinates to Cartesian More...
 
void cv::cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
 converts Cartesian coordinates to polar More...
 
void cv::phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
 computes angle (angle(i)) of each (x(i), y(i)) vector More...
 
void cv::magnitude (InputArray x, InputArray y, OutputArray magnitude)
 computes magnitude (magnitude(i)) of each (x(i), y(i)) vector More...
 
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. More...
 
void cv::patchNaNs (InputOutputArray a, double val=0)
 converts NaN's to the given number More...
 
void cv::gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0)
 implements generalized matrix product algorithm GEMM from BLAS More...
 
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 More...
 
void cv::transpose (InputArray src, OutputArray dst)
 transposes the matrix More...
 
void cv::transform (InputArray src, OutputArray dst, InputArray m)
 performs affine transformation of each element of multi-channel input matrix More...
 
void cv::perspectiveTransform (InputArray src, OutputArray dst, InputArray m)
 performs perspective transformation of each element of multi-channel input matrix More...
 
void cv::completeSymm (InputOutputArray mtx, bool lowerToUpper=false)
 extends the symmetrical matrix from the lower half or from the upper half More...
 
void cv::setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1))
 initializes scaled identity matrix More...
 
double cv::determinant (InputArray mtx)
 computes determinant of a square matrix More...
 
Scalar cv::trace (InputArray mtx)
 computes trace of a matrix More...
 
double cv::invert (InputArray src, OutputArray dst, int flags=DECOMP_LU)
 computes inverse or pseudo-inverse matrix More...
 
bool cv::solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
 solves linear system or a least-square problem More...
 
void cv::sort (InputArray src, OutputArray dst, int flags)
 sorts independently each matrix row or each matrix column More...
 
void cv::sortIdx (InputArray src, OutputArray dst, int flags)
 sorts independently each matrix row or each matrix column More...
 
int cv::solveCubic (InputArray coeffs, OutputArray roots)
 finds real roots of a cubic polynomial More...
 
double cv::solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300)
 finds real and complex roots of a polynomial More...
 
bool cv::eigen (InputArray src, OutputArray eigenvalues, int lowindex=-1, int highindex=-1)
 finds eigenvalues of a symmetric matrix More...
 
bool cv::eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors, int lowindex=-1, int highindex=-1)
 finds eigenvalues and eigenvectors of a symmetric matrix More...
 
bool cv::eigen (InputArray src, bool computeEigenvectors, OutputArray eigenvalues, OutputArray eigenvectors)
 
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 More...
 
void cv::calcCovarMatrix (InputArray samples, OutputArray covar, OutputArray mean, int flags, int ctype=CV_64F)
 computes covariation matrix of a set of samples More...
 
void cv::PCACompute (InputArray data, CV_OUT InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0)
 
void cv::PCAComputeVar (InputArray data, CV_OUT InputOutputArray mean, OutputArray eigenvectors, double retainedVariance)
 
void cv::PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
 
void cv::PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
 
void cv::SVDecomp (InputArray src, CV_OUT OutputArray w, CV_OUT OutputArray u, CV_OUT OutputArray vt, int flags=0)
 computes SVD of src More...
 
void cv::SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, CV_OUT OutputArray dst)
 performs back substitution for the previously computed SVD More...
 
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 More...
 
double cv::Mahalonobis (InputArray v1, InputArray v2, InputArray icovar)
 a synonym for Mahalanobis More...
 
void cv::dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
 performs forward or inverse 1D or 2D Discrete Fourier Transformation More...
 
void cv::idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
 performs inverse 1D or 2D Discrete Fourier Transformation More...
 
void cv::dct (InputArray src, OutputArray dst, int flags=0)
 performs forward or inverse 1D or 2D Discrete Cosine Transformation More...
 
void cv::idct (InputArray src, OutputArray dst, int flags=0)
 performs inverse 1D or 2D Discrete Cosine Transformation More...
 
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 More...
 
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 More...
 
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 More...
 
RNG & cv::theRNG ()
 returns the thread-local Random number generator More...
 
void cv::setRNGSeed (int seed)
 sets state of the thread-local Random number generator More...
 
void cv::randu (InputOutputArray dst, InputArray low, InputArray high)
 fills array with uniformly-distributed random numbers from the range [low, high) More...
 
void cv::randn (InputOutputArray dst, InputArray mean, InputArray stddev)
 fills array with normally-distributed random numbers with the specified mean and the standard deviation More...
 
void cv::randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0)
 shuffles the input array elements More...
 
 cv::CV_EXPORTS_AS (randShuffle) void randShuffle_(InputOutputArray dst
 
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 More...
 
void cv::arrowedLine (CV_IN_OUT Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int line_type=8, int shift=0, double tipLength=0.1)
 draws an arrow from pt1 to pt2 in the image More...
 
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 More...
 
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 More...
 
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 More...
 
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 More...
 
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 More...
 
void cv::drawMarker (CV_IN_OUT Mat &img, Point position, const Scalar &color, int markerType=MARKER_CROSS, int markerSize=20, int thickness=1, int line_type=8)
 Draws a marker on a predefined position in an image. More...
 
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 More...
 
void cv::fillConvexPoly (InputOutputArray img, InputArray points, const Scalar &color, int lineType=8, int shift=0)
 
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 More...
 
void cv::fillPoly (InputOutputArray img, InputArrayOfArrays pts, const Scalar &color, int lineType=8, int shift=0, Point offset=Point())
 
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 More...
 
void cv::polylines (InputOutputArray img, InputArrayOfArrays pts, bool isClosed, const Scalar &color, int thickness=1, int lineType=8, int shift=0)
 
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) More...
 
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 More...
 
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 More...
 
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 More...
 
Size cv::getTextSize (const string &text, int fontFace, double fontScale, int thickness, CV_OUT int *baseLine)
 returns bounding box of the text string More...
 
ConvertData cv::getConvertElem (int fromType, int toType)
 returns the function for converting pixels from one data type to another More...
 
ConvertScaleData cv::getConvertScaleElem (int fromType, int toType)
 returns the function for converting pixels from one data type to another with the optional scaling More...
 
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 More...
 
double cv::norm (const SparseMat &src, int normType)
 computes norm of a sparse matrix More...
 
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 More...
 
template<>
std::string cv::CommandLineParser::analyzeValue< std::string > (const std::string &str, bool space_delete)
 
void cv::parallel_for_ (const Range &range, const ParallelLoopBody &body, double nstripes=-1.)
 

Variables

double cv::iterFactor =1.)
 

Macro Definition Documentation

§ CV_Assert

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

§ CV_DbgAssert

#define CV_DbgAssert (   expr)

§ CV_Error

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

§ CV_Error_

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

§ CV_Func

#define CV_Func   ""