class cv::_InputOutputArray

#include <mat.hpp>

class _InputOutputArray: public cv::_OutputArray
{
public:
    // construction

    _InputOutputArray();

    _InputOutputArray(
        int _flags,
        void* _obj
        );

    _InputOutputArray(Mat& m);
    _InputOutputArray(std::vector<Mat>& vec);
    _InputOutputArray(cuda::GpuMat& d_mat);
    _InputOutputArray(ogl::Buffer& buf);
    _InputOutputArray(cuda::HostMem& cuda_mem);

    template <typename _Tp>
    _InputOutputArray(cudev::GpuMat_<_Tp>& m);

    template <typename _Tp>
    _InputOutputArray(std::vector<_Tp>& vec);

    _InputOutputArray(std::vector<bool>& vec);

    template <typename _Tp>
    _InputOutputArray(std::vector<std::vector<_Tp>>& vec);

    template <typename _Tp>
    _InputOutputArray(std::vector<Mat_<_Tp>>& vec);

    template <typename _Tp>
    _InputOutputArray(Mat_<_Tp>& m);

    template <typename _Tp>
    _InputOutputArray(
        _Tp* vec,
        int n
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    _InputOutputArray(Matx<_Tp, m, n>& matx);

    _InputOutputArray(UMat& m);
    _InputOutputArray(std::vector<UMat>& vec);
    _InputOutputArray(const Mat& m);
    _InputOutputArray(const std::vector<Mat>& vec);
    _InputOutputArray(const cuda::GpuMat& d_mat);
    _InputOutputArray(const std::vector<cuda::GpuMat>& d_mat);
    _InputOutputArray(const ogl::Buffer& buf);
    _InputOutputArray(const cuda::HostMem& cuda_mem);

    template <typename _Tp>
    _InputOutputArray(const cudev::GpuMat_<_Tp>& m);

    template <typename _Tp>
    _InputOutputArray(const std::vector<_Tp>& vec);

    template <typename _Tp>
    _InputOutputArray(const std::vector<std::vector<_Tp>>& vec);

    template <typename _Tp>
    _InputOutputArray(const std::vector<Mat_<_Tp>>& vec);

    template <typename _Tp>
    _InputOutputArray(const Mat_<_Tp>& m);

    template <typename _Tp>
    _InputOutputArray(
        const _Tp* vec,
        int n
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    _InputOutputArray(const Matx<_Tp, m, n>& matx);

    _InputOutputArray(const UMat& m);
    _InputOutputArray(const std::vector<UMat>& vec);
};

Inherited Members

public:
    // enums

    enum
    {
        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,
    };

    enum
    {
        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_ALL        = (DEPTH_MASK_64F<<1)-1,
        DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL& ~DEPTH_MASK_8S,
        DEPTH_MASK_FLT        = DEPTH_MASK_32F + DEPTH_MASK_64F,
    };

    // methods

    int
    channels(int i = -1) const;

    int
    cols(int i = -1) const;

    void
    copyTo(const _OutputArray& arr) const;

    void
    copyTo(
        const _OutputArray& arr,
        const _InputArray& mask
        ) const;

    int
    depth(int i = -1) const;

    int
    dims(int i = -1) const;

    bool
    empty() const;

    int
    getFlags() const;

    cuda::GpuMat
    getGpuMat() const;

    void
    getGpuMatVector(std::vector<cuda::GpuMat>& gpumv) const;

    Mat
    getMat(int idx = -1) const;

    Mat
    getMat_(int idx = -1) const;

    void
    getMatVector(std::vector<Mat>& mv) const;

    void*
    getObj() const;

    ogl::Buffer
    getOGlBuffer() const;

    Size
    getSz() const;

    UMat
    getUMat(int idx = -1) const;

    void
    getUMatVector(std::vector<UMat>& umv) const;

    bool
    isContinuous(int i = -1) 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;

    int
    kind() const;

    size_t
    offset(int i = -1) const;

    int
    rows(int i = -1) const;

    bool
    sameSize(const _InputArray& arr) 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;

    void
    assign(const UMat& u) const;

    void
    assign(const Mat& m) const;

    void
    clear() const;

    void
    create(
        Size sz,
        int type,
        int i = -1,
        bool allowTransposed = false,
        int fixedDepthMask = 0
        ) const;

    void
    create(
        int rows,
        int cols,
        int type,
        int i = -1,
        bool allowTransposed = false,
        int fixedDepthMask = 0
        ) const;

    void
    create(
        int dims,
        const int* size,
        int type,
        int i = -1,
        bool allowTransposed = false,
        int fixedDepthMask = 0
        ) const;

    void
    createSameSize(
        const _InputArray& arr,
        int mtype
        ) const;

    bool
    fixedSize() const;

    bool
    fixedType() const;

    cuda::GpuMat&
    getGpuMatRef() const;

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

    cuda::HostMem&
    getHostMemRef() const;

    Mat&
    getMatRef(int i = -1) const;

    ogl::Buffer&
    getOGlBufferRef() const;

    UMat&
    getUMatRef(int i = -1) const;

    bool
    needed() const;

    void
    release() const;

    void
    setTo(
        const _InputArray& value,
        const _InputArray& mask = _InputArray()
        ) const;

protected:
    // fields

    int flags;
    void* obj;
    Size sz;

    // methods

    void
    init(
        int _flags,
        const void* _obj
        );

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