| OpenCV 4.3.0 Open Source Computer Vision

Public Member Functions | List of all members
cv::ximgproc::RICInterpolator Class Referenceabstract
Extended Image Processing » Filters

Sparse match interpolation algorithm based on modified piecewise locally-weighted affine estimator called Robust Interpolation method of Correspondences or RIC from [109] and Variational and Fast Global Smoother as post-processing filter. The RICInterpolator is a extension of the EdgeAwareInterpolator. Main concept of this extension is an piece-wise affine model based on over-segmentation via SLIC superpixel estimation. The method contains an efficient propagation mechanism to estimate among the pieces-wise models. More...

`#include <opencv2/ximgproc/sparse_match_interpolator.hpp>`

Inheritance diagram for cv::ximgproc::RICInterpolator:

## Public Member Functions
virtual float | getAlpha () const =0
| Alpha is a parameter defining a global weight for transforming geodesic distance into weight. More...
virtual float | getFGSLambda () const =0
| Sets the respective fastGlobalSmootherFilter() parameter. More...
virtual float | getFGSSigma () const =0
| Sets the respective fastGlobalSmootherFilter() parameter. More...
virtual int | getK () const =0
| K is a number of nearest-neighbor matches considered, when fitting a locally affine model for a superpixel segment. However, lower values would make the interpolation noticeably faster. The original implementation of [109] uses 32. More...
virtual float | getMaxFlow () const =0
| MaxFlow is a threshold to validate the predictions using a certain piece-wise affine model. If the prediction exceeds the treshold the translational model will be applied instead. More...
virtual int | getModelIter () const =0
| Parameter defining the number of iterations for piece-wise affine model estimation. More...
virtual bool | getRefineModels () const =0
| Parameter to choose wether additional refinement of the piece-wise affine models is employed. More...
virtual int | getSuperpixelMode () const =0
| Parameter to choose superpixel algorithm variant to use: More...
virtual int | getSuperpixelNNCnt () const =0
| Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine model. More...
virtual float | getSuperpixelRuler () const =0
| Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation. More...
virtual int | getSuperpixelSize () const =0
| Get the internal cost, i.e. edge map, used for estimating the edge-aware term. More...
virtual bool | getUseGlobalSmootherFilter () const =0
| Sets whether the fastGlobalSmootherFilter() post-processing is employed. More...
virtual bool | getUseVariationalRefinement () const =0
| Parameter to choose wether the VariationalRefinement post-processing is employed. More...
virtual void | setAlpha (float alpha=0.7f)=0
| Alpha is a parameter defining a global weight for transforming geodesic distance into weight. More...
virtual void | setCostMap (const Mat &costMap)=0
| Interface to provide a more elaborated cost map, i.e. edge map, for the edge-aware term. This implementation is based on a rather simple gradient-based edge map estimation. To used more complex edge map estimator (e.g. StructuredEdgeDetection that has been used in the original publication) that may lead to improved accuracies, the internal edge map estimation can be bypassed here. More...
virtual void | setFGSLambda (float lambda=500.f)=0
| Sets the respective fastGlobalSmootherFilter() parameter. More...
virtual void | setFGSSigma (float sigma=1.5f)=0
| Sets the respective fastGlobalSmootherFilter() parameter. More...
virtual void | setK (int k=32)=0
| K is a number of nearest-neighbor matches considered, when fitting a locally affine model for a superpixel segment. However, lower values would make the interpolation noticeably faster. The original implementation of [109] uses 32. More...
virtual void | setMaxFlow (float maxFlow=250.f)=0
| MaxFlow is a threshold to validate the predictions using a certain piece-wise affine model. If the prediction exceeds the treshold the translational model will be applied instead. More...
virtual void | setModelIter (int modelIter=4)=0
| Parameter defining the number of iterations for piece-wise affine model estimation. More...
virtual void | setRefineModels (bool refineModles=true)=0
| Parameter to choose wether additional refinement of the piece-wise affine models is employed. More...
virtual void | setSuperpixelMode (int mode=100)=0
| Parameter to choose superpixel algorithm variant to use: More...
virtual void | setSuperpixelNNCnt (int spNN=150)=0
| Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine model. More...
virtual void | setSuperpixelRuler (float ruler=15.f)=0
| Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation. More...
virtual void | setSuperpixelSize (int spSize=15)=0
| Get the internal cost, i.e. edge map, used for estimating the edge-aware term. More...
virtual void | setUseGlobalSmootherFilter (bool use_FGS=true)=0
| Sets whether the fastGlobalSmootherFilter() post-processing is employed. More...
virtual void | setUseVariationalRefinement (bool use_variational_refinement=false)=0
| Parameter to choose wether the VariationalRefinement post-processing is employed. More...
Public Member Functions inherited from cv::ximgproc::SparseMatchInterpolator
virtual void | interpolate (InputArray from_image, InputArray from_points, InputArray to_image, InputArray to_points, OutputArray dense_flow)=0
| Interpolate input sparse matches. More...
Public Member Functions inherited from cv::Algorithm
| Algorithm ()
virtual | ~Algorithm ()
virtual void | clear ()
| Clears the algorithm state. More...
virtual bool | empty () const
| Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read. More...
virtual String | getDefaultName () const
virtual void | read (const FileNode &fn)
| Reads algorithm parameters from a file storage. More...
virtual void | save (const String &filename) const
virtual void | write (FileStorage &fs) const
| Stores algorithm parameters in a file storage. More...
void | write (const Ptr< FileStorage > &fs, const String &name=String()) const
| simplified API for language bindings This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

