OpenCV  3.2.0-dev
Open Source Computer Vision
Classes | Typedefs | Enumerations | Functions
Basic structures
Core functionality
Collaboration diagram for Basic structures:

Classes

class  cv::_InputArray
 This is the proxy class for passing read-only input arrays into OpenCV functions. More...
 
class  cv::_InputOutputArray
 
class  cv::_OutputArray
 This type is very similar to InputArray except that it is used for input/output and output function parameters. More...
 
class  cv::Algorithm
 This is a base class for all more or less complex algorithms in OpenCV. More...
 
class  cv::Complex< _Tp >
 A complex number class. More...
 
class  cv::DataDepth< _Tp >
 A helper class for cv::DataType. More...
 
class  cv::DataType< _Tp >
 Template "trait" class for OpenCV primitive data types. More...
 
class  cv::DMatch
 Class for matching keypoint descriptors. More...
 
class  cv::Formatted
 
class  cv::Formatter
 
class  cv::KeyPoint
 Data structure for salient point detectors. More...
 
class  cv::Mat
 n-dimensional dense array class More...
 
class  cv::Mat_< _Tp >
 Template matrix class derived from Mat. More...
 
class  cv::MatAllocator
 Custom array allocator. More...
 
class  cv::MatCommaInitializer_< _Tp >
 Comma-separated Matrix Initializer. More...
 
class  cv::MatConstIterator
 
class  cv::MatConstIterator_< _Tp >
 Matrix read-only iterator. More...
 
class  cv::MatExpr
 Matrix expression representation. More...
 
class  cv::MatIterator_< _Tp >
 Matrix read-write iterator. More...
 
class  cv::MatOp
 
struct  cv::MatSize
 
struct  cv::MatStep
 
class  cv::Matx< _Tp, m, n >
 Template class for small matrices whose type and size are known at compilation time. More...
 
class  cv::MatxCommaInitializer< _Tp, m, n >
 Comma-separated Matrix Initializer. More...
 
class  cv::NAryMatIterator
 n-ary multi-dimensional array iterator. More...
 
struct  cv::Param
 
struct  cv::ParamType< _Tp >
 
struct  cv::ParamType< Algorithm >
 
struct  cv::ParamType< bool >
 
struct  cv::ParamType< double >
 
struct  cv::ParamType< float >
 
struct  cv::ParamType< Mat >
 
struct  cv::ParamType< std::vector< Mat > >
 
struct  cv::ParamType< String >
 
struct  cv::ParamType< uchar >
 
struct  cv::ParamType< uint64 >
 
struct  cv::ParamType< unsigned >
 
class  cv::Point3_< _Tp >
 Template class for 3D points specified by its coordinates x, y and z. More...
 
class  cv::Point_< _Tp >
 Template class for 2D points specified by its coordinates x and y. More...
 
struct  cv::Ptr< T >
 Template class for smart pointers with shared ownership. More...
 
class  cv::Range
 Template class specifying a continuous subsequence (slice) of a sequence. More...
 
class  cv::Rect_< _Tp >
 Template class for 2D rectangles. More...
 
