fast-yolo4/3rdparty/opencv/inc/opencv2/optflow/rlofflow.hpp

// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#ifndef __OPENCV_OPTFLOW_RLOFFLOW_HPP__
#define __OPENCV_OPTFLOW_RLOFFLOW_HPP__

#include "opencv2/core.hpp"
#include "opencv2/video.hpp"

namespace cv
{
namespace optflow
{
//! @addtogroup optflow
//! @{

enum SupportRegionType {
    SR_FIXED = 0,           /**<  Apply a constant support region */
    SR_CROSS = 1            /**<  Apply a adaptive support region obtained by cross-based segmentation
                             *    as described in @cite Senst2014
                            */
};
enum SolverType {
    ST_STANDART = 0,        /**< Apply standard iterative refinement */
    ST_BILINEAR = 1         /**< Apply optimized iterative refinement based bilinear equation solutions
                             *   as described in @cite Senst2013
                            */
};

enum InterpolationType
{
    INTERP_GEO = 0,    /**<  Fast geodesic interpolation, see @cite Geistert2016 */
    INTERP_EPIC = 1,   /**<  Edge-preserving interpolation using ximgproc::EdgeAwareInterpolator, see @cite Revaud2015,Geistert2016. */
    INTERP_RIC = 2,    /**<  SLIC based robust interpolation using ximgproc::RICInterpolator, see @cite Hu2017. */
};

/** @brief This is used store and set up the parameters of the robust local optical flow (RLOF) algoritm.
 *
 * The RLOF is a fast local optical flow approach described in @cite Senst2012 @cite Senst2013 @cite Senst2014
 * and @cite Senst2016 similar to the pyramidal iterative Lucas-Kanade method as
 * proposed by @cite Bouguet00. More details and experiments can be found in the following thesis @cite Senst2019.
 * The implementation is derived from optflow::calcOpticalFlowPyrLK().
 * This RLOF implementation can be seen as an improved pyramidal iterative Lucas-Kanade and includes
 * a set of improving modules. The main improvements in respect to the pyramidal iterative Lucas-Kanade
 * are:
 *  - A more robust redecending M-estimator framework (see @cite Senst2012) to improve the accuracy at
 *     motion boundaries and appearing and disappearing pixels.
 *  - an adaptive support region strategies to improve the accuracy at motion boundaries to reduce the
 *     corona effect, i.e oversmoothing of the PLK at motion/object boundaries. The cross-based segementation
 *     strategy (SR_CROSS) proposed in @cite Senst2014 uses a simple segmenation approach to obtain the optimal
 *     shape of the support region.
 *  - To deal with illumination changes (outdoor sequences and shadow) the intensity constancy assumption
 *     based optical flow equation has been adopt with the Gennert and Negahdaripour illumination model
 *     (see @cite Senst2016). This model can be switched on/off with the useIlluminationModel variable.
 *  - By using a global motion prior initialization (see @cite Senst2016) of the iterative refinement
 *     the accuracy could be significantly improved for large displacements. This initialization can be
 *     switched on and of with useGlobalMotionPrior variable.
 *
 * The RLOF can be computed with the SparseOpticalFlow class or function interface to track a set of features
 * or with the DenseOpticalFlow class or function interface to compute dense optical flow.
 *
 * @see optflow::DenseRLOFOpticalFlow, optflow::calcOpticalFlowDenseRLOF(), optflow::SparseRLOFOpticalFlow, optflow::calcOpticalFlowSparseRLOF()
 */
class CV_EXPORTS_W RLOFOpticalFlowParameter{
public:
    RLOFOpticalFlowParameter()
        :solverType(ST_BILINEAR)
        ,supportRegionType(SR_CROSS)
        ,normSigma0(std::numeric_limits<float>::max())
        ,normSigma1(std::numeric_limits<float>::max())
        ,smallWinSize(9)
        ,largeWinSize(21)
        ,crossSegmentationThreshold(25)
        ,maxLevel(4)
        ,useInitialFlow(false)
        ,useIlluminationModel(true)
        ,useGlobalMotionPrior(true)
        ,maxIteration(30)
        ,minEigenValue(0.0001f)
        ,globalMotionRansacThreshold(10)
    {}