## Additional Inherited Members
Static Public Member Functions inherited from cv::Algorithm
template<typename _Tp >
static Ptr< _Tp > | load (const String &filename, const String &objname=String())
| Loads algorithm from the file. More...
template<typename _Tp >
static Ptr< _Tp > | loadFromString (const String &strModel, const String &objname=String())
| Loads algorithm from a String. More...
template<typename _Tp >
static Ptr< _Tp > | read (const FileNode &fn)
| Reads algorithm from the file node. More...
Protected Member Functions inherited from cv::Algorithm
void | writeFormat (FileStorage &fs) const

## Detailed Description

Sparse match interpolation algorithm based on modified piecewise locally-weighted affine estimator called Robust Interpolation method of Correspondences or RIC from [109] and Variational and Fast Global Smoother as post-processing filter. The RICInterpolator is a extension of the EdgeAwareInterpolator. Main concept of this extension is an piece-wise affine model based on over-segmentation via SLIC superpixel estimation. The method contains an efficient propagation mechanism to estimate among the pieces-wise models.

## Member Function Documentation

## ◆ getAlpha()

virtual float cv::ximgproc::RICInterpolator::getAlpha | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getAlpha( |  | )

Alpha is a parameter defining a global weight for transforming geodesic distance into weight.

See also
  setAlpha

## ◆ getFGSLambda()

virtual float cv::ximgproc::RICInterpolator::getFGSLambda | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getFGSLambda( |  | )

Sets the respective fastGlobalSmootherFilter() parameter.

See also
  setFGSLambda

## ◆ getFGSSigma()

virtual float cv::ximgproc::RICInterpolator::getFGSSigma | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getFGSSigma( |  | )

Sets the respective fastGlobalSmootherFilter() parameter.

See also
  setFGSSigma

## ◆ getK()

virtual int cv::ximgproc::RICInterpolator::getK | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getK( |  | )

K is a number of nearest-neighbor matches considered, when fitting a locally affine model for a superpixel segment. However, lower values would make the interpolation noticeably faster. The original implementation of [109] uses 32.

See also
  setK

## ◆ getMaxFlow()

virtual float cv::ximgproc::RICInterpolator::getMaxFlow | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getMaxFlow( |  | )

MaxFlow is a threshold to validate the predictions using a certain piece-wise affine model. If the prediction exceeds the treshold the translational model will be applied instead.

See also
  setMaxFlow

## ◆ getModelIter()

virtual int cv::ximgproc::RICInterpolator::getModelIter | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getModelIter( |  | )

Parameter defining the number of iterations for piece-wise affine model estimation.

See also
  setModelIter

## ◆ getRefineModels()

virtual bool cv::ximgproc::RICInterpolator::getRefineModels | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getRefineModels( |  | )

Parameter to choose wether additional refinement of the piece-wise affine models is employed.

See also
  setRefineModels

## ◆ getSuperpixelMode()

virtual int cv::ximgproc::RICInterpolator::getSuperpixelMode | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getSuperpixelMode( |  | )

Parameter to choose superpixel algorithm variant to use:

See also
  setSuperpixelMode

## ◆ getSuperpixelNNCnt()

virtual int cv::ximgproc::RICInterpolator::getSuperpixelNNCnt | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getSuperpixelNNCnt( |  | )

Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine model.

See also
  setSuperpixelNNCnt

## ◆ getSuperpixelRuler()

virtual float cv::ximgproc::RICInterpolator::getSuperpixelRuler | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getSuperpixelRuler( |  | )

Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation.

See also
  setSuperpixelRuler

## ◆ getSuperpixelSize()

virtual int cv::ximgproc::RICInterpolator::getSuperpixelSize | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getSuperpixelSize( |  | )

Get the internal cost, i.e. edge map, used for estimating the edge-aware term.

See also
  setSuperpixelSize

## ◆ getUseGlobalSmootherFilter()

virtual bool cv::ximgproc::RICInterpolator::getUseGlobalSmootherFilter | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getUseGlobalSmootherFilter( |  | )

Sets whether the fastGlobalSmootherFilter() post-processing is employed.

See also
  setUseGlobalSmootherFilter

