OpenCV  3.2.0-dev
Open Source Computer Vision
Core functionality
Collaboration diagram for Core functionality:

Modules

 Basic structures
 
 C structures and operations
 
 Operations on arrays
 
 XML/YAML Persistence
 XML/YAML/JSON file storages.
 
 Clustering
 
 Utility and system functions and macros
 
 OpenGL interoperability
 This section describes OpenGL interoperability.
 
 Intel IPP Asynchronous C/C++ Converters
 This section describes conversion between OpenCV and Intel® IPP Asynchronous C/C++ library.
 
 Optimization Algorithms
 The algorithms in this section minimize or maximize function value within specified constraints or without any constraints.
 
 DirectX interoperability
 
 Eigen support
 
 OpenCL support
 
 Intel VA-API/OpenCL (CL-VA) interoperability
 This section describes Intel VA-API/OpenCL (CL-VA) interoperability.
 
 Hardware Acceleration Layer
 

Classes

class  cv::Affine3< T >
 Affine transform. More...
 
class  cv::BufferPoolController
 
class  cv::WImage< T >
 Image class which provides a thin layer around an IplImage. More...
 
class  cv::WImageBuffer< T >
 Image class which owns the data, so it can be allocated and is always freed. More...
 
class  cv::WImageBufferC< T, C >
 Like a WImageBuffer class but when the number of channels is known at compile time. More...
 
class  cv::WImageC< T, C >
 Image class when both the pixel type and number of channels are known at compile time. More...
 
class  cv::WImageView< T >
 View into an image class which allows treating a subimage as an image or treating external data as an image. More...
 
class  cv::WImageViewC< T, C >
 

Typedefs

typedef Affine3< double > cv::Affine3d
 
typedef Affine3< float > cv::Affine3f
 
typedef WImageC< short, 1 > cv::WImage1_16s
 
typedef WImageC< ushort, 1 > cv::WImage1_16u
 
typedef WImageC< uchar, 1 > cv::WImage1_b
 
typedef WImageC< float, 1 > cv::WImage1_f
 
typedef WImageC< short, 3 > cv::WImage3_16s
 
typedef WImageC< ushort, 3 > cv::WImage3_16u
 
typedef WImageC< uchar, 3 > cv::WImage3_b
 
typedef WImageC< float, 3 > cv::WImage3_f
 
typedef WImage< short > cv::WImage_16s
 
typedef WImage< ushortcv::WImage_16u
 
typedef WImage< ucharcv::WImage_b
 
typedef WImage< float > cv::WImage_f
 
typedef WImageBufferC< short, 1 > cv::WImageBuffer1_16s
 
typedef WImageBufferC< ushort, 1 > cv::WImageBuffer1_16u
 
typedef WImageBufferC< uchar, 1 > cv::WImageBuffer1_b
 
typedef WImageBufferC< float, 1 > cv::WImageBuffer1_f
 
typedef WImageBufferC< short, 3 > cv::WImageBuffer3_16s
 
typedef WImageBufferC< ushort, 3 > cv::WImageBuffer3_16u
 
typedef WImageBufferC< uchar, 3 > cv::WImageBuffer3_b
 
typedef WImageBufferC< float, 3 > cv::WImageBuffer3_f
 
typedef WImageBuffer< short > cv::WImageBuffer_16s
 
typedef WImageBuffer< ushortcv::WImageBuffer_16u
 
typedef WImageBuffer< ucharcv::WImageBuffer_b
 
typedef WImageBuffer< float > cv::WImageBuffer_f
 
typedef WImageViewC< short, 1 > cv::WImageView1_16s
 
typedef WImageViewC< ushort, 1 > cv::WImageView1_16u
 
typedef WImageViewC< uchar, 1 > cv::WImageView1_b
 
typedef WImageViewC< float, 1 > cv::WImageView1_f
 
typedef WImageViewC< short, 3 > cv::WImageView3_16s
 
typedef WImageViewC< ushort, 3 > cv::WImageView3_16u
 
typedef WImageViewC< uchar, 3 > cv::WImageView3_b
 
typedef WImageViewC< float, 3 > cv::WImageView3_f
 
typedef WImageView< short > cv::WImageView_16s
 
typedef WImageView< ushortcv::WImageView_16u
 
typedef WImageView< ucharcv::WImageView_b
 
typedef WImageView< float > cv::WImageView_f
 

Enumerations

enum  cv::CovarFlags {
  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
}
 Covariation flags. More...
 
