class cv::UMat

Overview

Todo document More…

#include <mat.hpp>

class UMat
{
public:
    // enums

    enum
    {
        MAGIC_VAL       = 0x42FF0000,
        AUTO_STEP       = 0,
        CONTINUOUS_FLAG = CV_MAT_CONT_FLAG,
        SUBMATRIX_FLAG  = CV_SUBMAT_FLAG,
    };

    enum
    {
        MAGIC_MASK = 0xFFFF0000,
        TYPE_MASK  = 0x00000FFF,
        DEPTH_MASK = 7,
    };

    // fields

    MatAllocator* allocator;
    int cols;
    int dims;
    int flags;
    size_t offset;
    int rows;
    MatSize size;
    MatStep step;
    UMatData* u;
    UMatUsageFlags usageFlags;

    // construction

    UMat(UMatUsageFlags usageFlags = USAGE_DEFAULT);

    UMat(
        int rows,
        int cols,
        int type,
        UMatUsageFlags usageFlags = USAGE_DEFAULT
        );

    UMat(
        Size size,
        int type,
        UMatUsageFlags usageFlags = USAGE_DEFAULT
        );

    UMat(
        int rows,
        int cols,
        int type,
        const Scalar& s,
        UMatUsageFlags usageFlags = USAGE_DEFAULT
        );

    UMat(
        Size size,
        int type,
        const Scalar& s,
        UMatUsageFlags usageFlags = USAGE_DEFAULT
        );

    UMat(
        int ndims,
        const int* sizes,
        int type,
        UMatUsageFlags usageFlags = USAGE_DEFAULT
        );

    UMat(
        int ndims,
        const int* sizes,
        int type,
        const Scalar& s,
        UMatUsageFlags usageFlags = USAGE_DEFAULT
        );

    UMat(const UMat& m);

    UMat(
        const UMat& m,
        const Range& rowRange,
        const Range& colRange = Range::all()
        );

    UMat(
        const UMat& m,
        const Rect& roi
        );

    UMat(
        const UMat& m,
        const Range* ranges
        );

    UMat(
        const UMat& m,
        const std::vector<Range>& ranges
        );

    template <typename _Tp>
    UMat(
        const std::vector<_Tp>& vec,
        bool copyData = false
        );

    template <
        typename _Tp,
        int n
        >
    UMat(
        const Vec<_Tp, n>& vec,
        bool copyData = true
        );

    template <
        typename _Tp,
        int m,
        int n
        >
    UMat(
        const Matx<_Tp, m, n>& mtx,
        bool copyData = true
        );

    template <typename _Tp>
    UMat(
        const Point_<_Tp>& pt,
        bool copyData = true
        );

    template <typename _Tp>
    UMat(
        const Point3_<_Tp>& pt,
        bool copyData = true
        );

    template <typename _Tp>
    UMat(const MatCommaInitializer_<_Tp>& commaInitializer);

    // methods

    void
    addref();

    UMat&
    adjustROI(
        int dtop,
        int dbottom,
        int dleft,
        int dright
        );

    void
    assignTo(
        UMat& m,
        int type = -1
        ) const;

    int
    channels() const;

    int
    checkVector(
        int elemChannels,
        int depth = -1,
        bool requireContinuous = true
        ) const;

    UMat
    clone() const;

    UMat
    col(int x) const;

    UMat
    colRange(
        int startcol,
        int endcol
        ) const;

    UMat
    colRange(const Range& r) const;

    void
    convertTo(
        OutputArray m,
        int rtype,
        double alpha = 1,
        double beta = 0
        ) const;

    void
    copySize(const UMat& m);

    void
    copyTo(OutputArray m) const;

    void
    copyTo(
        OutputArray m,
        InputArray mask
        ) const;

    void
    create(
        int rows,
        int cols,
        int type,
        UMatUsageFlags usageFlags = USAGE_DEFAULT
        );

    void
    create(
        Size size,
        int type,
        UMatUsageFlags usageFlags = USAGE_DEFAULT
        );

    void
    create(
        int ndims,
        const int* sizes,
        int type,
        UMatUsageFlags usageFlags = USAGE_DEFAULT
        );

