UMat (JavaCPP Presets for OpenCV 4.3.0-1.5.3 API)

java.lang.Object
- org.bytedeco.javacpp.Pointer
- - org.bytedeco.opencv.opencv_core.UMat

All Implemented Interfaces:: AutoCloseable

@Namespace(value="cv")
 @NoOffset
 @Properties(inherit=opencv_core.class)
public class UMat
extends Pointer

\todo document

Nested Class Summary
- Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer
  Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`AUTO_STEP` enum cv::UMat::
`static int`	`CONTINUOUS_FLAG` enum cv::UMat::
`static int`	`DEPTH_MASK` enum cv::UMat::
`static int`	`MAGIC_MASK` enum cv::UMat::
`static int`	`MAGIC_VAL` enum cv::UMat::
`static int`	`SUBMATRIX_FLAG` enum cv::UMat::
`static int`	`TYPE_MASK` enum cv::UMat::

Fields inherited from class org.bytedeco.javacpp.Pointer
address, capacity, limit, position

Constructor Summary

Constructors
Constructor and Description
`UMat()`
`UMat(int usageFlags)` default constructor
`UMat(int ndims, int[] sizes, int type)`
`UMat(int ndims, int[] sizes, int type, int usageFlags)`
`UMat(int ndims, int[] sizes, int type, Scalar s)`
`UMat(int ndims, int[] sizes, int type, Scalar s, int usageFlags)`
`UMat(int ndims, IntBuffer sizes, int type)`
`UMat(int ndims, IntBuffer sizes, int type, int usageFlags)`
`UMat(int ndims, IntBuffer sizes, int type, Scalar s)`
`UMat(int ndims, IntBuffer sizes, int type, Scalar s, int usageFlags)`
`UMat(int rows, int cols, int type)`
`UMat(int rows, int cols, int type, int usageFlags)` constructs 2D matrix of the specified size and type
`UMat(int rows, int cols, int type, Scalar s)`
`UMat(int rows, int cols, int type, Scalar s, int usageFlags)` constructs 2D matrix and fills it with the specified value _s.
`UMat(int ndims, IntPointer sizes, int type)`
`UMat(int ndims, IntPointer sizes, int type, int usageFlags)` constructs n-dimensional matrix
`UMat(int ndims, IntPointer sizes, int type, Scalar s)`
`UMat(int ndims, IntPointer sizes, int type, Scalar s, int usageFlags)`
`UMat(Pointer p)` Pointer cast constructor.
`UMat(Size size, int type)`
`UMat(Size size, int type, int usageFlags)`
`UMat(Size size, int type, Scalar s)`
`UMat(Size size, int type, Scalar s, int usageFlags)`
`UMat(UMat m)` copy constructor
`UMat(UMat m, Range rowRange)`
`UMat(UMat m, Range rowRange, Range colRange)` creates a matrix header for a part of the bigger matrix
`UMat(UMat m, Rect roi)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`_deallocate()` deallocates the matrix data
`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.
`MatAllocator`	`allocator()` custom allocator
`UMat`	`allocator(MatAllocator setter)`
`UMat`	`apply(Range ranges)`
`UMat`	`apply(Range rowRange, Range colRange)` extracts a rectangular sub-matrix
`UMat`	`apply(Rect roi)`
`void`	`assignTo(UMat m)`
`void`	`assignTo(UMat m, int type)`
`int`	`channels()` returns element type, similar to CV_MAT_CN(cvmat->type)
`int`	`checkVector(int elemChannels)`
`int`	`checkVector(int elemChannels, int depth, boolean requireContinuous)` 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()` returns deep copy of the matrix, i.e.
`UMat`	`col(int x)` returns a new matrix header for the specified column
`UMat`	`colRange(int startcol, int endcol)` ...
`UMat`	`colRange(Range r)`
`int`	`cols()`
`UMat`	`cols(int setter)`
`void`	`convertTo(GpuMat m, int rtype)`
`void`	`convertTo(GpuMat m, int rtype, double alpha, double beta)`
`void`	`convertTo(Mat m, int rtype)`
`void`	`convertTo(Mat m, int rtype, double alpha, double beta)` converts matrix to another datatype with optional scaling.
`void`	`convertTo(UMat m, int rtype)`
`void`	`convertTo(UMat m, int rtype, double alpha, double beta)`
`void`	`copySize(UMat m)` internal use function; properly re-allocates _size, _step arrays
`void`	`copyTo(GpuMat m)`
`void`	`copyTo(GpuMat m, GpuMat mask)`
`void`	`copyTo(Mat m)` copies the matrix content to "m".
`void`	`copyTo(Mat m, Mat mask)` copies those matrix elements to "m" that are marked with non-zero mask elements.
`void`	`copyTo(UMat m)`
`void`	`copyTo(UMat m, UMat mask)`
`void`	`create(int[] sizes, int type)`
`void`	`create(int[] sizes, int type, int usageFlags)`
`void`	`create(IntBuffer sizes, int type)`
`void`	`create(IntBuffer sizes, int type, int usageFlags)`
`void`	`create(int ndims, int[] sizes, int type)`
`void`	`create(int ndims, int[] sizes, int type, int usageFlags)`
`void`	`create(int ndims, IntBuffer sizes, int type)`
`void`	`create(int ndims, IntBuffer sizes, int type, int usageFlags)`
`void`	`create(int rows, int cols, int type)`
`void`	`create(int rows, int cols, int type, int usageFlags)` allocates new matrix data unless the matrix already has specified size and type.
`void`	`create(int ndims, IntPointer sizes, int type)`
`void`	`create(int ndims, IntPointer sizes, int type, int usageFlags)`
`void`	`create(IntPointer sizes, int type)`
`void`	`create(IntPointer sizes, int type, int usageFlags)`
`void`	`create(Size size, int type)`
`void`	`create(Size size, int type, int usageFlags)`
`int`	`depth()` returns element type, similar to CV_MAT_DEPTH(cvmat->type)
`UMat`	`diag()`
`UMat`	`diag(int d)` ...
`static UMat`	`diag(UMat d)` constructs a square diagonal matrix which main diagonal is vector "d"
`int`	`dims()` the matrix dimensionality, >= 2
`UMat`	`dims(int setter)`
`double`	`dot(GpuMat m)`
`double`	`dot(Mat m)` computes dot-product
`double`	`dot(UMat m)`
`long`	`elemSize()` returns element size in bytes,
`long`	`elemSize1()` returns the size of element channel in bytes.
`boolean`	`empty()` returns true if matrix data is NULL
`static UMat`	`eye(int rows, int cols, int type)`
`static UMat`	`eye(Size size, int type)`
`int`	`flags()` includes several bit-fields: - the magic signature - continuity flag - depth - number of channels
`UMat`	`flags(int setter)`
`Mat`	`getMat(int flags)`
`static MatAllocator`	`getStdAllocator()` and the standard allocator
`Pointer`	`handle(int accessFlags)` Returns the OpenCL buffer handle on which UMat operates on.
`UMat`	`inv()`
`UMat`	`inv(int method)` matrix inversion by means of matrix expressions
`boolean`	`isContinuous()` returns true iff the matrix data is continuous
`boolean`	`isSubmatrix()` returns true if the matrix is a submatrix of another matrix
`void`	`locateROI(Size wholeSize, Point ofs)` locates matrix header within a parent matrix.
`UMat`	`mul(GpuMat m)`
`UMat`	`mul(GpuMat m, double scale)`
`UMat`	`mul(Mat m)`
`UMat`	`mul(Mat m, double scale)` per-element matrix multiplication by means of matrix expressions
`UMat`	`mul(UMat m)`
`UMat`	`mul(UMat m, double scale)`
`void`	`ndoffset(SizeTPointer ofs)`
`long`	`offset()`
`UMat`	`offset(long setter)`
`static UMat`	`ones(int rows, int cols, int type)`
`static UMat`	`ones(Size size, int type)`
`UMat`	`put(Scalar s)` sets every matrix element to s
`UMat`	`put(UMat m)` assignment operators
`void`	`release()` decreases reference counter;
`UMat`	`reshape(int cn)`
`UMat`	`reshape(int cn, int rows)` creates alternative matrix header for the same data, with different
`UMat`	`reshape(int cn, int newndims, int[] newsz)`
`UMat`	`reshape(int cn, int newndims, IntBuffer newsz)`
`UMat`	`reshape(int cn, int newndims, IntPointer newsz)`
`UMat`	`row(int y)` returns a new matrix header for the specified row
`UMat`	`rowRange(int startrow, int endrow)` ...
`UMat`	`rowRange(Range r)`
`int`	`rows()` the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
`UMat`	`rows(int setter)`
`UMat`	`setTo(GpuMat value)`
`UMat`	`setTo(GpuMat value, GpuMat mask)`
`UMat`	`setTo(Mat value)`
`UMat`	`setTo(Mat value, Mat mask)` sets some of the matrix elements to s, according to the mask
`UMat`	`setTo(UMat value)`
`UMat`	`setTo(UMat value, UMat mask)`
`Size`	`size()`
`int`	`size(int i)`
`long`	`step()`
`long`	`step(int i)`
`long`	`step1()`
`long`	`step1(int i)` returns step/elemSize1()
`UMat`	`t()` matrix transposition by means of matrix expressions
`long`	`total()` returns the total number of matrix elements
`int`	`type()` returns element type, similar to CV_MAT_TYPE(cvmat->type)
`UMatData`	`u()`
`UMat`	`u(UMatData setter)`
`void`	`updateContinuityFlag()` internal use method: updates the continuity flag
`int`	`usageFlags()`
`UMat`	`usageFlags(int setter)`
`static UMat`	`zeros(int rows, int cols, int type)` Matlab-style matrix initialization
`static UMat`	`zeros(Size size, int type)`

Methods inherited from class org.bytedeco.javacpp.Pointer
address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, toString, totalBytes, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail
- MAGIC_VAL
```
public static final int MAGIC_VAL
```
  enum cv::UMat::
  
  See Also:
  
  Constant Field Values
- AUTO_STEP
```
public static final int AUTO_STEP
```
  enum cv::UMat::
  
  See Also:
  
  Constant Field Values
- CONTINUOUS_FLAG
```
public static final int CONTINUOUS_FLAG
```
  enum cv::UMat::
  
  See Also:
  
  Constant Field Values
- SUBMATRIX_FLAG
```
public static final int SUBMATRIX_FLAG
```
  enum cv::UMat::
  
  See Also:
  
  Constant Field Values
- MAGIC_MASK
```
public static final int MAGIC_MASK
```
  enum cv::UMat::
  
  See Also:
  
  Constant Field Values
- TYPE_MASK
```
public static final int TYPE_MASK
```
  enum cv::UMat::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK
```
public static final int DEPTH_MASK
```
  enum cv::UMat::
  
  See Also:
  
  Constant Field Values

Constructor Detail

UMat
```
public UMat(Pointer p)
```
Pointer cast constructor. Invokes Pointer.Pointer(Pointer).

UMat

public UMat(@Cast(value="cv::UMatUsageFlags")
            int usageFlags)

default constructor

UMat
```
public UMat()
```

UMat

public UMat(int rows,
            int cols,
            int type,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

constructs 2D matrix of the specified size and type

UMat

public UMat(int rows,
            int cols,
            int type)

UMat

public UMat(@ByVal
            Size size,
            int type,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

UMat

public UMat(@ByVal
            Size size,
            int type)

UMat

public UMat(int rows,
            int cols,
            int type,
            @Const @ByRef
            Scalar s,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

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

UMat

public UMat(int rows,
            int cols,
            int type,
            @Const @ByRef
            Scalar s)

UMat

public UMat(@ByVal
            Size size,
            int type,
            @Const @ByRef
            Scalar s,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

UMat

public UMat(@ByVal
            Size size,
            int type,
            @Const @ByRef
            Scalar s)

UMat

public UMat(int ndims,
            @Const
            IntPointer sizes,
            int type,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

constructs n-dimensional matrix

UMat

public UMat(int ndims,
            @Const
            IntPointer sizes,
            int type)

UMat

public UMat(int ndims,
            @Const
            IntBuffer sizes,
            int type,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

UMat

public UMat(int ndims,
            @Const
            IntBuffer sizes,
            int type)

UMat

public UMat(int ndims,
            @Const
            int[] sizes,
            int type,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

UMat

public UMat(int ndims,
            @Const
            int[] sizes,
            int type)

UMat

public UMat(int ndims,
            @Const
            IntPointer sizes,
            int type,
            @Const @ByRef
            Scalar s,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

UMat

public UMat(int ndims,
            @Const
            IntPointer sizes,
            int type,
            @Const @ByRef
            Scalar s)

UMat

public UMat(int ndims,
            @Const
            IntBuffer sizes,
            int type,
            @Const @ByRef
            Scalar s,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

UMat

public UMat(int ndims,
            @Const
            IntBuffer sizes,
            int type,
            @Const @ByRef
            Scalar s)

UMat

public UMat(int ndims,
            @Const
            int[] sizes,
            int type,
            @Const @ByRef
            Scalar s,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

UMat

public UMat(int ndims,
            @Const
            int[] sizes,
            int type,
            @Const @ByRef
            Scalar s)

UMat

public UMat(@Const @ByRef
            UMat m)

copy constructor

UMat

public UMat(@Const @ByRef
            UMat m,
            @Const @ByRef
            Range rowRange,
            @Const @ByRef(nullValue="cv::Range::all()")
            Range colRange)

creates a matrix header for a part of the bigger matrix

UMat

public UMat(@Const @ByRef
            UMat m,
            @Const @ByRef
            Range rowRange)

UMat

public UMat(@Const @ByRef
            UMat m,
            @Const @ByRef
            Rect roi)

Method Detail

put

@ByRef
 @Name(value="operator =")
public UMat put(@Const @ByRef
                                                  UMat m)

assignment operators

getMat

@ByVal
public Mat getMat(@Cast(value="cv::AccessFlag")
                         int flags)

row
```
@ByVal
public UMat row(int y)
```
returns a new matrix header for the specified row

col
```
@ByVal
public UMat col(int x)
```
returns a new matrix header for the specified column

rowRange

@ByVal
public UMat rowRange(int startrow,
                            int endrow)

... for the specified row span

rowRange

@ByVal
public UMat rowRange(@Const @ByRef
                            Range r)

colRange

@ByVal
public UMat colRange(int startcol,
                            int endcol)

... for the specified column span

colRange

@ByVal
public UMat colRange(@Const @ByRef
                            Range r)

diag
```
@ByVal
public UMat diag(int d)
```
... for the specified diagonal (d=0 - the main diagonal, >0 - a diagonal from the upper half, <0 - a diagonal from the lower half)

diag
```
@ByVal
public UMat diag()
```

diag

@ByVal
public static UMat diag(@Const @ByRef
                               UMat d)

constructs a square diagonal matrix which main diagonal is vector "d"

clone
```
@ByVal
public UMat clone()
```
returns deep copy of the matrix, i.e. the data is copied

Overrides:

clone in class Object

copyTo

public void copyTo(@ByVal
                   Mat m)

copies the matrix content to "m".

copyTo

public void copyTo(@ByVal
                   UMat m)

copyTo

public void copyTo(@ByVal
                   GpuMat m)

copyTo

public void copyTo(@ByVal
                   Mat m,
                   @ByVal
                   Mat mask)

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

copyTo

public void copyTo(@ByVal
                   UMat m,
                   @ByVal
                   UMat mask)

copyTo

public void copyTo(@ByVal
                   GpuMat m,
                   @ByVal
                   GpuMat mask)

convertTo

public void convertTo(@ByVal
                      Mat m,
                      int rtype,
                      double alpha,
                      double beta)

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

convertTo

public void convertTo(@ByVal
                      Mat m,
                      int rtype)

convertTo

public void convertTo(@ByVal
                      UMat m,
                      int rtype,
                      double alpha,
                      double beta)

convertTo

public void convertTo(@ByVal
                      UMat m,
                      int rtype)

convertTo

public void convertTo(@ByVal
                      GpuMat m,
                      int rtype,
                      double alpha,
                      double beta)

convertTo

public void convertTo(@ByVal
                      GpuMat m,
                      int rtype)

assignTo

public void assignTo(@ByRef
                     UMat m,
                     int type)

assignTo

public void assignTo(@ByRef
                     UMat m)

put

@ByRef
 @Name(value="operator =")
public UMat put(@Const @ByRef
                                                  Scalar s)

sets every matrix element to s

setTo

@ByRef
public UMat setTo(@ByVal
                         Mat value,
                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                         Mat mask)

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

setTo

@ByRef
public UMat setTo(@ByVal
                         Mat value)

setTo

@ByRef
public UMat setTo(@ByVal
                         UMat value,
                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                         UMat mask)

setTo

@ByRef
public UMat setTo(@ByVal
                         UMat value)

setTo

@ByRef
public UMat setTo(@ByVal
                         GpuMat value,
                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                         GpuMat mask)

setTo

@ByRef
public UMat setTo(@ByVal
                         GpuMat value)

reshape

@ByVal
public UMat reshape(int cn,
                           int rows)

creates alternative matrix header for the same data, with different

reshape
```
@ByVal
public UMat reshape(int cn)
```

reshape

@ByVal
public UMat reshape(int cn,
                           int newndims,
                           @Const
                           IntPointer newsz)

reshape

@ByVal
public UMat reshape(int cn,
                           int newndims,
                           @Const
                           IntBuffer newsz)

reshape

@ByVal
public UMat reshape(int cn,
                           int newndims,
                           @Const
                           int[] newsz)

t
```
@ByVal
public UMat t()
```
matrix transposition by means of matrix expressions

inv
```
@ByVal
public UMat inv(int method)
```
matrix inversion by means of matrix expressions

inv
```
@ByVal
public UMat inv()
```

mul

@ByVal
public UMat mul(@ByVal
                       Mat m,
                       double scale)

per-element matrix multiplication by means of matrix expressions

mul

@ByVal
public UMat mul(@ByVal
                       Mat m)

mul

@ByVal
public UMat mul(@ByVal
                       UMat m,
                       double scale)

mul

@ByVal
public UMat mul(@ByVal
                       UMat m)

mul

@ByVal
public UMat mul(@ByVal
                       GpuMat m,
                       double scale)

mul

@ByVal
public UMat mul(@ByVal
                       GpuMat m)

dot

public double dot(@ByVal
                  Mat m)

computes dot-product

dot

public double dot(@ByVal
                  UMat m)

dot

public double dot(@ByVal
                  GpuMat m)

zeros

@ByVal
public static UMat zeros(int rows,
                                int cols,
                                int type)

Matlab-style matrix initialization

zeros

@ByVal
public static UMat zeros(@ByVal
                                Size size,
                                int type)

ones

@ByVal
public static UMat ones(int rows,
                               int cols,
                               int type)

ones

@ByVal
public static UMat ones(@ByVal
                               Size size,
                               int type)

eye

@ByVal
public static UMat eye(int rows,
                              int cols,
                              int type)

eye

@ByVal
public static UMat eye(@ByVal
                              Size size,
                              int type)

create

public void create(int rows,
                   int cols,
                   int type,
                   @Cast(value="cv::UMatUsageFlags")
                   int usageFlags)

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

create

public void create(int rows,
                   int cols,
                   int type)

create

public void create(@ByVal
                   Size size,
                   int type,
                   @Cast(value="cv::UMatUsageFlags")
                   int usageFlags)

create

public void create(@ByVal
                   Size size,
                   int type)

create

public void create(int ndims,
                   @Const
                   IntPointer sizes,
                   int type,
                   @Cast(value="cv::UMatUsageFlags")
                   int usageFlags)

create

public void create(int ndims,
                   @Const
                   IntPointer sizes,
                   int type)

create

public void create(int ndims,
                   @Const
                   IntBuffer sizes,
                   int type,
                   @Cast(value="cv::UMatUsageFlags")
                   int usageFlags)

create

public void create(int ndims,
                   @Const
                   IntBuffer sizes,
                   int type)

create

public void create(int ndims,
                   @Const
                   int[] sizes,
                   int type,
                   @Cast(value="cv::UMatUsageFlags")
                   int usageFlags)

create

public void create(int ndims,
                   @Const
                   int[] sizes,
                   int type)

create

public void create(@StdVector
                   IntPointer sizes,
                   int type,
                   @Cast(value="cv::UMatUsageFlags")
                   int usageFlags)

create

public void create(@StdVector
                   IntPointer sizes,
                   int type)

create

public void create(@StdVector
                   IntBuffer sizes,
                   int type,
                   @Cast(value="cv::UMatUsageFlags")
                   int usageFlags)

create

public void create(@StdVector
                   IntBuffer sizes,
                   int type)

create

public void create(@StdVector
                   int[] sizes,
                   int type,
                   @Cast(value="cv::UMatUsageFlags")
                   int usageFlags)

create

public void create(@StdVector
                   int[] sizes,
                   int type)

addref
```
public void addref()
```
increases the reference counter; use with care to avoid memleaks

release
```
public void release()
```
decreases reference counter;

_deallocate

@Name(value="deallocate")
public void _deallocate()

deallocates the matrix data

copySize

public void copySize(@Const @ByRef
                     UMat m)

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

locateROI

public void locateROI(@ByRef
                      Size wholeSize,
                      @ByRef
                      Point ofs)

locates matrix header within a parent matrix. See below

adjustROI

@ByRef
public UMat adjustROI(int dtop,
                             int dbottom,
                             int dleft,
                             int dright)

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

apply

@ByVal
 @Name(value="operator ()")
public UMat apply(@ByVal
                                                     Range rowRange,
                                                     @ByVal
                                                     Range colRange)

extracts a rectangular sub-matrix

apply

@ByVal
 @Name(value="operator ()")
public UMat apply(@Const @ByRef
                                                     Rect roi)

apply

@ByVal
 @Name(value="operator ()")
public UMat apply(@Const
                                                     Range ranges)

isContinuous
```
@Cast(value="bool")
public boolean isContinuous()
```
returns true iff the matrix data is continuous

isSubmatrix
```
@Cast(value="bool")
public boolean isSubmatrix()
```
returns true if the matrix is a submatrix of another matrix

elemSize

@Cast(value="size_t")
public long elemSize()

returns element size in bytes,

elemSize1
```
@Cast(value="size_t")
public long elemSize1()
```
returns the size of element channel in bytes.

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

depth
```
public int depth()
```
returns element type, similar to CV_MAT_DEPTH(cvmat->type)

channels
```
public int channels()
```
returns element type, similar to CV_MAT_CN(cvmat->type)

step1

@Cast(value="size_t")
public long step1(int i)

returns step/elemSize1()

step1

@Cast(value="size_t")
public long step1()

empty

@Cast(value="bool")
public boolean empty()

returns true if matrix data is NULL

total
```
@Cast(value="size_t")
public long total()
```
returns the total number of matrix elements

checkVector

public int checkVector(int elemChannels,
                       int depth,
                       @Cast(value="bool")
                       boolean requireContinuous)

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

checkVector

public int checkVector(int elemChannels)

handle
```
public Pointer handle(@Cast(value="cv::AccessFlag")
                      int accessFlags)