    SolverType solverType;
    /**< Variable specifies the iterative refinement strategy. Please consider citing  @cite Senst2013 when
     *  using ST_BILINEAR.
    */

    SupportRegionType supportRegionType;
    /**< Variable specifies the support region shape extraction or shrinking strategy.
    */

    float normSigma0;
    /**< &sigma parameter of the shrinked Hampel norm introduced in @cite Senst2012. If
     * &sigma = std::numeric_limist<float>::max() the least-square estimator will be used
     * instead of the M-estimator. Althoug M-estimator is more robust against outlier in the support
     * region the least-square can be fast in computation.
    */
    float normSigma1;
    /**< &sigma parameter of the shrinked Hampel norm introduced in @cite Senst2012. If
     * &sigma = std::numeric_limist<float>::max() the least-square estimator will be used
     * instead of the M-estimator. Althoug M-estimator is more robust against outlier in the support
     * region the least-square can be fast in computation.
    */
    int smallWinSize;
    /**< Minimal window size of the support region. This parameter is only used if supportRegionType is SR_CROSS.
    */
    int largeWinSize;
    /**< Maximal window size of the support region. If supportRegionType is SR_FIXED this gives the exact support
     * region size. The speed of the RLOF is related to the applied win sizes. The smaller the window size the lower is the runtime,
     * but the more sensitive to noise is the method.
    */
    int crossSegmentationThreshold;
    /**< Color similarity threshold used by cross-based segmentation following @cite Senst2014 .
     *   (Only used  if supportRegionType is SR_CROSS). With the cross-bassed segmentation
     *   motion boundaries can be computed more accurately.
    */
    int maxLevel;
    /**< Maximal number of pyramid level used. The large this value is the more likely it is
     *   to obtain accurate solutions for long-range motions. The runtime is linear related to
     *   this parameter.
    */
    bool useInitialFlow;
    /**< Use next point list as initial values. A good intialization can imporve the algortihm
     *   accuracy and reduce the runtime by a faster convergence of the iteration refinement.
    */
    bool useIlluminationModel;
    /**< Use the Gennert and Negahdaripour illumination model instead of the intensity brigthness
     *   constraint. (proposed in @cite Senst2016 ) This model is defined as follow:
     *   \f[ I(\mathbf{x},t) + m \cdot I(\mathbf{x},t) + c = I(\mathbf{x},t+1) \f]
     *   and contains with m and c a multiplicative and additive term which makes the estimate
     *   more robust against illumination changes. The computational complexity is increased by
     *   enabling the illumination model.
    */
    bool useGlobalMotionPrior;
    /**< Use global motion prior initialisation has been introduced in @cite Senst2016 . It
     *   allows to be more accurate for long-range motion. The computational complexity is
     *   slightly increased by enabling the global motion prior initialisation.
    */
    int maxIteration;
    /**< Number of maximal iterations used for the iterative refinement. Lower values can
     *   reduce the runtime but also the accuracy.
    */
    float minEigenValue;
    /**< Threshold for the minimal eigenvalue of the gradient matrix defines when to abort the
     *   iterative refinement.
    */
    float globalMotionRansacThreshold;
    /**< To apply the global motion prior motion vectors will be computed on a regulary sampled which
     *   are the basis for Homography estimation using RANSAC. The reprojection threshold is based on
     *   n-th percentil (given by this value [0 ... 100]) of the motion vectors magnitude.
     *   See @cite Senst2016 for more details.
    */

    //! @brief Enable M-estimator or disable and use least-square estimator.
    /** Enables M-estimator by setting sigma parameters to (3.2, 7.0). Disabling M-estimator can reduce
     *  runtime, while enabling can improve the accuracy.
     *  @param val If true M-estimator is used. If false least-square estimator is used.
     *    @see setNormSigma0, setNormSigma1
    */
    CV_WRAP void setUseMEstimator(bool val);

