This is used store and set up the parameters of the robust local optical flow (RLOF) algoritm.
More...
#include <opencv2/optflow/rlofflow.hpp>
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 [207] [208] [209] and [210] similar to the pyramidal iterative Lucas-Kanade method as proposed by [25]. More details and experiments can be found in the following thesis [211]. 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 [207]) 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 [209] 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 [210]). This model can be switched on/off with the useIlluminationModel variable.
- By using a global motion prior initialization (see [210]) 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 also
- optflow::DenseRLOFOpticalFlow, optflow::calcOpticalFlowDenseRLOF(), optflow::SparseRLOFOpticalFlow, optflow::calcOpticalFlowSparseRLOF()
◆ RLOFOpticalFlowParameter()
| cv::optflow::RLOFOpticalFlowParameter::RLOFOpticalFlowParameter |
( |
| ) |
|
|
inline |
◆ create()
| Python: |
|---|
| retval | = | cv.optflow.RLOFOpticalFlowParameter_create( | | ) |
◆ getCrossSegmentationThreshold()
| int cv::optflow::RLOFOpticalFlowParameter::getCrossSegmentationThreshold |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getCrossSegmentationThreshold( | | ) |
◆ getGlobalMotionRansacThreshold()
| float cv::optflow::RLOFOpticalFlowParameter::getGlobalMotionRansacThreshold |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getGlobalMotionRansacThreshold( | | ) |
◆ getLargeWinSize()
| int cv::optflow::RLOFOpticalFlowParameter::getLargeWinSize |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getLargeWinSize( | | ) |
◆ getMaxIteration()
| int cv::optflow::RLOFOpticalFlowParameter::getMaxIteration |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getMaxIteration( | | ) |
◆ getMaxLevel()
| int cv::optflow::RLOFOpticalFlowParameter::getMaxLevel |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getMaxLevel( | | ) |
◆ getMinEigenValue()
| float cv::optflow::RLOFOpticalFlowParameter::getMinEigenValue |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getMinEigenValue( | | ) |
◆ getNormSigma0()
| float cv::optflow::RLOFOpticalFlowParameter::getNormSigma0 |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getNormSigma0( | | ) |
◆ getNormSigma1()
| float cv::optflow::RLOFOpticalFlowParameter::getNormSigma1 |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getNormSigma1( | | ) |
◆ getSmallWinSize()
| int cv::optflow::RLOFOpticalFlowParameter::getSmallWinSize |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getSmallWinSize( | | ) |
◆ getSolverType()
| SolverType cv::optflow::RLOFOpticalFlowParameter::getSolverType |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getSolverType( | | ) |
◆ getSupportRegionType()
| SupportRegionType cv::optflow::RLOFOpticalFlowParameter::getSupportRegionType |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getSupportRegionType( | | ) |
◆ getUseGlobalMotionPrior()
| bool cv::optflow::RLOFOpticalFlowParameter::getUseGlobalMotionPrior |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getUseGlobalMotionPrior( | | ) |
◆ getUseIlluminationModel()
| bool cv::optflow::RLOFOpticalFlowParameter::getUseIlluminationModel |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getUseIlluminationModel( | | ) |
◆ getUseInitialFlow()
| bool cv::optflow::RLOFOpticalFlowParameter::getUseInitialFlow |
( |
| ) |
const |
| Python: |
|---|
| retval | = | cv.optflow_RLOFOpticalFlowParameter.getUseInitialFlow( | | ) |
◆ setCrossSegmentationThreshold()
| void cv::optflow::RLOFOpticalFlowParameter::setCrossSegmentationThreshold |
( |
int |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setCrossSegmentationThreshold( | val | ) |
◆ setGlobalMotionRansacThreshold()
| void cv::optflow::RLOFOpticalFlowParameter::setGlobalMotionRansacThreshold |
( |
float |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setGlobalMotionRansacThreshold( | val | ) |
◆ setLargeWinSize()
| void cv::optflow::RLOFOpticalFlowParameter::setLargeWinSize |
( |
int |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setLargeWinSize( | val | ) |
◆ setMaxIteration()
| void cv::optflow::RLOFOpticalFlowParameter::setMaxIteration |
( |
int |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setMaxIteration( | val | ) |
◆ setMaxLevel()
| void cv::optflow::RLOFOpticalFlowParameter::setMaxLevel |
( |
int |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setMaxLevel( | val | ) |
◆ setMinEigenValue()
| void cv::optflow::RLOFOpticalFlowParameter::setMinEigenValue |
( |
float |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setMinEigenValue( | val | ) |
◆ setNormSigma0()
| void cv::optflow::RLOFOpticalFlowParameter::setNormSigma0 |
( |
float |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setNormSigma0( | val | ) |
◆ setNormSigma1()
| void cv::optflow::RLOFOpticalFlowParameter::setNormSigma1 |
( |
float |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setNormSigma1( | val | ) |
◆ setSmallWinSize()
| void cv::optflow::RLOFOpticalFlowParameter::setSmallWinSize |
( |
int |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setSmallWinSize( | val | ) |
◆ setSolverType()
| void cv::optflow::RLOFOpticalFlowParameter::setSolverType |
( |
SolverType |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setSolverType( | val | ) |
◆ setSupportRegionType()
| void cv::optflow::RLOFOpticalFlowParameter::setSupportRegionType |
( |
SupportRegionType |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setSupportRegionType( | val | ) |
◆ setUseGlobalMotionPrior()
| void cv::optflow::RLOFOpticalFlowParameter::setUseGlobalMotionPrior |
( |
bool |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setUseGlobalMotionPrior( | val | ) |
◆ setUseIlluminationModel()
| void cv::optflow::RLOFOpticalFlowParameter::setUseIlluminationModel |
( |
bool |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setUseIlluminationModel( | val | ) |
◆ setUseInitialFlow()
| void cv::optflow::RLOFOpticalFlowParameter::setUseInitialFlow |
( |
bool |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setUseInitialFlow( | val | ) |
◆ setUseMEstimator()
| void cv::optflow::RLOFOpticalFlowParameter::setUseMEstimator |
( |
bool |
val | ) |
|
| Python: |
|---|
| None | = | cv.optflow_RLOFOpticalFlowParameter.setUseMEstimator( | val | ) |
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.
- Parameters
-
| val | If true M-estimator is used. If false least-square estimator is used. |
- See also
- setNormSigma0, setNormSigma1
◆ crossSegmentationThreshold
| int cv::optflow::RLOFOpticalFlowParameter::crossSegmentationThreshold |
Color similarity threshold used by cross-based segmentation following [209] . (Only used if supportRegionType is SR_CROSS). With the cross-bassed segmentation motion boundaries can be computed more accurately.
◆ globalMotionRansacThreshold
| float cv::optflow::RLOFOpticalFlowParameter::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 [210] for more details.
◆ largeWinSize
| int cv::optflow::RLOFOpticalFlowParameter::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.
◆ maxIteration
| int cv::optflow::RLOFOpticalFlowParameter::maxIteration |
Number of maximal iterations used for the iterative refinement. Lower values can reduce the runtime but also the accuracy.
◆ maxLevel
| int cv::optflow::RLOFOpticalFlowParameter::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.
◆ minEigenValue
| float cv::optflow::RLOFOpticalFlowParameter::minEigenValue |
Threshold for the minimal eigenvalue of the gradient matrix defines when to abort the iterative refinement.
◆ normSigma0
| float cv::optflow::RLOFOpticalFlowParameter::normSigma0 |
&sigma parameter of the shrinked Hampel norm introduced in [207]. 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.
◆ normSigma1
| float cv::optflow::RLOFOpticalFlowParameter::normSigma1 |
&sigma parameter of the shrinked Hampel norm introduced in [207]. 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.
◆ smallWinSize
| int cv::optflow::RLOFOpticalFlowParameter::smallWinSize |
Minimal window size of the support region. This parameter is only used if supportRegionType is SR_CROSS.
◆ solverType
| SolverType cv::optflow::RLOFOpticalFlowParameter::solverType |
Variable specifies the iterative refinement strategy. Please consider citing [208] when using ST_BILINEAR.
◆ supportRegionType
Variable specifies the support region shape extraction or shrinking strategy.
◆ useGlobalMotionPrior
| bool cv::optflow::RLOFOpticalFlowParameter::useGlobalMotionPrior |
Use global motion prior initialisation has been introduced in [210] . It allows to be more accurate for long-range motion. The computational complexity is slightly increased by enabling the global motion prior initialisation.
◆ useIlluminationModel
| bool cv::optflow::RLOFOpticalFlowParameter::useIlluminationModel |
Use the Gennert and Negahdaripour illumination model instead of the intensity brigthness constraint. (proposed in [210] ) This model is defined as follow:
\[ I(\mathbf{x},t) + m \cdot I(\mathbf{x},t) + c = I(\mathbf{x},t+1) \]
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.
◆ useInitialFlow
| bool cv::optflow::RLOFOpticalFlowParameter::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.
The documentation for this class was generated from the following file:
1.8.13