OpenCV  4.1.1-pre
Open Source Computer Vision
Looking for a C++ dev who knows OpenCV?
I'm looking for work. Hire me!
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
cv::_OutputArray Class Reference
Core functionality » Basic structures

This type is very similar to InputArray except that it is used for input/output and output function parameters. More...

#include <opencv2/core/mat.hpp>

Inheritance diagram for cv::_OutputArray:
Inheritance graph
[legend]
Collaboration diagram for cv::_OutputArray:
Collaboration graph
[legend]

Public Types

enum  DepthMask {
  DEPTH_MASK_8U = 1 << CV_8U,
  DEPTH_MASK_8S = 1 << CV_8S,
  DEPTH_MASK_16U = 1 << CV_16U,
  DEPTH_MASK_16S = 1 << CV_16S,
  DEPTH_MASK_32S = 1 << CV_32S,
  DEPTH_MASK_32F = 1 << CV_32F,
  DEPTH_MASK_64F = 1 << CV_64F,
  DEPTH_MASK_16F = 1 << CV_16F,
  DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
  DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
  DEPTH_MASK_ALL_16F = (DEPTH_MASK_16F<<1)-1,
  DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
}
 
enum  KindFlag {
  KIND_SHIFT = 16,
  FIXED_TYPE = 0x8000 << KIND_SHIFT,
  FIXED_SIZE = 0x4000 << KIND_SHIFT,
  KIND_MASK = 31 << KIND_SHIFT,
  NONE = 0 << KIND_SHIFT,
  MAT = 1 << KIND_SHIFT,
  MATX = 2 << KIND_SHIFT,
  STD_VECTOR = 3 << KIND_SHIFT,
  STD_VECTOR_VECTOR = 4 << KIND_SHIFT,
  STD_VECTOR_MAT = 5 << KIND_SHIFT,
  EXPR = 6 << KIND_SHIFT,
  OPENGL_BUFFER = 7 << KIND_SHIFT,
  CUDA_HOST_MEM = 8 << KIND_SHIFT,
  CUDA_GPU_MAT = 9 << KIND_SHIFT,
  UMAT =10 << KIND_SHIFT,
  STD_VECTOR_UMAT =11 << KIND_SHIFT,
  STD_BOOL_VECTOR =12 << KIND_SHIFT,
  STD_VECTOR_CUDA_GPU_MAT = 13 << KIND_SHIFT,
  STD_ARRAY =14 << KIND_SHIFT,
  STD_ARRAY_MAT =15 << KIND_SHIFT
}
 

Public Member Functions

 _OutputArray ()
 
 _OutputArray (int _flags, void *_obj)
 
 _OutputArray (Mat &m)
 
 _OutputArray (std::vector< Mat > &vec)
 
 _OutputArray (cuda::GpuMat &d_mat)
 
 _OutputArray (std::vector< cuda::GpuMat > &d_mat)
 
 _OutputArray (ogl::Buffer &buf)
 
 _OutputArray (cuda::HostMem &cuda_mem)
 
template<typename _Tp >
 _OutputArray (cudev::GpuMat_< _Tp > &m)
 
template<typename _Tp >
 _OutputArray (std::vector< _Tp > &vec)
 
 _OutputArray (std::vector< bool > &vec)=delete
 
template<typename _Tp >
 _OutputArray (std::vector< std::vector< _Tp > > &vec)
 
 _OutputArray (std::vector< std::vector< bool > > &)=delete
 
template<typename _Tp >
 _OutputArray (std::vector< Mat_< _Tp > > &vec)
 
template<typename _Tp >
 _OutputArray (Mat_< _Tp > &m)
 
template<typename _Tp >
 _OutputArray (_Tp *vec, int n)
 
