org.bytedeco.javacpp

Class opencv_core.SVD

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.javacpp.opencv_core.SVD

All Implemented Interfaces:

AutoCloseable

Enclosing class:

opencv_core

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

\brief Singular Value Decomposition

Class for computing Singular Value Decomposition of a floating-point matrix. The Singular Value Decomposition is used to solve least-square problems, under-determined linear systems, invert matrices, compute condition numbers, and so on.

If you want to compute a condition number of a matrix or an absolute value of its determinant, you do not need u and vt. You can pass flags=SVD::NO_UV|... . Another flag SVD::FULL_UV indicates that full-size u and vt must be computed, which is not necessary most of the time.

\sa invert, solve, eigen, determinant

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	FULL_UV enum cv::SVD::Flags
static int	MODIFY_A enum cv::SVD::Flags
static int	NO_UV enum cv::SVD::Flags

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
SVD() \brief the default constructor
SVD(long size) Native array allocator.
SVD(opencv_core.Mat src)
SVD(opencv_core.Mat src, int flags) \overload initializes an empty SVD structure and then calls SVD::operator()
SVD(opencv_core.UMat src)
SVD(opencv_core.UMat src, int flags)
SVD(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
opencv_core.SVD	apply(opencv_core.Mat src)
opencv_core.SVD	apply(opencv_core.Mat src, int flags) \brief the operator that performs SVD.
opencv_core.SVD	apply(opencv_core.UMat src)
opencv_core.SVD	apply(opencv_core.UMat src, int flags)
void	backSubst(opencv_core.Mat rhs, opencv_core.Mat dst) \brief performs a singular value back substitution.
static void	backSubst(opencv_core.Mat w, opencv_core.Mat u, opencv_core.Mat vt, opencv_core.Mat rhs, opencv_core.Mat dst) \brief performs back substitution
void	backSubst(opencv_core.UMat rhs, opencv_core.UMat dst)
static void	backSubst(opencv_core.UMat w, opencv_core.UMat u, opencv_core.UMat vt, opencv_core.UMat rhs, opencv_core.UMat dst)
static void	compute(opencv_core.Mat src, opencv_core.Mat w)
static void	compute(opencv_core.Mat src, opencv_core.Mat w, int flags) \overload computes singular values of a matrix
static void	compute(opencv_core.Mat src, opencv_core.Mat w, opencv_core.Mat u, opencv_core.Mat vt)
static void	compute(opencv_core.Mat src, opencv_core.Mat w, opencv_core.Mat u, opencv_core.Mat vt, int flags) \brief decomposes matrix and stores the results to user-provided matrices
static void	compute(opencv_core.UMat src, opencv_core.UMat w)
static void	compute(opencv_core.UMat src, opencv_core.UMat w, int flags)
static void	compute(opencv_core.UMat src, opencv_core.UMat w, opencv_core.UMat u, opencv_core.UMat vt)
static void	compute(opencv_core.UMat src, opencv_core.UMat w, opencv_core.UMat u, opencv_core.UMat vt, int flags)
opencv_core.SVD	position(long position)
static void	solveZ(opencv_core.Mat src, opencv_core.Mat dst) \brief solves an under-determined singular linear system
static void	solveZ(opencv_core.UMat src, opencv_core.UMat dst)
opencv_core.Mat	u() \todo document
opencv_core.SVD	u(opencv_core.Mat u)
opencv_core.Mat	vt()
opencv_core.SVD	vt(opencv_core.Mat vt)
opencv_core.Mat	w()
opencv_core.SVD	w(opencv_core.Mat w)

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, free, hashCode, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, physicalBytes, position, put, realloc, setNull, sizeof, toString, totalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

MODIFY_A

public static final int MODIFY_A

enum cv::SVD::Flags

See Also:

Constant Field Values

NO_UV

public static final int NO_UV

enum cv::SVD::Flags

See Also:

Constant Field Values

FULL_UV

public static final int FULL_UV

enum cv::SVD::Flags

See Also:

Constant Field Values

Constructor Detail

SVD

public SVD(Pointer p)

Pointer cast constructor. Invokes Pointer.Pointer(Pointer).

SVD

public SVD(long size)

Native array allocator. Access with Pointer.position(long).

SVD

public SVD()

\brief the default constructor

initializes an empty SVD structure

SVD

public SVD(@ByVal
           opencv_core.Mat src,
           int flags)

\overload initializes an empty SVD structure and then calls SVD::operator()

Parameters:

src - decomposed matrix.

flags - operation flags (SVD::Flags)

SVD

public SVD(@ByVal
           opencv_core.Mat src)

SVD

public SVD(@ByVal
           opencv_core.UMat src,
           int flags)

SVD

public SVD(@ByVal
           opencv_core.UMat src)

Method Detail

position

public opencv_core.SVD position(long position)

Overrides:

position in class Pointer

apply

@ByRef
 @Name(value="operator ()")
public opencv_core.SVD apply(@ByVal
                                                                opencv_core.Mat src,
                                                                int flags)

\brief the operator that performs SVD. The previously allocated u, w and vt are released.

The operator performs the singular value decomposition of the supplied matrix. The u,vt , and the vector of singular values w are stored in the structure. The same SVD structure can be reused many times with different matrices. Each time, if needed, the previous u,vt , and w are reclaimed and the new matrices are created, which is all handled by Mat::create.

Parameters:

src - decomposed matrix.

flags - operation flags (SVD::Flags)

apply

@ByRef
 @Name(value="operator ()")
public opencv_core.SVD apply(@ByVal
                                                                opencv_core.Mat src)

apply

@ByRef
 @Name(value="operator ()")
public opencv_core.SVD apply(@ByVal
                                                                opencv_core.UMat src,
                                                                int flags)

apply

@ByRef
 @Name(value="operator ()")
public opencv_core.SVD apply(@ByVal
                                                                opencv_core.UMat src)

compute

public static void compute(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat w,
                           @ByVal
                           opencv_core.Mat u,
                           @ByVal
                           opencv_core.Mat vt,
                           int flags)

\brief decomposes matrix and stores the results to user-provided matrices

The methods/functions perform SVD of matrix. Unlike SVD::SVD constructor and SVD::operator(), they store the results to the user-provided matrices:

 {.cpp}
    Mat A, w, u, vt;
    SVD::compute(A, w, u, vt);
    

Parameters:

src - decomposed matrix

w - calculated singular values

u - calculated left singular vectors

vt - transposed matrix of right singular values

flags - operation flags - see SVD::SVD.

compute

public static void compute(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat w,
                           @ByVal
                           opencv_core.Mat u,
                           @ByVal
                           opencv_core.Mat vt)

compute

public static void compute(@ByVal
                           opencv_core.UMat src,
                           @ByVal
                           opencv_core.UMat w,
                           @ByVal
                           opencv_core.UMat u,
                           @ByVal
                           opencv_core.UMat vt,
                           int flags)

compute

public static void compute(@ByVal
                           opencv_core.UMat src,
                           @ByVal
                           opencv_core.UMat w,
                           @ByVal
                           opencv_core.UMat u,
                           @ByVal
                           opencv_core.UMat vt)

compute

public static void compute(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat w,
                           int flags)

\overload computes singular values of a matrix

Parameters:

src - decomposed matrix

w - calculated singular values

flags - operation flags - see SVD::Flags.

compute

public static void compute(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat w)

compute

public static void compute(@ByVal
                           opencv_core.UMat src,
                           @ByVal
                           opencv_core.UMat w,
                           int flags)

compute

public static void compute(@ByVal
                           opencv_core.UMat src,
                           @ByVal
                           opencv_core.UMat w)

backSubst

public static void backSubst(@ByVal
                             opencv_core.Mat w,
                             @ByVal
                             opencv_core.Mat u,
                             @ByVal
                             opencv_core.Mat vt,
                             @ByVal
                             opencv_core.Mat rhs,
                             @ByVal
                             opencv_core.Mat dst)

\brief performs back substitution

backSubst

public static void backSubst(@ByVal
                             opencv_core.UMat w,
                             @ByVal
                             opencv_core.UMat u,
                             @ByVal
                             opencv_core.UMat vt,
                             @ByVal
                             opencv_core.UMat rhs,
                             @ByVal
                             opencv_core.UMat dst)

solveZ

public static void solveZ(@ByVal
                          opencv_core.Mat src,
                          @ByVal
                          opencv_core.Mat dst)

\brief solves an under-determined singular linear system

The method finds a unit-length solution x of a singular linear system A\*x = 0. Depending on the rank of A, there can be no solutions, a single solution or an infinite number of solutions. In general, the algorithm solves the following problem: \f[dst = \arg \min _{x: \| x \| =1} \| src \cdot x \|\f]

Parameters:

src - left-hand-side matrix.

dst - found solution.

solveZ

public static void solveZ(@ByVal
                          opencv_core.UMat src,
                          @ByVal
                          opencv_core.UMat dst)

backSubst

public void backSubst(@ByVal
                      opencv_core.Mat rhs,
                      @ByVal
                      opencv_core.Mat dst)

\brief performs a singular value back substitution.

The method calculates a back substitution for the specified right-hand side:

\f[\texttt{x} = \texttt{vt} ^T \cdot diag( \texttt{w} )^{-1} \cdot \texttt{u} ^T \cdot \texttt{rhs} \sim \texttt{A} ^{-1} \cdot \texttt{rhs}\f]

Using this technique you can either get a very accurate solution of the convenient linear system, or the best (in the least-squares terms) pseudo-solution of an overdetermined linear system.

Parameters:

rhs - right-hand side of a linear system (u\*w\*v')\*dst = rhs to be solved, where A has been previously decomposed.

dst - found solution of the system.

\note Explicit SVD with the further back substitution only makes sense if you need to solve many linear systems with the same left-hand side (for example, src ). If all you need is to solve a single system (possibly with multiple rhs immediately available), simply call solve add pass DECOMP_SVD there. It does absolutely the same thing.

backSubst

public void backSubst(@ByVal
                      opencv_core.UMat rhs,
                      @ByVal
                      opencv_core.UMat dst)

u

@ByRef
public opencv_core.Mat u()

\todo document

u

public opencv_core.SVD u(opencv_core.Mat u)

w

@ByRef
public opencv_core.Mat w()

w

public opencv_core.SVD w(opencv_core.Mat w)

vt

@ByRef
public opencv_core.Mat vt()

vt

public opencv_core.SVD vt(opencv_core.Mat vt)