    CV_WRAP void setSolverType(SolverType val);
    CV_WRAP SolverType getSolverType() const;

    CV_WRAP void setSupportRegionType(SupportRegionType val);
    CV_WRAP SupportRegionType getSupportRegionType() const;

    CV_WRAP void setNormSigma0(float val);
    CV_WRAP float getNormSigma0() const;

    CV_WRAP void setNormSigma1(float val);
    CV_WRAP float getNormSigma1() const;

    CV_WRAP void setSmallWinSize(int val);
    CV_WRAP int getSmallWinSize() const;

    CV_WRAP void setLargeWinSize(int val);
    CV_WRAP int getLargeWinSize() const;

    CV_WRAP void setCrossSegmentationThreshold(int val);
    CV_WRAP int getCrossSegmentationThreshold() const;

    CV_WRAP void setMaxLevel(int val);
    CV_WRAP int getMaxLevel() const;

    CV_WRAP void setUseInitialFlow(bool val);
    CV_WRAP bool getUseInitialFlow() const;

    CV_WRAP void setUseIlluminationModel(bool val);
    CV_WRAP bool getUseIlluminationModel() const;

    CV_WRAP void setUseGlobalMotionPrior(bool val);
    CV_WRAP bool getUseGlobalMotionPrior() const;

    CV_WRAP void setMaxIteration(int val);
    CV_WRAP int getMaxIteration() const;

    CV_WRAP void setMinEigenValue(float val);
    CV_WRAP float getMinEigenValue() const;

    CV_WRAP void setGlobalMotionRansacThreshold(float val);
    CV_WRAP float getGlobalMotionRansacThreshold() const;

    //! @brief Creates instance of optflow::RLOFOpticalFlowParameter
    CV_WRAP static Ptr<RLOFOpticalFlowParameter> create();
};

/** @brief Fast dense optical flow computation based on robust local optical flow (RLOF) algorithms and sparse-to-dense interpolation
 * scheme.
 *
 * The RLOF is a fast local optical flow approach described in @cite Senst2012 @cite Senst2013 @cite Senst2014
 * and @cite Senst2016 similar to the pyramidal iterative Lucas-Kanade method as
 * proposed by @cite Bouguet00. More details and experiments can be found in the following thesis @cite Senst2019.
 * The implementation is derived from optflow::calcOpticalFlowPyrLK().
 *
 * The sparse-to-dense interpolation scheme allows for fast computation of dense optical flow using RLOF (see @cite Geistert2016).
 * For this scheme the following steps are applied:
 * -# motion vector seeded at a regular sampled grid are computed. The sparsity of this grid can be configured with setGridStep
 * -# (optinally) errornous motion vectors are filter based on the forward backward confidence. The threshold can be configured
 * with setForwardBackward. The filter is only applied if the threshold >0 but than the runtime is doubled due to the estimation
 * of the backward flow.
 * -# Vector field interpolation is applied to the motion vector set to obtain a dense vector field.
 *
 * For the RLOF configuration see optflow::RLOFOpticalFlowParameter for further details.
 * Parameters have been described in @cite Senst2012 @cite Senst2013 @cite Senst2014 and @cite Senst2016.
 *
 * @note If the grid size is set to (1,1) and the forward backward threshold <= 0 than pixelwise dense optical flow field is
 * computed by RLOF without using interpolation.
 *
 * @note Note that in output, if no correspondences are found between \a I0 and \a I1, the \a flow is set to 0.
 * @see optflow::calcOpticalFlowDenseRLOF(), optflow::RLOFOpticalFlowParameter
*/
class CV_EXPORTS_W DenseRLOFOpticalFlow : public DenseOpticalFlow
{
public:
    //! @brief Configuration of the RLOF alogrithm.
    /**
        @see optflow::RLOFOpticalFlowParameter, getRLOFOpticalFlowParameter
    */
    CV_WRAP virtual void setRLOFOpticalFlowParameter(Ptr<RLOFOpticalFlowParameter>  val) = 0;
    /** @copybrief setRLOFOpticalFlowParameter
        @see optflow::RLOFOpticalFlowParameter, setRLOFOpticalFlowParameter
    */
    CV_WRAP virtual Ptr<RLOFOpticalFlowParameter>  getRLOFOpticalFlowParameter() const = 0;
    //! @brief Threshold for the forward backward confidence check
    /**For each grid point \f$ \mathbf{x} \f$ a motion vector \f$ d_{I0,I1}(\mathbf{x}) \f$ is computed.
     *     If the forward backward error \f[ EP_{FB} = || d_{I0,I1} + d_{I1,I0} || \f]
     *     is larger than threshold given by this function then the motion vector will not be used by the following
     *    vector field interpolation. \f$ d_{I1,I0} \f$ denotes the backward flow. Note, the forward backward test
     *    will only be applied if the threshold > 0. This may results into a doubled runtime for the motion estimation.
     *    @see getForwardBackward, setGridStep
    */
    CV_WRAP virtual void setForwardBackward(float val) = 0;
    /** @copybrief setForwardBackward
        @see setForwardBackward
    */
    CV_WRAP virtual float getForwardBackward() const = 0;
    //! @brief Size of the grid to spawn the motion vectors.
    /** For each grid point a motion vector is computed. Some motion vectors will be removed due to the forwatd backward
     *  threshold (if set >0). The rest will be the base of the vector field interpolation.
     *    @see getForwardBackward, setGridStep
    */
    CV_WRAP virtual Size getGridStep() const = 0;
    /** @copybrief getGridStep
     *    @see getGridStep
     */
    CV_WRAP virtual void setGridStep(Size val) = 0;