template<typename _Tp , int m, int n>
 _OutputArray (Matx< _Tp, m, n > &matx)
 
 _OutputArray (UMat &m)
 
 _OutputArray (std::vector< UMat > &vec)
 
 _OutputArray (const Mat &m)
 
 _OutputArray (const std::vector< Mat > &vec)
 
 _OutputArray (const cuda::GpuMat &d_mat)
 
 _OutputArray (const std::vector< cuda::GpuMat > &d_mat)
 
 _OutputArray (const ogl::Buffer &buf)
 
 _OutputArray (const cuda::HostMem &cuda_mem)
 
template<typename _Tp >
 _OutputArray (const cudev::GpuMat_< _Tp > &m)
 
template<typename _Tp >
 _OutputArray (const std::vector< _Tp > &vec)
 
template<typename _Tp >
 _OutputArray (const std::vector< std::vector< _Tp > > &vec)
 
template<typename _Tp >
 _OutputArray (const std::vector< Mat_< _Tp > > &vec)
 
template<typename _Tp >
 _OutputArray (const Mat_< _Tp > &m)
 
template<typename _Tp >
 _OutputArray (const _Tp *vec, int n)
 
template<typename _Tp , int m, int n>
 _OutputArray (const Matx< _Tp, m, n > &matx)
 
 _OutputArray (const UMat &m)
 
 _OutputArray (const std::vector< UMat > &vec)
 
template<typename _Tp , std::size_t _Nm>
 _OutputArray (std::array< _Tp, _Nm > &arr)
 
template<typename _Tp , std::size_t _Nm>
 _OutputArray (const std::array< _Tp, _Nm > &arr)
 
template<std::size_t _Nm>
 _OutputArray (std::array< Mat, _Nm > &arr)
 
template<std::size_t _Nm>
 _OutputArray (const std::array< Mat, _Nm > &arr)
 
void assign (const UMat &u) const
 
void assign (const Mat &m) const
 
void assign (const std::vector< UMat > &v) const
 
void assign (const std::vector< Mat > &v) const
 
int channels (int i=-1) const
 
void clear () const
 
int cols (int i=-1) const
 
void copyTo (const _OutputArray &arr) const
 
void copyTo (const _OutputArray &arr, const _InputArray &mask) const
 
void create (Size sz, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast< _OutputArray::DepthMask >(0)) const
 
void create (int rows, int cols, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast< _OutputArray::DepthMask >(0)) const
 
void create (int dims, const int *size, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast< _OutputArray::DepthMask >(0)) const
 
void createSameSize (const _InputArray &arr, int mtype) const
 
int depth (int i=-1) const
 
int dims (int i=-1) const
 
bool empty () const
 
bool fixedSize () const
 
bool fixedType () const
 
int getFlags () const
 
cuda::GpuMat getGpuMat () const
 
cuda::GpuMat & getGpuMatRef () const
 
std::vector< cuda::GpuMat > & getGpuMatVecRef () const
 
void getGpuMatVector (std::vector< cuda::GpuMat > &gpumv) const
 
cuda::HostMem & getHostMemRef () const
 
Mat getMat (int idx=-1) const
 
Mat getMat_ (int idx=-1) const
 
Mat & getMatRef (int i=-1) const
 
void getMatVector (std::vector< Mat > &mv) const
 
void * getObj () const
 
ogl::Buffer getOGlBuffer () const
 
ogl::Buffer & getOGlBufferRef () const
 
Size getSz () const
 
UMat getUMat (int idx=-1) const
 
UMat & getUMatRef (int i=-1) const
 
void getUMatVector (std::vector< UMat > &umv) const
 
bool isContinuous (int i=-1) const
 
bool isGpuMat () const
 
bool isGpuMatVector () const
 
bool isMat () const
 
bool isMatVector () const
 
bool isMatx () const
 
bool isSubmatrix (int i=-1) const
 
bool isUMat () const
 
bool isUMatVector () const
 
bool isVector () const
 
_InputArray::KindFlag kind () const
 
void move (UMat &u) const
 
void move (Mat &m) const
 
bool needed () const
 
size_t offset (int i=-1) const
 
