using OpenCVForUnity.CoreModule; using OpenCVForUnity.UtilsModule; using System; using System.Collections.Generic; using System.Runtime.InteropServices; namespace OpenCVForUnity.XimgprocModule { // C++: class EdgeAwareInterpolator /** * Sparse match interpolation algorithm based on modified locally-weighted affine * estimator from CITE: Revaud2015 and Fast Global Smoother as post-processing filter. */ public class EdgeAwareInterpolator : SparseMatchInterpolator { protected override void Dispose(bool disposing) { try { if (disposing) { } if (IsEnabledDispose) { if (nativeObj != IntPtr.Zero) ximgproc_EdgeAwareInterpolator_delete(nativeObj); nativeObj = IntPtr.Zero; } } finally { base.Dispose(disposing); } } protected internal EdgeAwareInterpolator(IntPtr addr) : base(addr) { } // internal usage only public static new EdgeAwareInterpolator __fromPtr__(IntPtr addr) { return new EdgeAwareInterpolator(addr); } // // C++: void cv::ximgproc::EdgeAwareInterpolator::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_EdgeAwareInterpolator_setCostMap_10(nativeObj, _costMap.nativeObj); } // // C++: void cv::ximgproc::EdgeAwareInterpolator::setK(int _k) // /** * K is a number of nearest-neighbor matches considered, when fitting a locally affine * model. Usually it should be around 128. However, lower values would make the interpolation * noticeably faster. * param _k automatically generated */ public void setK(int _k) { ThrowIfDisposed(); ximgproc_EdgeAwareInterpolator_setK_10(nativeObj, _k); } // // C++: int cv::ximgproc::EdgeAwareInterpolator::getK() // /** * SEE: setK * return automatically generated */ public int getK() { ThrowIfDisposed(); return ximgproc_EdgeAwareInterpolator_getK_10(nativeObj); } // // C++: void cv::ximgproc::EdgeAwareInterpolator::setSigma(float _sigma) // /** * Sigma is a parameter defining how fast the weights decrease in the locally-weighted affine * fitting. Higher values can help preserve fine details, lower values can help to get rid of noise in the * output flow. * param _sigma automatically generated */ public void setSigma(float _sigma) { ThrowIfDisposed(); ximgproc_EdgeAwareInterpolator_setSigma_10(nativeObj, _sigma); } // // C++: float cv::ximgproc::EdgeAwareInterpolator::getSigma() // /** * SEE: setSigma * return automatically generated */ public float getSigma() { ThrowIfDisposed(); return ximgproc_EdgeAwareInterpolator_getSigma_10(nativeObj); } // // C++: void cv::ximgproc::EdgeAwareInterpolator::setLambda(float _lambda) // /** * Lambda is a parameter defining the weight of the edge-aware term in geodesic distance, * should be in the range of 0 to 1000. * param _lambda automatically generated */ public void setLambda(float _lambda) { ThrowIfDisposed(); ximgproc_EdgeAwareInterpolator_setLambda_10(nativeObj, _lambda); } // // C++: float cv::ximgproc::EdgeAwareInterpolator::getLambda() // /** * SEE: setLambda * return automatically generated */ public float getLambda() { ThrowIfDisposed(); return ximgproc_EdgeAwareInterpolator_getLambda_10(nativeObj); } // // C++: void cv::ximgproc::EdgeAwareInterpolator::setUsePostProcessing(bool _use_post_proc) // /** * Sets whether the fastGlobalSmootherFilter() post-processing is employed. It is turned on by * default. * param _use_post_proc automatically generated */ public void setUsePostProcessing(bool _use_post_proc) { ThrowIfDisposed(); ximgproc_EdgeAwareInterpolator_setUsePostProcessing_10(nativeObj, _use_post_proc); } // // C++: bool cv::ximgproc::EdgeAwareInterpolator::getUsePostProcessing() // /** * SEE: setUsePostProcessing * return automatically generated */ public bool getUsePostProcessing() { ThrowIfDisposed(); return ximgproc_EdgeAwareInterpolator_getUsePostProcessing_10(nativeObj); } // // C++: void cv::ximgproc::EdgeAwareInterpolator::setFGSLambda(float _lambda) // /** * Sets the respective fastGlobalSmootherFilter() parameter. * param _lambda automatically generated */ public void setFGSLambda(float _lambda) { ThrowIfDisposed(); ximgproc_EdgeAwareInterpolator_setFGSLambda_10(nativeObj, _lambda); } // // C++: float cv::ximgproc::EdgeAwareInterpolator::getFGSLambda() // /** * SEE: setFGSLambda * return automatically generated */ public float getFGSLambda() { ThrowIfDisposed(); return ximgproc_EdgeAwareInterpolator_getFGSLambda_10(nativeObj); } // // C++: void cv::ximgproc::EdgeAwareInterpolator::setFGSSigma(float _sigma) // /** * SEE: setFGSLambda * param _sigma automatically generated */ public void setFGSSigma(float _sigma) { ThrowIfDisposed(); ximgproc_EdgeAwareInterpolator_setFGSSigma_10(nativeObj, _sigma); } // // C++: float cv::ximgproc::EdgeAwareInterpolator::getFGSSigma() // /** * SEE: setFGSLambda * return automatically generated */ public float getFGSSigma() { ThrowIfDisposed(); return ximgproc_EdgeAwareInterpolator_getFGSSigma_10(nativeObj); } #if (UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR const string LIBNAME = "__Internal"; #else const string LIBNAME = "opencvforunity"; #endif // C++: void cv::ximgproc::EdgeAwareInterpolator::setCostMap(Mat _costMap) [DllImport(LIBNAME)] private static extern void ximgproc_EdgeAwareInterpolator_setCostMap_10(IntPtr nativeObj, IntPtr _costMap_nativeObj); // C++: void cv::ximgproc::EdgeAwareInterpolator::setK(int _k) [DllImport(LIBNAME)] private static extern void ximgproc_EdgeAwareInterpolator_setK_10(IntPtr nativeObj, int _k); // C++: int cv::ximgproc::EdgeAwareInterpolator::getK() [DllImport(LIBNAME)] private static extern int ximgproc_EdgeAwareInterpolator_getK_10(IntPtr nativeObj); // C++: void cv::ximgproc::EdgeAwareInterpolator::setSigma(float _sigma) [DllImport(LIBNAME)] private static extern void ximgproc_EdgeAwareInterpolator_setSigma_10(IntPtr nativeObj, float _sigma); // C++: float cv::ximgproc::EdgeAwareInterpolator::getSigma() [DllImport(LIBNAME)] private static extern float ximgproc_EdgeAwareInterpolator_getSigma_10(IntPtr nativeObj); // C++: void cv::ximgproc::EdgeAwareInterpolator::setLambda(float _lambda) [DllImport(LIBNAME)] private static extern void ximgproc_EdgeAwareInterpolator_setLambda_10(IntPtr nativeObj, float _lambda); // C++: float cv::ximgproc::EdgeAwareInterpolator::getLambda() [DllImport(LIBNAME)] private static extern float ximgproc_EdgeAwareInterpolator_getLambda_10(IntPtr nativeObj); // C++: void cv::ximgproc::EdgeAwareInterpolator::setUsePostProcessing(bool _use_post_proc) [DllImport(LIBNAME)] private static extern void ximgproc_EdgeAwareInterpolator_setUsePostProcessing_10(IntPtr nativeObj, [MarshalAs(UnmanagedType.U1)] bool _use_post_proc); // C++: bool cv::ximgproc::EdgeAwareInterpolator::getUsePostProcessing() [DllImport(LIBNAME)] [return: MarshalAs(UnmanagedType.U1)] private static extern bool ximgproc_EdgeAwareInterpolator_getUsePostProcessing_10(IntPtr nativeObj); // C++: void cv::ximgproc::EdgeAwareInterpolator::setFGSLambda(float _lambda) [DllImport(LIBNAME)] private static extern void ximgproc_EdgeAwareInterpolator_setFGSLambda_10(IntPtr nativeObj, float _lambda); // C++: float cv::ximgproc::EdgeAwareInterpolator::getFGSLambda() [DllImport(LIBNAME)] private static extern float ximgproc_EdgeAwareInterpolator_getFGSLambda_10(IntPtr nativeObj); // C++: void cv::ximgproc::EdgeAwareInterpolator::setFGSSigma(float _sigma) [DllImport(LIBNAME)] private static extern void ximgproc_EdgeAwareInterpolator_setFGSSigma_10(IntPtr nativeObj, float _sigma); // C++: float cv::ximgproc::EdgeAwareInterpolator::getFGSSigma() [DllImport(LIBNAME)] private static extern float ximgproc_EdgeAwareInterpolator_getFGSSigma_10(IntPtr nativeObj); // native support for java finalize() [DllImport(LIBNAME)] private static extern void ximgproc_EdgeAwareInterpolator_delete(IntPtr nativeObj); } }