    //! @brief Interpolation used to compute the dense optical flow.
    /** Two interpolation algorithms are supported
     * - **INTERP_GEO** applies the fast geodesic interpolation, see @cite Geistert2016.
     * - **INTERP_EPIC_RESIDUAL** applies the edge-preserving interpolation, see @cite Revaud2015,Geistert2016.
     * @see ximgproc::EdgeAwareInterpolator, getInterpolation
    */
    CV_WRAP virtual void setInterpolation(InterpolationType val) = 0;
    /** @copybrief setInterpolation
     *    @see ximgproc::EdgeAwareInterpolator, setInterpolation
     */
    CV_WRAP virtual InterpolationType getInterpolation() const = 0;
    //! @brief see ximgproc::EdgeAwareInterpolator() K value.
    /** K is a number of nearest-neighbor matches considered, when fitting a locally affine
     *    model. Usually it should be around 128. However, lower values would make the interpolation noticeably faster.
     *    @see ximgproc::EdgeAwareInterpolator,  setEPICK
    */
    CV_WRAP virtual int getEPICK() const = 0;
    /** @copybrief getEPICK
     *    @see ximgproc::EdgeAwareInterpolator, getEPICK
     */
    CV_WRAP virtual void setEPICK(int val) = 0;
    //! @brief see ximgproc::EdgeAwareInterpolator() sigma value.
    /** Sigma is a parameter defining how fast the weights decrease in the locally-weighted affine
     *  fitting. Higher values can help preserve fine details, lower values can help to get rid of noise in the
     *  output flow.
     *    @see ximgproc::EdgeAwareInterpolator, setEPICSigma
    */
    CV_WRAP virtual float getEPICSigma() const = 0;
    /** @copybrief getEPICSigma
     *  @see ximgproc::EdgeAwareInterpolator, getEPICSigma
     */
    CV_WRAP virtual void setEPICSigma(float val) = 0;
    //! @brief  see ximgproc::EdgeAwareInterpolator() lambda value.
    /** Lambda is a parameter defining the weight of the edge-aware term in geodesic distance,
     *    should be in the range of 0 to 1000.
     *    @see ximgproc::EdgeAwareInterpolator, setEPICSigma
    */
    CV_WRAP virtual float getEPICLambda() const = 0;
    /** @copybrief getEPICLambda
     *    @see ximgproc::EdgeAwareInterpolator, getEPICLambda
    */
    CV_WRAP virtual void setEPICLambda(float val) = 0;
    //! @brief see ximgproc::EdgeAwareInterpolator().
    /** Sets the respective fastGlobalSmootherFilter() parameter.
     *    @see ximgproc::EdgeAwareInterpolator, setFgsLambda
    */
    CV_WRAP virtual float getFgsLambda() const = 0;
    /** @copybrief getFgsLambda
     *    @see ximgproc::EdgeAwareInterpolator, ximgproc::fastGlobalSmootherFilter, getFgsLambda
    */
    CV_WRAP virtual void setFgsLambda(float val) = 0;
    //! @brief see ximgproc::EdgeAwareInterpolator().
    /** Sets the respective fastGlobalSmootherFilter() parameter.
     *    @see ximgproc::EdgeAwareInterpolator, ximgproc::fastGlobalSmootherFilter, setFgsSigma
    */
    CV_WRAP virtual float getFgsSigma() const = 0;
    /** @copybrief getFgsSigma
     *    @see ximgproc::EdgeAwareInterpolator, ximgproc::fastGlobalSmootherFilter, getFgsSigma
     */
    CV_WRAP virtual void setFgsSigma(float val) = 0;
    //! @brief enables ximgproc::fastGlobalSmootherFilter
    /**
     * @see getUsePostProc
     */
    CV_WRAP virtual void setUsePostProc(bool val) = 0;
    /** @copybrief setUsePostProc
     *    @see ximgproc::fastGlobalSmootherFilter, setUsePostProc
     */
    CV_WRAP virtual bool getUsePostProc() const = 0;
    //! @brief enables VariationalRefinement
    /**
     * @see getUseVariationalRefinement
     */
    CV_WRAP virtual void setUseVariationalRefinement(bool val) = 0;
    /** @copybrief setUseVariationalRefinement
     *    @see ximgproc::fastGlobalSmootherFilter, setUsePostProc
     */
    CV_WRAP virtual bool getUseVariationalRefinement() const = 0;
    //! @brief Parameter to tune the approximate size of the superpixel used for oversegmentation.
    /**
     * @see cv::ximgproc::createSuperpixelSLIC, cv::ximgproc::RICInterpolator
     */
    CV_WRAP virtual void setRICSPSize(int val) = 0;
    /** @copybrief setRICSPSize
    *    @see setRICSPSize
    */
    CV_WRAP virtual int  getRICSPSize() const = 0;
    /** @brief Parameter to choose superpixel algorithm variant to use:
     * - cv::ximgproc::SLICType SLIC segments image using a desired region_size (value: 100)
     * - cv::ximgproc::SLICType SLICO will optimize using adaptive compactness factor (value: 101)
     * - cv::ximgproc::SLICType MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels (value: 102).
     *  @see cv::ximgproc::createSuperpixelSLIC, cv::ximgproc::RICInterpolator
    */
    CV_WRAP virtual void setRICSLICType(int val) = 0;
    /** @copybrief setRICSLICType
     *    @see setRICSLICType
     */
    CV_WRAP virtual int  getRICSLICType() const = 0;
    //! @brief Creates instance of optflow::DenseRLOFOpticalFlow
    /**
     *    @param rlofParam see optflow::RLOFOpticalFlowParameter
     *    @param forwardBackwardThreshold see setForwardBackward
     *    @param gridStep see setGridStep
     *    @param interp_type see setInterpolation
     *    @param epicK see setEPICK
     *    @param epicSigma see setEPICSigma
     *    @param epicLambda see setEPICLambda
     *    @param ricSPSize see setRICSPSize
     *    @param ricSLICType see setRICSLICType
     *    @param use_post_proc see setUsePostProc
     *    @param fgsLambda see setFgsLambda
     *    @param fgsSigma see setFgsSigma
     *    @param use_variational_refinement see setUseVariationalRefinement
    */
    CV_WRAP static Ptr<DenseRLOFOpticalFlow> create(
        Ptr<RLOFOpticalFlowParameter> rlofParam = Ptr<RLOFOpticalFlowParameter>(),
        float forwardBackwardThreshold = 1.f,
        Size gridStep = Size(6, 6),
        InterpolationType interp_type = InterpolationType::INTERP_EPIC,
        int epicK = 128,
        float epicSigma = 0.05f,
        float epicLambda = 999.0f,
        int ricSPSize = 15,
        int ricSLICType = 100,
        bool use_post_proc = true,
        float fgsLambda = 500.0f,
        float fgsSigma = 1.5f,
        bool use_variational_refinement = false);
};

/** @brief Class used for calculation sparse optical flow and feature tracking with robust local optical flow (RLOF) algorithms.
*
* The RLOF is a fast local optical flow approach described in @cite Senst2012 @cite Senst2013 @cite Senst2014
 * and @cite Senst2016 similar to the pyramidal iterative Lucas-Kanade method as
* proposed by @cite Bouguet00. More details and experiments can be found in the following thesis @cite Senst2019.
* The implementation is derived from optflow::calcOpticalFlowPyrLK().
*
* For the RLOF configuration see optflow::RLOFOpticalFlowParameter for further details.
* Parameters have been described in @cite Senst2012, @cite Senst2013, @cite Senst2014 and @cite Senst2016.
*
* @note SIMD parallelization is only available when compiling with SSE4.1.
* @see optflow::calcOpticalFlowSparseRLOF(), optflow::RLOFOpticalFlowParameter
*/
class CV_EXPORTS_W SparseRLOFOpticalFlow : public SparseOpticalFlow
{
public:
    /** @copydoc DenseRLOFOpticalFlow::setRLOFOpticalFlowParameter
    */
    CV_WRAP virtual void setRLOFOpticalFlowParameter(Ptr<RLOFOpticalFlowParameter> val) = 0;
    /** @copybrief setRLOFOpticalFlowParameter
     *    @see setRLOFOpticalFlowParameter
    */
    CV_WRAP virtual Ptr<RLOFOpticalFlowParameter>  getRLOFOpticalFlowParameter() const = 0;
    //! @brief Threshold for the forward backward confidence check
    /** For each feature point a motion vector \f$ d_{I0,I1}(\mathbf{x}) \f$ is computed.
     *     If the forward backward error \f[ EP_{FB} = || d_{I0,I1} + d_{I1,I0} || \f]
     *     is larger than threshold given by this function then the status  will not be used by the following
     *    vector field interpolation. \f$ d_{I1,I0} \f$ denotes the backward flow. Note, the forward backward test
     *    will only be applied if the threshold > 0. This may results into a doubled runtime for the motion estimation.
     *    @see setForwardBackward
    */
    CV_WRAP virtual void setForwardBackward(float val) = 0;
    /** @copybrief setForwardBackward
     *    @see setForwardBackward
    */
    CV_WRAP virtual float getForwardBackward() const = 0;

