org.bytedeco.opencv.global

Class opencv_videostab

java.lang.Object

org.bytedeco.opencv.presets.opencv_videostab

org.bytedeco.opencv.global.opencv_videostab

All Implemented Interfaces:

InfoMapper

public class opencv_videostab
extends opencv_videostab

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.opencv.presets.opencv_videostab

opencv_videostab.MaskCallback

Field Summary

Fields

Modifier and Type	Field and Description
static int	MM_AFFINE enum cv::videostab::MotionModel
static int	MM_HOMOGRAPHY enum cv::videostab::MotionModel
static int	MM_RIGID enum cv::videostab::MotionModel
static int	MM_ROTATION enum cv::videostab::MotionModel
static int	MM_SIMILARITY enum cv::videostab::MotionModel
static int	MM_TRANSLATION enum cv::videostab::MotionModel
static int	MM_TRANSLATION_AND_SCALE enum cv::videostab::MotionModel
static int	MM_UNKNOWN enum cv::videostab::MotionModel

Constructor Summary

Constructors

Constructor and Description
opencv_videostab()

Method Summary

Modifier and Type	Method and Description
static float	calcBlurriness(Mat frame) \addtogroup videostab \{
static void	calcFlowMask(Mat flowX, Mat flowY, Mat errors, float maxError, Mat mask0, Mat mask1, Mat flowMask) \}
static void	completeFrameAccordingToFlow(Mat flowMask, Mat flowX, Mat flowY, Mat frame1, Mat mask1, float distThresh, Mat frame0, Mat mask0)
static Mat	ensureInclusionConstraint(Mat M, Size size, float trimRatio) \}
static Mat	estimateGlobalMotionLeastSquares(GpuMat points0, GpuMat points1)
static Mat	estimateGlobalMotionLeastSquares(GpuMat points0, GpuMat points1, int model, float[] rmse)
static Mat	estimateGlobalMotionLeastSquares(GpuMat points0, GpuMat points1, int model, FloatBuffer rmse)
static Mat	estimateGlobalMotionLeastSquares(GpuMat points0, GpuMat points1, int model, FloatPointer rmse)
static Mat	estimateGlobalMotionLeastSquares(Mat points0, Mat points1)
static Mat	estimateGlobalMotionLeastSquares(Mat points0, Mat points1, int model, float[] rmse)
static Mat	estimateGlobalMotionLeastSquares(Mat points0, Mat points1, int model, FloatBuffer rmse)
static Mat	estimateGlobalMotionLeastSquares(Mat points0, Mat points1, int model, FloatPointer rmse) \addtogroup videostab_motion \{
static Mat	estimateGlobalMotionLeastSquares(UMat points0, UMat points1)
static Mat	estimateGlobalMotionLeastSquares(UMat points0, UMat points1, int model, float[] rmse)
static Mat	estimateGlobalMotionLeastSquares(UMat points0, UMat points1, int model, FloatBuffer rmse)
static Mat	estimateGlobalMotionLeastSquares(UMat points0, UMat points1, int model, FloatPointer rmse)
static Mat	estimateGlobalMotionRansac(GpuMat points0, GpuMat points1)
static Mat	estimateGlobalMotionRansac(GpuMat points0, GpuMat points1, int model, RansacParams params, float[] rmse, int[] ninliers)
static Mat	estimateGlobalMotionRansac(GpuMat points0, GpuMat points1, int model, RansacParams params, FloatBuffer rmse, IntBuffer ninliers)
static Mat	estimateGlobalMotionRansac(GpuMat points0, GpuMat points1, int model, RansacParams params, FloatPointer rmse, IntPointer ninliers)
static Mat	estimateGlobalMotionRansac(Mat points0, Mat points1)
static Mat	estimateGlobalMotionRansac(Mat points0, Mat points1, int model, RansacParams params, float[] rmse, int[] ninliers)
static Mat	estimateGlobalMotionRansac(Mat points0, Mat points1, int model, RansacParams params, FloatBuffer rmse, IntBuffer ninliers)
static Mat	estimateGlobalMotionRansac(Mat points0, Mat points1, int model, RansacParams params, FloatPointer rmse, IntPointer ninliers) \brief Estimates best global motion between two 2D point clouds robustly (using RANSAC method).
static Mat	estimateGlobalMotionRansac(UMat points0, UMat points1)
static Mat	estimateGlobalMotionRansac(UMat points0, UMat points1, int model, RansacParams params, float[] rmse, int[] ninliers)
static Mat	estimateGlobalMotionRansac(UMat points0, UMat points1, int model, RansacParams params, FloatBuffer rmse, IntBuffer ninliers)
static Mat	estimateGlobalMotionRansac(UMat points0, UMat points1, int model, RansacParams params, FloatPointer rmse, IntPointer ninliers)
static float	estimateOptimalTrimRatio(Mat M, Size size)
static Mat	getMotion(int from, int to, MatVector motions) \brief Computes motion between two frames assuming that all the intermediate motions are known.

Methods inherited from class org.bytedeco.opencv.presets.opencv_videostab

map

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

MM_TRANSLATION

public static final int MM_TRANSLATION

enum cv::videostab::MotionModel

See Also:

Constant Field Values

MM_TRANSLATION_AND_SCALE

public static final int MM_TRANSLATION_AND_SCALE

enum cv::videostab::MotionModel

See Also:

Constant Field Values

MM_ROTATION

public static final int MM_ROTATION

enum cv::videostab::MotionModel

See Also:

Constant Field Values

MM_RIGID

public static final int MM_RIGID

enum cv::videostab::MotionModel

See Also:

Constant Field Values

MM_SIMILARITY

public static final int MM_SIMILARITY

enum cv::videostab::MotionModel

See Also:

Constant Field Values

MM_AFFINE

public static final int MM_AFFINE

enum cv::videostab::MotionModel

See Also:

Constant Field Values

MM_HOMOGRAPHY

public static final int MM_HOMOGRAPHY

enum cv::videostab::MotionModel

See Also:

Constant Field Values

MM_UNKNOWN

public static final int MM_UNKNOWN

enum cv::videostab::MotionModel

See Also:

Constant Field Values

Constructor Detail

opencv_videostab

public opencv_videostab()

Method Detail

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             Mat points0,
                                                                                             @ByVal
                                                                                             Mat points1,
                                                                                             int model,
                                                                                             FloatPointer rmse)

