[−][src]Trait opencv::optflow::prelude::RLOFOpticalFlowParameterTrait

pub trait RLOFOpticalFlowParameterTrait {
    pub fn as_raw_RLOFOpticalFlowParameter(&self) -> *const c_void;
    pub fn as_raw_mut_RLOFOpticalFlowParameter(&mut self) -> *mut c_void;

    pub fn solver_type(&self) -> SolverType { ... }
    pub fn set_solver_type(&mut self, val: SolverType) { ... }
    pub fn support_region_type(&self) -> SupportRegionType { ... }
    pub fn set_support_region_type(&mut self, val: SupportRegionType) { ... }
    pub fn norm_sigma0(&self) -> f32 { ... }
    pub fn set_norm_sigma0(&mut self, val: f32) { ... }
    pub fn norm_sigma1(&self) -> f32 { ... }
    pub fn set_norm_sigma1(&mut self, val: f32) { ... }
    pub fn small_win_size(&self) -> i32 { ... }
    pub fn set_small_win_size(&mut self, val: i32) { ... }
    pub fn large_win_size(&self) -> i32 { ... }
    pub fn set_large_win_size(&mut self, val: i32) { ... }
    pub fn cross_segmentation_threshold(&self) -> i32 { ... }
    pub fn set_cross_segmentation_threshold(&mut self, val: i32) { ... }
    pub fn max_level(&self) -> i32 { ... }
    pub fn set_max_level(&mut self, val: i32) { ... }
    pub fn use_initial_flow(&self) -> bool { ... }
    pub fn set_use_initial_flow(&mut self, val: bool) { ... }
    pub fn use_illumination_model(&self) -> bool { ... }
    pub fn set_use_illumination_model(&mut self, val: bool) { ... }
    pub fn use_global_motion_prior(&self) -> bool { ... }
    pub fn set_use_global_motion_prior(&mut self, val: bool) { ... }
    pub fn max_iteration(&self) -> i32 { ... }
    pub fn set_max_iteration(&mut self, val: i32) { ... }
    pub fn min_eigen_value(&self) -> f32 { ... }
    pub fn set_min_eigen_value(&mut self, val: f32) { ... }
    pub fn global_motion_ransac_threshold(&self) -> f32 { ... }
    pub fn set_global_motion_ransac_threshold(&mut self, val: f32) { ... }
    pub fn set_use_m_estimator(&mut self, val: bool) -> Result<()> { ... }
    pub fn set_solver_type_1(&mut self, val: SolverType) -> Result<()> { ... }
    pub fn get_solver_type(&self) -> Result<SolverType> { ... }
    pub fn set_support_region_type_1(
        &mut self, 
        val: SupportRegionType
    ) -> Result<()> { ... }
    pub fn get_support_region_type(&self) -> Result<SupportRegionType> { ... }
    pub fn set_norm_sigma0_1(&mut self, val: f32) -> Result<()> { ... }
    pub fn get_norm_sigma0(&self) -> Result<f32> { ... }
    pub fn set_norm_sigma1_1(&mut self, val: f32) -> Result<()> { ... }
    pub fn get_norm_sigma1(&self) -> Result<f32> { ... }
    pub fn set_small_win_size_1(&mut self, val: i32) -> Result<()> { ... }
    pub fn get_small_win_size(&self) -> Result<i32> { ... }
    pub fn set_large_win_size_1(&mut self, val: i32) -> Result<()> { ... }
    pub fn get_large_win_size(&self) -> Result<i32> { ... }
    pub fn set_cross_segmentation_threshold_1(&mut self, val: i32) -> Result<()> { ... }
    pub fn get_cross_segmentation_threshold(&self) -> Result<i32> { ... }
    pub fn set_max_level_1(&mut self, val: i32) -> Result<()> { ... }
    pub fn get_max_level(&self) -> Result<i32> { ... }
    pub fn set_use_initial_flow_1(&mut self, val: bool) -> Result<()> { ... }
    pub fn get_use_initial_flow(&self) -> Result<bool> { ... }
    pub fn set_use_illumination_model_1(&mut self, val: bool) -> Result<()> { ... }
    pub fn get_use_illumination_model(&self) -> Result<bool> { ... }
    pub fn set_use_global_motion_prior_1(&mut self, val: bool) -> Result<()> { ... }
    pub fn get_use_global_motion_prior(&self) -> Result<bool> { ... }
    pub fn set_max_iteration_1(&mut self, val: i32) -> Result<()> { ... }
    pub fn get_max_iteration(&self) -> Result<i32> { ... }
    pub fn set_min_eigen_value_1(&mut self, val: f32) -> Result<()> { ... }
    pub fn get_min_eigen_value(&self) -> Result<f32> { ... }
    pub fn set_global_motion_ransac_threshold_1(
        &mut self, 
        val: f32
    ) -> Result<()> { ... }
    pub fn get_global_motion_ransac_threshold(&self) -> Result<f32> { ... }
}

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 Senst2012 Senst2013 Senst2014 and Senst2016 similar to the pyramidal iterative Lucas-Kanade method as proposed by Bouguet00. More details and experiments can be found in the following thesis 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 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 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 Senst2016). This model can be switched on/off with the useIlluminationModel variable.
By using a global motion prior initialization (see 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.

Required methods

`pub fn as_raw_RLOFOpticalFlowParameter(&self) -> *const c_void`[src]

`pub fn as_raw_mut_RLOFOpticalFlowParameter(&mut self) -> *mut c_void`[src]

Loading content...

Provided methods

`pub fn solver_type(&self) -> SolverType`[src]

`pub fn set_solver_type(&mut self, val: SolverType)`[src]

`pub fn support_region_type(&self) -> SupportRegionType`[src]

`pub fn set_support_region_type(&mut self, val: SupportRegionType)`[src]

`pub fn norm_sigma0(&self) -> f32`[src]

`pub fn set_norm_sigma0(&mut self, val: f32)`[src]

`pub fn norm_sigma1(&self) -> f32`[src]

`pub fn set_norm_sigma1(&mut self, val: f32)`[src]

`pub fn small_win_size(&self) -> i32`[src]

`pub fn set_small_win_size(&mut self, val: i32)`[src]

`pub fn large_win_size(&self) -> i32`[src]

`pub fn set_large_win_size(&mut self, val: i32)`[src]

`pub fn cross_segmentation_threshold(&self) -> i32`[src]

`pub fn set_cross_segmentation_threshold(&mut self, val: i32)`[src]

`pub fn max_level(&self) -> i32`[src]

`pub fn set_max_level(&mut self, val: i32)`[src]

`pub fn use_initial_flow(&self) -> bool`[src]

`pub fn set_use_initial_flow(&mut self, val: bool)`[src]

`pub fn use_illumination_model(&self) -> bool`[src]

`pub fn set_use_illumination_model(&mut self, val: bool)`[src]

`pub fn use_global_motion_prior(&self) -> bool`[src]

`pub fn set_use_global_motion_prior(&mut self, val: bool)`[src]

`pub fn max_iteration(&self) -> i32`[src]

`pub fn set_max_iteration(&mut self, val: i32)`[src]

`pub fn min_eigen_value(&self) -> f32`[src]

`pub fn set_min_eigen_value(&mut self, val: f32)`[src]

`pub fn global_motion_ransac_threshold(&self) -> f32`[src]

`pub fn set_global_motion_ransac_threshold(&mut self, val: f32)`[src]

`pub fn set_use_m_estimator(&mut self, val: bool) -> Result<()>`[src]

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.