|
template<> |
uchar | saturate_cast< uchar > (schar v) |
|
template<> |
uchar | saturate_cast< uchar > (ushort v) |
|
template<> |
uchar | saturate_cast< uchar > (int v) |
|
template<> |
uchar | saturate_cast< uchar > (short v) |
|
template<> |
uchar | saturate_cast< uchar > (unsigned v) |
|
template<> |
uchar | saturate_cast< uchar > (float v) |
|
template<> |
uchar | saturate_cast< uchar > (double v) |
|
template<> |
schar | saturate_cast< schar > (uchar v) |
|
template<> |
schar | saturate_cast< schar > (ushort v) |
|
template<> |
schar | saturate_cast< schar > (int v) |
|
template<> |
schar | saturate_cast< schar > (short v) |
|
template<> |
schar | saturate_cast< schar > (unsigned v) |
|
template<> |
schar | saturate_cast< schar > (float v) |
|
template<> |
schar | saturate_cast< schar > (double v) |
|
template<> |
ushort | saturate_cast< ushort > (schar v) |
|
template<> |
ushort | saturate_cast< ushort > (short v) |
|
template<> |
ushort | saturate_cast< ushort > (int v) |
|
template<> |
ushort | saturate_cast< ushort > (unsigned v) |
|
template<> |
ushort | saturate_cast< ushort > (float v) |
|
template<> |
ushort | saturate_cast< ushort > (double v) |
|
template<> |
short | saturate_cast< short > (ushort v) |
|
template<> |
short | saturate_cast< short > (int v) |
|
template<> |
short | saturate_cast< short > (unsigned v) |
|
template<> |
short | saturate_cast< short > (float v) |
|
template<> |
short | saturate_cast< short > (double v) |
|
template<> |
int | saturate_cast< int > (float v) |
|
template<> |
int | saturate_cast< int > (double v) |
|
template<> |
unsigned | saturate_cast< unsigned > (float v) |
|
template<> |
unsigned | saturate_cast< unsigned > (double v) |
|
int | fast_abs (uchar v) |
|
int | fast_abs (schar v) |
|
int | fast_abs (ushort v) |
|
int | fast_abs (short v) |
|
int | fast_abs (int v) |
|
float | fast_abs (float v) |
|
double | fast_abs (double v) |
|
int | LU (float *A, size_t astep, int m, float *b, size_t bstep, int n) |
|
int | LU (double *A, size_t astep, int m, double *b, size_t bstep, int n) |
|
bool | Cholesky (float *A, size_t astep, int m, float *b, size_t bstep, int n) |
|
bool | Cholesky (double *A, size_t astep, int m, double *b, size_t bstep, int n) |
|
float | normL2Sqr_ (const float *a, const float *b, int n) |
|
float | normL1_ (const float *a, const float *b, int n) |
|
int | normL1_ (const uchar *a, const uchar *b, int n) |
|
int | normHamming (const uchar *a, const uchar *b, int n) |
|
int | normHamming (const uchar *a, const uchar *b, int n, int cellSize) |
|
template<> |
float | normL2Sqr (const float *a, const float *b, int n) |
|
template<> |
float | normL1 (const float *a, const float *b, int n) |
|
template<> |
int | normL1 (const uchar *a, const uchar *b, int n) |
|
template<typename _Tp > |
Vec< _Tp, 2 > | conjugate (const Vec< _Tp, 2 > &v) |
|
template<typename _Tp > |
Vec< _Tp, 4 > | conjugate (const Vec< _Tp, 4 > &v) |
|
template<typename _Tp > |
Vec< _Tp, 4 > | operator* (const Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2) |
|
template<typename _Tp > |
Vec< _Tp, 4 > & | operator*= (Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2) |
|
template<typename _Tp , int cn> |
Vec< _Tp, cn > | normalize (const Vec< _Tp, cn > &v) |
|
template<typename _Tp > |
DataType< _Tp >::work_type | dot (const Vector< _Tp > &v1, const Vector< _Tp > &v2) |
|
template<typename T > |
Ptr< T > | makePtr () |
|
template<typename T , typename A1 > |
Ptr< T > | makePtr (const A1 &a1) |
|
template<typename T , typename A1 , typename A2 > |
Ptr< T > | makePtr (const A1 &a1, const A2 &a2) |
|
template<typename T , typename A1 , typename A2 , typename A3 > |
Ptr< T > | makePtr (const A1 &a1, const A2 &a2, const A3 &a3) |
|
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 > |
Ptr< T > | 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 > | 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 > | 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 > | 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 > | 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 > | 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 > | 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) |
|
void | write (FileStorage &fs, const string &name, int value) |
|
void | write (FileStorage &fs, const string &name, float value) |
|
void | write (FileStorage &fs, const string &name, double value) |
|
void | write (FileStorage &fs, const string &name, const string &value) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const _Tp &value) |
|
void | writeScalar (FileStorage &fs, int value) |
|
void | writeScalar (FileStorage &fs, float value) |
|
void | writeScalar (FileStorage &fs, double value) |
|
void | writeScalar (FileStorage &fs, const string &value) |
|
template<> |
void | write (FileStorage &fs, const int &value) |
|
template<> |
void | write (FileStorage &fs, const float &value) |
|
template<> |
void | write (FileStorage &fs, const double &value) |
|
template<> |
void | write (FileStorage &fs, const string &value) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const Point_< _Tp > &pt) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const Point3_< _Tp > &pt) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const Size_< _Tp > &sz) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const Complex< _Tp > &c) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const Rect_< _Tp > &r) |
|
template<typename _Tp , int cn> |
void | write (FileStorage &fs, const Vec< _Tp, cn > &v) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const Scalar_< _Tp > &s) |
|
void | write (FileStorage &fs, const Range &r) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const string &name, const Point_< _Tp > &pt) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const string &name, const Point3_< _Tp > &pt) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const string &name, const Size_< _Tp > &sz) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const string &name, const Complex< _Tp > &c) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const string &name, const Rect_< _Tp > &r) |
|
template<typename _Tp , int cn> |
void | write (FileStorage &fs, const string &name, const Vec< _Tp, cn > &v) |
|
template<typename _Tp > |
void | write (FileStorage &fs, const string &name, const Scalar_< _Tp > &s) |
|
void | write (FileStorage &fs, const string &name, const Range &r) |
|
void | write (FileStorage &fs, const string &name, const Mat &value) |
|
void | write (FileStorage &fs, const string &name, const SparseMat &value) |
|
FileStorage & | operator<< (FileStorage &fs, const string &str) |
|
void | read (const FileNode &node, Mat &mat, const Mat &default_mat=Mat()) |
|
void | read (const FileNode &node, SparseMat &mat, const SparseMat &default_mat=SparseMat()) |
|
template<typename _Tp , class _LT > |
void | sort (vector< _Tp > &vec, _LT LT=_LT()) |
|
template<typename _Tp , class _EqPredicate > |
int | partition (const vector< _Tp > &_vec, vector< int > &labels, _EqPredicate predicate=_EqPredicate()) |
|
schar * | seqPush (CvSeq *seq, const void *element=0) |
|
schar * | seqPushFront (CvSeq *seq, const void *element=0) |
|
void | seqPop (CvSeq *seq, void *element=0) |
|
void | seqPopFront (CvSeq *seq, void *element=0) |
|
void | seqPopMulti (CvSeq *seq, void *elements, int count, int in_front=0) |
|
void | seqRemove (CvSeq *seq, int index) |
|
void | clearSeq (CvSeq *seq) |
|
schar * | getSeqElem (const CvSeq *seq, int index) |
|
void | seqRemoveSlice (CvSeq *seq, CvSlice slice) |
|
void | seqInsertSlice (CvSeq *seq, int before_index, const CvArr *from_arr) |
|
template<typename _Tp > |
ptrdiff_t | operator- (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b) |
|
template<typename _Tp > |
bool | operator== (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b) |
|
template<typename _Tp > |
bool | operator!= (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b) |
|
template<typename _Tp , int m, int n> |
std::ostream & | operator<< (std::ostream &out, const Matx< _Tp, m, n > &matx) |
|
template<typename _Tp > |
std::ostream & | operator<< (std::ostream &out, const Point_< _Tp > &p) |
|
template<typename _Tp > |
std::ostream & | operator<< (std::ostream &out, const Point3_< _Tp > &p) |
|
template<typename _Tp , int n> |
std::ostream & | operator<< (std::ostream &out, const Vec< _Tp, n > &vec) |
|
template<typename _Tp > |
std::ostream & | operator<< (std::ostream &out, const Size_< _Tp > &size) |
|
template<typename _Tp > |
std::ostream & | operator<< (std::ostream &out, const Rect_< _Tp > &rect) |
|
template<typename T1 , typename T2 , typename Op > |
void | process (const Mat_< T1 > &m1, Mat_< T2 > &m2, Op op) |
|
template<typename T1 , typename T2 , typename T3 , typename Op > |
void | process (const Mat_< T1 > &m1, const Mat_< T2 > &m2, Mat_< T3 > &m3, Op op) |
|
MatExpr | operator+ (const Mat &a, const Mat &b) |
|
MatExpr | operator+ (const Mat &a, const Scalar &s) |
|
MatExpr | operator+ (const Scalar &s, const Mat &a) |
|
MatExpr | operator+ (const MatExpr &e, const Mat &m) |
|
MatExpr | operator+ (const Mat &m, const MatExpr &e) |
|
MatExpr | operator+ (const MatExpr &e, const Scalar &s) |
|
MatExpr | operator+ (const Scalar &s, const MatExpr &e) |
|
MatExpr | operator+ (const MatExpr &e1, const MatExpr &e2) |
|
MatExpr | operator- (const Mat &a, const Mat &b) |
|
MatExpr | operator- (const Mat &a, const Scalar &s) |
|
MatExpr | operator- (const Scalar &s, const Mat &a) |
|
MatExpr | operator- (const MatExpr &e, const Mat &m) |
|
MatExpr | operator- (const Mat &m, const MatExpr &e) |
|
MatExpr | operator- (const MatExpr &e, const Scalar &s) |
|
MatExpr | operator- (const Scalar &s, const MatExpr &e) |
|
MatExpr | operator- (const MatExpr &e1, const MatExpr &e2) |
|
MatExpr | operator- (const Mat &m) |
|
MatExpr | operator- (const MatExpr &e) |
|
MatExpr | operator* (const Mat &a, const Mat &b) |
|
MatExpr | operator* (const Mat &a, double s) |
|
MatExpr | operator* (double s, const Mat &a) |
|
MatExpr | operator* (const MatExpr &e, const Mat &m) |
|
MatExpr | operator* (const Mat &m, const MatExpr &e) |
|
MatExpr | operator* (const MatExpr &e, double s) |
|
MatExpr | operator* (double s, const MatExpr &e) |
|
MatExpr | operator* (const MatExpr &e1, const MatExpr &e2) |
|
MatExpr | operator/ (const Mat &a, const Mat &b) |
|
MatExpr | operator/ (const Mat &a, double s) |
|
MatExpr | operator/ (double s, const Mat &a) |
|
MatExpr | operator/ (const MatExpr &e, const Mat &m) |
|
MatExpr | operator/ (const Mat &m, const MatExpr &e) |
|
MatExpr | operator/ (const MatExpr &e, double s) |
|
MatExpr | operator/ (double s, const MatExpr &e) |
|
MatExpr | operator/ (const MatExpr &e1, const MatExpr &e2) |
|
MatExpr | operator< (const Mat &a, const Mat &b) |
|
MatExpr | operator< (const Mat &a, double s) |
|
MatExpr | operator< (double s, const Mat &a) |
|
MatExpr | operator<= (const Mat &a, const Mat &b) |
|
MatExpr | operator<= (const Mat &a, double s) |
|
MatExpr | operator<= (double s, const Mat &a) |
|
MatExpr | operator== (const Mat &a, const Mat &b) |
|
MatExpr | operator== (const Mat &a, double s) |
|
MatExpr | operator== (double s, const Mat &a) |
|
MatExpr | operator!= (const Mat &a, const Mat &b) |
|
MatExpr | operator!= (const Mat &a, double s) |
|
MatExpr | operator!= (double s, const Mat &a) |
|
MatExpr | operator>= (const Mat &a, const Mat &b) |
|
MatExpr | operator>= (const Mat &a, double s) |
|
MatExpr | operator>= (double s, const Mat &a) |
|
MatExpr | operator> (const Mat &a, const Mat &b) |
|
MatExpr | operator> (const Mat &a, double s) |
|
MatExpr | operator> (double s, const Mat &a) |
|
MatExpr | min (const Mat &a, const Mat &b) |
|
MatExpr | min (const Mat &a, double s) |
|
MatExpr | min (double s, const Mat &a) |
|
MatExpr | max (const Mat &a, const Mat &b) |
|
MatExpr | max (const Mat &a, double s) |
|
MatExpr | max (double s, const Mat &a) |
|
MatExpr | operator& (const Mat &a, const Mat &b) |
|
MatExpr | operator& (const Mat &a, const Scalar &s) |
|
MatExpr | operator& (const Scalar &s, const Mat &a) |
|
MatExpr | operator| (const Mat &a, const Mat &b) |
|
MatExpr | operator| (const Mat &a, const Scalar &s) |
|
MatExpr | operator| (const Scalar &s, const Mat &a) |
|
MatExpr | operator^ (const Mat &a, const Mat &b) |
|
MatExpr | operator^ (const Mat &a, const Scalar &s) |
|
MatExpr | operator^ (const Scalar &s, const Mat &a) |
|
MatExpr | operator~ (const Mat &m) |
|
MatExpr | abs (const Mat &m) |
|
MatExpr | abs (const MatExpr &e) |
|
template<typename _Tp > |
void | split (const Mat &src, vector< Mat_< _Tp > > &mv) |
|
ptrdiff_t | operator- (const MatConstIterator &b, const MatConstIterator &a) |
|
const char * | currentParallelFramework () |
|
void | render (const GlTexture &tex, Rect_< double > wndRect=Rect_< double >(0.0, 0.0, 1.0, 1.0), Rect_< double > texRect=Rect_< double >(0.0, 0.0, 1.0, 1.0)) |
| render functions More...
|
|
void | render (const GlArrays &arr, int mode=RenderMode::POINTS, Scalar color=Scalar::all(255)) |
| render OpenGL arrays More...
|
|
void | render (const std::string &str, const Ptr< GlFont > &font, Scalar color, Point2d pos) |
|
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols> |
void | eigen2cv (const Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &src, Mat &dst) |
|
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols> |
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst) |
|
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols> |
void | cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst) |
|
template<typename _Tp > |
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst) |
|
template<typename _Tp , int _rows, int _cols> |
void | cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst) |
|
template<typename _Tp > |
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst) |
|
template<typename _Tp , int _rows> |
void | cv2eigen (const Matx< _Tp, _rows, 1 > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst) |
|
template<typename _Tp > |
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst) |
|
template<typename _Tp , int _cols> |
void | cv2eigen (const Matx< _Tp, 1, _cols > &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst) |
|
string | fromUtf16 (const WString &str) |
|
WString | toUtf16 (const string &str) |
|
string | format (const char *fmt,...) |
|
string | tempfile (const char *suffix CV_DEFAULT(0)) |
|
void | error (const Exception &exc) |
| Signals an error and raises the exception. More...
|
|
bool | setBreakOnError (bool flag) |
| Sets/resets the break-on-error mode. More...
|
|
ErrorCallback | redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0) |
| Sets the new error handler and the optional user data. More...
|
|
void | glob (String pattern, std::vector< String > &result, bool recursive=false) |
|
void | setNumThreads (int nthreads) |
|
int | getNumThreads () |
|
int | getThreadNum () |
|
const string & | getBuildInformation () |
|
int64 | getTickCount () |
| Returns the number of ticks. More...
|
|
double | getTickFrequency () |
|
int64 | getCPUTickCount () |
|
bool | checkHardwareSupport (int feature) |
|
int | getNumberOfCPUs () |
| returns the number of CPUs (including hyper-threading) More...
|
|
void * | fastMalloc (size_t bufSize) |
|
void | fastFree (void *ptr) |
|
void | setUseOptimized (bool onoff) |
|
bool | useOptimized () |
|
void | scalarToRawData (const Scalar &s, void *buf, int type, int unroll_to=0) |
|
OutputArray | noArray () |
|
BinaryFunc | getConvertFunc (int sdepth, int ddepth) |
|
BinaryFunc | getConvertScaleFunc (int sdepth, int ddepth) |
|
BinaryFunc | getCopyMaskFunc (size_t esz) |
|
void | swap (Mat &a, Mat &b) |
| swaps two matrices More...
|
|
Mat | cvarrToMat (const CvArr *arr, bool copyData=false, bool allowND=true, int coiMode=0) |
| converts array (CvMat or IplImage) to cv::Mat More...
|
|
void | 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 | insertImageCOI (InputArray coiimg, CvArr *arr, int coi=-1) |
| inserts single-channel cv::Mat into a multi-channel CvMat or IplImage More...
|
|
void | add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) |
| adds one matrix to another (dst = src1 + src2) More...
|
|
void | subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) |
| subtracts one matrix from another (dst = src1 - src2) More...
|
|
void | 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 | 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 | divide (double scale, InputArray src2, OutputArray dst, int dtype=-1) |
| computes element-wise weighted reciprocal of an array (dst = scale/src2) More...
|
|
void | scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst) |
| adds scaled array to another one (dst = alpha*src1 + src2) More...
|
|
void | 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 | 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 | 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_EXPORTS_AS (sumElems) Scalar sum(InputArray src) |
| computes sum of array elements More...
|
|
int | countNonZero (InputArray src) |
| computes the number of nonzero array elements More...
|
|
void | findNonZero (InputArray src, OutputArray idx) |
| returns the list of locations of non-zero pixels More...
|
|
Scalar | mean (InputArray src, InputArray mask=noArray()) |
| computes mean value of selected array elements More...
|
|
void | meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray()) |
| computes mean value and standard deviation of all or selected array elements More...
|
|
double | norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray()) |
| computes norm of the selected array part More...
|
|
double | 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 | 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 | 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 | 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 | minMaxIdx (InputArray src, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray()) |
|
void | 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 | merge (const Mat *mv, size_t count, OutputArray dst) |
| makes multi-channel array out of several single-channel arrays More...
|
|
void | merge (const vector< Mat > &mv, OutputArray dst) |
|
void | merge (InputArrayOfArrays mv, OutputArray dst) |
| makes multi-channel array out of several single-channel arrays More...
|
|
void | split (const Mat &src, Mat *mvbegin) |
| copies each plane of a multi-channel array to a dedicated array More...
|
|
void | split (const Mat &m, vector< Mat > &mv) |
|
void | split (InputArray m, OutputArrayOfArrays mv) |
| copies each plane of a multi-channel array to a dedicated array More...
|
|
void | 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 | mixChannels (const vector< Mat > &src, vector< Mat > &dst, const int *fromTo, size_t npairs) |
|
void | mixChannels (InputArrayOfArrays src, InputArrayOfArrays dst, const vector< int > &fromTo) |
|
void | extractChannel (InputArray src, OutputArray dst, int coi) |
| extracts a single channel from src (coi is 0-based index) More...
|
|
void | insertChannel (InputArray src, InputOutputArray dst, int coi) |
| inserts a single channel to dst (coi is 0-based index) More...
|
|
void | flip (InputArray src, OutputArray dst, int flipCode) |
| reverses the order of the rows, columns or both in a matrix More...
|
|
void | 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 | repeat (const Mat &src, int ny, int nx) |
|
void | hconcat (const Mat *src, size_t nsrc, OutputArray dst) |
|
void | hconcat (InputArray src1, InputArray src2, OutputArray dst) |
|
void | hconcat (InputArrayOfArrays src, OutputArray dst) |
|
void | vconcat (const Mat *src, size_t nsrc, OutputArray dst) |
|
void | vconcat (InputArray src1, InputArray src2, OutputArray dst) |
|
void | vconcat (InputArrayOfArrays src, OutputArray dst) |
|
void | bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) |
| computes bitwise conjunction of the two arrays (dst = src1 & src2) More...
|
|
void | bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) |
| computes bitwise disjunction of the two arrays (dst = src1 | src2) More...
|
|
void | bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) |
| computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2) More...
|
|
void | bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray()) |
| inverts each bit of array (dst = ~src) More...
|
|
void | absdiff (InputArray src1, InputArray src2, OutputArray dst) |
| computes element-wise absolute difference of two arrays (dst = abs(src1 - src2)) More...
|
|
void | 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 | compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop) |
| compares elements of two arrays (dst = src1 <cmpop> src2) More...
|
|
void | min (InputArray src1, InputArray src2, OutputArray dst) |
| computes per-element minimum of two arrays (dst = min(src1, src2)) More...
|
|
void | max (InputArray src1, InputArray src2, OutputArray dst) |
| computes per-element maximum of two arrays (dst = max(src1, src2)) More...
|
|
void | min (const Mat &src1, const Mat &src2, Mat &dst) |
| computes per-element minimum of two arrays (dst = min(src1, src2)) More...
|
|
void | min (const Mat &src1, double src2, Mat &dst) |
| computes per-element minimum of array and scalar (dst = min(src1, src2)) More...
|
|
void | max (const Mat &src1, const Mat &src2, Mat &dst) |
| computes per-element maximum of two arrays (dst = max(src1, src2)) More...
|
|
void | max (const Mat &src1, double src2, Mat &dst) |
| computes per-element maximum of array and scalar (dst = max(src1, src2)) More...
|
|
void | sqrt (InputArray src, OutputArray dst) |
| computes square root of each matrix element (dst = src**0.5) More...
|
|
void | pow (InputArray src, double power, OutputArray dst) |
| raises the input matrix elements to the specified power (b = a**power) More...
|
|
void | exp (InputArray src, OutputArray dst) |
| computes exponent of each matrix element (dst = e**src) More...
|
|
void | log (InputArray src, OutputArray dst) |
| computes natural logarithm of absolute value of each matrix element: dst = log(abs(src)) More...
|
|
float | cubeRoot (float val) |
| computes cube root of the argument More...
|
|
float | fastAtan2 (float y, float x) |
| computes the angle in degrees (0..360) of the vector (x,y) More...
|
|
void | exp (const float *src, float *dst, int n) |
|
void | log (const float *src, float *dst, int n) |
|
void | fastAtan2 (const float *y, const float *x, float *dst, int n, bool angleInDegrees) |
|
void | magnitude (const float *x, const float *y, float *dst, int n) |
|
void | polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false) |
| converts polar coordinates to Cartesian More...
|
|
void | cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false) |
| converts Cartesian coordinates to polar More...
|
|
void | phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false) |
| computes angle (angle(i)) of each (x(i), y(i)) vector More...
|
|
void | magnitude (InputArray x, InputArray y, OutputArray magnitude) |
| computes magnitude (magnitude(i)) of each (x(i), y(i)) vector More...
|
|
bool | 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 | patchNaNs (InputOutputArray a, double val=0) |
| converts NaN's to the given number More...
|
|
void | 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 | 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 | transpose (InputArray src, OutputArray dst) |
| transposes the matrix More...
|
|
void | transform (InputArray src, OutputArray dst, InputArray m) |
| performs affine transformation of each element of multi-channel input matrix More...
|
|
void | perspectiveTransform (InputArray src, OutputArray dst, InputArray m) |
| performs perspective transformation of each element of multi-channel input matrix More...
|
|
void | completeSymm (InputOutputArray mtx, bool lowerToUpper=false) |
| extends the symmetrical matrix from the lower half or from the upper half More...
|
|
void | setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1)) |
| initializes scaled identity matrix More...
|
|
double | determinant (InputArray mtx) |
| computes determinant of a square matrix More...
|
|
Scalar | trace (InputArray mtx) |
| computes trace of a matrix More...
|
|
double | invert (InputArray src, OutputArray dst, int flags=DECOMP_LU) |
| computes inverse or pseudo-inverse matrix More...
|
|
bool | solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU) |
| solves linear system or a least-square problem More...
|
|
void | sort (InputArray src, OutputArray dst, int flags) |
| sorts independently each matrix row or each matrix column More...
|
|
void | sortIdx (InputArray src, OutputArray dst, int flags) |
| sorts independently each matrix row or each matrix column More...
|
|
int | solveCubic (InputArray coeffs, OutputArray roots) |
| finds real roots of a cubic polynomial More...
|
|
double | solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300) |
| finds real and complex roots of a polynomial More...
|
|
bool | eigen (InputArray src, OutputArray eigenvalues, int lowindex=-1, int highindex=-1) |
| finds eigenvalues of a symmetric matrix More...
|
|
bool | eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors, int lowindex=-1, int highindex=-1) |
| finds eigenvalues and eigenvectors of a symmetric matrix More...
|
|
bool | eigen (InputArray src, bool computeEigenvectors, OutputArray eigenvalues, OutputArray eigenvectors) |
|
void | 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 | calcCovarMatrix (InputArray samples, OutputArray covar, OutputArray mean, int flags, int ctype=CV_64F) |
| computes covariation matrix of a set of samples More...
|
|
void | PCACompute (InputArray data, CV_OUT InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0) |
|
void | PCAComputeVar (InputArray data, CV_OUT InputOutputArray mean, OutputArray eigenvectors, double retainedVariance) |
|
void | PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result) |
|
void | PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result) |
|
void | SVDecomp (InputArray src, CV_OUT OutputArray w, CV_OUT OutputArray u, CV_OUT OutputArray vt, int flags=0) |
| computes SVD of src More...
|
|
void | SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, CV_OUT OutputArray dst) |
| performs back substitution for the previously computed SVD More...
|
|
double | 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 | Mahalonobis (InputArray v1, InputArray v2, InputArray icovar) |
| a synonym for Mahalanobis More...
|
|
void | dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0) |
| performs forward or inverse 1D or 2D Discrete Fourier Transformation More...
|
|
void | idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0) |
| performs inverse 1D or 2D Discrete Fourier Transformation More...
|
|
void | dct (InputArray src, OutputArray dst, int flags=0) |
| performs forward or inverse 1D or 2D Discrete Cosine Transformation More...
|
|
void | idct (InputArray src, OutputArray dst, int flags=0) |
| performs inverse 1D or 2D Discrete Cosine Transformation More...
|
|
void | 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 | 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 | 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 & | theRNG () |
| returns the thread-local Random number generator More...
|
|
void | setRNGSeed (int seed) |
| sets state of the thread-local Random number generator More...
|
|
void | randu (InputOutputArray dst, InputArray low, InputArray high) |
| fills array with uniformly-distributed random numbers from the range [low, high) More...
|
|
void | randn (InputOutputArray dst, InputArray mean, InputArray stddev) |
| fills array with normally-distributed random numbers with the specified mean and the standard deviation More...
|
|
void | randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0) |
| shuffles the input array elements More...
|
|
| CV_EXPORTS_AS (randShuffle) void randShuffle_(InputOutputArray dst |
|
void | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | fillConvexPoly (InputOutputArray img, InputArray points, const Scalar &color, int lineType=8, int shift=0) |
|
void | 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 | fillPoly (InputOutputArray img, InputArrayOfArrays pts, const Scalar &color, int lineType=8, int shift=0, Point offset=Point()) |
|
void | 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 | polylines (InputOutputArray img, InputArrayOfArrays pts, bool isClosed, const Scalar &color, int thickness=1, int lineType=8, int shift=0) |
|
bool | 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 | 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 | 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 | 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 | getTextSize (const string &text, int fontFace, double fontScale, int thickness, CV_OUT int *baseLine) |
| returns bounding box of the text string More...
|
|
ConvertData | getConvertElem (int fromType, int toType) |
| returns the function for converting pixels from one data type to another More...
|
|
ConvertScaleData | getConvertScaleElem (int fromType, int toType) |
| returns the function for converting pixels from one data type to another with the optional scaling More...
|
|
void | 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 | norm (const SparseMat &src, int normType) |
| computes norm of a sparse matrix More...
|
|
void | 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 | CommandLineParser::analyzeValue< std::string > (const std::string &str, bool space_delete) |
|
void | parallel_for_ (const Range &range, const ParallelLoopBody &body, double nstripes=-1.) |
|
int | borderInterpolate (int p, int len, int borderType) |
| 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p. More...
|
|
int | getKernelType (InputArray kernel, Point anchor) |
| returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients. More...
|
|
Ptr< BaseRowFilter > | getLinearRowFilter (int srcType, int bufType, InputArray kernel, int anchor, int symmetryType) |
| returns the primitive row filter with the specified kernel More...
|
|
Ptr< BaseColumnFilter > | getLinearColumnFilter (int bufType, int dstType, InputArray kernel, int anchor, int symmetryType, double delta=0, int bits=0) |
| returns the primitive column filter with the specified kernel More...
|
|
Ptr< BaseFilter > | getLinearFilter (int srcType, int dstType, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0) |
| returns 2D filter with the specified kernel More...
|
|
Ptr< FilterEngine > | createSeparableLinearFilter (int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar &borderValue=Scalar()) |
| returns the separable linear filter engine More...
|
|
Ptr< FilterEngine > | createLinearFilter (int srcType, int dstType, InputArray kernel, Point _anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar &borderValue=Scalar()) |
| returns the non-separable linear filter engine More...
|
|
Mat | getGaussianKernel (int ksize, double sigma, int ktype=CV_64F) |
| returns the Gaussian kernel with the specified parameters More...
|
|
Ptr< FilterEngine > | createGaussianFilter (int type, Size ksize, double sigma1, double sigma2=0, int borderType=BORDER_DEFAULT) |
| returns the Gaussian filter engine More...
|
|
void | getDerivKernels (OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F) |
| initializes kernels of the generalized Sobel operator More...
|
|
Ptr< FilterEngine > | createDerivFilter (int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT) |
| returns filter engine for the generalized Sobel operator More...
|
|
Ptr< BaseRowFilter > | getRowSumFilter (int srcType, int sumType, int ksize, int anchor=-1) |
| returns horizontal 1D box filter More...
|
|
Ptr< BaseColumnFilter > | getColumnSumFilter (int sumType, int dstType, int ksize, int anchor=-1, double scale=1) |
| returns vertical 1D box filter More...
|
|
Ptr< FilterEngine > | createBoxFilter (int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT) |
| returns box filter engine More...
|
|
Mat | getGaborKernel (Size ksize, double sigma, double theta, double lambd, double gamma, double psi=CV_PI *0.5, int ktype=CV_64F) |
| returns the Gabor kernel with the specified parameters More...
|
|
Ptr< BaseRowFilter > | getMorphologyRowFilter (int op, int type, int ksize, int anchor=-1) |
| returns horizontal 1D morphological filter More...
|
|
Ptr< BaseColumnFilter > | getMorphologyColumnFilter (int op, int type, int ksize, int anchor=-1) |
| returns vertical 1D morphological filter More...
|
|
Ptr< BaseFilter > | getMorphologyFilter (int op, int type, InputArray kernel, Point anchor=Point(-1,-1)) |
| returns 2D morphological filter More...
|
|
Ptr< FilterEngine > | createMorphologyFilter (int op, int type, InputArray kernel, Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT, int columnBorderType=-1, const Scalar &borderValue=morphologyDefaultBorderValue()) |
| returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported. More...
|
|
Mat | getStructuringElement (int shape, Size ksize, Point anchor=Point(-1,-1)) |
| returns structuring element of the specified shape and size More...
|
|
void | copyMakeBorder (InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar()) |
| copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode More...
|
|
void | medianBlur (InputArray src, OutputArray dst, int ksize) |
| smooths the image using median filter. More...
|
|
void | GaussianBlur (InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT) |
| smooths the image using Gaussian filter. More...
|
|
void | bilateralFilter (InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT) |
| smooths the image using bilateral filter More...
|
|
void | adaptiveBilateralFilter (InputArray src, OutputArray dst, Size ksize, double sigmaSpace, double maxSigmaColor=20.0, Point anchor=Point(-1, -1), int borderType=BORDER_DEFAULT) |
| smooths the image using adaptive bilateral filter More...
|
|
void | boxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT) |
| smooths the image using the box filter. Each pixel is processed in O(1) time More...
|
|
void | blur (InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT) |
| a synonym for normalized box filter More...
|
|
void | filter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT) |
| applies non-separable 2D linear filter to the image More...
|
|
void | sepFilter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernelX, InputArray kernelY, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT) |
| applies separable 2D linear filter to the image More...
|
|
void | Sobel (InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
| applies generalized Sobel operator to the image More...
|
|
void | Scharr (InputArray src, OutputArray dst, int ddepth, int dx, int dy, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
| applies the vertical or horizontal Scharr operator to the image More...
|
|
void | Laplacian (InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
| applies Laplacian operator to the image More...
|
|
void | Canny (InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false) |
| applies Canny edge detector and produces the edge map. More...
|
|
void | cornerMinEigenVal (InputArray src, OutputArray dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT) |
| computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria More...
|
|
void | cornerHarris (InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT) |
| computes Harris cornerness criteria at each image pixel More...
|
|
void | eigen2x2 (const float *a, float *e, int n) |
|
void | cornerEigenValsAndVecs (InputArray src, OutputArray dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT) |
| computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix. More...
|
|
void | preCornerDetect (InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT) |
| computes another complex cornerness criteria at each pixel More...
|
|
void | cornerSubPix (InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria) |
| adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria More...
|
|
void | goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04) |
| finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima More...
|
|
void | HoughLines (InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0) |
| finds lines in the black-n-white image using the standard or pyramid Hough transform More...
|
|
void | HoughLinesP (InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0) |
| finds line segments in the black-n-white image using probabilistic Hough transform More...
|
|
void | HoughCircles (InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0) |
| finds circles in the grayscale image using 2+1 gradient Hough transform More...
|
|
void | erode (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue()) |
| erodes the image (applies the local minimum operator) More...
|
|
void | dilate (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue()) |
| dilates the image (applies the local maximum operator) More...
|
|
void | morphologyEx (InputArray src, OutputArray dst, int op, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue()) |
| applies an advanced morphological operation to the image More...
|
|
void | resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR) |
| resizes the image More...
|
|
void | warpAffine (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
| warps the image using affine transformation More...
|
|
void | warpPerspective (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
| warps the image using perspective transformation More...
|
|
void | remap (InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
| warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format More...
|
|
void | convertMaps (InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false) |
| converts maps for remap from floating-point to fixed-point format or backwards More...
|
|
Mat | getRotationMatrix2D (Point2f center, double angle, double scale) |
| returns 2x3 affine transformation matrix for the planar rotation. More...
|
|
Mat | getPerspectiveTransform (const Point2f src[], const Point2f dst[]) |
| returns 3x3 perspective transformation for the corresponding 4 point pairs. More...
|
|
Mat | getAffineTransform (const Point2f src[], const Point2f dst[]) |
| returns 2x3 affine transformation for the corresponding 3 point pairs. More...
|
|
void | invertAffineTransform (InputArray M, OutputArray iM) |
| computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation. More...
|
|
Mat | getPerspectiveTransform (InputArray src, InputArray dst) |
|
Mat | getAffineTransform (InputArray src, InputArray dst) |
|
void | getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1) |
| extracts rectangle from the image at sub-pixel location More...
|
|
void | integral (InputArray src, OutputArray sum, int sdepth=-1) |
| computes the integral image More...
|
|
| CV_EXPORTS_AS (integral2) void integral(InputArray src |
| computes the integral image and integral for the squared image More...
|
|
| CV_EXPORTS_AS (integral3) void integral(InputArray src |
| computes the integral image, integral for the squared image and the tilted integral image More...
|
|
void | accumulate (InputArray src, InputOutputArray dst, InputArray mask=noArray()) |
| adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types. More...
|
|
void | accumulateSquare (InputArray src, InputOutputArray dst, InputArray mask=noArray()) |
| adds squared src image to the accumulator (dst += src*src). More...
|
|
void | accumulateProduct (InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray()) |
| adds product of the 2 images to the accumulator (dst += src1*src2). More...
|
|
void | accumulateWeighted (InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray()) |
| updates the running average (dst = dst*(1-alpha) + src*alpha) More...
|
|
double | PSNR (InputArray src1, InputArray src2) |
| computes PSNR image/video quality metric More...
|
|
Point2d | phaseCorrelate (InputArray src1, InputArray src2, InputArray window=noArray()) |
|
Point2d | phaseCorrelateRes (InputArray src1, InputArray src2, InputArray window, CV_OUT double *response=0) |
|
void | createHanningWindow (OutputArray dst, Size winSize, int type) |
|
double | threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type) |
| applies fixed threshold to the image More...
|
|
void | adaptiveThreshold (InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) |
| applies variable (adaptive) threshold to the image More...
|
|
void | pyrDown (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT) |
| smooths and downsamples the image More...
|
|
void | pyrUp (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT) |
| upsamples and smoothes the image More...
|
|
void | buildPyramid (InputArray src, OutputArrayOfArrays dst, int maxlevel, int borderType=BORDER_DEFAULT) |
| builds the gaussian pyramid using pyrDown() as a basic operation More...
|
|
void | undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray()) |
| corrects lens distortion for the given camera matrix and distortion coefficients More...
|
|
void | initUndistortRectifyMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2) |
| initializes maps for cv::remap() to correct lens distortion and optionally rectify the image More...
|
|
float | initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType=PROJ_SPHERICAL_EQRECT, double alpha=0) |
| initializes maps for cv::remap() for wide-angle More...
|
|
Mat | getDefaultNewCameraMatrix (InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false) |
| returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true) More...
|
|
void | undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray()) |
| returns points' coordinates after lens distortion correction More...
|
|
void | calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, OutputArray hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false) |
| computes the joint dense histogram for a set of images. More...
|
|
void | calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, SparseMat &hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false) |
| computes the joint sparse histogram for a set of images. More...
|
|
void | calcHist (InputArrayOfArrays images, const vector< int > &channels, InputArray mask, OutputArray hist, const vector< int > &histSize, const vector< float > &ranges, bool accumulate=false) |
|
void | calcBackProject (const Mat *images, int nimages, const int *channels, InputArray hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true) |
| computes back projection for the set of images More...
|
|
void | calcBackProject (const Mat *images, int nimages, const int *channels, const SparseMat &hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true) |
| computes back projection for the set of images More...
|
|
void | calcBackProject (InputArrayOfArrays images, const vector< int > &channels, InputArray hist, OutputArray dst, const vector< float > &ranges, double scale) |
|
double | compareHist (InputArray H1, InputArray H2, int method) |
| compares two histograms stored in dense arrays More...
|
|
double | compareHist (const SparseMat &H1, const SparseMat &H2, int method) |
| compares two histograms stored in sparse arrays More...
|
|
void | equalizeHist (InputArray src, OutputArray dst) |
| normalizes the grayscale image brightness and contrast by normalizing its histogram More...
|
|
Ptr< CLAHE > | createCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8)) |
|
float | EMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float *lowerBound=0, OutputArray flow=noArray()) |
|
void | watershed (InputArray image, InputOutputArray markers) |
| segments the image using watershed algorithm More...
|
|
void | pyrMeanShiftFiltering (InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1)) |
| filters image using meanshift algorithm More...
|
|
void | grabCut (InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode=GC_EVAL) |
| segments the image using GrabCut algorithm More...
|
|
| CV_EXPORTS_AS (distanceTransformWithLabels) void distanceTransform(InputArray src |
| builds the discrete Voronoi diagram More...
|
|
void | distanceTransform (InputArray src, OutputArray dst, int distanceType, int maskSize) |
| computes the distance transform map More...
|
|
int | floodFill (InputOutputArray image, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4) |
| fills the semi-uniform image region starting from the specified seed point More...
|
|
int | floodFill (InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4) |
| fills the semi-uniform image region and/or the mask starting from the specified seed point More...
|
|
void | cvtColor (InputArray src, OutputArray dst, int code, int dstCn=0) |
| converts image from one color space to another More...
|
|
Moments | moments (InputArray array, bool binaryImage=false) |
| computes moments of the rasterized shape or a vector of points More...
|
|
void | HuMoments (const Moments &moments, double hu[7]) |
| computes 7 Hu invariants from the moments More...
|
|
void | HuMoments (const Moments &m, CV_OUT OutputArray hu) |
|
void | matchTemplate (InputArray image, InputArray templ, OutputArray result, int method) |
| computes the proximity map for the raster template and the image where the template is searched for More...
|
|
void | findContours (InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point()) |
| retrieves contours and the hierarchical information from black-n-white image. More...
|
|
void | findContours (InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point()) |
| retrieves contours from black-n-white image. More...
|
|
void | drawContours (InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar &color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point()) |
| draws contours in the image More...
|
|
void | approxPolyDP (InputArray curve, OutputArray approxCurve, double epsilon, bool closed) |
| approximates contour or a curve using Douglas-Peucker algorithm More...
|
|
double | arcLength (InputArray curve, bool closed) |
| computes the contour perimeter (closed=true) or a curve length More...
|
|
Rect | boundingRect (InputArray points) |
| computes the bounding rectangle for a contour More...
|
|
double | contourArea (InputArray contour, bool oriented=false) |
| computes the contour area More...
|
|
RotatedRect | minAreaRect (InputArray points) |
| computes the minimal rotated rectangle for a set of points More...
|
|
void | minEnclosingCircle (InputArray points, CV_OUT Point2f ¢er, CV_OUT float &radius) |
| computes the minimal enclosing circle for a set of points More...
|
|
double | matchShapes (InputArray contour1, InputArray contour2, int method, double parameter) |
| matches two contours using one of the available algorithms More...
|
|
void | convexHull (InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true) |
| computes convex hull for a set of 2D points. More...
|
|
void | convexityDefects (InputArray contour, InputArray convexhull, OutputArray convexityDefects) |
| computes the contour convexity defects More...
|
|
bool | isContourConvex (InputArray contour) |
| returns true if the contour is convex. Does not support contours with self-intersection More...
|
|
float | intersectConvexConvex (InputArray _p1, InputArray _p2, OutputArray _p12, bool handleNested=true) |
| finds intersection of two convex polygons More...
|
|
RotatedRect | fitEllipse (InputArray points) |
| fits ellipse to the set of 2D points More...
|
|
void | fitLine (InputArray points, OutputArray line, int distType, double param, double reps, double aeps) |
| fits line to the set of 2D points using M-estimator algorithm More...
|
|
double | pointPolygonTest (InputArray contour, Point2f pt, bool measureDist) |
| checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary More...
|
|
void | namedWindow (const string &winname, int flags=WINDOW_AUTOSIZE) |
|
void | destroyWindow (const string &winname) |
|
void | destroyAllWindows () |
|
int | startWindowThread () |
|
int | waitKey (int delay=0) |
|
void | imshow (const string &winname, InputArray mat) |
|
void | resizeWindow (const string &winname, int width, int height) |
|
void | moveWindow (const string &winname, int x, int y) |
|
void | setWindowProperty (const string &winname, int prop_id, double prop_value) |
|
double | getWindowProperty (const string &winname, int prop_id) |
|
void | setMouseCallback (const string &winname, MouseCallback onMouse, void *userdata=0) |
| assigns callback for mouse events More...
|
|
int | createTrackbar (const string &trackbarname, const string &winname, int *value, int count, TrackbarCallback onChange=0, void *userdata=0) |
|
int | getTrackbarPos (const string &trackbarname, const string &winname) |
|
void | setTrackbarPos (const string &trackbarname, const string &winname, int pos) |
|
void | setOpenGlDrawCallback (const string &winname, OpenGlDrawCallback onOpenGlDraw, void *userdata=0) |
|
void | setOpenGlContext (const string &winname) |
|
void | updateWindow (const string &winname) |
|
void | pointCloudShow (const string &winname, const GlCamera &camera, const GlArrays &arr) |
|
void | pointCloudShow (const string &winname, const GlCamera &camera, InputArray points, InputArray colors=noArray()) |
|
CvFont | fontQt (const string &nameFont, int pointSize=-1, Scalar color=Scalar::all(0), int weight=CV_FONT_NORMAL, int style=CV_STYLE_NORMAL, int spacing=0) |
|
void | addText (const Mat &img, const string &text, Point org, CvFont font) |
|
void | displayOverlay (const string &winname, const string &text, int delayms CV_DEFAULT(0)) |
|
void | displayStatusBar (const string &winname, const string &text, int delayms CV_DEFAULT(0)) |
|
void | saveWindowParameters (const string &windowName) |
|
void | loadWindowParameters (const string &windowName) |
|
int | startLoop (int(*pt2Func)(int argc, char *argv[]), int argc, char *argv[]) |
|
void | stopLoop () |
|
int | createButton (const string &bar_name, ButtonCallback on_change, void *userdata=NULL, int type=CV_PUSH_BUTTON, bool initial_button_state=0) |
|
Mat | imread (const string &filename, int flags=1) |
|
bool | imwrite (const string &filename, InputArray img, const vector< int > ¶ms=vector< int >()) |
|
Mat | imdecode (InputArray buf, int flags) |
|
Mat | imdecode (InputArray buf, int flags, Mat *dst) |
|
bool | imencode (const string &ext, InputArray img, CV_OUT vector< uchar > &buf, const vector< int > ¶ms=vector< int >()) |
|
void | updateMotionHistory (InputArray silhouette, InputOutputArray mhi, double timestamp, double duration) |
| updates motion history image using the current silhouette More...
|
|
void | calcMotionGradient (InputArray mhi, OutputArray mask, OutputArray orientation, double delta1, double delta2, int apertureSize=3) |
| computes the motion gradient orientation image from the motion history image More...
|
|
double | calcGlobalOrientation (InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration) |
| computes the global orientation of the selected motion history image part More...
|
|
void | segmentMotion (InputArray mhi, OutputArray segmask, CV_OUT vector< Rect > &boundingRects, double timestamp, double segThresh) |
|
RotatedRect | CamShift (InputArray probImage, CV_OUT CV_IN_OUT Rect &window, TermCriteria criteria) |
| updates the object tracking window using CAMSHIFT algorithm More...
|
|
int | meanShift (InputArray probImage, CV_OUT CV_IN_OUT Rect &window, TermCriteria criteria) |
| updates the object tracking window using meanshift algorithm More...
|
|
int | buildOpticalFlowPyramid (InputArray img, OutputArrayOfArrays pyramid, Size winSize, int maxLevel, bool withDerivatives=true, int pyrBorder=BORDER_REFLECT_101, int derivBorder=BORDER_CONSTANT, bool tryReuseInputImage=true) |
| constructs a pyramid which can be used as input for calcOpticalFlowPyrLK More...
|
|
void | calcOpticalFlowPyrLK (InputArray prevImg, InputArray nextImg, InputArray prevPts, CV_OUT InputOutputArray nextPts, OutputArray status, OutputArray err, Size winSize=Size(21, 21), int maxLevel=3, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags=0, double minEigThreshold=1e-4) |
| computes sparse optical flow using multi-scale Lucas-Kanade algorithm More...
|
|
void | calcOpticalFlowFarneback (InputArray prev, InputArray next, CV_OUT InputOutputArray flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags) |
| computes dense optical flow using Farneback algorithm More...
|
|
Mat | estimateRigidTransform (InputArray src, InputArray dst, bool fullAffine) |
| estimates the best-fit Euqcidean, similarity, affine or perspective transformation More...
|
|
void | calcOpticalFlowSF (Mat &from, Mat &to, Mat &flow, int layers, int averaging_block_size, int max_flow) |
| computes dense optical flow using Simple Flow algorithm More...
|
|
void | calcOpticalFlowSF (Mat &from, Mat &to, Mat &flow, int layers, int averaging_block_size, int max_flow, double sigma_dist, double sigma_color, int postprocess_window, double sigma_dist_fix, double sigma_color_fix, double occ_thr, int upscale_averaging_radius, double upscale_sigma_dist, double upscale_sigma_color, double speed_up_thr) |
|
Ptr< DenseOpticalFlow > | createOptFlow_DualTVL1 () |
|
bool | initModule_video (void) |
|
void | Rodrigues (InputArray src, OutputArray dst, OutputArray jacobian=noArray()) |
| converts rotation vector to rotation matrix or vice versa using Rodrigues transformation More...
|
|
Mat | findHomography (InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray()) |
| computes the best-fit perspective transformation mapping srcPoints to dstPoints. More...
|
|
Mat | findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, int method=0, double ransacReprojThreshold=3) |
| variant of findHomography for backward compatibility More...
|
|
Vec3d | RQDecomp3x3 (InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray()) |
| Computes RQ decomposition of 3x3 matrix. More...
|
|
void | decomposeProjectionMatrix (InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray()) |
| Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector. More...
|
|
void | matMulDeriv (InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB) |
| computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients More...
|
|
void | composeRT (InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray()) |
| composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments More...
|
|
void | projectPoints (InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0) |
| projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters More...
|
|
bool | solvePnP (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int flags=ITERATIVE) |
|
void | solvePnPRansac (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount=100, float reprojectionError=8.0, int minInliersCount=100, OutputArray inliers=noArray(), int flags=ITERATIVE) |
| computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible. More...
|
|
Mat | initCameraMatrix2D (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.) |
| initializes camera matrix from a few 3D points and the corresponding projections. More...
|
|
bool | findChessboardCorners (InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE) |
| finds checkerboard pattern of the specified size in the image More...
|
|
bool | find4QuadCornerSubpix (InputArray img, InputOutputArray corners, Size region_size) |
| finds subpixel-accurate positions of the chessboard corners More...
|
|
void | drawChessboardCorners (InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound) |
| draws the checkerboard pattern (found or partly found) in the image More...
|
|
bool | findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr< FeatureDetector > &blobDetector=new SimpleBlobDetector()) |
| finds circles' grid pattern of the specified size in the image More...
|
|
bool | findCirclesGridDefault (InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID) |
| the deprecated function. Use findCirclesGrid() instead of it. More...
|
|
double | calibrateCamera (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, CV_OUT InputOutputArray cameraMatrix, CV_OUT InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON)) |
| finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern. More...
|
|
void | calibrationMatrixValues (InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, CV_OUT double &fovx, CV_OUT double &fovy, CV_OUT double &focalLength, CV_OUT Point2d &principalPoint, CV_OUT double &aspectRatio) |
| computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size. More...
|
|
double | stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, CV_OUT InputOutputArray cameraMatrix1, CV_OUT InputOutputArray distCoeffs1, CV_OUT InputOutputArray cameraMatrix2, CV_OUT InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC) |
| finds intrinsic and extrinsic parameters of a stereo camera More...
|
|
void | stereoRectify (InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags=CALIB_ZERO_DISPARITY, double alpha=-1, Size newImageSize=Size(), CV_OUT Rect *validPixROI1=0, CV_OUT Rect *validPixROI2=0) |
| computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters More...
|
|
bool | stereoRectifyUncalibrated (InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5) |
| computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed) More...
|
|
float | rectify3Collinear (InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, InputArray cameraMatrix3, InputArray distCoeffs3, InputArrayOfArrays imgpt1, InputArrayOfArrays imgpt3, Size imageSize, InputArray R12, InputArray T12, InputArray R13, InputArray T13, OutputArray R1, OutputArray R2, OutputArray R3, OutputArray P1, OutputArray P2, OutputArray P3, OutputArray Q, double alpha, Size newImgSize, CV_OUT Rect *roi1, CV_OUT Rect *roi2, int flags) |
| computes the rectification transformations for 3-head camera, where all the heads are on the same line. More...
|
|
Mat | getOptimalNewCameraMatrix (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize=Size(), CV_OUT Rect *validPixROI=0, bool centerPrincipalPoint=false) |
| returns the optimal new camera matrix More...
|
|
void | convertPointsToHomogeneous (InputArray src, OutputArray dst) |
| converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1)) More...
|
|
void | convertPointsFromHomogeneous (InputArray src, OutputArray dst) |
| converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z)) More...
|
|
void | convertPointsHomogeneous (InputArray src, OutputArray dst) |
| for backward compatibility More...
|
|
Mat | findFundamentalMat (InputArray points1, InputArray points2, int method=FM_RANSAC, double param1=3., double param2=0.99, OutputArray mask=noArray()) |
| finds fundamental matrix from a set of corresponding 2D points More...
|
|
Mat | findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, int method=FM_RANSAC, double param1=3., double param2=0.99) |
| variant of findFundamentalMat for backward compatibility More...
|
|
void | computeCorrespondEpilines (InputArray points, int whichImage, InputArray F, OutputArray lines) |
| finds coordinates of epipolar lines corresponding the specified points More...
|
|
void | triangulatePoints (InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, OutputArray points4D) |
|
void | correctMatches (InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2) |
|
void | filterSpeckles (InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray()) |
| filters off speckles (small regions of incorrectly computed disparity) More...
|
|
Rect | getValidDisparityROI (Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize) |
| computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify()) More...
|
|
void | validateDisparity (InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp=1) |
| validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm More...
|
|
void | reprojectImageTo3D (InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int ddepth=-1) |
| reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify More...
|
|
int | estimateAffine3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99) |
|
bool | initModule_features2d () |
|
void | write (FileStorage &fs, const string &name, const vector< KeyPoint > &keypoints) |
| writes vector of keypoints to the file storage More...
|
|
void | read (const FileNode &node, CV_OUT vector< KeyPoint > &keypoints) |
| reads vector of keypoints from the specified file storage node More...
|
|
void | FAST (InputArray image, CV_OUT vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression=true) |
| detects corners using FAST algorithm by E. Rosten More...
|
|
void | FASTX (InputArray image, CV_OUT vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression, int type) |
|
Mat | windowedMatchingMask (const vector< KeyPoint > &keypoints1, const vector< KeyPoint > &keypoints2, float maxDeltaX, float maxDeltaY) |
|
void | drawKeypoints (const Mat &image, const vector< KeyPoint > &keypoints, CV_OUT Mat &outImage, const Scalar &color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT) |
|
void | drawMatches (const Mat &img1, const vector< KeyPoint > &keypoints1, const Mat &img2, const vector< KeyPoint > &keypoints2, const vector< DMatch > &matches1to2, Mat &outImg, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const vector< char > &matchesMask=vector< char >(), int flags=DrawMatchesFlags::DEFAULT) |
|
void | drawMatches (const Mat &img1, const vector< KeyPoint > &keypoints1, const Mat &img2, const vector< KeyPoint > &keypoints2, const vector< vector< DMatch > > &matches1to2, Mat &outImg, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const vector< vector< char > > &matchesMask=vector< vector< char > >(), int flags=DrawMatchesFlags::DEFAULT) |
|
void | evaluateFeatureDetector (const Mat &img1, const Mat &img2, const Mat &H1to2, vector< KeyPoint > *keypoints1, vector< KeyPoint > *keypoints2, float &repeatability, int &correspCount, const Ptr< FeatureDetector > &fdetector=Ptr< FeatureDetector >()) |
|
void | computeRecallPrecisionCurve (const vector< vector< DMatch > > &matches1to2, const vector< vector< uchar > > &correctMatches1to2Mask, vector< Point2f > &recallPrecisionCurve) |
|
float | getRecall (const vector< Point2f > &recallPrecisionCurve, float l_precision) |
|
int | getNearestPoint (const vector< Point2f > &recallPrecisionCurve, float l_precision) |
|
void | evaluateGenericDescriptorMatcher (const Mat &img1, const Mat &img2, const Mat &H1to2, vector< KeyPoint > &keypoints1, vector< KeyPoint > &keypoints2, vector< vector< DMatch > > *matches1to2, vector< vector< uchar > > *correctMatches1to2Mask, vector< Point2f > &recallPrecisionCurve, const Ptr< GenericDescriptorMatcher > &dmatch=Ptr< GenericDescriptorMatcher >()) |
|
void | groupRectangles (CV_OUT CV_IN_OUT vector< Rect > &rectList, int groupThreshold, double eps=0.2) |
|
void | groupRectangles (CV_OUT CV_IN_OUT vector< Rect > &rectList, CV_OUT vector< int > &weights, int groupThreshold, double eps=0.2) |
|
void | groupRectangles (vector< Rect > &rectList, int groupThreshold, double eps, vector< int > *weights, vector< double > *levelWeights) |
|
void | groupRectangles (vector< Rect > &rectList, vector< int > &rejectLevels, vector< double > &levelWeights, int groupThreshold, double eps=0.2) |
|
void | groupRectangles_meanshift (vector< Rect > &rectList, vector< double > &foundWeights, vector< double > &foundScales, double detectThreshold=0.0, Size winDetSize=Size(64, 128)) |
|
void | findDataMatrix (InputArray image, CV_OUT vector< string > &codes, OutputArray corners=noArray(), OutputArrayOfArrays dmtx=noArray()) |
|
void | drawDataMatrixCodes (InputOutputArray image, const vector< string > &codes, InputArray corners) |
|
bool | initModule_ml (void) |
|
void | inpaint (InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRadius, int flags) |
| restores the damaged image areas using one of the available intpainting algorithms More...
|
|
void | fastNlMeansDenoising (InputArray src, OutputArray dst, float h=3, int templateWindowSize=7, int searchWindowSize=21) |
|
void | fastNlMeansDenoisingColored (InputArray src, OutputArray dst, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21) |
|
void | fastNlMeansDenoisingMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, int templateWindowSize=7, int searchWindowSize=21) |
|
void | fastNlMeansDenoisingColoredMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21) |
|
bool | initModule_nonfree () |
|
std::ostream & | operator<< (std::ostream &out, const TickMeter &tm) |
|
int | chamerMatching (Mat &img, Mat &templ, CV_OUT vector< vector< Point > > &results, CV_OUT vector< float > &cost, double templScale=1, int maxMatches=20, double minMatchDistance=1.0, int padX=3, int padY=3, int scales=5, double minScale=0.6, double maxScale=1.6, double orientationWeight=0.5, double truncate=20) |
|
void | polyfit (const Mat &srcx, const Mat &srcy, Mat &dst, int order) |
|
void | generateColors (std::vector< Scalar > &colors, size_t count, size_t factor=100) |
|
bool | RGBDOdometry (Mat &Rt, const Mat &initRt, const Mat &image0, const Mat &depth0, const Mat &mask0, const Mat &image1, const Mat &depth1, const Mat &mask1, const Mat &cameraMatrix, float minDepth=0.f, float maxDepth=4.f, float maxDepthDiff=0.07f, const std::vector< int > &iterCounts=std::vector< int >(), const std::vector< float > &minGradientMagnitudes=std::vector< float >(), int transformType=RIGID_BODY_MOTION) |
|
Mat | subspaceProject (InputArray W, InputArray mean, InputArray src) |
|
Mat | subspaceReconstruct (InputArray W, InputArray mean, InputArray src) |
|
Ptr< FaceRecognizer > | createEigenFaceRecognizer (int num_components=0, double threshold=DBL_MAX) |
|
Ptr< FaceRecognizer > | createFisherFaceRecognizer (int num_components=0, double threshold=DBL_MAX) |
|
Ptr< FaceRecognizer > | createLBPHFaceRecognizer (int radius=1, int neighbors=8, int grid_x=8, int grid_y=8, double threshold=DBL_MAX) |
|
void | applyColorMap (InputArray src, OutputArray dst, int colormap) |
|
bool | initModule_contrib () |
|
uchar * | getData (IplImage *image) |
|