enum  cv::HersheyFonts {
  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
}
 Only a subset of Hershey fonts http://sources.isc.org/utils/misc/hershey-font.txt are supported. More...
 
enum  cv::KmeansFlags {
  cv::KMEANS_RANDOM_CENTERS = 0,
  cv::KMEANS_PP_CENTERS = 2,
  cv::KMEANS_USE_INITIAL_LABELS = 1
}
 k-Means flags More...
 
enum  cv::LineTypes {
  cv::FILLED = -1,
  cv::LINE_4 = 4,
  cv::LINE_8 = 8,
  cv::LINE_AA = 16
}
 type of line More...
 
enum  cv::ReduceTypes {
  cv::REDUCE_SUM = 0,
  cv::REDUCE_AVG = 1,
  cv::REDUCE_MAX = 2,
  cv::REDUCE_MIN = 3
}
 

Functions

 cv::WImageView< T >::WImageView (WImage< T > *img, int c, int r, int width, int height)
 
 cv::WImageView< T >::WImageView (T *data, int width, int height, int channels, int width_step=-1)
 
 cv::WImageViewC< T, C >::WImageViewC ()
 
 cv::WImageViewC< T, C >::WImageViewC (WImageC< T, C > *img, int c, int r, int width, int height)
 
 cv::WImageViewC< T, C >::WImageViewC (T *data, int width, int height, int width_step=-1)
 
virtual cv::WImage< T >::~WImage ()=0
 
virtual cv::WImageC< T, C >::~WImageC ()=0
 
void cv::WImageBuffer< T >::Allocate (int width, int height, int nchannels)
 
void cv::WImageBufferC< T, C >::Allocate (int width, int height)
 
template<typename T >
static Affine3< T > cv::operator* (const Affine3< T > &affine1, const Affine3< T > &affine2)
 
template<typename T , typename V >
static V cv::operator* (const Affine3< T > &affine, const V &vector)
 
static Vec3f cv::operator* (const Affine3f &affine, const Vec3f &vector)
 
static Vec3d cv::operator* (const Affine3d &affine, const Vec3d &vector)
 
void cv::swap (Mat &a, Mat &b)
 Swaps two matrices. More...
 
void cv::swap (UMat &a, UMat &b)
 
WImageView< T > cv::WImage< T >::View (int c, int r, int width, int height)
 
WImageViewC< T, C > cv::WImageC< T, C >::View (int c, int r, int width, int height)
 

Detailed Description

Typedef Documentation

typedef Affine3<double> cv::Affine3d

#include <core/include/opencv2/core/affine.hpp>

typedef Affine3<float> cv::Affine3f

#include <core/include/opencv2/core/affine.hpp>

typedef WImageC<short, 1> cv::WImage1_16s

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageC<ushort, 1> cv::WImage1_16u

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageC<uchar, 1> cv::WImage1_b

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageC<float, 1> cv::WImage1_f

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageC<short, 3> cv::WImage3_16s

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageC<ushort, 3> cv::WImage3_16u

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageC<uchar, 3> cv::WImage3_b

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageC<float, 3> cv::WImage3_f

#include <core/include/opencv2/core/wimage.hpp>

typedef WImage<short> cv::WImage_16s

#include <core/include/opencv2/core/wimage.hpp>

typedef WImage<ushort> cv::WImage_16u

#include <core/include/opencv2/core/wimage.hpp>

typedef WImage<uchar> cv::WImage_b

#include <core/include/opencv2/core/wimage.hpp>

typedef WImage<float> cv::WImage_f

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBufferC<short, 1> cv::WImageBuffer1_16s

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBufferC<ushort, 1> cv::WImageBuffer1_16u

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBufferC<uchar, 1> cv::WImageBuffer1_b

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBufferC<float, 1> cv::WImageBuffer1_f

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBufferC<short, 3> cv::WImageBuffer3_16s

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBufferC<ushort, 3> cv::WImageBuffer3_16u

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBufferC<uchar, 3> cv::WImageBuffer3_b

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBufferC<float, 3> cv::WImageBuffer3_f

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBuffer<short> cv::WImageBuffer_16s

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBuffer<ushort> cv::WImageBuffer_16u

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBuffer<uchar> cv::WImageBuffer_b

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageBuffer<float> cv::WImageBuffer_f

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageViewC<short, 1> cv::WImageView1_16s

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageViewC<ushort, 1> cv::WImageView1_16u

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageViewC<uchar, 1> cv::WImageView1_b

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageViewC<float, 1> cv::WImageView1_f

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageViewC<short, 3> cv::WImageView3_16s

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageViewC<ushort, 3> cv::WImageView3_16u

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageViewC<uchar, 3> cv::WImageView3_b

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageViewC<float, 3> cv::WImageView3_f

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageView<short> cv::WImageView_16s

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageView<ushort> cv::WImageView_16u

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageView<uchar> cv::WImageView_b