    void
    create(
        const std::vector<int>& sizes,
        int type,
        UMatUsageFlags usageFlags = USAGE_DEFAULT
        );

    void
    deallocate();

    int
    depth() const;

    UMat
    diag(int d = 0) const;

    double
    dot(InputArray m) const;

    size_t
    elemSize() const;

    size_t
    elemSize1() const;

    bool
    empty() const;

    Mat
    getMat(int flags) const;

    void*
    handle(int accessFlags) const;

    UMat
    inv(int method = DECOMP_LU) const;

    bool
    isContinuous() const;

    bool
    isSubmatrix() const;

    void
    locateROI(
        Size& wholeSize,
        Point& ofs
        ) const;

    UMat
    mul(
        InputArray m,
        double scale = 1
        ) const;

    void
    ndoffset(size_t* ofs) const;

    UMat
    operator()(
        Range rowRange,
        Range colRange
        ) const;

    UMat
    operator()(const Rect& roi) const;

    UMat
    operator()(const Range* ranges) const;

    UMat
    operator()(const std::vector<Range>& ranges) const;

    UMat&
    operator=(const UMat& m);

    UMat&
    operator=(const Scalar& s);

    void
    release();

    UMat
    reshape(
        int cn,
        int rows = 0
        ) const;

    UMat
    reshape(
        int cn,
        int newndims,
        const int* newsz
        ) const;

    UMat
    row(int y) const;

    UMat
    rowRange(
        int startrow,
        int endrow
        ) const;

    UMat
    rowRange(const Range& r) const;

    UMat&
    setTo(
        InputArray value,
        InputArray mask = noArray()
        );

    size_t
    step1(int i = 0) const;

    UMat
    t() const;

    size_t
    total() const;

    int
    type() const;

    static
    UMat
    diag(const UMat& d);

    static
    UMat
    eye(
        int rows,
        int cols,
        int type
        );

    static
    UMat
    eye(
        Size size,
        int type
        );

    static
    MatAllocator*
    getStdAllocator();

    static
    UMat
    ones(
        int rows,
        int cols,
        int type
        );

    static
    UMat
    ones(
        Size size,
        int type
        );

    static
    UMat
    ones(
        int ndims,
        const int* sz,
        int type
        );

    static
    UMat
    zeros(
        int rows,
        int cols,
        int type
        );

    static
    UMat
    zeros(
        Size size,
        int type
        );

    static
    UMat
    zeros(
        int ndims,
        const int* sz,
        int type
        );
};

Detailed Documentation

Todo document

Fields

MatAllocator* allocator

custom allocator

int dims

the matrix dimensionality, >= 2

int flags

includes several bit-fields:

• the magic signature
• continuity flag
• depth
• number of channels

int rows

the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions

Construction

UMat(UMatUsageFlags usageFlags = USAGE_DEFAULT)

default constructor

UMat(
    int rows,
    int cols,
    int type,
    UMatUsageFlags usageFlags = USAGE_DEFAULT
    )

constructs 2D matrix of the specified size and type

UMat(
    int rows,
    int cols,
    int type,
    const Scalar& s,
    UMatUsageFlags usageFlags = USAGE_DEFAULT
    )

constucts 2D matrix and fills it with the specified value _s.

UMat(
    int ndims,
    const int* sizes,
    int type,
    UMatUsageFlags usageFlags = USAGE_DEFAULT
    )

constructs n-dimensional matrix

UMat(const UMat& m)

copy constructor

UMat(
    const UMat& m,
    const Range& rowRange,
    const Range& colRange = Range::all()
    )

creates a matrix header for a part of the bigger matrix

template <typename _Tp>
UMat(
    const std::vector<_Tp>& vec,
    bool copyData = false
    )

builds matrix from std::vector with or without copying the data

template <
    typename _Tp,
    int n
    >
UMat(
    const Vec<_Tp, n>& vec,
    bool copyData = true
    )

builds matrix from cv::Vec; the data is copied by default

template <
    typename _Tp,
    int m,
    int n
    >
UMat(
    const Matx<_Tp, m, n>& mtx,
    bool copyData = true
    )

builds matrix from cv::Matx; the data is copied by default