```
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.

ndoffset

public void ndoffset(@Cast(value="size_t*")
                     SizeTPointer ofs)

flags
```
public int flags()
```
includes several bit-fields: - the magic signature - continuity flag - depth - number of channels

flags
```
public UMat flags(int setter)
```

dims
```
public int dims()
```
the matrix dimensionality, >= 2

dims
```
public UMat dims(int setter)
```

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

rows
```
public UMat rows(int setter)
```

cols
```
public int cols()
```

cols
```
public UMat cols(int setter)
```

allocator
```
public MatAllocator allocator()
```
custom allocator

allocator

public UMat allocator(MatAllocator setter)

usageFlags

@Cast(value="cv::UMatUsageFlags")
public int usageFlags()

usageFlags
```
public UMat usageFlags(int setter)
```

getStdAllocator

public static MatAllocator getStdAllocator()

and the standard allocator

updateContinuityFlag
```
public void updateContinuityFlag()
```
internal use method: updates the continuity flag

u
```
public UMatData u()
```

u
```
public UMat u(UMatData setter)
```

offset

@Cast(value="size_t")
public long offset()

offset
```
public UMat offset(long setter)
```

size
```
@ByVal
public Size size()
```

size
```
@MemberGetter
public int size(int i)
```

step
```
@MemberGetter
public long step()
```

step

@MemberGetter
public long step(int i)

Class UMat

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.javacpp.Pointer

Methods inherited from class java.lang.Object

Field Detail

MAGIC_VAL

AUTO_STEP

CONTINUOUS_FLAG

SUBMATRIX_FLAG

MAGIC_MASK

TYPE_MASK

DEPTH_MASK

Constructor Detail

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

UMat

Method Detail

put

getMat

row

col

rowRange

rowRange

colRange

colRange

diag

diag

diag

clone

copyTo

copyTo

copyTo

copyTo

copyTo

copyTo

convertTo

convertTo

convertTo

convertTo

convertTo

convertTo

assignTo

assignTo

put

setTo

setTo

setTo

setTo

setTo

setTo

reshape