391 lines
11 KiB
C#
391 lines
11 KiB
C#
|
|
using OpenCVForUnity.CoreModule;
|
|
using OpenCVForUnity.UtilsModule;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace OpenCVForUnity.VideoModule
|
|
{
|
|
|
|
// C++: class VariationalRefinement
|
|
/**
|
|
* Variational optical flow refinement
|
|
*
|
|
* This class implements variational refinement of the input flow field, i.e.
|
|
* it uses input flow to initialize the minimization of the following functional:
|
|
* \(E(U) = \int_{\Omega} \delta \Psi(E_I) + \gamma \Psi(E_G) + \alpha \Psi(E_S) \),
|
|
* where \(E_I,E_G,E_S\) are color constancy, gradient constancy and smoothness terms
|
|
* respectively. \(\Psi(s^2)=\sqrt{s^2+\epsilon^2}\) is a robust penalizer to limit the
|
|
* influence of outliers. A complete formulation and a description of the minimization
|
|
* procedure can be found in CITE: Brox2004
|
|
*/
|
|
|
|
public class VariationalRefinement : DenseOpticalFlow
|
|
{
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
|
|
try
|
|
{
|
|
if (disposing)
|
|
{
|
|
}
|
|
if (IsEnabledDispose)
|
|
{
|
|
if (nativeObj != IntPtr.Zero)
|
|
video_VariationalRefinement_delete(nativeObj);
|
|
nativeObj = IntPtr.Zero;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
}
|
|
|
|
protected internal VariationalRefinement(IntPtr addr) : base(addr) { }
|
|
|
|
// internal usage only
|
|
public static new VariationalRefinement __fromPtr__(IntPtr addr) { return new VariationalRefinement(addr); }
|
|
|
|
//
|
|
// C++: void cv::VariationalRefinement::calcUV(Mat I0, Mat I1, Mat& flow_u, Mat& flow_v)
|
|
//
|
|
|
|
/**
|
|
* REF: calc function overload to handle separate horizontal (u) and vertical (v) flow components
|
|
* (to avoid extra splits/merges)
|
|
* param I0 automatically generated
|
|
* param I1 automatically generated
|
|
* param flow_u automatically generated
|
|
* param flow_v automatically generated
|
|
*/
|
|
public void calcUV(Mat I0, Mat I1, Mat flow_u, Mat flow_v)
|
|
{
|
|
ThrowIfDisposed();
|
|
if (I0 != null) I0.ThrowIfDisposed();
|
|
if (I1 != null) I1.ThrowIfDisposed();
|
|
if (flow_u != null) flow_u.ThrowIfDisposed();
|
|
if (flow_v != null) flow_v.ThrowIfDisposed();
|
|
|
|
video_VariationalRefinement_calcUV_10(nativeObj, I0.nativeObj, I1.nativeObj, flow_u.nativeObj, flow_v.nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::VariationalRefinement::getFixedPointIterations()
|
|
//
|
|
|
|
/**
|
|
* Number of outer (fixed-point) iterations in the minimization procedure.
|
|
* SEE: setFixedPointIterations
|
|
* return automatically generated
|
|
*/
|
|
public int getFixedPointIterations()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_VariationalRefinement_getFixedPointIterations_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::VariationalRefinement::setFixedPointIterations(int val)
|
|
//
|
|
|
|
/**
|
|
* getFixedPointIterations SEE: getFixedPointIterations
|
|
* param val automatically generated
|
|
*/
|
|
public void setFixedPointIterations(int val)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_VariationalRefinement_setFixedPointIterations_10(nativeObj, val);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: int cv::VariationalRefinement::getSorIterations()
|
|
//
|
|
|
|
/**
|
|
* Number of inner successive over-relaxation (SOR) iterations
|
|
* in the minimization procedure to solve the respective linear system.
|
|
* SEE: setSorIterations
|
|
* return automatically generated
|
|
*/
|
|
public int getSorIterations()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_VariationalRefinement_getSorIterations_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::VariationalRefinement::setSorIterations(int val)
|
|
//
|
|
|
|
/**
|
|
* getSorIterations SEE: getSorIterations
|
|
* param val automatically generated
|
|
*/
|
|
public void setSorIterations(int val)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_VariationalRefinement_setSorIterations_10(nativeObj, val);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::VariationalRefinement::getOmega()
|
|
//
|
|
|
|
/**
|
|
* Relaxation factor in SOR
|
|
* SEE: setOmega
|
|
* return automatically generated
|
|
*/
|
|
public float getOmega()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_VariationalRefinement_getOmega_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::VariationalRefinement::setOmega(float val)
|
|
//
|
|
|
|
/**
|
|
* getOmega SEE: getOmega
|
|
* param val automatically generated
|
|
*/
|
|
public void setOmega(float val)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_VariationalRefinement_setOmega_10(nativeObj, val);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::VariationalRefinement::getAlpha()
|
|
//
|
|
|
|
/**
|
|
* Weight of the smoothness term
|
|
* SEE: setAlpha
|
|
* return automatically generated
|
|
*/
|
|
public float getAlpha()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_VariationalRefinement_getAlpha_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::VariationalRefinement::setAlpha(float val)
|
|
//
|
|
|
|
/**
|
|
* getAlpha SEE: getAlpha
|
|
* param val automatically generated
|
|
*/
|
|
public void setAlpha(float val)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_VariationalRefinement_setAlpha_10(nativeObj, val);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::VariationalRefinement::getDelta()
|
|
//
|
|
|
|
/**
|
|
* Weight of the color constancy term
|
|
* SEE: setDelta
|
|
* return automatically generated
|
|
*/
|
|
public float getDelta()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_VariationalRefinement_getDelta_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::VariationalRefinement::setDelta(float val)
|
|
//
|
|
|
|
/**
|
|
* getDelta SEE: getDelta
|
|
* param val automatically generated
|
|
*/
|
|
public void setDelta(float val)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_VariationalRefinement_setDelta_10(nativeObj, val);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: float cv::VariationalRefinement::getGamma()
|
|
//
|
|
|
|
/**
|
|
* Weight of the gradient constancy term
|
|
* SEE: setGamma
|
|
* return automatically generated
|
|
*/
|
|
public float getGamma()
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
return video_VariationalRefinement_getGamma_10(nativeObj);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: void cv::VariationalRefinement::setGamma(float val)
|
|
//
|
|
|
|
/**
|
|
* getGamma SEE: getGamma
|
|
* param val automatically generated
|
|
*/
|
|
public void setGamma(float val)
|
|
{
|
|
ThrowIfDisposed();
|
|
|
|
video_VariationalRefinement_setGamma_10(nativeObj, val);
|
|
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// C++: static Ptr_VariationalRefinement cv::VariationalRefinement::create()
|
|
//
|
|
|
|
/**
|
|
* Creates an instance of VariationalRefinement
|
|
* return automatically generated
|
|
*/
|
|
public static VariationalRefinement create()
|
|
{
|
|
|
|
|
|
return VariationalRefinement.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(video_VariationalRefinement_create_10()));
|
|
|
|
|
|
}
|
|
|
|
|
|
#if (UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR
|
|
const string LIBNAME = "__Internal";
|
|
#else
|
|
const string LIBNAME = "opencvforunity";
|
|
#endif
|
|
|
|
|
|
|
|
// C++: void cv::VariationalRefinement::calcUV(Mat I0, Mat I1, Mat& flow_u, Mat& flow_v)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_VariationalRefinement_calcUV_10(IntPtr nativeObj, IntPtr I0_nativeObj, IntPtr I1_nativeObj, IntPtr flow_u_nativeObj, IntPtr flow_v_nativeObj);
|
|
|
|
// C++: int cv::VariationalRefinement::getFixedPointIterations()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int video_VariationalRefinement_getFixedPointIterations_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::VariationalRefinement::setFixedPointIterations(int val)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_VariationalRefinement_setFixedPointIterations_10(IntPtr nativeObj, int val);
|
|
|
|
// C++: int cv::VariationalRefinement::getSorIterations()
|
|
[DllImport(LIBNAME)]
|
|
private static extern int video_VariationalRefinement_getSorIterations_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::VariationalRefinement::setSorIterations(int val)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_VariationalRefinement_setSorIterations_10(IntPtr nativeObj, int val);
|
|
|
|
// C++: float cv::VariationalRefinement::getOmega()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float video_VariationalRefinement_getOmega_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::VariationalRefinement::setOmega(float val)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_VariationalRefinement_setOmega_10(IntPtr nativeObj, float val);
|
|
|
|
// C++: float cv::VariationalRefinement::getAlpha()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float video_VariationalRefinement_getAlpha_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::VariationalRefinement::setAlpha(float val)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_VariationalRefinement_setAlpha_10(IntPtr nativeObj, float val);
|
|
|
|
// C++: float cv::VariationalRefinement::getDelta()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float video_VariationalRefinement_getDelta_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::VariationalRefinement::setDelta(float val)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_VariationalRefinement_setDelta_10(IntPtr nativeObj, float val);
|
|
|
|
// C++: float cv::VariationalRefinement::getGamma()
|
|
[DllImport(LIBNAME)]
|
|
private static extern float video_VariationalRefinement_getGamma_10(IntPtr nativeObj);
|
|
|
|
// C++: void cv::VariationalRefinement::setGamma(float val)
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_VariationalRefinement_setGamma_10(IntPtr nativeObj, float val);
|
|
|
|
// C++: static Ptr_VariationalRefinement cv::VariationalRefinement::create()
|
|
[DllImport(LIBNAME)]
|
|
private static extern IntPtr video_VariationalRefinement_create_10();
|
|
|
|
// native support for java finalize()
|
|
[DllImport(LIBNAME)]
|
|
private static extern void video_VariationalRefinement_delete(IntPtr nativeObj);
|
|
|
|
}
|
|
}
|