GHZMRSpaceXR/Assets/OpenCVForUnity/org/opencv/video/VariationalRefinement.cs

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);

    }
}