void release () const
 
int rows (int i=-1) const
 
bool sameSize (const _InputArray &arr) const
 
void setTo (const _InputArray &value, const _InputArray &mask=_InputArray()) const
 
Size size (int i=-1) const
 
int sizend (int *sz, int i=-1) const
 
size_t step (int i=-1) const
 
size_t total (int i=-1) const
 
int type (int i=-1) const
 

Static Public Member Functions

template<typename _Tp >
static _InputArray rawIn (const std::vector< _Tp > &vec)
 
template<typename _Tp , std::size_t _Nm>
static _InputArray rawIn (const std::array< _Tp, _Nm > &arr)
 
template<typename _Tp >
static _OutputArray rawOut (std::vector< _Tp > &vec)
 
template<typename _Tp , std::size_t _Nm>
static _OutputArray rawOut (std::array< _Tp, _Nm > &arr)
 

Protected Member Functions

void init (int _flags, const void *_obj)
 
void init (int _flags, const void *_obj, Size _sz)
 

Protected Attributes

int flags
 
void * obj
 
Size sz
 

Detailed Description

This type is very similar to InputArray except that it is used for input/output and output function parameters.

Just like with InputArray, OpenCV users should not care about OutputArray, they just pass Mat, vector<T> etc. to the functions. The same limitation as for InputArray: Do not explicitly create OutputArray instances applies here too.

If you want to make your function polymorphic (i.e. accept different arrays as output parameters), it is also not very difficult. Take the sample above as the reference. Note that _OutputArray::create() needs to be called before _OutputArray::getMat(). This way you guarantee that the output array is properly allocated.

Optional output parameters. If you do not need certain output array to be computed and returned to you, pass cv::noArray(), just like you would in the case of optional input array. At the implementation level, use _OutputArray::needed() to check if certain output array needs to be computed or not.

There are several synonyms for OutputArray that are used to assist automatic Python/Java/... wrapper generators:

typedef OutputArray OutputArrayOfArrays;
typedef OutputArray InputOutputArray;
typedef OutputArray InputOutputArrayOfArrays;

Member Enumeration Documentation

◆ DepthMask

enum cv::_OutputArray::DepthMask
Enumerator
DEPTH_MASK_8U 
DEPTH_MASK_8S 
DEPTH_MASK_16U 
DEPTH_MASK_16S 
DEPTH_MASK_32S 
DEPTH_MASK_32F 
DEPTH_MASK_64F 
DEPTH_MASK_16F 
DEPTH_MASK_ALL 
DEPTH_MASK_ALL_BUT_8S 
DEPTH_MASK_ALL_16F 
DEPTH_MASK_FLT 

◆ KindFlag

enum cv::_InputArray::KindFlag
inherited
Enumerator
KIND_SHIFT 
FIXED_TYPE 
FIXED_SIZE 
KIND_MASK 
NONE 
MAT 
MATX 
STD_VECTOR 
STD_VECTOR_VECTOR 
STD_VECTOR_MAT 
EXPR 
OPENGL_BUFFER 
CUDA_HOST_MEM 
CUDA_GPU_MAT 
UMAT 
STD_VECTOR_UMAT 
STD_BOOL_VECTOR 
STD_VECTOR_CUDA_GPU_MAT 
STD_ARRAY 
STD_ARRAY_MAT 

Constructor & Destructor Documentation

◆ _OutputArray() [1/38]

cv::_OutputArray::_OutputArray ( )

◆ _OutputArray() [2/38]

cv::_OutputArray::_OutputArray ( int  _flags,
void *  _obj 
)

◆ _OutputArray() [3/38]

cv::_OutputArray::_OutputArray ( Mat &  m)

◆ _OutputArray() [4/38]

cv::_OutputArray::_OutputArray ( std::vector< Mat > &  vec)

◆ _OutputArray() [5/38]

cv::_OutputArray::_OutputArray ( cuda::GpuMat &  d_mat)

