opencv_core.UMat (JavaCPP Presets for OpenCV 3.1.0-1.2 API)

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

All Implemented Interfaces:: AutoCloseable

Enclosing class:: opencv_core

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

\todo document

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

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
`opencv_core.UMat()`
`opencv_core.UMat(int usageFlags)` default constructor
`opencv_core.UMat(int ndims, int[] sizes, int type)`
`opencv_core.UMat(int ndims, int[] sizes, int type, int usageFlags)`
`opencv_core.UMat(int ndims, int[] sizes, int type, opencv_core.Scalar s)`
`opencv_core.UMat(int ndims, int[] sizes, int type, opencv_core.Scalar s, int usageFlags)`
`opencv_core.UMat(int ndims, IntBuffer sizes, int type)`
`opencv_core.UMat(int ndims, IntBuffer sizes, int type, int usageFlags)`
`opencv_core.UMat(int ndims, IntBuffer sizes, int type, opencv_core.Scalar s)`
`opencv_core.UMat(int ndims, IntBuffer sizes, int type, opencv_core.Scalar s, int usageFlags)`
`opencv_core.UMat(int rows, int cols, int type)`
`opencv_core.UMat(int rows, int cols, int type, int usageFlags)` constructs 2D matrix of the specified size and type
`opencv_core.UMat(int rows, int cols, int type, opencv_core.Scalar s)`
`opencv_core.UMat(int rows, int cols, int type, opencv_core.Scalar s, int usageFlags)` constucts 2D matrix and fills it with the specified value _s.
`opencv_core.UMat(int ndims, IntPointer sizes, int type)`
`opencv_core.UMat(int ndims, IntPointer sizes, int type, int usageFlags)` constructs n-dimensional matrix
`opencv_core.UMat(int ndims, IntPointer sizes, int type, opencv_core.Scalar s)`
`opencv_core.UMat(int ndims, IntPointer sizes, int type, opencv_core.Scalar s, int usageFlags)`
`opencv_core.UMat(long size)` Native array allocator.
`opencv_core.UMat(opencv_core.Size size, int type)`
`opencv_core.UMat(opencv_core.Size size, int type, int usageFlags)`
`opencv_core.UMat(opencv_core.Size size, int type, opencv_core.Scalar s)`
`opencv_core.UMat(opencv_core.Size size, int type, opencv_core.Scalar s, int usageFlags)`
`opencv_core.UMat(opencv_core.UMat m)` copy constructor
`opencv_core.UMat(opencv_core.UMat m, opencv_core.Range rowRange)`
`opencv_core.UMat(opencv_core.UMat m, opencv_core.Range rowRange, opencv_core.Range colRange)` creates a matrix header for a part of the bigger matrix
`opencv_core.UMat(opencv_core.UMat m, opencv_core.Rect roi)`
`opencv_core.UMat(Pointer p)` Pointer cast constructor.

Method Summary

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
`opencv_core.UMat`	`adjustROI(int dtop, int dbottom, int dleft, int dright)` moves/resizes the current matrix ROI inside the parent matrix.
`opencv_core.MatAllocator`	`allocator()` custom allocator
`opencv_core.UMat`	`allocator(opencv_core.MatAllocator allocator)`
`opencv_core.UMat`	`apply(opencv_core.Range ranges)`
`opencv_core.UMat`	`apply(opencv_core.Range rowRange, opencv_core.Range colRange)` extracts a rectangular sub-matrix
`opencv_core.UMat`	`apply(opencv_core.Rect roi)`
`void`	`assignTo(opencv_core.UMat m)`
`void`	`assignTo(opencv_core.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
`opencv_core.UMat`	`clone()` returns deep copy of the matrix, i.e.
`opencv_core.UMat`	`col(int x)` returns a new matrix header for the specified column
`opencv_core.UMat`	`colRange(int startcol, int endcol)` ...
`opencv_core.UMat`	`colRange(opencv_core.Range r)`
`int`	`cols()`
`opencv_core.UMat`	`cols(int cols)`
`void`	`convertTo(opencv_core.Mat m, int rtype)`
`void`	`convertTo(opencv_core.Mat m, int rtype, double alpha, double beta)` converts matrix to another datatype with optional scalng.
`void`	`copySize(opencv_core.UMat m)` internal use function; properly re-allocates _size, _step arrays
`void`	`copyTo(opencv_core.Mat m)` copies the matrix content to "m".
`void`	`copyTo(opencv_core.Mat m, opencv_core.Mat mask)` copies those matrix elements to "m" that are marked with non-zero mask elements.
`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(opencv_core.Size size, int type)`
`void`	`create(opencv_core.Size size, int type, int usageFlags)`
`int`	`depth()` returns element type, similar to CV_MAT_DEPTH(cvmat->type)
`opencv_core.UMat`	`diag()`
`opencv_core.UMat`	`diag(int d)` ...
`static opencv_core.UMat`	`diag(opencv_core.UMat d)` constructs a square diagonal matrix which main diagonal is vector "d"
`int`	`dims()` the matrix dimensionality, >= 2
`opencv_core.UMat`	`dims(int dims)`
`double`	`dot(opencv_core.Mat m)` computes dot-product
`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 opencv_core.UMat`	`eye(int rows, int cols, int type)`
`static opencv_core.UMat`	`eye(opencv_core.Size size, int type)`
`int`	`flags()` includes several bit-fields: - the magic signature - continuity flag - depth - number of channels
`opencv_core.UMat`	`flags(int flags)`
`opencv_core.Mat`	`getMat(int flags)`
`static opencv_core.MatAllocator`	`getStdAllocator()` and the standard allocator
`Pointer`	`handle(int accessFlags)`
`opencv_core.UMat`	`inv()`
`opencv_core.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(opencv_core.Size wholeSize, opencv_core.Point ofs)` locates matrix header within a parent matrix.
`opencv_core.UMat`	`mul(opencv_core.Mat m)`
`opencv_core.UMat`	`mul(opencv_core.Mat m, double scale)` per-element matrix multiplication by means of matrix expressions
`void`	`ndoffset(SizeTPointer ofs)`
`long`	`offset()`
`opencv_core.UMat`	`offset(long offset)`
`static opencv_core.UMat`	`ones(int rows, int cols, int type)`
`static opencv_core.UMat`	`ones(opencv_core.Size size, int type)`
`opencv_core.UMat`	`position(long position)`
`opencv_core.UMat`	`put(opencv_core.Scalar s)` sets every matrix element to s
`opencv_core.UMat`	`put(opencv_core.UMat m)` assignment operators
`void`	`release()` decreases reference counter;
`opencv_core.UMat`	`reshape(int cn)`
`opencv_core.UMat`	`reshape(int cn, int rows)` creates alternative matrix header for the same data, with different
`opencv_core.UMat`	`reshape(int cn, int newndims, int[] newsz)`
`opencv_core.UMat`	`reshape(int cn, int newndims, IntBuffer newsz)`
`opencv_core.UMat`	`reshape(int cn, int newndims, IntPointer newsz)`
`opencv_core.UMat`	`row(int y)` returns a new matrix header for the specified row
`opencv_core.UMat`	`rowRange(int startrow, int endrow)` ...
`opencv_core.UMat`	`rowRange(opencv_core.Range r)`
`int`	`rows()` the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
`opencv_core.UMat`	`rows(int rows)`
`opencv_core.UMat`	`setTo(opencv_core.Mat value)`
`opencv_core.UMat`	`setTo(opencv_core.Mat value, opencv_core.Mat mask)` sets some of the matrix elements to s, according to the mask
`opencv_core.Size`	`size()`
`int`	`size(int i)`
`long`	`step()`
`int`	`step(int i)`
`long`	`step1()`
`long`	`step1(int i)` returns step/elemSize1()
`opencv_core.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)
`opencv_core.UMatData`	`u()`
`opencv_core.UMat`	`u(opencv_core.UMatData u)`
`int`	`usageFlags()`
`opencv_core.UMat`	`usageFlags(int usageFlags)`
`static opencv_core.UMat`	`zeros(int rows, int cols, int type)` Matlab-style matrix initialization
`static opencv_core.UMat`	`zeros(opencv_core.Size size, int type)`

Methods inherited from class org.bytedeco.javacpp.Pointer
address, asBuffer, asByteBuffer, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, hashCode, isNull, limit, limit, maxBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, position, put, setNull, sizeof, toString, totalBytes, 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

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