class  cv::RotatedRect
 The class represents rotated (i.e. More...
 
class  cv::Scalar_< _Tp >
 Template class for a 4-element vector derived from Vec. More...
 
class  cv::Size_< _Tp >
 Template class for specifying the size of an image or rectangle. More...
 
class  cv::SparseMat
 The class SparseMat represents multi-dimensional sparse numerical arrays. More...
 
class  cv::SparseMat_< _Tp >
 Template sparse n-dimensional array class derived from SparseMat. More...
 
class  cv::SparseMatConstIterator
 Read-Only Sparse Matrix Iterator. More...
 
class  cv::SparseMatConstIterator_< _Tp >
 Template Read-Only Sparse Matrix Iterator Class. More...
 
class  cv::SparseMatIterator
 Read-write Sparse Matrix Iterator. More...
 
class  cv::SparseMatIterator_< _Tp >
 Template Read-Write Sparse Matrix Iterator Class. More...
 
class  cv::String
 
class  cv::TermCriteria
 The class defining termination criteria for iterative algorithms. More...
 
class  cv::TypeDepth< _depth >
 
class  cv::TypeDepth< CV_16S >
 
class  cv::TypeDepth< CV_16U >
 
class  cv::TypeDepth< CV_32F >
 
class  cv::TypeDepth< CV_32S >
 
class  cv::TypeDepth< CV_64F >
 
class  cv::TypeDepth< CV_8S >
 
class  cv::TypeDepth< CV_8U >
 
class  cv::UMat
 
struct  cv::UMatData
 
struct  cv::UMatDataAutoLock
 
class  cv::Vec< _Tp, cn >
 Template class for short numerical vectors, a partial case of Matx. More...
 
class  cv::VecCommaInitializer< _Tp, m >
 Comma-separated Vec Initializer. More...
 

Typedefs

typedef Complex< double > cv::Complexd
 
typedef Complex< float > cv::Complexf
 
typedef const _InputArray & cv::InputArray
 
typedef InputArray cv::InputArrayOfArrays
 
typedef const _InputOutputArray & cv::InputOutputArray
 
typedef InputOutputArray cv::InputOutputArrayOfArrays
 
typedef Mat_< uchar > cv::Mat1b
 
typedef Mat_< double > cv::Mat1d
 
typedef Mat_< float > cv::Mat1f
 
typedef Mat_< int > cv::Mat1i
 
typedef Mat_< short > cv::Mat1s
 
typedef Mat_< ushort > cv::Mat1w
 
typedef Mat_< Vec2b > cv::Mat2b
 
typedef Mat_< Vec2d > cv::Mat2d
 
typedef Mat_< Vec2f > cv::Mat2f
 
typedef Mat_< Vec2i > cv::Mat2i
 
typedef Mat_< Vec2s > cv::Mat2s
 
typedef Mat_< Vec2w > cv::Mat2w
 
typedef Mat_< Vec3b > cv::Mat3b
 
typedef Mat_< Vec3d > cv::Mat3d
 
typedef Mat_< Vec3f > cv::Mat3f
 
typedef Mat_< Vec3i > cv::Mat3i
 
typedef Mat_< Vec3s > cv::Mat3s
 
typedef Mat_< Vec3w > cv::Mat3w
 
typedef Mat_< Vec4b > cv::Mat4b
 
typedef Mat_< Vec4d > cv::Mat4d
 
typedef Mat_< Vec4f > cv::Mat4f
 
typedef Mat_< Vec4i > cv::Mat4i
 
typedef Mat_< Vec4s > cv::Mat4s
 
typedef Mat_< Vec4w > cv::Mat4w
 
typedef Matx< double, 1, 2 > cv::Matx12d
 
typedef Matx< float, 1, 2 > cv::Matx12f
 
typedef Matx< double, 1, 3 > cv::Matx13d
 
typedef Matx< float, 1, 3 > cv::Matx13f
 
typedef Matx< double, 1, 4 > cv::Matx14d
 
typedef Matx< float, 1, 4 > cv::Matx14f
 
typedef Matx< double, 1, 6 > cv::Matx16d
 
typedef Matx< float, 1, 6 > cv::Matx16f
 
typedef Matx< double, 2, 1 > cv::Matx21d
 
typedef Matx< float, 2, 1 > cv::Matx21f
 
typedef Matx< double, 2, 2 > cv::Matx22d
 
typedef Matx< float, 2, 2 > cv::Matx22f
 
typedef Matx< double, 2, 3 > cv::Matx23d
 
typedef Matx< float, 2, 3 > cv::Matx23f
 
typedef Matx< double, 3, 1 > cv::Matx31d
 
typedef Matx< float, 3, 1 > cv::Matx31f
 
typedef Matx< double, 3, 2 > cv::Matx32d
 
typedef Matx< float, 3, 2 > cv::Matx32f
 
typedef Matx< double, 3, 3 > cv::Matx33d
 
typedef Matx< float, 3, 3 > cv::Matx33f
 
typedef Matx< double, 3, 4 > cv::Matx34d
 
typedef Matx< float, 3, 4 > cv::Matx34f
 
typedef Matx< double, 4, 1 > cv::Matx41d
 
typedef Matx< float, 4, 1 > cv::Matx41f
 
typedef Matx< double, 4, 3 > cv::Matx43d
 
typedef Matx< float, 4, 3 > cv::Matx43f
 
typedef Matx< double, 4, 4 > cv::Matx44d
 
typedef Matx< float, 4, 4 > cv::Matx44f
 
typedef Matx< double, 6, 1 > cv::Matx61d
 
typedef Matx< float, 6, 1 > cv::Matx61f
 
typedef Matx< double, 6, 6 > cv::Matx66d
 
typedef Matx< float, 6, 6 > cv::Matx66f
 
typedef const _OutputArray & cv::OutputArray
 
typedef OutputArray cv::OutputArrayOfArrays
 
typedef Point2i cv::Point
 
typedef Point_< double > cv::Point2d
 
typedef Point_< float > cv::Point2f
 
typedef Point_< int > cv::Point2i
 
typedef Point_< int64 > cv::Point2l
 
typedef Point3_< double > cv::Point3d
 
typedef Point3_< float > cv::Point3f
 
typedef Point3_< int > cv::Point3i
 
typedef Rect2i cv::Rect
 
typedef Rect_< double > cv::Rect2d
 
typedef Rect_< float > cv::Rect2f
 
typedef Rect_< int > cv::Rect2i
 
typedef Scalar_< double > cv::Scalar
 
typedef Size2i cv::Size
 
typedef Size_< double > cv::Size2d
 
typedef Size_< float > cv::Size2f
 
typedef Size_< int > cv::Size2i
 
typedef Size_< int64 > cv::Size2l
 

Enumerations

enum  {
  cv::ACCESS_READ =1<<24,
  cv::ACCESS_WRITE =1<<25,
  cv::ACCESS_RW =3<<24,
  cv::ACCESS_MASK =ACCESS_RW,
  cv::ACCESS_FAST =1<<26
}
 
enum  cv::UMatUsageFlags {
  cv::USAGE_DEFAULT = 0,
  cv::USAGE_ALLOCATE_HOST_MEMORY = 1 << 0,
  cv::USAGE_ALLOCATE_DEVICE_MEMORY = 1 << 1,
  cv::USAGE_ALLOCATE_SHARED_MEMORY = 1 << 2,
  cv::__UMAT_USAGE_FLAGS_32BIT = 0x7fffffff
}
 Usage flags for allocator. More...
 

Functions

template<typename _Tp , int m>
static double cv::determinant (const Matx< _Tp, m, m > &a)
 
template<typename T >
Ptr< T > cv::makePtr ()
 makePtr<T>(...) is equivalent to Ptr<T>(new T(...)). More...
 
template<typename T , typename A1 >
Ptr< T > cv::makePtr (const A1 &a1)
 
template<typename T , typename A1 , typename A2 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2)
 