◆ _OutputArray() [6/38]

cv::_OutputArray::_OutputArray ( std::vector< cuda::GpuMat > &  d_mat)

◆ _OutputArray() [7/38]

cv::_OutputArray::_OutputArray ( ogl::Buffer &  buf)

◆ _OutputArray() [8/38]

cv::_OutputArray::_OutputArray ( cuda::HostMem &  cuda_mem)

◆ _OutputArray() [9/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( cudev::GpuMat_< _Tp > &  m)

◆ _OutputArray() [10/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( std::vector< _Tp > &  vec)

◆ _OutputArray() [11/38]

cv::_OutputArray::_OutputArray ( std::vector< bool > &  vec)
delete

◆ _OutputArray() [12/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( std::vector< std::vector< _Tp > > &  vec)

◆ _OutputArray() [13/38]

cv::_OutputArray::_OutputArray ( std::vector< std::vector< bool > > &  )
delete

◆ _OutputArray() [14/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( std::vector< Mat_< _Tp > > &  vec)

◆ _OutputArray() [15/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( Mat_< _Tp > &  m)

◆ _OutputArray() [16/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( _Tp *  vec,
int  n 
)

◆ _OutputArray() [17/38]

template<typename _Tp , int m, int n>
cv::_OutputArray::_OutputArray ( Matx< _Tp, m, n > &  matx)

◆ _OutputArray() [18/38]

cv::_OutputArray::_OutputArray ( UMat &  m)

◆ _OutputArray() [19/38]

cv::_OutputArray::_OutputArray ( std::vector< UMat > &  vec)

◆ _OutputArray() [20/38]

cv::_OutputArray::_OutputArray ( const Mat &  m)

◆ _OutputArray() [21/38]

cv::_OutputArray::_OutputArray ( const std::vector< Mat > &  vec)

◆ _OutputArray() [22/38]

cv::_OutputArray::_OutputArray ( const cuda::GpuMat &  d_mat)

◆ _OutputArray() [23/38]

cv::_OutputArray::_OutputArray ( const std::vector< cuda::GpuMat > &  d_mat)

◆ _OutputArray() [24/38]

cv::_OutputArray::_OutputArray ( const ogl::Buffer &  buf)

◆ _OutputArray() [25/38]

cv::_OutputArray::_OutputArray ( const cuda::HostMem &  cuda_mem)

◆ _OutputArray() [26/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( const cudev::GpuMat_< _Tp > &  m)

◆ _OutputArray() [27/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( const std::vector< _Tp > &  vec)

◆ _OutputArray() [28/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( const std::vector< std::vector< _Tp > > &  vec)

◆ _OutputArray() [29/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( const std::vector< Mat_< _Tp > > &  vec)

◆ _OutputArray() [30/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( const Mat_< _Tp > &  m)

◆ _OutputArray() [31/38]

template<typename _Tp >
cv::_OutputArray::_OutputArray ( const _Tp *  vec,
int  n 
)

◆ _OutputArray() [32/38]

template<typename _Tp , int m, int n>
cv::_OutputArray::_OutputArray ( const Matx< _Tp, m, n > &  matx)

◆ _OutputArray() [33/38]

cv::_OutputArray::_OutputArray ( const UMat &  m)

◆ _OutputArray() [34/38]

cv::_OutputArray::_OutputArray ( const std::vector< UMat > &  vec)

◆ _OutputArray() [35/38]

template<typename _Tp , std::size_t _Nm>
cv::_OutputArray::_OutputArray ( std::array< _Tp, _Nm > &  arr)

◆ _OutputArray() [36/38]

template<typename _Tp , std::size_t _Nm>
cv::_OutputArray::_OutputArray ( const std::array< _Tp, _Nm > &  arr)

◆ _OutputArray() [37/38]

template<std::size_t _Nm>
cv::_OutputArray::_OutputArray ( std::array< Mat, _Nm > &  arr)

◆ _OutputArray() [38/38]

template<std::size_t _Nm>
cv::_OutputArray::_OutputArray ( const std::array< Mat, _Nm > &  arr)

Member Function Documentation

◆ assign() [1/4]

void cv::_OutputArray::assign ( const UMat &  u) const

◆ assign() [2/4]

void cv::_OutputArray::assign ( const Mat &  m) const

◆ assign() [3/4]

void cv::_OutputArray::assign ( const std::vector< UMat > &  v) const

◆ assign() [4/4]

void cv::_OutputArray::assign ( const std::vector< Mat > &  v) const

◆ channels()

int cv::_InputArray::channels ( int  i = -1) const
inherited

◆ clear()

void cv::_OutputArray::clear ( ) const

◆ cols()

int cv::_InputArray::cols ( int  i = -1) const
inherited

◆ copyTo() [1/2]

void cv::_InputArray::copyTo ( const _OutputArray &  arr) const
inherited

◆ copyTo() [2/2]

void cv::_InputArray::copyTo ( const _OutputArray &  arr,
const _InputArray &  mask 
) const
inherited

◆ create() [1/3]

void cv::_OutputArray::create ( Size  sz,
int  type,
int  i = -1,
bool  allowTransposed = false,
_OutputArray::DepthMask  fixedDepthMask = static_cast< _OutputArray::DepthMask >(0) 
) const

◆ create() [2/3]

void cv::_OutputArray::create ( int  rows,
int  cols,
int  type,
int  i = -1,
bool  allowTransposed = false,
_OutputArray::DepthMask  fixedDepthMask = static_cast< _OutputArray::DepthMask >(0) 
) const

◆ create() [3/3]

void cv::_OutputArray::create ( int  dims,
const int *  size,
int  type,
int  i = -1,
bool  allowTransposed = false,
_OutputArray::DepthMask  fixedDepthMask = static_cast< _OutputArray::DepthMask >(0) 
) const

◆ createSameSize()

void cv::_OutputArray::createSameSize ( const _InputArray &  arr,
int  mtype 
) const

◆ depth()

int cv::_InputArray::depth ( int  i = -1) const
inherited

◆ dims()

int cv::_InputArray::dims ( int  i = -1) const
inherited

◆ empty()

bool cv::_InputArray::empty ( ) const
inherited

◆ fixedSize()

bool cv::_OutputArray::fixedSize ( ) const

◆ fixedType()

bool cv::_OutputArray::fixedType ( ) const

◆ getFlags()

int cv::_InputArray::getFlags ( ) const
inherited

◆ getGpuMat()

cuda::GpuMat cv::_InputArray::getGpuMat ( ) const
inherited

◆ getGpuMatRef()

cuda::GpuMat& cv::_OutputArray::getGpuMatRef ( ) const

◆ getGpuMatVecRef()

std::vector<cuda::GpuMat>& cv::_OutputArray::getGpuMatVecRef ( ) const

◆ getGpuMatVector()

void cv::_InputArray::getGpuMatVector ( std::vector< cuda::GpuMat > &  gpumv) const
inherited

◆ getHostMemRef()

cuda::HostMem& cv::_OutputArray::getHostMemRef ( ) const

◆ getMat()

Mat cv::_InputArray::getMat ( int  idx = -1) const
inherited
Examples:
samples/cpp/pca.cpp.

◆ getMat_()

Mat cv::_InputArray::getMat_ ( int  idx = -1) const
inherited

◆ getMatRef()

Mat& cv::_OutputArray::getMatRef ( int  i = -1) const

◆ getMatVector()

void cv::_InputArray::getMatVector ( std::vector< Mat > &  mv) const
inherited

◆ getObj()

void* cv::_InputArray::getObj ( ) const
inherited

◆ getOGlBuffer()

ogl::Buffer cv::_InputArray::getOGlBuffer ( ) const
inherited

◆ getOGlBufferRef()

ogl::Buffer& cv::_OutputArray::getOGlBufferRef ( ) const

◆ getSz()

Size cv::_InputArray::getSz ( ) const
inherited

◆ getUMat()

UMat cv::_InputArray::getUMat ( int  idx = -1) const
inherited

◆ getUMatRef()

UMat& cv::_OutputArray::getUMatRef ( int  i = -1) const

◆ getUMatVector()

void cv::_InputArray::getUMatVector ( std::vector< UMat > &  umv) const
inherited

◆ init() [1/2]

void cv::_InputArray::init ( int  _flags,
const void *  _obj 
)
protectedinherited

◆ init() [2/2]

void cv::_InputArray::init ( int  _flags,
const void *  _obj,
Size  _sz 
)
protectedinherited

◆ isContinuous()

bool cv::_InputArray::isContinuous ( int  i = -1) const
inherited

◆ isGpuMat()

bool cv::_InputArray::isGpuMat ( ) const
inherited

◆ isGpuMatVector()

bool cv::_InputArray::isGpuMatVector ( ) const
inherited

◆ isMat()

bool cv::_InputArray::isMat ( ) const
inherited

◆ isMatVector()

bool cv::_InputArray::isMatVector ( ) const
inherited

◆ isMatx()

bool cv::_InputArray::isMatx ( ) const
inherited

◆ isSubmatrix()

bool cv::_InputArray::isSubmatrix ( int  i = -1) const
inherited

◆ isUMat()

bool cv::_InputArray::isUMat ( ) const
inherited

◆ isUMatVector()

bool cv::_InputArray::isUMatVector ( ) const
inherited

◆ isVector()

bool cv::_InputArray::isVector ( ) const
inherited

◆ kind()

_InputArray::KindFlag cv::_InputArray::kind ( ) const
inherited

◆ move() [1/2]

void cv::_OutputArray::move ( UMat &  u) const

◆ move() [2/2]

void cv::_OutputArray::move ( Mat &  m) const

◆ needed()

bool cv::_OutputArray::needed ( ) const

◆ offset()

size_t cv::_InputArray::offset ( int  i = -1) const
inherited

◆ rawIn() [1/2]

template<typename _Tp >
static _InputArray cv::_InputArray::rawIn ( const std::vector< _Tp > &  vec)
staticinherited

◆ rawIn() [2/2]

template<typename _Tp , std::size_t _Nm>
static _InputArray cv::_InputArray::rawIn ( const std::array< _Tp, _Nm > &  arr)
staticinherited

◆ rawOut() [1/2]

template<typename _Tp >
static _OutputArray cv::_OutputArray::rawOut ( std::vector< _Tp > &  vec)
static

◆ rawOut() [2/2]

template<typename _Tp , std::size_t _Nm>
static _OutputArray cv::_OutputArray::rawOut ( std::array< _Tp, _Nm > &  arr)
static

◆ release()

void cv::_OutputArray::release ( ) const

◆ rows()

int cv::_InputArray::rows ( int  i = -1) const
inherited

◆ sameSize()

bool cv::_InputArray::sameSize ( const _InputArray &  arr) const
inherited

◆ setTo()

void cv::_OutputArray::setTo ( const _InputArray &  value,
const _InputArray &  mask = _InputArray() 
) const

◆ size()

Size cv::_InputArray::size ( int  i = -1) const
inherited

◆ sizend()

int cv::_InputArray::sizend ( int *  sz,
int  i = -1 
) const
inherited

◆ step()

size_t cv::_InputArray::step ( int  i = -1) const
inherited

◆ total()

size_t cv::_InputArray::total ( int  i = -1) const
inherited

◆ type()

int cv::_InputArray::type ( int  i = -1) const
inherited

Member Data Documentation

◆ flags

int cv::_InputArray::flags
protectedinherited

◆ obj

void* cv::_InputArray::obj
protectedinherited

◆ sz

Size cv::_InputArray::sz
protectedinherited
The documentation for this class was generated from the following file: