opencv_core.UMat (JavaCPP Presets for OpenCV 3.4.3-1.4.3 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 org.bytedeco.javacpp.Pointer

\todo document

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

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
`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.GpuMat m, int rtype)`
`void`	`convertTo(opencv_core.GpuMat m, int rtype, double alpha, double beta)`
`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 scaling.
`void`	`convertTo(opencv_core.UMat m, int rtype)`
`void`	`convertTo(opencv_core.UMat m, int rtype, double alpha, double beta)`
`void`	`copySize(opencv_core.UMat m)` internal use function; properly re-allocates _size, _step arrays
`void`	`copyTo(opencv_core.GpuMat m)`
`void`	`copyTo(opencv_core.GpuMat m, opencv_core.GpuMat mask)`
`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`	`copyTo(opencv_core.UMat m)`
`void`	`copyTo(opencv_core.UMat m, opencv_core.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, org.bytedeco.javacpp.IntPointer sizes, int type)`
`void`	`create(int ndims, org.bytedeco.javacpp.IntPointer sizes, int type, int usageFlags)`
`void`	`create(org.bytedeco.javacpp.IntPointer sizes, int type)`
`void`	`create(org.bytedeco.javacpp.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.GpuMat m)`
`double`	`dot(opencv_core.Mat m)` computes dot-product
`double`	`dot(opencv_core.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 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
`org.bytedeco.javacpp.Pointer`	`handle(int accessFlags)` Returns the OpenCL buffer handle on which UMat operates on.
`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.GpuMat m)`
`opencv_core.UMat`	`mul(opencv_core.GpuMat m, double scale)`
`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
`opencv_core.UMat`	`mul(opencv_core.UMat m)`
`opencv_core.UMat`	`mul(opencv_core.UMat m, double scale)`
`void`	`ndoffset(org.bytedeco.javacpp.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, org.bytedeco.javacpp.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.GpuMat value)`
`opencv_core.UMat`	`setTo(opencv_core.GpuMat value, opencv_core.GpuMat mask)`
`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.UMat`	`setTo(opencv_core.UMat value)`
`opencv_core.UMat`	`setTo(opencv_core.UMat value, opencv_core.UMat 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)`
`void`	`updateContinuityFlag()` internal use method: updates the continuity flag
`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, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, hashCode, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, put, realloc, 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(org.bytedeco.javacpp.Pointer p)
```
Pointer cast constructor. Invokes Pointer.Pointer(Pointer).

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

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

UMat

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

UMat

public 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.

UMat

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

UMat

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

UMat

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

UMat

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

constructs n-dimensional matrix

UMat

public UMat(int ndims,
            @Const
            org.bytedeco.javacpp.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
            org.bytedeco.javacpp.IntPointer sizes,
            int type,
            @Const @ByRef
            opencv_core.Scalar s,
            @Cast(value="cv::UMatUsageFlags")
            int usageFlags)

UMat

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

UMat

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

UMat

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

UMat

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

UMat

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

UMat

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

copy constructor

UMat

public 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

UMat

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

UMat

public 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 org.bytedeco.javacpp.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 (d=0 - the main diagonal, >0 - a diagonal from the upper half, <0 - a diagonal from the lower half)

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

copyTo

public void copyTo(@ByVal
                   opencv_core.GpuMat 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.

copyTo

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

copyTo

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

convertTo

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

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

convertTo

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

convertTo

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

convertTo

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

convertTo

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

convertTo

public void convertTo(@ByVal
                      opencv_core.GpuMat 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::InputArray(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)

setTo

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

setTo

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

setTo

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

setTo

@ByRef
public opencv_core.UMat setTo(@ByVal
                                     opencv_core.GpuMat 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
                                       org.bytedeco.javacpp.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)

mul

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

mul

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

mul

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

mul

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

dot

public double dot(@ByVal
                  opencv_core.Mat m)

computes dot-product

dot

public double dot(@ByVal
                  opencv_core.UMat m)

dot

public double dot(@ByVal
                  opencv_core.GpuMat m)

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
                   org.bytedeco.javacpp.IntPointer sizes,
                   int type,
                   @Cast(value="cv::UMatUsageFlags")
                   int usageFlags)

create

public void create(int ndims,
                   @Const
                   org.bytedeco.javacpp.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
                   org.bytedeco.javacpp.IntPointer sizes,
                   int type,
                   @Cast(value="cv::UMatUsageFlags")
                   int usageFlags)

create

public void create(@StdVector
                   org.bytedeco.javacpp.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
                     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 org.bytedeco.javacpp.Pointer handle(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*")
                     org.bytedeco.javacpp.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

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

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

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

UMat

Method Detail

position

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