template<typename T , typename A1 , typename A2 , typename A3 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9)
 
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 >
Ptr< T > cv::makePtr (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9, const A10 &a10)
 
InputOutputArray cv::noArray ()
 
template<typename _Tp , int m, int n>
static double cv::norm (const Matx< _Tp, m, n > &M)
 
template<typename _Tp , int m, int n>
static double cv::norm (const Matx< _Tp, m, n > &M, int normType)
 
template<typename _Tp , int cn>
static Vec< _Tp, cn > cv::normalize (const Vec< _Tp, cn > &v)
 
template<typename T >
bool cv::operator!= (const Ptr< T > &ptr1, const Ptr< T > &ptr2)
 
static String & cv::operator<< (String &out, Ptr< Formatted > fmtd)
 
static String & cv::operator<< (String &out, const Mat &mtx)
 
template<typename T >
bool cv::operator== (const Ptr< T > &ptr1, const Ptr< T > &ptr2)
 Return whether ptr1.get() and ptr2.get() are equal and not equal, respectively. More...
 
template<typename T >
void cv::swap (Ptr< T > &ptr1, Ptr< T > &ptr2)
 Equivalent to ptr1.swap(ptr2). More...
 
template<typename _Tp , int m, int n>
static double cv::trace (const Matx< _Tp, m, n > &a)
 

Shorter aliases for the most popular specializations of Vec<T,n>

typedef Vec< uchar, 2 > cv::Vec2b
 
typedef Vec< uchar, 3 > cv::Vec3b
 
typedef Vec< uchar, 4 > cv::Vec4b
 
typedef Vec< short, 2 > cv::Vec2s
 
typedef Vec< short, 3 > cv::Vec3s
 
typedef Vec< short, 4 > cv::Vec4s
 
typedef Vec< ushort, 2 > cv::Vec2w
 
