java.lang.Object
- org.opencv.core.Algorithm
- - org.opencv.ximgproc.SparseMatchInterpolator
  - - org.opencv.ximgproc.RICInterpolator

```
public class RICInterpolator
extends SparseMatchInterpolator
```
Sparse match interpolation algorithm based on modified piecewise locally-weighted affine estimator called Robust Interpolation method of Correspondences or RIC from CITE: Hu2017 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.

Field Summary
- Fields inherited from class org.opencv.core.Algorithm
  nativeObj

Constructor Summary

Constructors
Modifier Constructor Description

protected RICInterpolator(long addr)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`static RICInterpolator`	`__fromPtr__(long addr)`
`protected void`	`finalize()`
`float`	`getAlpha()`	setAlpha SEE: setAlpha
`float`	`getFGSLambda()`	setFGSLambda SEE: setFGSLambda
`float`	`getFGSSigma()`	setFGSSigma SEE: setFGSSigma
`int`	`getK()`	setK SEE: setK
`float`	`getMaxFlow()`	setMaxFlow SEE: setMaxFlow
`int`	`getModelIter()`	setModelIter SEE: setModelIter
`boolean`	`getRefineModels()`	setRefineModels SEE: setRefineModels
`int`	`getSuperpixelMode()`	setSuperpixelMode SEE: setSuperpixelMode
`int`	`getSuperpixelNNCnt()`	setSuperpixelNNCnt SEE: setSuperpixelNNCnt
`float`	`getSuperpixelRuler()`	setSuperpixelRuler SEE: setSuperpixelRuler
`int`	`getSuperpixelSize()`	setSuperpixelSize SEE: setSuperpixelSize
`boolean`	`getUseGlobalSmootherFilter()`	setUseGlobalSmootherFilter SEE: setUseGlobalSmootherFilter
`boolean`	`getUseVariationalRefinement()`	setUseVariationalRefinement SEE: setUseVariationalRefinement
`void`	`setAlpha()`	Alpha is a parameter defining a global weight for transforming geodesic distance into weight.
`void`	`setAlpha(float alpha)`	Alpha is a parameter defining a global weight for transforming geodesic distance into weight.
`void`	`setCostMap(Mat costMap)`	Interface to provide a more elaborated cost map, i.e.
`void`	`setFGSLambda()`	Sets the respective fastGlobalSmootherFilter() parameter.
`void`	`setFGSLambda(float lambda)`	Sets the respective fastGlobalSmootherFilter() parameter.
`void`	`setFGSSigma()`	Sets the respective fastGlobalSmootherFilter() parameter.
`void`	`setFGSSigma(float sigma)`	Sets the respective fastGlobalSmootherFilter() parameter.
`void`	`setK()`	K is a number of nearest-neighbor matches considered, when fitting a locally affine model for a superpixel segment.
`void`	`setK(int k)`	K is a number of nearest-neighbor matches considered, when fitting a locally affine model for a superpixel segment.
`void`	`setMaxFlow()`	MaxFlow is a threshold to validate the predictions using a certain piece-wise affine model.
`void`	`setMaxFlow(float maxFlow)`	MaxFlow is a threshold to validate the predictions using a certain piece-wise affine model.
`void`	`setModelIter()`	Parameter defining the number of iterations for piece-wise affine model estimation.
`void`	`setModelIter(int modelIter)`	Parameter defining the number of iterations for piece-wise affine model estimation.
`void`	`setRefineModels()`	Parameter to choose wether additional refinement of the piece-wise affine models is employed.
`void`	`setRefineModels(boolean refineModles)`	Parameter to choose wether additional refinement of the piece-wise affine models is employed.
`void`	`setSuperpixelMode()`	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).
`void`	`setSuperpixelMode(int 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).
`void`	`setSuperpixelNNCnt()`	Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine model.
`void`	`setSuperpixelNNCnt(int spNN)`	Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine model.
`void`	`setSuperpixelRuler()`	Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation.
`void`	`setSuperpixelRuler(float ruler)`	Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation.
`void`	`setSuperpixelSize()`	Get the internal cost, i.e.
`void`	`setSuperpixelSize(int spSize)`	Get the internal cost, i.e.
`void`	`setUseGlobalSmootherFilter()`	Sets whether the fastGlobalSmootherFilter() post-processing is employed.
`void`	`setUseGlobalSmootherFilter(boolean use_FGS)`	Sets whether the fastGlobalSmootherFilter() post-processing is employed.
`void`	`setUseVariationalRefinement()`	Parameter to choose wether the VariationalRefinement post-processing is employed.
`void`	`setUseVariationalRefinement(boolean use_variational_refinement)`	Parameter to choose wether the VariationalRefinement post-processing is employed.

Methods inherited from class org.opencv.ximgproc.SparseMatchInterpolator
interpolate

Methods inherited from class org.opencv.core.Algorithm
clear, empty, getDefaultName, getNativeObjAddr, save

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RICInterpolator
```
protected RICInterpolator(long addr)
```
- Method Detail
  - __fromPtr__
```
public static RICInterpolator __fromPtr__(long addr)
```
  - getRefineModels
```
public boolean getRefineModels()
```
    setRefineModels SEE: setRefineModels
    
    Returns:
    
    automatically generated
  - getUseGlobalSmootherFilter
```
public boolean getUseGlobalSmootherFilter()
```
    setUseGlobalSmootherFilter SEE: setUseGlobalSmootherFilter
    
    Returns:
    
    automatically generated
  - getUseVariationalRefinement
```
public boolean getUseVariationalRefinement()
```
    setUseVariationalRefinement SEE: setUseVariationalRefinement
    
    Returns:
    
    automatically generated
  - getAlpha
```
public float getAlpha()
```
    setAlpha SEE: setAlpha
    
    Returns:
    
    automatically generated
  - getFGSLambda
```
public float getFGSLambda()
```
    setFGSLambda SEE: setFGSLambda
    
    Returns:
    
    automatically generated
  - getFGSSigma
```
public float getFGSSigma()
```
    setFGSSigma SEE: setFGSSigma
    
    Returns:
    
    automatically generated
  - getMaxFlow
```
public float getMaxFlow()
```
    setMaxFlow SEE: setMaxFlow
    
    Returns:
    
    automatically generated
  - getSuperpixelRuler
```
public float getSuperpixelRuler()
```
    setSuperpixelRuler SEE: setSuperpixelRuler
    
    Returns:
    
    automatically generated
  - getK
```
public int getK()
```
    setK SEE: setK
    
    Returns:
    
    automatically generated
  - getModelIter
```
public int getModelIter()
```
    setModelIter SEE: setModelIter
    
    Returns:
    
    automatically generated
  - getSuperpixelMode
```
public int getSuperpixelMode()
```
    setSuperpixelMode SEE: setSuperpixelMode
    
    Returns:
    
    automatically generated
  - getSuperpixelNNCnt
```
public int getSuperpixelNNCnt()
```
    setSuperpixelNNCnt SEE: setSuperpixelNNCnt
    
    Returns:
    
    automatically generated
  - getSuperpixelSize
```
public int getSuperpixelSize()
```
    setSuperpixelSize SEE: setSuperpixelSize
    
    Returns:
    
    automatically generated
  - setAlpha
```
public void setAlpha(float alpha)
```
    Alpha is a parameter defining a global weight for transforming geodesic distance into weight.
    
    Parameters:
    
    alpha - automatically generated
  - setAlpha
```
public void setAlpha()
```
    Alpha is a parameter defining a global weight for transforming geodesic distance into weight.
  - setCostMap
```
public void setCostMap(Mat 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: cv::ximgproc::createSuperpixelSLIC
  - setFGSLambda
```
public void setFGSLambda(float lambda)
```
    Sets the respective fastGlobalSmootherFilter() parameter.
    
    Parameters:
    
    lambda - automatically generated
  - setFGSLambda
```
public void setFGSLambda()
```
    Sets the respective fastGlobalSmootherFilter() parameter.
  - setFGSSigma
```
public void setFGSSigma(float sigma)
```
    Sets the respective fastGlobalSmootherFilter() parameter.
    
    Parameters:
    
    sigma - automatically generated
  - setFGSSigma
```
public void setFGSSigma()
```
    Sets the respective fastGlobalSmootherFilter() parameter.
  - setK
```
public void setK(int 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 CITE: Hu2017 uses 32.
    
    Parameters:
    
    k - automatically generated
  - setK
```
public void setK()
```
    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 CITE: Hu2017 uses 32.
  - setMaxFlow
```
public void setMaxFlow(float 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.
    
    Parameters:
    
    maxFlow - automatically generated
  - setMaxFlow
```
public void setMaxFlow()
```
    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
```
public void setModelIter(int modelIter)
```
    Parameter defining the number of iterations for piece-wise affine model estimation.
    
    Parameters:
    
    modelIter - automatically generated
  - setModelIter
```
public void setModelIter()
```
    Parameter defining the number of iterations for piece-wise affine model estimation.
  - setRefineModels
```
public void setRefineModels(boolean refineModles)
```
    Parameter to choose wether additional refinement of the piece-wise affine models is employed.
    
    Parameters:
    
    refineModles - automatically generated
  - setRefineModels
```
public void setRefineModels()
```
    Parameter to choose wether additional refinement of the piece-wise affine models is employed.
  - setSuperpixelMode
```
public void setSuperpixelMode(int 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: cv::ximgproc::createSuperpixelSLIC
    
    Parameters:
    
    mode - automatically generated
  - setSuperpixelMode
```
public void setSuperpixelMode()
```
    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
  - setSuperpixelNNCnt
```
public void setSuperpixelNNCnt(int spNN)
```
    Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine model.
    
    Parameters:
    
    spNN - automatically generated
  - setSuperpixelNNCnt
```
public void setSuperpixelNNCnt()
```
    Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine model.
  - setSuperpixelRuler
```
public void setSuperpixelRuler(float ruler)
```
    Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation. SEE: cv::ximgproc::createSuperpixelSLIC
    
    Parameters:
    
    ruler - automatically generated
  - setSuperpixelRuler
```
public void setSuperpixelRuler()
```
    Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation. SEE: cv::ximgproc::createSuperpixelSLIC
  - setSuperpixelSize
```
public void setSuperpixelSize(int spSize)
```
    Get the internal cost, i.e. edge map, used for estimating the edge-aware term. SEE: setCostMap
    
    Parameters:
    
    spSize - automatically generated
  - setSuperpixelSize
```
public void setSuperpixelSize()
```
    Get the internal cost, i.e. edge map, used for estimating the edge-aware term. SEE: setCostMap
  - setUseGlobalSmootherFilter
```
public void setUseGlobalSmootherFilter(boolean use_FGS)
```
    Sets whether the fastGlobalSmootherFilter() post-processing is employed.
    
    Parameters:
    
    use_FGS - automatically generated
  - setUseGlobalSmootherFilter
```
public void setUseGlobalSmootherFilter()
```
    Sets whether the fastGlobalSmootherFilter() post-processing is employed.
  - setUseVariationalRefinement
```
public void setUseVariationalRefinement(boolean use_variational_refinement)
```
    Parameter to choose wether the VariationalRefinement post-processing is employed.
    
    Parameters:
    
    use_variational_refinement - automatically generated
  - setUseVariationalRefinement
```
public void setUseVariationalRefinement()
```
    Parameter to choose wether the VariationalRefinement post-processing is employed.
  - finalize
```
protected void finalize()
                 throws java.lang.Throwable
```
    Overrides:
    
    finalize in class SparseMatchInterpolator
    
    Throws:
    
    java.lang.Throwable

Class RICInterpolator

Field Summary

Fields inherited from class org.opencv.core.Algorithm

Constructor Summary

Method Summary

Methods inherited from class org.opencv.ximgproc.SparseMatchInterpolator

Methods inherited from class org.opencv.core.Algorithm

Methods inherited from class java.lang.Object

Constructor Detail

RICInterpolator

Method Detail

__fromPtr__

getRefineModels

getUseGlobalSmootherFilter

getUseVariationalRefinement

getAlpha

getFGSLambda

getFGSSigma

getMaxFlow

getSuperpixelRuler

getK

getModelIter

getSuperpixelMode

getSuperpixelNNCnt

getSuperpixelSize

setAlpha

setAlpha

setCostMap

setFGSLambda

setFGSLambda

setFGSSigma

setFGSSigma

setK

setK

setMaxFlow

setMaxFlow

setModelIter

setModelIter

setRefineModels

setRefineModels

setSuperpixelMode

setSuperpixelMode

setSuperpixelNNCnt

setSuperpixelNNCnt

setSuperpixelRuler

setSuperpixelRuler

setSuperpixelSize

setSuperpixelSize

setUseGlobalSmootherFilter

setUseGlobalSmootherFilter

setUseVariationalRefinement

setUseVariationalRefinement

finalize

fromPtr