#include <core/include/opencv2/core/wimage.hpp>

typedef WImageView<float> cv::WImageView_f

#include <core/include/opencv2/core/wimage.hpp>

Enumeration Type Documentation

#include <core/include/opencv2/core.hpp>

Covariation flags.

Enumerator
COVAR_SCRAMBLED 

The output covariance matrix is calculated as:

\[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...],\]

The covariance matrix will be nsamples x nsamples.

Such an unusual covariance matrix is used for fast PCA of a set of very large vectors (see, for example, the EigenFaces technique for face recognition). Eigenvalues of this "scrambled" matrix match the eigenvalues of the true covariance matrix. The "true" eigenvectors can be easily calculated from the eigenvectors of the "scrambled" covariance matrix.

COVAR_NORMAL 

The output covariance matrix is calculated as:

\[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...] \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T,\]

covar will be a square matrix of the same size as the total number of elements in each input vector.

One and only one of COVAR_SCRAMBLED and COVAR_NORMAL must be specified.

COVAR_USE_AVG 

If the flag is specified, the function does not calculate mean from the input vectors but, instead, uses the passed mean vector.

This is useful if mean has been pre-calculated or known in advance, or if the covariance matrix is calculated by parts. In this case, mean is not a mean vector of the input sub-set of vectors but rather the mean vector of the whole set.

COVAR_SCALE 

If the flag is specified, the covariance matrix is scaled.

In the "normal" mode, scale is 1./nsamples . In the "scrambled" mode, scale is the reciprocal of the total number of elements in each input vector. By default (if the flag is not specified), the covariance matrix is not scaled ( scale=1 ).

COVAR_ROWS 

If the flag is specified, all the input vectors are stored as rows of the samples matrix.

mean should be a single-row vector in this case.

COVAR_COLS 

If the flag is specified, all the input vectors are stored as columns of the samples matrix.

mean should be a single-column vector in this case.

#include <core/include/opencv2/core.hpp>

Only a subset of Hershey fonts http://sources.isc.org/utils/misc/hershey-font.txt are supported.

Enumerator
FONT_HERSHEY_SIMPLEX 

normal size sans-serif font

FONT_HERSHEY_PLAIN 

small size sans-serif font

FONT_HERSHEY_DUPLEX 

normal size sans-serif font (more complex than FONT_HERSHEY_SIMPLEX)

FONT_HERSHEY_COMPLEX 

normal size serif font

FONT_HERSHEY_TRIPLEX 

normal size serif font (more complex than FONT_HERSHEY_COMPLEX)

FONT_HERSHEY_COMPLEX_SMALL 

smaller version of FONT_HERSHEY_COMPLEX

FONT_HERSHEY_SCRIPT_SIMPLEX 

hand-writing style font

FONT_HERSHEY_SCRIPT_COMPLEX 

more complex variant of FONT_HERSHEY_SCRIPT_SIMPLEX

FONT_ITALIC 

flag for italic font

#include <core/include/opencv2/core.hpp>

k-Means flags

Enumerator
KMEANS_RANDOM_CENTERS 

Select random initial centers in each attempt.

KMEANS_PP_CENTERS 

Use kmeans++ center initialization by Arthur and Vassilvitskii [Arthur2007].

KMEANS_USE_INITIAL_LABELS 

During the first (and possibly the only) attempt, use the user-supplied labels instead of computing them from the initial centers.

For the second and further attempts, use the random or semi-random centers. Use one of KMEANS_*_CENTERS flag to specify the exact method.

#include <core/include/opencv2/core.hpp>

type of line

Enumerator
FILLED 
LINE_4 

4-connected line

LINE_8 

8-connected line

LINE_AA 

antialiased line

#include <core/include/opencv2/core.hpp>

Enumerator
REDUCE_SUM 

the output is the sum of all rows/columns of the matrix.

REDUCE_AVG 

the output is the mean vector of all rows/columns of the matrix.

REDUCE_MAX 

the output is the maximum (column/row-wise) of all rows/columns of the matrix.