typedef Vec< ushort, 3 > cv::Vec3w
 
typedef Vec< ushort, 4 > cv::Vec4w
 
typedef Vec< int, 2 > cv::Vec2i
 
typedef Vec< int, 3 > cv::Vec3i
 
typedef Vec< int, 4 > cv::Vec4i
 
typedef Vec< int, 6 > cv::Vec6i
 
typedef Vec< int, 8 > cv::Vec8i
 
typedef Vec< float, 2 > cv::Vec2f
 
typedef Vec< float, 3 > cv::Vec3f
 
typedef Vec< float, 4 > cv::Vec4f
 
typedef Vec< float, 6 > cv::Vec6f
 
typedef Vec< double, 2 > cv::Vec2d
 
typedef Vec< double, 3 > cv::Vec3d
 
typedef Vec< double, 4 > cv::Vec4d
 
typedef Vec< double, 6 > cv::Vec6d
 

Detailed Description

Typedef Documentation

typedef Complex<double> cv::Complexd

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

typedef Complex<float> cv::Complexf

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

typedef const _InputArray& cv::InputArray

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

typedef InputArray cv::InputArrayOfArrays

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

typedef const _InputOutputArray& cv::InputOutputArray

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

typedef InputOutputArray cv::InputOutputArrayOfArrays

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

typedef Mat_<uchar> cv::Mat1b

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

typedef Mat_<double> cv::Mat1d

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

typedef Mat_<float> cv::Mat1f

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

typedef Mat_<int> cv::Mat1i

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

typedef Mat_<short> cv::Mat1s

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

typedef Mat_<ushort> cv::Mat1w

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

typedef Mat_<Vec2b> cv::Mat2b

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

typedef Mat_<Vec2d> cv::Mat2d

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

typedef Mat_<Vec2f> cv::Mat2f

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

typedef Mat_<Vec2i> cv::Mat2i

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

typedef Mat_<Vec2s> cv::Mat2s

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

typedef Mat_<Vec2w> cv::Mat2w

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

typedef Mat_<Vec3b> cv::Mat3b

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

typedef Mat_<Vec3d> cv::Mat3d

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

typedef Mat_<Vec3f> cv::Mat3f

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

typedef Mat_<Vec3i> cv::Mat3i

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

typedef Mat_<Vec3s> cv::Mat3s

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

typedef Mat_<Vec3w> cv::Mat3w

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

typedef Mat_<Vec4b> cv::Mat4b

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

typedef Mat_<Vec4d> cv::Mat4d

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

typedef Mat_<Vec4f> cv::Mat4f

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

typedef Mat_<Vec4i> cv::Mat4i

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

typedef Mat_<Vec4s> cv::Mat4s

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

typedef Mat_<Vec4w> cv::Mat4w

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

typedef Matx<double, 1, 2> cv::Matx12d

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

typedef Matx<float, 1, 2> cv::Matx12f

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

typedef Matx<double, 1, 3> cv::Matx13d

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

typedef Matx<float, 1, 3> cv::Matx13f

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

typedef Matx<double, 1, 4> cv::Matx14d

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

typedef Matx<float, 1, 4> cv::Matx14f

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

typedef Matx<double, 1, 6> cv::Matx16d

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

typedef Matx<float, 1, 6> cv::Matx16f

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

typedef Matx<double, 2, 1> cv::Matx21d

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

typedef Matx<float, 2, 1> cv::Matx21f

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

typedef Matx<double, 2, 2> cv::Matx22d

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

typedef Matx<float, 2, 2> cv::Matx22f

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

typedef Matx<double, 2, 3> cv::Matx23d

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

typedef Matx<float, 2, 3> cv::Matx23f

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

typedef Matx<double, 3, 1> cv::Matx31d

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

typedef Matx<float, 3, 1> cv::Matx31f

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

typedef Matx<double, 3, 2> cv::Matx32d

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

typedef Matx<float, 3, 2> cv::Matx32f

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

typedef Matx<double, 3, 3> cv::Matx33d

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

typedef Matx<float, 3, 3> cv::Matx33f

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

typedef Matx<double, 3, 4> cv::Matx34d

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

typedef Matx<float, 3, 4> cv::Matx34f

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

typedef Matx<double, 4, 1> cv::Matx41d

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

typedef Matx<float, 4, 1> cv::Matx41f

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