    //! @brief Creates instance of SparseRLOFOpticalFlow
    /**
     *    @param rlofParam see setRLOFOpticalFlowParameter
     *    @param forwardBackwardThreshold see setForwardBackward
    */
    CV_WRAP static Ptr<SparseRLOFOpticalFlow> create(
        Ptr<RLOFOpticalFlowParameter> rlofParam = Ptr<RLOFOpticalFlowParameter>(),
        float forwardBackwardThreshold = 1.f);

};

/** @brief Fast dense optical flow computation based on robust local optical flow (RLOF) algorithms and sparse-to-dense interpolation scheme.
 *
 * The RLOF is a fast local optical flow approach described in @cite Senst2012 @cite Senst2013 @cite Senst2014
 * and @cite Senst2016 similar to the pyramidal iterative Lucas-Kanade method as
 * proposed by @cite Bouguet00. More details and experiments can be found in the following thesis @cite Senst2019.
 * The implementation is derived from optflow::calcOpticalFlowPyrLK().
 *
 * The sparse-to-dense interpolation scheme allows for fast computation of dense optical flow using RLOF (see @cite Geistert2016).
 * For this scheme the following steps are applied:
 * -# motion vector seeded at a regular sampled grid are computed. The sparsity of this grid can be configured with setGridStep
 * -# (optinally) errornous motion vectors are filter based on the forward backward confidence. The threshold can be configured
 * with setForwardBackward. The filter is only applied if the threshold >0 but than the runtime is doubled due to the estimation
 * of the backward flow.
 * -# Vector field interpolation is applied to the motion vector set to obtain a dense vector field.
 *
 * @param I0 first 8-bit input image. If The cross-based RLOF is used (by selecting optflow::RLOFOpticalFlowParameter::supportRegionType
 * = SupportRegionType::SR_CROSS) image has to be a 8-bit 3 channel image.
 * @param I1 second 8-bit input image. If The cross-based RLOF is used (by selecting optflow::RLOFOpticalFlowParameter::supportRegionType
 * = SupportRegionType::SR_CROSS) image has to be a 8-bit 3 channel image.
 * @param flow computed flow image that has the same size as I0 and type CV_32FC2.
 * @param rlofParam see optflow::RLOFOpticalFlowParameter
 * @param forwardBackwardThreshold Threshold for the forward backward confidence check.
 * For each grid point \f$ \mathbf{x} \f$ a motion vector \f$ d_{I0,I1}(\mathbf{x}) \f$ is computed.
 * If the forward backward error \f[ EP_{FB} = || d_{I0,I1} + d_{I1,I0} || \f]
 * is larger than threshold given by this function then the motion vector will not be used by the following
 * vector field interpolation. \f$ d_{I1,I0} \f$ denotes the backward flow. Note, the forward backward test
 *    will only be applied if the threshold > 0. This may results into a doubled runtime for the motion estimation.
 * @param gridStep Size of the grid to spawn the motion vectors. For each grid point a motion vector is computed.
 * Some motion vectors will be removed due to the forwatd backward threshold (if set >0). The rest will be the
 * base of the vector field interpolation.
 * @param interp_type interpolation method used to compute the dense optical flow. Two interpolation algorithms are
 * supported:
 * - **INTERP_GEO** applies the fast geodesic interpolation, see @cite Geistert2016.
 * - **INTERP_EPIC_RESIDUAL** applies the edge-preserving interpolation, see @cite Revaud2015,Geistert2016.
 * @param epicK see ximgproc::EdgeAwareInterpolator sets the respective parameter.
 * @param epicSigma see ximgproc::EdgeAwareInterpolator sets the respective parameter.
 * @param epicLambda see ximgproc::EdgeAwareInterpolator sets the respective parameter.
 * @param ricSPSize  see ximgproc::RICInterpolator sets the respective parameter.
 * @param ricSLICType see ximgproc::RICInterpolator sets the respective parameter.
 * @param use_post_proc enables ximgproc::fastGlobalSmootherFilter() parameter.
 * @param fgsLambda sets the respective ximgproc::fastGlobalSmootherFilter() parameter.
 * @param fgsSigma sets the respective ximgproc::fastGlobalSmootherFilter() parameter.
 * @param use_variational_refinement enables VariationalRefinement
 *
 * Parameters have been described in @cite Senst2012, @cite Senst2013, @cite Senst2014, @cite Senst2016.
 * For the RLOF configuration see optflow::RLOFOpticalFlowParameter for further details.
 * @note If the grid size is set to (1,1) and the forward backward threshold <= 0 that the dense optical flow field is purely
 * computed with the RLOF.
 *
 * @note SIMD parallelization is only available when compiling with SSE4.1.
 * @note Note that in output, if no correspondences are found between \a I0 and \a I1, the \a flow is set to 0.
 *
 * @sa optflow::DenseRLOFOpticalFlow, optflow::RLOFOpticalFlowParameter
*/
CV_EXPORTS_W void calcOpticalFlowDenseRLOF(InputArray I0, InputArray I1, InputOutputArray flow,
    Ptr<RLOFOpticalFlowParameter> rlofParam = Ptr<RLOFOpticalFlowParameter>(),
    float forwardBackwardThreshold = 0, Size gridStep = Size(6, 6),
    InterpolationType interp_type = InterpolationType::INTERP_EPIC,
    int epicK = 128, float epicSigma = 0.05f, float epicLambda = 100.f,
    int ricSPSize = 15, int ricSLICType = 100,
    bool use_post_proc = true, float fgsLambda = 500.0f, float fgsSigma = 1.5f,
    bool use_variational_refinement = false);

/** @brief Calculates fast optical flow for a sparse feature set using the robust local optical flow (RLOF) similar
* to optflow::calcOpticalFlowPyrLK().
*
* The RLOF is a fast local optical flow approach described in @cite Senst2012 @cite Senst2013 @cite Senst2014
 * and @cite Senst2016 similar to the pyramidal iterative Lucas-Kanade method as
* proposed by @cite Bouguet00. More details and experiments can be found in the following thesis @cite Senst2019.
* The implementation is derived from optflow::calcOpticalFlowPyrLK().
*
* @param prevImg first 8-bit input image. If The cross-based RLOF is used (by selecting optflow::RLOFOpticalFlowParameter::supportRegionType
* = SupportRegionType::SR_CROSS) image has to be a 8-bit 3 channel image.
* @param nextImg second 8-bit input image. If The cross-based RLOF is used (by selecting optflow::RLOFOpticalFlowParameter::supportRegionType
* = SupportRegionType::SR_CROSS) image has to be a 8-bit 3 channel image.
* @param prevPts vector of 2D points for which the flow needs to be found; point coordinates must be single-precision
* floating-point numbers.
* @param nextPts output vector of 2D points (with single-precision floating-point coordinates) containing the calculated
* new positions of input features in the second image; when optflow::RLOFOpticalFlowParameter::useInitialFlow variable is true  the vector must
* have the same size as in the input and contain the initialization point correspondences.
* @param status output status vector (of unsigned chars); each element of the vector is set to 1 if the flow for the
* corresponding features has passed the forward backward check.
* @param err output vector of errors; each element of the vector is set to the forward backward error for the corresponding feature.
* @param rlofParam see optflow::RLOFOpticalFlowParameter
* @param forwardBackwardThreshold Threshold for the forward backward confidence check. If forewardBackwardThreshold <=0 the forward
*
* @note SIMD parallelization is only available when compiling with SSE4.1.
*
* Parameters have been described in @cite Senst2012, @cite Senst2013, @cite Senst2014 and @cite Senst2016.
* For the RLOF configuration see optflow::RLOFOpticalFlowParameter for further details.
*/
CV_EXPORTS_W void calcOpticalFlowSparseRLOF(InputArray prevImg, InputArray nextImg,
    InputArray prevPts, InputOutputArray nextPts,
    OutputArray status, OutputArray err,
    Ptr<RLOFOpticalFlowParameter> rlofParam = Ptr<RLOFOpticalFlowParameter>(),
    float forwardBackwardThreshold = 0);

//! Additional interface to the Dense RLOF algorithm - optflow::calcOpticalFlowDenseRLOF()
CV_EXPORTS_W Ptr<DenseOpticalFlow> createOptFlow_DenseRLOF();

//! Additional interface to the Sparse RLOF algorithm - optflow::calcOpticalFlowSparseRLOF()
CV_EXPORTS_W Ptr<SparseOpticalFlow> createOptFlow_SparseRLOF();
//! @}

} // namespace
} // namespace
#endif