\addtogroup videostab_motion \{

/** \brief Estimates best global motion between two 2D point clouds in the least-squares sense.

\note Works in-place and changes input point arrays.

Parameters:

points0 - Source set of 2D points (32F).

points1 - Destination set of 2D points (32F).

model - Motion model (up to MM_AFFINE).

rmse - Final root-mean-square error.

Returns:

3x3 2D transformation matrix (32F).

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             Mat points0,
                                                                                             @ByVal
                                                                                             Mat points1)

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             Mat points0,
                                                                                             @ByVal
                                                                                             Mat points1,
                                                                                             int model,
                                                                                             FloatBuffer rmse)

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             Mat points0,
                                                                                             @ByVal
                                                                                             Mat points1,
                                                                                             int model,
                                                                                             float[] rmse)

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             UMat points0,
                                                                                             @ByVal
                                                                                             UMat points1,
                                                                                             int model,
                                                                                             FloatPointer rmse)

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             UMat points0,
                                                                                             @ByVal
                                                                                             UMat points1)

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             UMat points0,
                                                                                             @ByVal
                                                                                             UMat points1,
                                                                                             int model,
                                                                                             FloatBuffer rmse)

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             UMat points0,
                                                                                             @ByVal
                                                                                             UMat points1,
                                                                                             int model,
                                                                                             float[] rmse)

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             GpuMat points0,
                                                                                             @ByVal
                                                                                             GpuMat points1,
                                                                                             int model,
                                                                                             FloatPointer rmse)

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             GpuMat points0,
                                                                                             @ByVal
                                                                                             GpuMat points1)

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             GpuMat points0,
                                                                                             @ByVal
                                                                                             GpuMat points1,
                                                                                             int model,
                                                                                             FloatBuffer rmse)

estimateGlobalMotionLeastSquares

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionLeastSquares(@ByVal
                                                                                             GpuMat points0,
                                                                                             @ByVal
                                                                                             GpuMat points1,
                                                                                             int model,
                                                                                             float[] rmse)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       Mat points0,
                                                                                       @ByVal
                                                                                       Mat points1,
                                                                                       int model,
                                                                                       @Const @ByRef(nullValue="cv::videostab::RansacParams::default2dMotion(cv::videostab::MM_AFFINE)")
                                                                                       RansacParams params,
                                                                                       FloatPointer rmse,
                                                                                       IntPointer ninliers)

\brief Estimates best global motion between two 2D point clouds robustly (using RANSAC method).

Parameters:

points0 - Source set of 2D points (32F).

points1 - Destination set of 2D points (32F).

model - Motion model. See cv::videostab::MotionModel.

params - RANSAC method parameters. See videostab::RansacParams.

rmse - Final root-mean-square error.

ninliers - Final number of inliers.

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       Mat points0,
                                                                                       @ByVal
                                                                                       Mat points1)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       Mat points0,
                                                                                       @ByVal
                                                                                       Mat points1,
                                                                                       int model,
                                                                                       @Const @ByRef(nullValue="cv::videostab::RansacParams::default2dMotion(cv::videostab::MM_AFFINE)")
                                                                                       RansacParams params,
                                                                                       FloatBuffer rmse,
                                                                                       IntBuffer ninliers)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       Mat points0,
                                                                                       @ByVal
                                                                                       Mat points1,
                                                                                       int model,
                                                                                       @Const @ByRef(nullValue="cv::videostab::RansacParams::default2dMotion(cv::videostab::MM_AFFINE)")
                                                                                       RansacParams params,
                                                                                       float[] rmse,
                                                                                       int[] ninliers)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       UMat points0,
                                                                                       @ByVal
                                                                                       UMat points1,
                                                                                       int model,
                                                                                       @Const @ByRef(nullValue="cv::videostab::RansacParams::default2dMotion(cv::videostab::MM_AFFINE)")
                                                                                       RansacParams params,
                                                                                       FloatPointer rmse,
                                                                                       IntPointer ninliers)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       UMat points0,
                                                                                       @ByVal
                                                                                       UMat points1)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       UMat points0,
                                                                                       @ByVal
                                                                                       UMat points1,
                                                                                       int model,
                                                                                       @Const @ByRef(nullValue="cv::videostab::RansacParams::default2dMotion(cv::videostab::MM_AFFINE)")
                                                                                       RansacParams params,
                                                                                       FloatBuffer rmse,
                                                                                       IntBuffer ninliers)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       UMat points0,
                                                                                       @ByVal
                                                                                       UMat points1,
                                                                                       int model,
                                                                                       @Const @ByRef(nullValue="cv::videostab::RansacParams::default2dMotion(cv::videostab::MM_AFFINE)")
                                                                                       RansacParams params,
                                                                                       float[] rmse,
                                                                                       int[] ninliers)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       GpuMat points0,
                                                                                       @ByVal
                                                                                       GpuMat points1,
                                                                                       int model,
                                                                                       @Const @ByRef(nullValue="cv::videostab::RansacParams::default2dMotion(cv::videostab::MM_AFFINE)")
                                                                                       RansacParams params,
                                                                                       FloatPointer rmse,
                                                                                       IntPointer ninliers)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       GpuMat points0,
                                                                                       @ByVal
                                                                                       GpuMat points1)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       GpuMat points0,
                                                                                       @ByVal
                                                                                       GpuMat points1,
                                                                                       int model,
                                                                                       @Const @ByRef(nullValue="cv::videostab::RansacParams::default2dMotion(cv::videostab::MM_AFFINE)")
                                                                                       RansacParams params,
                                                                                       FloatBuffer rmse,
                                                                                       IntBuffer ninliers)

estimateGlobalMotionRansac

@Namespace(value="cv::videostab")
 @ByVal
public static Mat estimateGlobalMotionRansac(@ByVal
                                                                                       GpuMat points0,
                                                                                       @ByVal
                                                                                       GpuMat points1,
                                                                                       int model,
                                                                                       @Const @ByRef(nullValue="cv::videostab::RansacParams::default2dMotion(cv::videostab::MM_AFFINE)")
                                                                                       RansacParams params,
                                                                                       float[] rmse,
                                                                                       int[] ninliers)

getMotion

@Namespace(value="cv::videostab")
 @ByVal
public static Mat getMotion(int from,
                                                                      int to,
                                                                      @Const @ByRef
                                                                      MatVector motions)

\brief Computes motion between two frames assuming that all the intermediate motions are known.

Parameters:

from - Source frame index.

to - Destination frame index.

motions - Pair-wise motions. motions[i] denotes motion from the frame i to the frame i+1

Returns:

Motion from the Source frame to the Destination frame.

ensureInclusionConstraint

@Namespace(value="cv::videostab")
 @ByVal
public static Mat ensureInclusionConstraint(@Const @ByRef
                                                                                      Mat M,
                                                                                      @ByVal
                                                                                      Size size,
                                                                                      float trimRatio)

\}

estimateOptimalTrimRatio

@Namespace(value="cv::videostab")
public static float estimateOptimalTrimRatio(@Const @ByRef
                                                                               Mat M,
                                                                               @ByVal
                                                                               Size size)

calcFlowMask

@Namespace(value="cv::videostab")
public static void calcFlowMask(@Const @ByRef
                                                                  Mat flowX,
                                                                  @Const @ByRef
                                                                  Mat flowY,
                                                                  @Const @ByRef
                                                                  Mat errors,
                                                                  float maxError,
                                                                  @Const @ByRef
                                                                  Mat mask0,
                                                                  @Const @ByRef
                                                                  Mat mask1,
                                                                  @ByRef
                                                                  Mat flowMask)

\}

completeFrameAccordingToFlow

@Namespace(value="cv::videostab")
public static void completeFrameAccordingToFlow(@Const @ByRef
                                                                                  Mat flowMask,
                                                                                  @Const @ByRef
                                                                                  Mat flowX,
                                                                                  @Const @ByRef
                                                                                  Mat flowY,
                                                                                  @Const @ByRef
                                                                                  Mat frame1,
                                                                                  @Const @ByRef
                                                                                  Mat mask1,
                                                                                  float distThresh,
                                                                                  @ByRef
                                                                                  Mat frame0,
                                                                                  @ByRef
                                                                                  Mat mask0)

calcBlurriness

@Namespace(value="cv::videostab")
public static float calcBlurriness(@Const @ByRef
                                                                     Mat frame)

\addtogroup videostab \{