typedef Matx<double, 4, 3> cv::Matx43d

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

typedef Matx<float, 4, 3> cv::Matx43f

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

typedef Matx<double, 4, 4> cv::Matx44d

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

typedef Matx<float, 4, 4> cv::Matx44f

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

typedef Matx<double, 6, 1> cv::Matx61d

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

typedef Matx<float, 6, 1> cv::Matx61f

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

typedef Matx<double, 6, 6> cv::Matx66d

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

typedef Matx<float, 6, 6> cv::Matx66f

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

typedef const _OutputArray& cv::OutputArray

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

typedef OutputArray cv::OutputArrayOfArrays

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

typedef Point2i cv::Point

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

Examples:
contours2.cpp, demhist.cpp, ffilldemo.cpp, grabcut.cpp, houghcircles.cpp, houghlines.cpp, morphology2.cpp, segment_objects.cpp, and watershed.cpp.
typedef Point_<double> cv::Point2d

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

typedef Point_<float> cv::Point2f

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

Examples:
cout_mat.cpp.
typedef Point_<int> cv::Point2i

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

typedef Point_<int64> cv::Point2l

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

typedef Point3_<double> cv::Point3d

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

typedef Point3_<float> cv::Point3f

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

typedef Point3_<int> cv::Point3i

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

typedef Rect2i cv::Rect

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

Examples:
grabcut.cpp.
typedef Rect_<double> cv::Rect2d

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

typedef Rect_<float> cv::Rect2f

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

typedef Rect_<int> cv::Rect2i

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

typedef Scalar_<double> cv::Scalar

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

Examples:
contours2.cpp, convexhull.cpp, distrans.cpp, ffilldemo.cpp, fitellipse.cpp, grabcut.cpp, houghcircles.cpp, houghlines.cpp, kmeans.cpp, and minarea.cpp.
typedef Size2i cv::Size

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

Examples:
contours2.cpp, edge.cpp, laplace.cpp, and morphology2.cpp.
typedef Size_<double> cv::Size2d

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

typedef Size_<float> cv::Size2f

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

typedef Size_<int> cv::Size2i

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

typedef Size_<int64> cv::Size2l

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

typedef Vec<uchar, 2> cv::Vec2b

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

typedef Vec<double, 2> cv::Vec2d

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

typedef Vec<float, 2> cv::Vec2f

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

typedef Vec<int, 2> cv::Vec2i

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

typedef Vec<short, 2> cv::Vec2s

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

typedef Vec<ushort, 2> cv::Vec2w

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

typedef Vec<uchar, 3> cv::Vec3b

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

Examples:
watershed.cpp.
typedef Vec<double, 3> cv::Vec3d

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

typedef Vec<float, 3> cv::Vec3f

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

typedef Vec<int, 3> cv::Vec3i

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

typedef Vec<short, 3> cv::Vec3s

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

typedef Vec<ushort, 3> cv::Vec3w

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

typedef Vec<uchar, 4> cv::Vec4b

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

typedef Vec<double, 4> cv::Vec4d

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

typedef Vec<float, 4> cv::Vec4f

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

typedef Vec<int, 4> cv::Vec4i

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

typedef Vec<short, 4> cv::Vec4s

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

typedef Vec<ushort, 4> cv::Vec4w

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

typedef Vec<double, 6> cv::Vec6d

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

typedef Vec<float, 6> cv::Vec6f

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

typedef Vec<int, 6> cv::Vec6i

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

typedef Vec<int, 8> cv::Vec8i

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

Enumeration Type Documentation

anonymous enum

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

Enumerator
ACCESS_READ 
ACCESS_WRITE 
ACCESS_RW 
ACCESS_MASK 
ACCESS_FAST 
enum cv::UMatUsageFlags

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

Usage flags for allocator.

Enumerator
USAGE_DEFAULT 
USAGE_ALLOCATE_HOST_MEMORY 
USAGE_ALLOCATE_DEVICE_MEMORY 
USAGE_ALLOCATE_SHARED_MEMORY 
__UMAT_USAGE_FLAGS_32BIT 

Function Documentation

template<typename _Tp , int m>
static double cv::determinant ( const Matx< _Tp, m, m > &  a)
static

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

template<typename T >
Ptr<T> cv::makePtr ( )

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