## ◆ getUseVariationalRefinement()

virtual bool cv::ximgproc::RICInterpolator::getUseVariationalRefinement | ( |  | ) | const
| pure virtual

Python:
| retval | = | cv.ximgproc_RICInterpolator.getUseVariationalRefinement( |  | )

Parameter to choose wether the VariationalRefinement post-processing is employed.

See also
  setUseVariationalRefinement

## ◆ setAlpha()

virtual void cv::ximgproc::RICInterpolator::setAlpha | ( | float | alpha = `0.7f` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setAlpha( | [, alpha] | )

Alpha is a parameter defining a global weight for transforming geodesic distance into weight.

## ◆ setCostMap()

virtual void cv::ximgproc::RICInterpolator::setCostMap | ( | const Mat & | costMap | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setCostMap( | costMap | )

Interface to provide a more elaborated cost map, i.e. edge map, for the edge-aware term. This implementation is based on a rather simple gradient-based edge map estimation. To used more complex edge map estimator (e.g. StructuredEdgeDetection that has been used in the original publication) that may lead to improved accuracies, the internal edge map estimation can be bypassed here.

Parameters

  costMap | a type CV_32FC1 Mat is required.

See also
  cv::ximgproc::createSuperpixelSLIC

## ◆ setFGSLambda()

virtual void cv::ximgproc::RICInterpolator::setFGSLambda | ( | float | lambda = `500.f` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setFGSLambda( | [, lambda] | )

Sets the respective fastGlobalSmootherFilter() parameter.

## ◆ setFGSSigma()

virtual void cv::ximgproc::RICInterpolator::setFGSSigma | ( | float | sigma = `1.5f` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setFGSSigma( | [, sigma] | )

Sets the respective fastGlobalSmootherFilter() parameter.

## ◆ setK()

virtual void cv::ximgproc::RICInterpolator::setK | ( | int | k = `32` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setK( | [, k] | )

K is a number of nearest-neighbor matches considered, when fitting a locally affine model for a superpixel segment. However, lower values would make the interpolation noticeably faster. The original implementation of [109] uses 32.

## ◆ setMaxFlow()

virtual void cv::ximgproc::RICInterpolator::setMaxFlow | ( | float | maxFlow = `250.f` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setMaxFlow( | [, maxFlow] | )

MaxFlow is a threshold to validate the predictions using a certain piece-wise affine model. If the prediction exceeds the treshold the translational model will be applied instead.

## ◆ setModelIter()

virtual void cv::ximgproc::RICInterpolator::setModelIter | ( | int | modelIter = `4` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setModelIter( | [, modelIter] | )

Parameter defining the number of iterations for piece-wise affine model estimation.

## ◆ setRefineModels()

virtual void cv::ximgproc::RICInterpolator::setRefineModels | ( | bool | refineModles = `true` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setRefineModels( | [, refineModles] | )

Parameter to choose wether additional refinement of the piece-wise affine models is employed.

## ◆ setSuperpixelMode()

virtual void cv::ximgproc::RICInterpolator::setSuperpixelMode | ( | int | mode = `100` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setSuperpixelMode( | [, mode] | )

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 also
    cv::ximgproc::createSuperpixelSLIC

## ◆ setSuperpixelNNCnt()

virtual void cv::ximgproc::RICInterpolator::setSuperpixelNNCnt | ( | int | spNN = `150` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setSuperpixelNNCnt( | [, spNN] | )

Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine model.

## ◆ setSuperpixelRuler()

virtual void cv::ximgproc::RICInterpolator::setSuperpixelRuler | ( | float | ruler = `15.f` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setSuperpixelRuler( | [, ruler] | )

Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation.

See also
  cv::ximgproc::createSuperpixelSLIC

## ◆ setSuperpixelSize()

virtual void cv::ximgproc::RICInterpolator::setSuperpixelSize | ( | int | spSize = `15` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setSuperpixelSize( | [, spSize] | )

Get the internal cost, i.e. edge map, used for estimating the edge-aware term.

See also
  setCostMap

## ◆ setUseGlobalSmootherFilter()

virtual void cv::ximgproc::RICInterpolator::setUseGlobalSmootherFilter | ( | bool | use_FGS = `true` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setUseGlobalSmootherFilter( | [, use_FGS] | )

Sets whether the fastGlobalSmootherFilter() post-processing is employed.

## ◆ setUseVariationalRefinement()

virtual void cv::ximgproc::RICInterpolator::setUseVariationalRefinement | ( | bool | use_variational_refinement = `false` | ) |
| pure virtual

Python:
| None | = | cv.ximgproc_RICInterpolator.setUseVariationalRefinement( | [, use_variational_refinement] | )

Parameter to choose wether the VariationalRefinement post-processing is employed.

The documentation for this class was generated from the following file:

- opencv2/ximgproc/sparse_match_interpolator.hpp