template <typename _Tp>
UMat(
    const Point_<_Tp>& pt,
    bool copyData = true
    )

builds matrix from a 2D point

template <typename _Tp>
UMat(
    const Point3_<_Tp>& pt,
    bool copyData = true
    )

builds matrix from a 3D point

template <typename _Tp>
UMat(const MatCommaInitializer_<_Tp>& commaInitializer)

builds matrix from comma initializer

Methods

void
addref()

increases the reference counter; use with care to avoid memleaks

UMat&
adjustROI(
    int dtop,
    int dbottom,
    int dleft,
    int dright
    )

moves/resizes the current matrix ROI inside the parent matrix.

int
channels() const

returns element type, similar to CV_MAT_CN(cvmat->type)

int
checkVector(
    int elemChannels,
    int depth = -1,
    bool requireContinuous = true
    ) const

returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number otherwise

UMat
clone() const

returns deep copy of the matrix, i.e. the data is copied

UMat
col(int x) const

returns a new matrix header for the specified column

UMat
colRange(
    int startcol,
    int endcol
    ) const

… for the specified column span

void
convertTo(
    OutputArray m,
    int rtype,
    double alpha = 1,
    double beta = 0
    ) const

converts matrix to another datatype with optional scalng. See cvConvertScale.

void
copySize(const UMat& m)

internal use function; properly re-allocates _size, _step arrays

void
copyTo(OutputArray m) const

copies the matrix content to “m”.

void
copyTo(
    OutputArray m,
    InputArray mask
    ) const

copies those matrix elements to “m” that are marked with non-zero mask elements.

void
create(
    int rows,
    int cols,
    int type,
    UMatUsageFlags usageFlags = USAGE_DEFAULT
    )

allocates new matrix data unless the matrix already has specified size and type.

void
deallocate()

deallocates the matrix data

int
depth() const

returns element type, similar to CV_MAT_DEPTH(cvmat->type)

UMat
diag(int d = 0) const

… for the specified diagonal (d=0 - the main diagonal, >0 - a diagonal from the upper half, <0 - a diagonal from the lower half)

double
dot(InputArray m) const

computes dot-product

size_t
elemSize() const

returns element size in bytes,

size_t
elemSize1() const

returns the size of element channel in bytes.

bool
empty() const

returns true if matrix data is NULL

void*
handle(int accessFlags) const

Returns the OpenCL buffer handle on which UMat operates on. The UMat instance should be kept alive during the use of the handle to prevent the buffer to be returned to the OpenCV buffer pool.

UMat
inv(int method = DECOMP_LU) const

matrix inversion by means of matrix expressions

bool
isContinuous() const

returns true iff the matrix data is continuous

bool
isSubmatrix() const

returns true if the matrix is a submatrix of another matrix

void
locateROI(
    Size& wholeSize,
    Point& ofs
    ) const

locates matrix header within a parent matrix. See below

UMat
mul(
    InputArray m,
    double scale = 1
    ) const

per-element matrix multiplication by means of matrix expressions

UMat
operator()(
    Range rowRange,
    Range colRange
    ) const

extracts a rectangular sub-matrix

UMat&
operator=(const UMat& m)

assignment operators

UMat&
operator=(const Scalar& s)

sets every matrix element to s

void
release()

decreases reference counter;

UMat
reshape(
    int cn,
    int rows = 0
    ) const

creates alternative matrix header for the same data, with different

UMat
row(int y) const

returns a new matrix header for the specified row

UMat
rowRange(
    int startrow,
    int endrow
    ) const

… for the specified row span

UMat&
setTo(
    InputArray value,
    InputArray mask = noArray()
    )

sets some of the matrix elements to s, according to the mask

size_t
step1(int i = 0) const

returns step/elemSize1()

UMat
t() const

matrix transposition by means of matrix expressions

size_t
total() const

returns the total number of matrix elements

int
type() const

returns element type, similar to CV_MAT_TYPE(cvmat->type)

static
UMat
diag(const UMat& d)

constructs a square diagonal matrix which main diagonal is vector “d”

static
MatAllocator*
getStdAllocator()

and the standard allocator

static
UMat
zeros(
    int rows,
    int cols,
    int type
    )

Matlab-style matrix initialization.