makePtr<T>(...) is equivalent to Ptr<T>(new T(...)).

It is shorter than the latter, and it's marginally safer than using a constructor or Ptr::reset, since it ensures that the owned pointer is new and thus not owned by any other Ptr instance. Unfortunately, perfect forwarding is impossible to implement in C++03, and so makePtr is limited to constructors of T that have up to 10 arguments, none of which are non-const references.

template<typename T , typename A1 >
Ptr<T> cv::makePtr ( const A1 &  a1)

#include <core/include/opencv2/core/cvstd.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 , typename A1 , typename A2 >
Ptr<T> cv::makePtr ( const A1 &  a1,
const A2 &  a2 
)

#include <core/include/opencv2/core/cvstd.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 , typename A1 , typename A2 , typename A3 >
Ptr<T> cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3 
)

#include <core/include/opencv2/core/cvstd.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 , typename A1 , typename A2 , typename A3 , typename A4 >
Ptr<T> cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4 
)

#include <core/include/opencv2/core/cvstd.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 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 >
Ptr<T> cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5 
)

#include <core/include/opencv2/core/cvstd.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 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 >
Ptr<T> cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5,
const A6 &  a6 
)

#include <core/include/opencv2/core/cvstd.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 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 >
Ptr<T> cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5,
const A6 &  a6,
const A7 &  a7 
)

#include <core/include/opencv2/core/cvstd.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 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 >
Ptr<T> cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5,
const A6 &  a6,
const A7 &  a7,
const A8 &  a8 
)

#include <core/include/opencv2/core/cvstd.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 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 >
Ptr<T> cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5,
const A6 &  a6,
const A7 &  a7,
const A8 &  a8,
const A9 &  a9 
)

#include <core/include/opencv2/core/cvstd.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 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 >
Ptr<T> cv::makePtr ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const A4 &  a4,
const A5 &  a5,
const A6 &  a6,
const A7 &  a7,
const A8 &  a8,
const A9 &  a9,
const A10 &  a10 
)

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

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

InputOutputArray cv::noArray ( )

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

Referenced by cv::BFMatcher::isMaskSupported(), cv::viz::isNan(), cv::ml::TrainData::missingValue(), and cv::morphologyDefaultBorderValue().

Here is the caller graph for this function:

template<typename _Tp , int m, int n>
static double cv::norm ( const Matx< _Tp, m, n > &  M)
static

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

template<typename _Tp , int m, int n>
static double cv::norm ( const Matx< _Tp, m, n > &  M,
int  normType 
)
static

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

template<typename _Tp , int cn>
static Vec<_Tp, cn> cv::normalize ( const Vec< _Tp, cn > &  v)
static

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

Examples:
demhist.cpp, and pca.cpp.

Referenced by cv::morphologyDefaultBorderValue(), and cv::LineSegmentDetector::~LineSegmentDetector().

Here is the caller graph for this function:

template<typename T >
bool cv::operator!= ( const Ptr< T > &  ptr1,
const Ptr< T > &  ptr2 
)

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

static String& cv::operator<< ( String &  out,
Ptr< Formatted >  fmtd 
)
inlinestatic

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

static String& cv::operator<< ( String &  out,
const Mat &  mtx 
)
inlinestatic

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

References CV_EXPORTS, and cv::Formatter::get().

Here is the call graph for this function:

template<typename T >
bool cv::operator== ( const Ptr< T > &  ptr1,
const Ptr< T > &  ptr2 
)

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

Return whether ptr1.get() and ptr2.get() are equal and not equal, respectively.

template<typename T >
void cv::swap ( Ptr< T > &  ptr1,
Ptr< T > &  ptr2 
)

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

Equivalent to ptr1.swap(ptr2).

Provided to help write generic algorithms.

Referenced by cv::abs(), cvflann::addValue(), cvflann::find_nearest(), cvflann::KDTreeSingleIndex< Distance >::findNeighbors(), cvflann::KDTreeIndex< Distance >::getParameters(), cvflann::KMeansIndex< Distance >::getParameters(), cvflann::HierarchicalClusteringIndex< Distance >::getParameters(), cvflann::any::swap(), and cv::cuda::GpuMat::Allocator::~Allocator().

Here is the caller graph for this function:

template<typename _Tp , int m, int n>
static double cv::trace ( const Matx< _Tp, m, n > &  a)
static

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