opencv_core.UMat
```
public opencv_core.UMat(long size)
```
Native array allocator. Access with Pointer.position(long).

opencv_core.UMat

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

default constructor

opencv_core.UMat
```
public opencv_core.UMat()
```

opencv_core.UMat

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

constructs 2D matrix of the specified size and type

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

public opencv_core.UMat(@ByVal
                opencv_core.Size size,
                int type)

opencv_core.UMat

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

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

constructs n-dimensional matrix

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

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

opencv_core.UMat

public opencv_core.UMat(@Const@ByRef
                opencv_core.UMat m)

copy constructor

opencv_core.UMat

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

creates a matrix header for a part of the bigger matrix

opencv_core.UMat

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

opencv_core.UMat

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

Method Detail

position

public opencv_core.UMat position(long position)

Overrides:: position in class Pointer

put

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

assignment operators

getMat

@ByVal
public opencv_core.Mat getMat(int flags)

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

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

rowRange

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

... for the specified row span

rowRange

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

colRange

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

... for the specified column span

colRange

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

diag

@ByVal
public opencv_core.UMat diag(int d)

... for the specified diagonal

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

diag

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

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

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

Overrides:

clone in class Object

copyTo

public void copyTo(@ByVal
          opencv_core.Mat m)

copies the matrix content to "m".

copyTo

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

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

convertTo

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

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

convertTo

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

assignTo

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

assignTo

public void assignTo(@ByRef
            opencv_core.UMat m)

put

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

sets every matrix element to s

setTo

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

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

setTo

@ByRef
public opencv_core.UMat setTo(@ByVal
                           opencv_core.Mat value)

reshape

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

creates alternative matrix header for the same data, with different

reshape

@ByVal
public opencv_core.UMat reshape(int cn)

reshape

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

reshape

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

reshape

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

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

inv

@ByVal
public opencv_core.UMat inv(int method)

matrix inversion by means of matrix expressions

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

mul

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

per-element matrix multiplication by means of matrix expressions

mul

@ByVal
public opencv_core.UMat mul(@ByVal
                         opencv_core.Mat m)

dot

public double dot(@ByVal
         opencv_core.Mat m)

computes dot-product

zeros

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

Matlab-style matrix initialization

zeros

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

ones

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

ones

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

eye

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

eye

@ByVal
public static opencv_core.UMat eye(@ByVal
                         opencv_core.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
          opencv_core.Size size,
          int type,
          @Cast(value="cv::UMatUsageFlags")
          int usageFlags)

create

public void create(@ByVal
          opencv_core.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)

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
            opencv_core.UMat m)

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

locateROI

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

locates matrix header within a parent matrix. See below

adjustROI

@ByRef
public opencv_core.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 opencv_core.UMat apply(@ByVal
                                     opencv_core.Range rowRange,
                                     @ByVal
                                     opencv_core.Range colRange)

extracts a rectangular sub-matrix

apply

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

apply

@ByVal
@Name(value="operator ()")
public opencv_core.UMat apply(@Const
                                     opencv_core.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(int accessFlags)

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 opencv_core.UMat flags(int flags)

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

dims

public opencv_core.UMat dims(int dims)

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

rows

public opencv_core.UMat rows(int rows)

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

cols

public opencv_core.UMat cols(int cols)

allocator

public opencv_core.MatAllocator allocator()

custom allocator

allocator

public opencv_core.UMat allocator(opencv_core.MatAllocator allocator)

usageFlags

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

usageFlags

public opencv_core.UMat usageFlags(int usageFlags)

getStdAllocator

public static opencv_core.MatAllocator getStdAllocator()

and the standard allocator

u
```
public opencv_core.UMatData u()
```

u

public opencv_core.UMat u(opencv_core.UMatData u)

offset

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

offset

public opencv_core.UMat offset(long offset)

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

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

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

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

Class opencv_core.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

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

opencv_core.UMat

Method Detail

position

put

getMat

row

col

rowRange

rowRange

colRange

colRange

diag

diag

diag

clone

copyTo

copyTo

convertTo

convertTo

assignTo

assignTo

put

setTo

setTo

reshape

reshape

reshape

reshape

reshape

t

inv

inv

mul

mul

dot