Soviby/com.soviby.unity.ui.ugui-toolkit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
c1
com.soviby.unity.ui.ugui-to.../Assets/Plugins/org/opencv_contrib/ximgproc/RICInterpolator.cs

882 lines
26 KiB
C#
Raw Permalink Normal View History

添加快速查找
2024-12-09 18:39:04 +00:00
using OpenCVForUnity.CoreModule;
using OpenCVForUnity.UtilsModule;
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
namespace OpenCVForUnity.XimgprocModule
{
// C++: class RICInterpolator
/**
* 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.
*/
public class RICInterpolator : SparseMatchInterpolator
{
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
}
if (IsEnabledDispose)
{
if (nativeObj != IntPtr.Zero)
ximgproc_RICInterpolator_delete(nativeObj);
nativeObj = IntPtr.Zero;
}
}
finally
{
base.Dispose(disposing);
}
}
protected internal RICInterpolator(IntPtr addr) : base(addr) { }
// internal usage only
public static new RICInterpolator __fromPtr__(IntPtr addr) { return new RICInterpolator(addr); }
//
// C++: void cv::ximgproc::RICInterpolator::setK(int k = 32)
//
/**
* 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.
* param k automatically generated
*/
public void setK(int k)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setK_10(nativeObj, 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.
*/
public void setK()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setK_11(nativeObj);
}
//
// C++: int cv::ximgproc::RICInterpolator::getK()
//
/**
* setK
* SEE: setK
* return automatically generated
*/
public int getK()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getK_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::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.
* param costMap a type CV_32FC1 Mat is required.
* SEE: cv::ximgproc::createSuperpixelSLIC
*/
public void setCostMap(Mat costMap)
{
ThrowIfDisposed();
if (costMap != null) costMap.ThrowIfDisposed();
ximgproc_RICInterpolator_setCostMap_10(nativeObj, costMap.nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setSuperpixelSize(int spSize = 15)
//
/**
* Get the internal cost, i.e. edge map, used for estimating the edge-aware term.
* SEE: setCostMap
* param spSize automatically generated
*/
public void setSuperpixelSize(int spSize)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setSuperpixelSize_10(nativeObj, spSize);
}
/**
* Get the internal cost, i.e. edge map, used for estimating the edge-aware term.
* SEE: setCostMap
*/
public void setSuperpixelSize()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setSuperpixelSize_11(nativeObj);
}
//
// C++: int cv::ximgproc::RICInterpolator::getSuperpixelSize()
//
/**
* setSuperpixelSize
* SEE: setSuperpixelSize
* return automatically generated
*/
public int getSuperpixelSize()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getSuperpixelSize_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setSuperpixelNNCnt(int spNN = 150)
//
/**
* Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine
* model.
* param spNN automatically generated
*/
public void setSuperpixelNNCnt(int spNN)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setSuperpixelNNCnt_10(nativeObj, spNN);
}
/**
* Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine
* model.
*/
public void setSuperpixelNNCnt()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setSuperpixelNNCnt_11(nativeObj);
}
//
// C++: int cv::ximgproc::RICInterpolator::getSuperpixelNNCnt()
//
/**
* setSuperpixelNNCnt
* SEE: setSuperpixelNNCnt
* return automatically generated
*/
public int getSuperpixelNNCnt()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getSuperpixelNNCnt_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setSuperpixelRuler(float ruler = 15.f)
//
/**
* Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation.
* SEE: cv::ximgproc::createSuperpixelSLIC
* param ruler automatically generated
*/
public void setSuperpixelRuler(float ruler)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setSuperpixelRuler_10(nativeObj, ruler);
}
/**
* Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation.
* SEE: cv::ximgproc::createSuperpixelSLIC
*/
public void setSuperpixelRuler()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setSuperpixelRuler_11(nativeObj);
}
//
// C++: float cv::ximgproc::RICInterpolator::getSuperpixelRuler()
//
/**
* setSuperpixelRuler
* SEE: setSuperpixelRuler
* return automatically generated
*/
public float getSuperpixelRuler()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getSuperpixelRuler_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setSuperpixelMode(int mode = 100)
//
/**
* 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
* param mode automatically generated
*/
public void setSuperpixelMode(int mode)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setSuperpixelMode_10(nativeObj, 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
*/
public void setSuperpixelMode()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setSuperpixelMode_11(nativeObj);
}
//
// C++: int cv::ximgproc::RICInterpolator::getSuperpixelMode()
//
/**
* setSuperpixelMode
* SEE: setSuperpixelMode
* return automatically generated
*/
public int getSuperpixelMode()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getSuperpixelMode_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setAlpha(float alpha = 0.7f)
//
/**
* Alpha is a parameter defining a global weight for transforming geodesic distance into weight.
* param alpha automatically generated
*/
public void setAlpha(float alpha)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setAlpha_10(nativeObj, alpha);
}
/**
* Alpha is a parameter defining a global weight for transforming geodesic distance into weight.
*/
public void setAlpha()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setAlpha_11(nativeObj);
}
//
// C++: float cv::ximgproc::RICInterpolator::getAlpha()
//
/**
* setAlpha
* SEE: setAlpha
* return automatically generated
*/
public float getAlpha()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getAlpha_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setModelIter(int modelIter = 4)
//
/**
* Parameter defining the number of iterations for piece-wise affine model estimation.
* param modelIter automatically generated
*/
public void setModelIter(int modelIter)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setModelIter_10(nativeObj, modelIter);
}
/**
* Parameter defining the number of iterations for piece-wise affine model estimation.
*/
public void setModelIter()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setModelIter_11(nativeObj);
}
//
// C++: int cv::ximgproc::RICInterpolator::getModelIter()
//
/**
* setModelIter
* SEE: setModelIter
* return automatically generated
*/
public int getModelIter()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getModelIter_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setRefineModels(bool refineModles = true)
//
/**
* Parameter to choose wether additional refinement of the piece-wise affine models is employed.
* param refineModles automatically generated
*/
public void setRefineModels(bool refineModles)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setRefineModels_10(nativeObj, refineModles);
}
/**
* Parameter to choose wether additional refinement of the piece-wise affine models is employed.
*/
public void setRefineModels()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setRefineModels_11(nativeObj);
}
//
// C++: bool cv::ximgproc::RICInterpolator::getRefineModels()
//
/**
* setRefineModels
* SEE: setRefineModels
* return automatically generated
*/
public bool getRefineModels()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getRefineModels_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setMaxFlow(float maxFlow = 250.f)
//
/**
* 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.
* param maxFlow automatically generated
*/
public void setMaxFlow(float maxFlow)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setMaxFlow_10(nativeObj, 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.
*/
public void setMaxFlow()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setMaxFlow_11(nativeObj);
}
//
// C++: float cv::ximgproc::RICInterpolator::getMaxFlow()
//
/**
* setMaxFlow
* SEE: setMaxFlow
* return automatically generated
*/
public float getMaxFlow()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getMaxFlow_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setUseVariationalRefinement(bool use_variational_refinement = false)
//
/**
* Parameter to choose wether the VariationalRefinement post-processing is employed.
* param use_variational_refinement automatically generated
*/
public void setUseVariationalRefinement(bool use_variational_refinement)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setUseVariationalRefinement_10(nativeObj, use_variational_refinement);
}
/**
* Parameter to choose wether the VariationalRefinement post-processing is employed.
*/
public void setUseVariationalRefinement()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setUseVariationalRefinement_11(nativeObj);
}
//
// C++: bool cv::ximgproc::RICInterpolator::getUseVariationalRefinement()
//
/**
* setUseVariationalRefinement
* SEE: setUseVariationalRefinement
* return automatically generated
*/
public bool getUseVariationalRefinement()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getUseVariationalRefinement_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setUseGlobalSmootherFilter(bool use_FGS = true)
//
/**
* Sets whether the fastGlobalSmootherFilter() post-processing is employed.
* param use_FGS automatically generated
*/
public void setUseGlobalSmootherFilter(bool use_FGS)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setUseGlobalSmootherFilter_10(nativeObj, use_FGS);
}
/**
* Sets whether the fastGlobalSmootherFilter() post-processing is employed.
*/
public void setUseGlobalSmootherFilter()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setUseGlobalSmootherFilter_11(nativeObj);
}
//
// C++: bool cv::ximgproc::RICInterpolator::getUseGlobalSmootherFilter()
//
/**
* setUseGlobalSmootherFilter
* SEE: setUseGlobalSmootherFilter
* return automatically generated
*/
public bool getUseGlobalSmootherFilter()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getUseGlobalSmootherFilter_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setFGSLambda(float lambda = 500.f)
//
/**
* Sets the respective fastGlobalSmootherFilter() parameter.
* param lambda automatically generated
*/
public void setFGSLambda(float lambda)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setFGSLambda_10(nativeObj, lambda);
}
/**
* Sets the respective fastGlobalSmootherFilter() parameter.
*/
public void setFGSLambda()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setFGSLambda_11(nativeObj);
}
//
// C++: float cv::ximgproc::RICInterpolator::getFGSLambda()
//
/**
* setFGSLambda
* SEE: setFGSLambda
* return automatically generated
*/
public float getFGSLambda()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getFGSLambda_10(nativeObj);
}
//
// C++: void cv::ximgproc::RICInterpolator::setFGSSigma(float sigma = 1.5f)
//
/**
* Sets the respective fastGlobalSmootherFilter() parameter.
* param sigma automatically generated
*/
public void setFGSSigma(float sigma)
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setFGSSigma_10(nativeObj, sigma);
}
/**
* Sets the respective fastGlobalSmootherFilter() parameter.
*/
public void setFGSSigma()
{
ThrowIfDisposed();
ximgproc_RICInterpolator_setFGSSigma_11(nativeObj);
}
//
// C++: float cv::ximgproc::RICInterpolator::getFGSSigma()
//
/**
* setFGSSigma
* SEE: setFGSSigma
* return automatically generated
*/
public float getFGSSigma()
{
ThrowIfDisposed();
return ximgproc_RICInterpolator_getFGSSigma_10(nativeObj);
}
#if (UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR
const string LIBNAME = "__Internal";
#else
const string LIBNAME = "opencvforunity";
#endif
// C++: void cv::ximgproc::RICInterpolator::setK(int k = 32)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setK_10(IntPtr nativeObj, int k);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setK_11(IntPtr nativeObj);
// C++: int cv::ximgproc::RICInterpolator::getK()
[DllImport(LIBNAME)]
private static extern int ximgproc_RICInterpolator_getK_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setCostMap(Mat costMap)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setCostMap_10(IntPtr nativeObj, IntPtr costMap_nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setSuperpixelSize(int spSize = 15)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setSuperpixelSize_10(IntPtr nativeObj, int spSize);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setSuperpixelSize_11(IntPtr nativeObj);
// C++: int cv::ximgproc::RICInterpolator::getSuperpixelSize()
[DllImport(LIBNAME)]
private static extern int ximgproc_RICInterpolator_getSuperpixelSize_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setSuperpixelNNCnt(int spNN = 150)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setSuperpixelNNCnt_10(IntPtr nativeObj, int spNN);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setSuperpixelNNCnt_11(IntPtr nativeObj);
// C++: int cv::ximgproc::RICInterpolator::getSuperpixelNNCnt()
[DllImport(LIBNAME)]
private static extern int ximgproc_RICInterpolator_getSuperpixelNNCnt_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setSuperpixelRuler(float ruler = 15.f)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setSuperpixelRuler_10(IntPtr nativeObj, float ruler);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setSuperpixelRuler_11(IntPtr nativeObj);
// C++: float cv::ximgproc::RICInterpolator::getSuperpixelRuler()
[DllImport(LIBNAME)]
private static extern float ximgproc_RICInterpolator_getSuperpixelRuler_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setSuperpixelMode(int mode = 100)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setSuperpixelMode_10(IntPtr nativeObj, int mode);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setSuperpixelMode_11(IntPtr nativeObj);
// C++: int cv::ximgproc::RICInterpolator::getSuperpixelMode()
[DllImport(LIBNAME)]
private static extern int ximgproc_RICInterpolator_getSuperpixelMode_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setAlpha(float alpha = 0.7f)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setAlpha_10(IntPtr nativeObj, float alpha);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setAlpha_11(IntPtr nativeObj);
// C++: float cv::ximgproc::RICInterpolator::getAlpha()
[DllImport(LIBNAME)]
private static extern float ximgproc_RICInterpolator_getAlpha_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setModelIter(int modelIter = 4)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setModelIter_10(IntPtr nativeObj, int modelIter);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setModelIter_11(IntPtr nativeObj);
// C++: int cv::ximgproc::RICInterpolator::getModelIter()
[DllImport(LIBNAME)]
private static extern int ximgproc_RICInterpolator_getModelIter_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setRefineModels(bool refineModles = true)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setRefineModels_10(IntPtr nativeObj, [MarshalAs(UnmanagedType.U1)] bool refineModles);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setRefineModels_11(IntPtr nativeObj);
// C++: bool cv::ximgproc::RICInterpolator::getRefineModels()
[DllImport(LIBNAME)]
[return: MarshalAs(UnmanagedType.U1)]
private static extern bool ximgproc_RICInterpolator_getRefineModels_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setMaxFlow(float maxFlow = 250.f)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setMaxFlow_10(IntPtr nativeObj, float maxFlow);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setMaxFlow_11(IntPtr nativeObj);
// C++: float cv::ximgproc::RICInterpolator::getMaxFlow()
[DllImport(LIBNAME)]
private static extern float ximgproc_RICInterpolator_getMaxFlow_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setUseVariationalRefinement(bool use_variational_refinement = false)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setUseVariationalRefinement_10(IntPtr nativeObj, [MarshalAs(UnmanagedType.U1)] bool use_variational_refinement);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setUseVariationalRefinement_11(IntPtr nativeObj);
// C++: bool cv::ximgproc::RICInterpolator::getUseVariationalRefinement()
[DllImport(LIBNAME)]
[return: MarshalAs(UnmanagedType.U1)]
private static extern bool ximgproc_RICInterpolator_getUseVariationalRefinement_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setUseGlobalSmootherFilter(bool use_FGS = true)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setUseGlobalSmootherFilter_10(IntPtr nativeObj, [MarshalAs(UnmanagedType.U1)] bool use_FGS);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setUseGlobalSmootherFilter_11(IntPtr nativeObj);
// C++: bool cv::ximgproc::RICInterpolator::getUseGlobalSmootherFilter()
[DllImport(LIBNAME)]
[return: MarshalAs(UnmanagedType.U1)]
private static extern bool ximgproc_RICInterpolator_getUseGlobalSmootherFilter_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setFGSLambda(float lambda = 500.f)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setFGSLambda_10(IntPtr nativeObj, float lambda);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setFGSLambda_11(IntPtr nativeObj);
// C++: float cv::ximgproc::RICInterpolator::getFGSLambda()
[DllImport(LIBNAME)]
private static extern float ximgproc_RICInterpolator_getFGSLambda_10(IntPtr nativeObj);
// C++: void cv::ximgproc::RICInterpolator::setFGSSigma(float sigma = 1.5f)
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setFGSSigma_10(IntPtr nativeObj, float sigma);
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_setFGSSigma_11(IntPtr nativeObj);
// C++: float cv::ximgproc::RICInterpolator::getFGSSigma()
[DllImport(LIBNAME)]
private static extern float ximgproc_RICInterpolator_getFGSSigma_10(IntPtr nativeObj);
// native support for java finalize()
[DllImport(LIBNAME)]
private static extern void ximgproc_RICInterpolator_delete(IntPtr nativeObj);
}
}
Reference in New Issue Copy Permalink