REDUCE_MIN 

the output is the minimum (column/row-wise) of all rows/columns of the matrix.

Function Documentation

template<typename T >
cv::WImageView< T >::WImageView ( WImage< T > *  img,
int  c,
int  r,
int  width,
int  height 
)

#include <core/include/opencv2/core/wimage.hpp>

References cv::WImageView< T >::header_, IplImage::height, IplImage::imageData, cv::WImage< T >::Ipl(), cv::WImage< T >::SetIpl(), and IplImage::width.

Here is the call graph for this function:

template<typename T >
cv::WImageView< T >::WImageView ( T *  data,
int  width,
int  height,
int  channels,
int  width_step = -1 
)

#include <core/include/opencv2/core/wimage.hpp>

References cvInitImageHeader(), cvSize(), cv::WImageView< T >::header_, IplImage::imageData, cv::WImage< T >::SetIpl(), and IplImage::widthStep.

Here is the call graph for this function:

template<typename T , int C>
cv::WImageViewC< T, C >::WImageViewC ( )

#include <core/include/opencv2/core/wimage.hpp>

References cvInitImageHeader(), cvSize(), cv::WImageViewC< T, C >::header_, IplImage::imageData, and cv::WImageC< T, C >::SetIpl().

Here is the call graph for this function:

template<typename T , int C>
cv::WImageViewC< T, C >::WImageViewC ( WImageC< T, C > *  img,
int  c,
int  r,
int  width,
int  height 
)

#include <core/include/opencv2/core/wimage.hpp>

References cv::WImageViewC< T, C >::header_, IplImage::height, IplImage::imageData, cv::WImage< T >::Ipl(), cv::WImageC< T, C >::SetIpl(), and IplImage::width.

Here is the call graph for this function:

template<typename T , int C>
cv::WImageViewC< T, C >::WImageViewC ( T *  data,
int  width,
int  height,
int  width_step = -1 
)

#include <core/include/opencv2/core/wimage.hpp>

References cvInitImageHeader(), cvSize(), cv::WImageViewC< T, C >::header_, IplImage::imageData, cv::WImageC< T, C >::SetIpl(), and IplImage::widthStep.

Here is the call graph for this function:

template<typename T >
cv::WImage< T >::~WImage ( )
inlinepure virtual

#include <core/include/opencv2/core/wimage.hpp>

template<typename T , int C>
cv::WImageC< T, C >::~WImageC ( )
inlinepure virtual

#include <core/include/opencv2/core/wimage.hpp>

template<typename T >
void cv::WImageBuffer< T >::Allocate ( int  width,
int  height,
int  nchannels 
)
inline

#include <core/include/opencv2/core/wimage.hpp>

References cvCreateImage(), and cvSize().

Here is the call graph for this function:

template<typename T , int C>
void cv::WImageBufferC< T, C >::Allocate ( int  width,
int  height 
)
inline

#include <core/include/opencv2/core/wimage.hpp>

References cvCreateImage(), cvSize(), and cv::WImageC< T, C >::SetIpl().

Here is the call graph for this function:

template<typename T >
static Affine3<T> cv::operator* ( const Affine3< T > &  affine1,
const Affine3< T > &  affine2 
)
static

#include <core/include/opencv2/core/affine.hpp>

template<typename T , typename V >
static V cv::operator* ( const Affine3< T > &  affine,
const V &  vector 
)
static

#include <core/include/opencv2/core/affine.hpp>

static Vec3f cv::operator* ( const Affine3f affine,
const Vec3f vector 
)
static

#include <core/include/opencv2/core/affine.hpp>

static Vec3d cv::operator* ( const Affine3d affine,
const Vec3d vector 
)
static

#include <core/include/opencv2/core/affine.hpp>

void cv::swap ( Mat a,
Mat b 
)

#include <core/include/opencv2/core.hpp>

Swaps two matrices.

void cv::swap ( UMat a,
UMat b 
)

#include <core/include/opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T >
WImageView< T > cv::WImage< T >::View ( int  c,
int  r,
int  width,
int  height 
)

#include <core/include/opencv2/core/wimage.hpp>

Referenced by cv::WImage< T >::SetZero(), and cv::WImageC< T, C >::WImageC().

Here is the caller graph for this function:

template<typename T , int C>
WImageViewC< T, C > cv::WImageC< T, C >::View ( int  c,
int  r,
int  width,
int  height 
)

#include <core/include/opencv2/core/wimage.hpp>