java.lang.Object
- org.opencv.ximgproc.Ximgproc

public class Ximgproc
extends java.lang.Object

字段摘要

字段
修饰符和类型	字段	描述
`static int`	`AM_FILTER`
`static int`	`ARO_0_45`
`static int`	`ARO_315_0`
`static int`	`ARO_315_135`
`static int`	`ARO_315_45`
`static int`	`ARO_45_135`
`static int`	`ARO_45_90`
`static int`	`ARO_90_135`
`static int`	`ARO_CTR_HOR`
`static int`	`ARO_CTR_VER`
`static int`	`BINARIZATION_NIBLACK`
`static int`	`BINARIZATION_NICK`
`static int`	`BINARIZATION_SAUVOLA`
`static int`	`BINARIZATION_WOLF`
`static int`	`DTF_IC`
`static int`	`DTF_NC`
`static int`	`DTF_RF`
`static int`	`FHT_ADD`
`static int`	`FHT_AVE`
`static int`	`FHT_MAX`
`static int`	`FHT_MIN`
`static int`	`GUIDED_FILTER`
`static int`	`HDO_DESKEW`
`static int`	`HDO_RAW`
`static int`	`MSLIC`
`static int`	`SLIC`
`static int`	`SLICO`
`static int`	`THINNING_GUOHALL`
`static int`	`THINNING_ZHANGSUEN`
`static int`	`WMF_COS`
`static int`	`WMF_EXP`
`static int`	`WMF_IV1`
`static int`	`WMF_IV2`
`static int`	`WMF_JAC`
`static int`	`WMF_OFF`

构造函数摘要

构造函数
构造函数描述

Ximgproc()

方法摘要

所有方法静态方法具体方法
修饰符和类型	方法	描述
`static void`	`amFilter(Mat joint, Mat src, Mat dst, double sigma_s, double sigma_r)`	简单的单行自适应流形滤波器调用。
`static void`	`amFilter(Mat joint, Mat src, Mat dst, double sigma_s, double sigma_r, boolean adjust_outliers)`	简单的单行自适应流形滤波器调用。
`static void`	`anisotropicDiffusion(Mat src, Mat dst, float alpha, float K, int niters)`	对图像执行各向异性扩散。
`static void`	`bilateralTextureFilter(Mat src, Mat dst)`	对图像应用双边纹理滤波器。
`static void`	`bilateralTextureFilter(Mat src, Mat dst, int fr)`	对图像应用双边纹理滤波器。
`static void`	`bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter)`	对图像应用双边纹理滤波器。
`static void`	`bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter, double sigmaAlpha)`	对图像应用双边纹理滤波器。
`static void`	`bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter, double sigmaAlpha, double sigmaAvg)`	对图像应用双边纹理滤波器。
`static void`	`colorMatchTemplate(Mat img, Mat templ, Mat result)`	比较彩色模板与重叠的彩色图像区域。
`静态双精度浮点型`	`computeBadPixelPercent(Mat GT, Mat src, Rect ROI)`	用于计算视差图中“坏”像素百分比的函数（错误高于指定阈值的像素）
`静态双精度浮点型`	`computeBadPixelPercent(Mat GT, Mat src, Rect ROI, int thresh)`	用于计算视差图中“坏”像素百分比的函数（错误高于指定阈值的像素）
`静态双精度浮点型`	`computeMSE(Mat GT, Mat src, Rect ROI)`	计算视差图均方误差的函数
`static void`	`contourSampling(Mat src, Mat out, int nbElt)`	轮廓采样。
`static void`	`covarianceEstimation(Mat src, Mat dst, int windowRows, int windowCols)`	使用滑动窗口公式计算图像的估计协方差矩阵。
`static AdaptiveManifoldFilter`	`createAMFilter(double sigma_s, double sigma_r)`	工厂方法，创建 AdaptiveManifoldFilter 实例并执行一些初始化例程。
`static AdaptiveManifoldFilter`	`createAMFilter(double sigma_s, double sigma_r, boolean adjust_outliers)`	工厂方法，创建 AdaptiveManifoldFilter 实例并执行一些初始化例程。
`static ContourFitting`	`createContourFitting()`	创建 ContourFitting 算法对象
`static ContourFitting`	`createContourFitting(int ctr)`	创建 ContourFitting 算法对象
`static ContourFitting`	`createContourFitting(int ctr, int fd)`	创建 ContourFitting 算法对象
`static DisparityWLSFilter`	`createDisparityWLSFilter(StereoMatcher matcher_left)`	便捷工厂方法，创建 DisparityWLSFilter 实例并根据匹配器实例自动设置所有相关过滤器参数。
`static DisparityWLSFilter`	`createDisparityWLSFilterGeneric(boolean use_confidence)`	更通用的工厂方法，创建 DisparityWLSFilter 实例并执行基本初始化例程。
`static DTFilter`	`createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor)`	工厂方法，创建 DTFilter 实例并执行初始化例程。
`static DTFilter`	`createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor, int mode)`	工厂方法，创建 DTFilter 实例并执行初始化例程。
`static DTFilter`	`createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)`	工厂方法，创建 DTFilter 实例并执行初始化例程。
`static EdgeAwareInterpolator`	`创建边缘感知插值器()`	创建 EdgeAwareInterpolator 实例的工厂方法。
`static EdgeBoxes`	`createEdgeBoxes()`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta, float eta)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta, float eta, float minScore)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag, float maxAspectRatio)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag, float maxAspectRatio, float minBoxArea)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag, float maxAspectRatio, float minBoxArea, float gamma)`	创建 Edgeboxes
`static EdgeBoxes`	`createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag, float maxAspectRatio, float minBoxArea, float gamma, float kappa)`	创建 Edgeboxes
`static EdgeDrawing`	`创建边缘绘制()`	创建 EdgeDrawing 对象的智能指针并进行初始化
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma)`	工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化例程。
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda)`	工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化例程。
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter)`	工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化例程。
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)`	工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化例程。
`static FastGlobalSmootherFilter`	`createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color)`	工厂方法，创建 FastGlobalSmootherFilter 实例并执行初始化例程。
`static FastGlobalSmootherFilter`	`createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color, double lambda_attenuation)`	工厂方法，创建 FastGlobalSmootherFilter 实例并执行初始化例程。
`static FastGlobalSmootherFilter`	`createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color, double lambda_attenuation, int num_iter)`	工厂方法，创建 FastGlobalSmootherFilter 实例并执行初始化例程。
`static FastLineDetector`	`createFastLineDetector()`	创建 FastLineDetector 对象的智能指针并进行初始化。超过此距离的线段将被视为离群值。如果为零，则不应用 Canny()，并将输入图像视为边缘图像。
`static FastLineDetector`	`createFastLineDetector(int length_threshold)`	创建 FastLineDetector 对象的智能指针并进行初始化
`static FastLineDetector`	`createFastLineDetector(int length_threshold, float distance_threshold)`	创建 FastLineDetector 对象的智能指针并进行初始化
`static FastLineDetector`	`createFastLineDetector(int length_threshold, float distance_threshold, double canny_th1)`	创建 FastLineDetector 对象的智能指针并进行初始化
`static FastLineDetector`	`createFastLineDetector(int length_threshold, float distance_threshold, double canny_th1, double canny_th2)`	创建 FastLineDetector 对象的智能指针并进行初始化
`static FastLineDetector`	`createFastLineDetector(int length_threshold, float distance_threshold, double canny_th1, double canny_th2, int canny_aperture_size)`	创建 FastLineDetector 对象的智能指针并进行初始化
`static FastLineDetector`	`createFastLineDetector(int length_threshold, float distance_threshold, double canny_th1, double canny_th2, int canny_aperture_size, boolean do_merge)`	创建 FastLineDetector 对象的智能指针并进行初始化
`static GraphSegmentation`	`createGraphSegmentation()`	创建基于图的分割器
`static GraphSegmentation`	`createGraphSegmentation(double sigma)`	创建基于图的分割器
`static GraphSegmentation`	`createGraphSegmentation(double sigma, float k)`	创建基于图的分割器
`static GraphSegmentation`	`createGraphSegmentation(double sigma, float k, int min_size)`	创建基于图的分割器
`static GuidedFilter`	`createGuidedFilter(Mat guide, int radius, double eps)`	工厂方法，创建 GuidedFilter 实例并执行初始化例程。
`static GuidedFilter`	`createGuidedFilter(Mat guide, int radius, double eps, double scale)`	工厂方法，创建 GuidedFilter 实例并执行初始化例程。
`static void`	`createQuaternionImage(Mat img, Mat qimg)`	创建四元数图像。
`static RFFeatureGetter`	`创建RFFeatureGetter()`
`static RICInterpolator`	`创建RIC插值器()`	创建 RICInterpolator 实例的工厂方法。
`static StereoMatcher`	`createRightMatcher(StereoMatcher matcher_left)`	便捷方法，用于设置匹配器以计算右视图视差图，这在带置信度滤波的情况下是必需的。
`static ScanSegment`	`createScanSegment(int image_width, int image_height, int num_superpixels)`	初始化 ScanSegment 对象。
`static ScanSegment`	`createScanSegment(int image_width, int image_height, int num_superpixels, int slices)`	初始化 ScanSegment 对象。
`static ScanSegment`	`createScanSegment(int image_width, int image_height, int num_superpixels, int slices, boolean merge_small)`	初始化 ScanSegment 对象。
`static SelectiveSearchSegmentation`	`createSelectiveSearchSegmentation()`	创建新的 SelectiveSearchSegmentation 类。
`static SelectiveSearchSegmentationStrategyColor`	`createSelectiveSearchSegmentationStrategyColor()`	创建新的基于颜色的策略
`static SelectiveSearchSegmentationStrategyFill`	`createSelectiveSearchSegmentationStrategyFill()`	创建新的基于填充的策略
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple()`	创建新的多重策略
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1)`	创建新的多重策略并设置一个子策略
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2)`	创建一个新的多策略并设置两个子策略，权重相等
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2, SelectiveSearchSegmentationStrategy s3)`	创建一个新的多策略并设置三个子策略，权重相等
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2, SelectiveSearchSegmentationStrategy s3, SelectiveSearchSegmentationStrategy s4)`	创建一个新的多策略并设置四个子策略，权重相等
`static SelectiveSearchSegmentationStrategySize`	`createSelectiveSearchSegmentationStrategySize()`	创建新的基于大小的策略
`static SelectiveSearchSegmentationStrategyTexture`	`createSelectiveSearchSegmentationStrategyTexture()`	创建新的基于大小的策略
`static StructuredEdgeDetection`	`createStructuredEdgeDetection(java.lang.String model)`
`static StructuredEdgeDetection`	`createStructuredEdgeDetection(java.lang.String model, RFFeatureGetter howToGetFeatures)`
`static SuperpixelLSC`	`createSuperpixelLSC(Mat image)`	实现 LSC (线性光谱聚类) 超像素的类
`static SuperpixelLSC`	`createSuperpixelLSC(Mat image, int region_size)`	实现 LSC (线性光谱聚类) 超像素的类
`static SuperpixelLSC`	`createSuperpixelLSC(Mat image, int region_size, float ratio)`	实现 LSC (线性光谱聚类) 超像素的类
`static SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels)`	初始化 SuperpixelSEEDS 对象。
`static SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior)`	初始化 SuperpixelSEEDS 对象。
`static SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior, int histogram_bins)`	初始化 SuperpixelSEEDS 对象。
`static SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior, int histogram_bins, boolean double_step)`	初始化 SuperpixelSEEDS 对象。
`static SuperpixelSLIC`	`createSuperpixelSLIC(Mat image)`	初始化 SuperpixelSLIC 对象
`static SuperpixelSLIC`	`createSuperpixelSLIC(Mat image, int algorithm)`	初始化 SuperpixelSLIC 对象
`static SuperpixelSLIC`	`createSuperpixelSLIC(Mat image, int algorithm, int region_size)`	初始化 SuperpixelSLIC 对象
`static SuperpixelSLIC`	`createSuperpixelSLIC(Mat image, int algorithm, int region_size, float ruler)`	初始化 SuperpixelSLIC 对象
`static void`	`dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor)`	简单的单行域变换滤波器调用。
`static void`	`dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor, int mode)`	简单的单行域变换滤波器调用。
`static void`	`dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor, int mode, int numIters)`	简单的单行域变换滤波器调用。
`static void`	`edgePreservingFilter(Mat src, Mat dst, int d, double threshold)`	使用边缘保留滤波器平滑图像。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst)`	简单的一行快速双边求解器过滤器调用。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial)`	简单的一行快速双边求解器过滤器调用。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma)`	简单的一行快速双边求解器过滤器调用。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma)`	简单的一行快速双边求解器过滤器调用。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda)`	简单的一行快速双边求解器过滤器调用。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter)`	简单的一行快速双边求解器过滤器调用。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)`	简单的一行快速双边求解器过滤器调用。
`static void`	`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color)`	简单的一行快速全局平滑器过滤器调用。
`static void`	`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation)`	简单的一行快速全局平滑器过滤器调用。
`static void`	`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation, int num_iter)`	简单的一行快速全局平滑器过滤器调用。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth)`	计算图像的 2D 快速霍夫变换。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange)`	计算图像的 2D 快速霍夫变换。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op)`	计算图像的 2D 快速霍夫变换。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op, int makeSkew)`	计算图像的 2D 快速霍夫变换。
`static void`	`findEllipses(Mat image, Mat ellipses)`	使用投影不变剪枝在图像中快速查找椭圆。
`static void`	`findEllipses(Mat image, Mat ellipses, float scoreThreshold)`	使用投影不变剪枝在图像中快速查找椭圆。
`static void`	`findEllipses(Mat image, Mat ellipses, float scoreThreshold, float reliabilityThreshold)`	使用投影不变剪枝在图像中快速查找椭圆。
`static void`	`findEllipses(Mat image, Mat ellipses, float scoreThreshold, float reliabilityThreshold, float centerDistanceThreshold)`	使用投影不变剪枝在图像中快速查找椭圆。
`static void`	`fourierDescriptor(Mat src, Mat dst)`	平面闭合曲线的傅里叶描述符。有关此实现的更多详细信息，请参见 CITE: PersoonFu1977
`static void`	`fourierDescriptor(Mat src, Mat dst, int nbElt)`	平面闭合曲线的傅里叶描述符。有关此实现的更多详细信息，请参见 CITE: PersoonFu1977
`static void`	`fourierDescriptor(Mat src, Mat dst, int nbElt, int nbFD)`	平面闭合曲线的傅里叶描述符。有关此实现的更多详细信息，请参见 CITE: PersoonFu1977
`static void`	`getDisparityVis(Mat src, Mat dst)`	用于创建视差图可视化（钳制 CV_8U 图像）的函数
`static void`	`getDisparityVis(Mat src, Mat dst, double scale)`	用于创建视差图可视化（钳制 CV_8U 图像）的函数
`static void`	`GradientDericheX(Mat op, Mat dst, double alpha, double omega)`	将 X Deriche 滤波器应用于图像。
`static void`	`GradientDericheY(Mat op, Mat dst, double alpha, double omega)`	将 Y Deriche 滤波器应用于图像。
`static void`	`guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps)`	简单的单行(快速)引导滤波器调用。
`static void`	`guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps, int dDepth)`	简单的单行(快速)引导滤波器调用。
`static void`	`guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps, int dDepth, double scale)`	简单的单行(快速)引导滤波器调用。
`static void`	`jointBilateralFilter(Mat joint, Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace)`	将联合双边滤波器应用于图像。
`static void`	`jointBilateralFilter(Mat joint, Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int borderType)`	将联合双边滤波器应用于图像。
`static void`	`l0Smooth(Mat src, Mat dst)`	通过 L0 梯度最小化进行全局图像平滑。
`static void`	`l0Smooth(Mat src, Mat dst, double lambda)`	通过 L0 梯度最小化进行全局图像平滑。
`static void`	`l0Smooth(Mat src, Mat dst, double lambda, double kappa)`	通过 L0 梯度最小化进行全局图像平滑。
`static void`	`niBlackThreshold(Mat _src, Mat _dst, double maxValue, int type, int blockSize, double k)`	使用 Niblack 技术或受其启发的一些流行变体对输入图像执行阈值处理。
`static void`	`niBlackThreshold(Mat _src, Mat _dst, double maxValue, int type, int blockSize, double k, int binarizationMethod)`	使用 Niblack 技术或受其启发的一些流行变体对输入图像执行阈值处理。
`static void`	`niBlackThreshold(Mat _src, Mat _dst, double maxValue, int type, int blockSize, double k, int binarizationMethod, double r)`	使用 Niblack 技术或受其启发的一些流行变体对输入图像执行阈值处理。
`static void`	`PeiLinNormalization(Mat I, Mat T)`
`static void`	`qconj(Mat qimg, Mat qcimg)`	计算四元数图像的共轭。
`static void`	`qdft(Mat img, Mat qimg, int flags, boolean sideLeft)`	对二维四元数数组执行正向或逆向离散四元数傅里叶变换。
`static void`	`qmultiply(Mat src1, Mat src2, Mat dst)`	计算两个数组的逐元素四元数积
`static void`	`qunitary(Mat qimg, Mat qnimg)`	将每个元素除以其模数。
`static void`	`RadonTransform(Mat src, Mat dst)`	计算图像的 Radon 变换。
`static void`	`RadonTransform(Mat src, Mat dst, double theta)`	计算图像的 Radon 变换。
`static void`	`RadonTransform(Mat src, Mat dst, double theta, double start_angle)`	计算图像的 Radon 变换。
`static void`	`RadonTransform(Mat src, Mat dst, double theta, double start_angle, double end_angle)`	计算图像的 Radon 变换。
`static void`	`RadonTransform(Mat src, Mat dst, double theta, double start_angle, double end_angle, boolean crop)`	计算图像的 Radon 变换。
`static void`	`RadonTransform(Mat src, Mat dst, double theta, double start_angle, double end_angle, boolean crop, boolean norm)`	计算图像的 Radon 变换。
`static int`	`readGT(java.lang.String src_path, Mat dst)`	用于读取真实视差图的函数。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst)`	将滚动引导滤波器应用于图像。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d)`	将滚动引导滤波器应用于图像。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor)`	将滚动引导滤波器应用于图像。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace)`	将滚动引导滤波器应用于图像。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter)`	将滚动引导滤波器应用于图像。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter, int borderType)`	将滚动引导滤波器应用于图像。
`static void`	`thinning(Mat src, Mat dst)`	应用二值斑点细化操作，以实现输入图像的骨架化。
`static void`	`thinning(Mat src, Mat dst, int thinningType)`	应用二值斑点细化操作，以实现输入图像的骨架化。
`static void`	`transformFD(Mat src, Mat t, Mat dst)`	变换轮廓
`static void`	`transformFD(Mat src, Mat t, Mat dst, boolean fdContour)`	变换轮廓
`static void`	`weightedMedianFilter(Mat joint, Mat src, Mat dst, int r)`	将加权中值滤波器应用于图像。
`static void`	`weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma)`	将加权中值滤波器应用于图像。
`static void`	`weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma, int weightType)`	将加权中值滤波器应用于图像。
`static void`	`weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma, int weightType, Mat mask)`	将加权中值滤波器应用于图像。

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细信息
  - ARO_0_45
```
public static final int ARO_0_45
```
    参见
    
    常量字段值
  - ARO_45_90
```
public static final int ARO_45_90
```
    参见
    
    常量字段值
  - ARO_90_135
```
public static final int ARO_90_135
```
    参见
    
    常量字段值
  - ARO_315_0
```
public static final int ARO_315_0
```
    参见
    
    常量字段值
  - ARO_315_45
```
public static final int ARO_315_45
```
    参见
    
    常量字段值
  - ARO_45_135
```
public static final int ARO_45_135
```
    参见
    
    常量字段值
  - ARO_315_135
```
public static final int ARO_315_135
```
    参见
    
    常量字段值
  - ARO_CTR_HOR
```
public static final int ARO_CTR_HOR
```
    参见
    
    常量字段值
  - ARO_CTR_VER
```
public static final int ARO_CTR_VER
```
    参见
    
    常量字段值
  - DTF_NC
```
public static final int DTF_NC
```
    参见
    
    常量字段值
  - DTF_IC
```
public static final int DTF_IC
```
    参见
    
    常量字段值
  - DTF_RF
```
public static final int DTF_RF
```
    参见
    
    常量字段值
  - GUIDED_FILTER
```
public static final int GUIDED_FILTER
```
    参见
    
    常量字段值
  - AM_FILTER
```
public static final int AM_FILTER
```
    参见
    
    常量字段值
  - HDO_RAW
```
public static final int HDO_RAW
```
    参见
    
    常量字段值
  - HDO_DESKEW
```
public static final int HDO_DESKEW
```
    参见
    
    常量字段值
  - FHT_MIN
```
public static final int FHT_MIN
```
    参见
    
    常量字段值
  - FHT_MAX
```
public static final int FHT_MAX
```
    参见
    
    常量字段值
  - FHT_ADD
```
public static final int FHT_ADD
```
    参见
    
    常量字段值
  - FHT_AVE
```
public static final int FHT_AVE
```
    参见
    
    常量字段值
  - BINARIZATION_NIBLACK
```
public static final int BINARIZATION_NIBLACK
```
    参见
    
    常量字段值
  - BINARIZATION_SAUVOLA
```
public static final int BINARIZATION_SAUVOLA
```
    参见
    
    常量字段值
  - BINARIZATION_WOLF
```
public static final int BINARIZATION_WOLF
```
    参见
    
    常量字段值
  - BINARIZATION_NICK
```
public static final int BINARIZATION_NICK
```
    参见
    
    常量字段值
  - SLIC
```
public static final int SLIC
```
    参见
    
    常量字段值
  - SLICO
```
public static final int SLICO
```
    参见
    
    常量字段值
  - MSLIC
```
public static final int MSLIC
```
    参见
    
    常量字段值
  - THINNING_ZHANGSUEN
```
public static final int THINNING_ZHANGSUEN
```
    参见
    
    常量字段值
  - THINNING_GUOHALL
```
public static final int THINNING_GUOHALL
```
    参见
    
    常量字段值
  - WMF_EXP
```
public static final int WMF_EXP
```
    参见
    
    常量字段值
  - WMF_IV1
```
public static final int WMF_IV1
```
    参见
    
    常量字段值
  - WMF_IV2
```
public static final int WMF_IV2
```
    参见
    
    常量字段值
  - WMF_COS
```
public static final int WMF_COS
```
    参见
    
    常量字段值
  - WMF_JAC
```
public static final int WMF_JAC
```
    参见
    
    常量字段值
  - WMF_OFF
```
public static final int WMF_OFF
```
    参见
    
    常量字段值
- 构造函数详细信息
  - Ximgproc
```
public Ximgproc()
```
- 方法详细信息
  - niBlackThreshold
```
public static void niBlackThreshold(Mat _src,
                                    Mat _dst,
                                    double maxValue,
                                    int type,
                                    int blockSize,
                                    double k,
                                    int binarizationMethod,
                                    double r)
```
    使用 Niblack 技术或受其启发的一些流行变体对输入图像执行阈值处理。该函数根据以下公式将灰度图像转换为二值图像：
    
    THRESH_BINARY $dst(x,y) = \fork{\texttt{maxValue}}{if \(src(x,y) > T(x,y)$}{0}{otherwise}\)
    
    THRESH_BINARY_INV $dst(x,y) = \fork{0}{if \(src(x,y) > T(x,y)$}{\texttt{maxValue}}{otherwise}\) 其中 $T(x,y)$ 是为每个像素单独计算的阈值。
    
    阈值 $T(x, y)$ 根据所选的二值化方法确定。对于经典的 Niblack 方法，它是 $(x, y)$ 处 $\texttt{blockSize} \times\texttt{blockSize}$ 邻域的均值减去 $ k $ 乘以标准差。该函数无法就地处理图像。
    参数
    
    _src - 源 8 位单通道图像。
    
    _dst - 与源图像大小和类型相同的目标图像。
    
    maxValue - 满足条件的像素分配的非零值，用于 THRESH_BINARY 和 THRESH_BINARY_INV 阈值类型。
    
    type - 阈值类型，参见 cv::ThresholdTypes。
    
    blockSize - 用于计算像素阈值的像素邻域大小：3、5、7 等。
    
    k - Niblack 和受其启发的技术使用的用户可调参数。对于 Niblack，这通常是一个介于 0 和 1 之间的值，它与标准差相乘并从均值中减去。
    
    binarizationMethod - 要使用的二值化方法。默认情况下使用 Niblack 技术。可以指定其他技术，参见 cv::ximgproc::LocalBinarizationMethods。
    
    r - Sauvola 技术使用的用户可调参数。这是标准差的动态范围。SEE: threshold, adaptiveThreshold
  - niBlackThreshold
```
public static void niBlackThreshold(Mat _src,
                                    Mat _dst,
                                    double maxValue,
                                    int type,
                                    int blockSize,
                                    double k,
                                    int binarizationMethod)
```
    使用 Niblack 技术或受其启发的一些流行变体对输入图像执行阈值处理。该函数根据以下公式将灰度图像转换为二值图像：
    
    THRESH_BINARY $dst(x,y) = \fork{\texttt{maxValue}}{if \(src(x,y) > T(x,y)$}{0}{otherwise}\)
    
    THRESH_BINARY_INV $dst(x,y) = \fork{0}{if \(src(x,y) > T(x,y)$}{\texttt{maxValue}}{otherwise}\) 其中 $T(x,y)$ 是为每个像素单独计算的阈值。
    
    阈值 $T(x, y)$ 根据所选的二值化方法确定。对于经典的 Niblack 方法，它是 $(x, y)$ 处 $\texttt{blockSize} \times\texttt{blockSize}$ 邻域的均值减去 $ k $ 乘以标准差。该函数无法就地处理图像。
    参数
    
    _src - 源 8 位单通道图像。
    
    _dst - 与源图像大小和类型相同的目标图像。
    
    maxValue - 满足条件的像素分配的非零值，用于 THRESH_BINARY 和 THRESH_BINARY_INV 阈值类型。
    
    type - 阈值类型，参见 cv::ThresholdTypes。
    
    blockSize - 用于计算像素阈值的像素邻域大小：3、5、7 等。
    
    k - Niblack 和受其启发的技术使用的用户可调参数。对于 Niblack，这通常是一个介于 0 和 1 之间的值，它与标准差相乘并从均值中减去。
    
    binarizationMethod - 要使用的二值化方法。默认情况下使用 Niblack 技术。可以指定其他技术，参见 cv::ximgproc::LocalBinarizationMethods。标准差。SEE: threshold, adaptiveThreshold
  - niBlackThreshold
```
public static void niBlackThreshold(Mat _src,
                                    Mat _dst,
                                    double maxValue,
                                    int type,
                                    int blockSize,
                                    double k)
```
    使用 Niblack 技术或受其启发的一些流行变体对输入图像执行阈值处理。该函数根据以下公式将灰度图像转换为二值图像：
    
    THRESH_BINARY $dst(x,y) = \fork{\texttt{maxValue}}{if \(src(x,y) > T(x,y)$}{0}{otherwise}\)
    
    THRESH_BINARY_INV $dst(x,y) = \fork{0}{if \(src(x,y) > T(x,y)$}{\texttt{maxValue}}{otherwise}\) 其中 $T(x,y)$ 是为每个像素单独计算的阈值。
    
    阈值 $T(x, y)$ 根据所选的二值化方法确定。对于经典的 Niblack 方法，它是 $(x, y)$ 处 $\texttt{blockSize} \times\texttt{blockSize}$ 邻域的均值减去 $ k $ 乘以标准差。该函数无法就地处理图像。
    参数
    
    _src - 源 8 位单通道图像。
    
    _dst - 与源图像大小和类型相同的目标图像。
    
    maxValue - 满足条件的像素分配的非零值，用于 THRESH_BINARY 和 THRESH_BINARY_INV 阈值类型。
    
    type - 阈值类型，参见 cv::ThresholdTypes。
    
    blockSize - 用于计算像素阈值的像素邻域大小：3、5、7 等。
    
    k - Niblack 和受其启发的技术使用的用户可调参数。对于 Niblack，这通常是一个介于 0 和 1 之间的值，它与标准差相乘并从均值中减去。可以指定其他技术，参见 cv::ximgproc::LocalBinarizationMethods。标准差。SEE: threshold, adaptiveThreshold
  - thinning
```
public static void thinning(Mat src,
                            Mat dst,
                            int thinningType)
```
    应用二值斑点细化操作，以实现输入图像的骨架化。该函数使用张-森 (Zhang-Suen) 技术将二值斑点图像转换为骨架化形式。
    
    参数
    
    src - 源 8 位单通道图像，包含二值斑点，斑点像素值为 255。
    
    dst - 与源图像大小和类型相同的目标图像。该函数可以就地工作。
    
    thinningType - 定义应使用哪种细化算法的值。参见 cv::ximgproc::ThinningTypes
  - thinning
```
public static void thinning(Mat src,
                            Mat dst)
```
    应用二值斑点细化操作，以实现输入图像的骨架化。该函数使用张-森 (Zhang-Suen) 技术将二值斑点图像转换为骨架化形式。
    
    参数
    
    src - 源 8 位单通道图像，包含二值斑点，斑点像素值为 255。
    
    dst - 与源图像大小和类型相同的目标图像。该函数可以就地工作。
  - anisotropicDiffusion
```
public static void anisotropicDiffusion(Mat src,
                                        Mat dst,
                                        float alpha,
                                        float K,
                                        int niters)
```
    对图像执行各向异性扩散。该函数将 Perona-Malik 各向异性扩散应用于图像。这是偏微分方程的解：${\frac {\partial I}{\partial t}}={\mathrm {div}}\left(c(x,y,t)\nabla I\right)=\nabla c\cdot \nabla I+c(x,y,t)\Delta I$ 建议的 c(x,y,t) 函数为：$c\left(\|\nabla I\|\right)=e^{{-\left(\|\nabla I\|/K\right)^{2}}}$ 或 $ c\left(\|\nabla I\|\right)={\frac {1}{1+\left({\frac {\|\nabla I\|}{K}}\right)^{2}}} $
    
    参数
    
    src - 3 通道源图像。
    
    dst - 与源图像大小和通道数相同的目标图像。
    
    alpha - 每次迭代向前步进的时间量（通常介于 0 和 1 之间）。
    
    K - 对边缘的敏感度
    
    niters - 迭代次数
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta,
                                        float eta,
                                        float minScore,
                                        int maxBoxes,
                                        float edgeMinMag,
                                        float edgeMergeThr,
                                        float clusterMinMag,
                                        float maxAspectRatio,
                                        float minBoxArea,
                                        float gamma,
                                        float kappa)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    eta - NMS 阈值的适应率。
    
    minScore - 要检测的框的最小得分。
    
    maxBoxes - 要检测的框的最大数量。
    
    edgeMinMag - 边缘最小幅度。增加此值可权衡精度和速度。
    
    edgeMergeThr - 边缘合并阈值。增加此值可权衡精度和速度。
    
    clusterMinMag - 聚类最小幅度。增加此值可权衡精度和速度。
    
    maxAspectRatio - 框的最大宽高比。
    
    minBoxArea - 框的最小面积。
    
    gamma - 亲和度敏感度。
    
    kappa - 尺度敏感度。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta,
                                        float eta,
                                        float minScore,
                                        int maxBoxes,
                                        float edgeMinMag,
                                        float edgeMergeThr,
                                        float clusterMinMag,
                                        float maxAspectRatio,
                                        float minBoxArea,
                                        float gamma)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    eta - NMS 阈值的适应率。
    
    minScore - 要检测的框的最小得分。
    
    maxBoxes - 要检测的框的最大数量。
    
    edgeMinMag - 边缘最小幅度。增加此值可权衡精度和速度。
    
    edgeMergeThr - 边缘合并阈值。增加此值可权衡精度和速度。
    
    clusterMinMag - 聚类最小幅度。增加此值可权衡精度和速度。
    
    maxAspectRatio - 框的最大宽高比。
    
    minBoxArea - 框的最小面积。
    
    gamma - 亲和度敏感度。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta,
                                        float eta,
                                        float minScore,
                                        int maxBoxes,
                                        float edgeMinMag,
                                        float edgeMergeThr,
                                        float clusterMinMag,
                                        float maxAspectRatio,
                                        float minBoxArea)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    eta - NMS 阈值的适应率。
    
    minScore - 要检测的框的最小得分。
    
    maxBoxes - 要检测的框的最大数量。
    
    edgeMinMag - 边缘最小幅度。增加此值可权衡精度和速度。
    
    edgeMergeThr - 边缘合并阈值。增加此值可权衡精度和速度。
    
    clusterMinMag - 聚类最小幅度。增加此值可权衡精度和速度。
    
    maxAspectRatio - 框的最大宽高比。
    
    minBoxArea - 框的最小面积。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta,
                                        float eta,
                                        float minScore,
                                        int maxBoxes,
                                        float edgeMinMag,
                                        float edgeMergeThr,
                                        float clusterMinMag,
                                        float maxAspectRatio)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    eta - NMS 阈值的适应率。
    
    minScore - 要检测的框的最小得分。
    
    maxBoxes - 要检测的框的最大数量。
    
    edgeMinMag - 边缘最小幅度。增加此值可权衡精度和速度。
    
    edgeMergeThr - 边缘合并阈值。增加此值可权衡精度和速度。
    
    clusterMinMag - 聚类最小幅度。增加此值可权衡精度和速度。
    
    maxAspectRatio - 框的最大宽高比。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta,
                                        float eta,
                                        float minScore,
                                        int maxBoxes,
                                        float edgeMinMag,
                                        float edgeMergeThr,
                                        float clusterMinMag)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    eta - NMS 阈值的适应率。
    
    minScore - 要检测的框的最小得分。
    
    maxBoxes - 要检测的框的最大数量。
    
    edgeMinMag - 边缘最小幅度。增加此值可权衡精度和速度。
    
    edgeMergeThr - 边缘合并阈值。增加此值可权衡精度和速度。
    
    clusterMinMag - 聚类最小幅度。增加此值可权衡精度和速度。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta,
                                        float eta,
                                        float minScore,
                                        int maxBoxes,
                                        float edgeMinMag,
                                        float edgeMergeThr)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    eta - NMS 阈值的适应率。
    
    minScore - 要检测的框的最小得分。
    
    maxBoxes - 要检测的框的最大数量。
    
    edgeMinMag - 边缘最小幅度。增加此值可权衡精度和速度。
    
    edgeMergeThr - 边缘合并阈值。增加此值可权衡精度和速度。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta,
                                        float eta,
                                        float minScore,
                                        int maxBoxes,
                                        float edgeMinMag)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    eta - NMS 阈值的适应率。
    
    minScore - 要检测的框的最小得分。
    
    maxBoxes - 要检测的框的最大数量。
    
    edgeMinMag - 边缘最小幅度。增加此值可权衡精度和速度。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta,
                                        float eta,
                                        float minScore,
                                        int maxBoxes)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    eta - NMS 阈值的适应率。
    
    minScore - 要检测的框的最小得分。
    
    maxBoxes - 要检测的框的最大数量。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta,
                                        float eta,
                                        float minScore)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    eta - NMS 阈值的适应率。
    
    minScore - 要检测的框的最小得分。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta,
                                        float eta)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    eta - NMS 阈值的适应率。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha,
                                        float beta)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    beta - 用于对象提议的 NMS 阈值。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes(float alpha)
```
    创建 Edgeboxes
    
    参数
    
    alpha - 滑动窗口搜索的步长。
    
    返回
    
    自动生成
  - createEdgeBoxes
```
public static EdgeBoxes createEdgeBoxes()
```
    创建 Edgeboxes
    
    返回
    
    自动生成
  - createSuperpixelSLIC
```
public static SuperpixelSLIC createSuperpixelSLIC(Mat image,
                                                  int algorithm,
                                                  int region_size,
                                                  float ruler)
```
    初始化 SuperpixelSLIC 对象
    
    参数
    
    image - 要分割的图像
    
    algorithm - 选择要使用的算法变体：SLIC 使用所需的 region_size 分割图像，此外 SLICO 将使用自适应紧凑因子进行优化，而 MSLIC 将使用流形方法进行优化，从而产生更具内容敏感性的超像素。
    
    region_size - 选择以像素为单位的平均超像素大小
    
    ruler - 选择超像素平滑因子的强制执行。该函数为输入图像初始化一个 SuperpixelSLIC 对象。它设置所选超像素算法的参数，即：region_size 和 ruler。它为给定图像上的未来计算迭代预分配一些缓冲区。为了增强结果，建议对彩色图像使用小型 3x3 高斯模糊进行预处理，并额外转换为 CieLAB 颜色空间。SLIC 与 SLICO 和 MSLIC 的示例在下图所示。![image](pics/superpixels_slic.png)
    
    返回
    
    自动生成
  - createSuperpixelSLIC
```
public static SuperpixelSLIC createSuperpixelSLIC(Mat image,
                                                  int algorithm,
                                                  int region_size)
```
    初始化 SuperpixelSLIC 对象
    
    参数
    
    image - 要分割的图像
    
    algorithm - 选择要使用的算法变体：SLIC 使用所需的 region_size 分割图像，此外 SLICO 将使用自适应紧凑因子进行优化，而 MSLIC 将使用流形方法进行优化，从而产生更具内容敏感性的超像素。
    
    region_size - 选择以像素为单位的平均超像素大小。该函数为输入图像初始化一个 SuperpixelSLIC 对象。它设置所选超像素算法的参数，即：region_size 和 ruler。它为给定图像上的未来计算迭代预分配一些缓冲区。为了增强结果，建议对彩色图像使用小型 3x3 高斯模糊进行预处理，并额外转换为 CieLAB 颜色空间。SLIC 与 SLICO 和 MSLIC 的示例在下图所示。![image](pics/superpixels_slic.png)
    
    返回
    
    自动生成
  - createSuperpixelSLIC
```
public static SuperpixelSLIC createSuperpixelSLIC(Mat image,
                                                  int algorithm)
```
    初始化 SuperpixelSLIC 对象
    
    参数
    
    image - 要分割的图像
    
    algorithm - 选择要使用的算法变体：SLIC 使用所需的 region_size 分割图像，此外 SLICO 将使用自适应紧凑因子进行优化，而 MSLIC 将使用流形方法进行优化，从而产生更具内容敏感性的超像素。该函数为输入图像初始化一个 SuperpixelSLIC 对象。它设置所选超像素算法的参数，即：region_size 和 ruler。它为给定图像上的未来计算迭代预分配一些缓冲区。为了增强结果，建议对彩色图像使用小型 3x3 高斯模糊进行预处理，并额外转换为 CieLAB 颜色空间。SLIC 与 SLICO 和 MSLIC 的示例在下图所示。![image](pics/superpixels_slic.png)
    
    返回
    
    自动生成
  - createSuperpixelSLIC
```
public static SuperpixelSLIC createSuperpixelSLIC(Mat image)
```
    初始化 SuperpixelSLIC 对象
    
    参数
    
    image - 要分割的图像。SLIC 使用所需的 region_size 分割图像，此外 SLICO 将使用自适应紧凑因子进行优化，而 MSLIC 将使用流形方法进行优化，从而产生更具内容敏感性的超像素。该函数为输入图像初始化一个 SuperpixelSLIC 对象。它设置所选超像素算法的参数，即：region_size 和 ruler。它为给定图像上的未来计算迭代预分配一些缓冲区。为了增强结果，建议对彩色图像使用小型 3x3 高斯模糊进行预处理，并额外转换为 CieLAB 颜色空间。SLIC 与 SLICO 和 MSLIC 的示例在下图所示。![image](pics/superpixels_slic.png)
    
    返回
    
    自动生成
  - FastHoughTransform
```
public static void FastHoughTransform(Mat src,
                                      Mat dst,
                                      int dstMatDepth,
                                      int angleRange,
                                      int op,
                                      int makeSkew)
```
    计算图像的 2D 快速霍夫变换。该函数计算全角、半角或四分之一角度范围的快速霍夫变换。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    dstMatDepth - 自动生成
    
    angleRange - 自动生成
    
    op - 自动生成
    
    makeSkew - 自动生成
  - FastHoughTransform
```
public static void FastHoughTransform(Mat src,
                                      Mat dst,
                                      int dstMatDepth,
                                      int angleRange,
                                      int op)
```
    计算图像的 2D 快速霍夫变换。该函数计算全角、半角或四分之一角度范围的快速霍夫变换。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    dstMatDepth - 自动生成
    
    angleRange - 自动生成
    
    op - 自动生成
  - FastHoughTransform
```
public static void FastHoughTransform(Mat src,
                                      Mat dst,
                                      int dstMatDepth,
                                      int angleRange)
```
    计算图像的 2D 快速霍夫变换。该函数计算全角、半角或四分之一角度范围的快速霍夫变换。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    dstMatDepth - 自动生成
    
    angleRange - 自动生成
  - FastHoughTransform
```
public static void FastHoughTransform(Mat src,
                                      Mat dst,
                                      int dstMatDepth)
```
    计算图像的 2D 快速霍夫变换。该函数计算全角、半角或四分之一角度范围的快速霍夫变换。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    dstMatDepth - 自动生成
  - fourierDescriptor
```
public static void fourierDescriptor(Mat src,
                                     Mat dst,
                                     int nbElt,
                                     int nbFD)
```
    平面闭合曲线的傅里叶描述符。有关此实现的更多详细信息，请参见 CITE: PersoonFu1977
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    nbElt - 自动生成
    
    nbFD - 自动生成
  - fourierDescriptor
```
public static void fourierDescriptor(Mat src,
                                     Mat dst,
                                     int nbElt)
```
    平面闭合曲线的傅里叶描述符。有关此实现的更多详细信息，请参见 CITE: PersoonFu1977
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    nbElt - 自动生成
  - fourierDescriptor
```
public static void fourierDescriptor(Mat src,
                                     Mat dst)
```
    平面闭合曲线的傅里叶描述符。有关此实现的更多详细信息，请参见 CITE: PersoonFu1977
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
  - transformFD
```
public static void transformFD(Mat src,
                               Mat t,
                               Mat dst,
                               boolean fdContour)
```
    变换轮廓
    
    参数
    
    src - 自动生成
    
    t - 自动生成
    
    dst - 自动生成
    
    fdContour - 自动生成
  - transformFD
```
public static void transformFD(Mat src,
                               Mat t,
                               Mat dst)
```
    变换轮廓
    
    参数
    
    src - 自动生成
    
    t - 自动生成
    
    dst - 自动生成
  - contourSampling
```
public static void contourSampling(Mat src,
                                   Mat out,
                                   int nbElt)
```
    轮廓采样。
    
    参数
    
    src - 自动生成
    
    out - 自动生成
    
    nbElt - 自动生成
  - createContourFitting
```
public static ContourFitting createContourFitting(int ctr,
                                                  int fd)
```
    创建 ContourFitting 算法对象
    
    参数
    
    ctr - 等于重采样后轮廓点数的傅里叶描述符数量。
    
    fd - 定义第二个形状（目标）的轮廓。
    
    返回
    
    自动生成
  - createContourFitting
```
public static ContourFitting createContourFitting(int ctr)
```
    创建 ContourFitting 算法对象
    
    参数
    
    ctr - 等于重采样后轮廓点数的傅里叶描述符数量。
    
    返回
    
    自动生成
  - createContourFitting
```
public static ContourFitting createContourFitting()
```
    创建 ContourFitting 算法对象
    
    返回
    
    自动生成
  - createSuperpixelLSC
```
public static SuperpixelLSC createSuperpixelLSC(Mat image,
                                                int region_size,
                                                float ratio)
```
    实现 LSC (线性光谱聚类) 超像素的类
    
    参数
    
    image - 要分割的图像
    
    region_size - 选择以像素为单位的平均超像素大小
    
    ratio - 选择超像素紧凑因子的强制执行。该函数为输入图像初始化一个 SuperpixelLSC 对象。它设置超像素算法的参数，即：region_size 和 ruler。它为给定图像上的未来计算迭代预分配一些缓冲区。LSC 的一个示例如下图所示。为了增强结果，建议对彩色图像使用小型 3x3 高斯模糊进行预处理，并额外转换为 CieLAB 颜色空间。![image](pics/superpixels_lsc.png)
    
    返回
    
    自动生成
  - createSuperpixelLSC
```
public static SuperpixelLSC createSuperpixelLSC(Mat image,
                                                int region_size)
```
    实现 LSC (线性光谱聚类) 超像素的类
    
    参数
    
    image - 要分割的图像
    
    region_size - 选择以像素为单位的平均超像素大小。该函数为输入图像初始化一个 SuperpixelLSC 对象。它设置超像素算法的参数，即：region_size 和 ruler。它为给定图像上的未来计算迭代预分配一些缓冲区。LSC 的一个示例如下图所示。为了增强结果，建议对彩色图像使用小型 3x3 高斯模糊进行预处理，并额外转换为 CieLAB 颜色空间。![image](pics/superpixels_lsc.png)
    
    返回
    
    自动生成
  - createSuperpixelLSC
```
public static SuperpixelLSC createSuperpixelLSC(Mat image)
```
    实现 LSC (线性光谱聚类) 超像素的类
    
    参数
    
    image - 要分割的图像。该函数为输入图像初始化一个 SuperpixelLSC 对象。它设置超像素算法的参数，即：region_size 和 ruler。它为给定图像上的未来计算迭代预分配一些缓冲区。LSC 的一个示例如下图所示。为了增强结果，建议对彩色图像使用小型 3x3 高斯模糊进行预处理，并额外转换为 CieLAB 颜色空间。![image](pics/superpixels_lsc.png)
    
    返回
    
    自动生成
  - createQuaternionImage
```
public static void createQuaternionImage(Mat img,
                                         Mat qimg)
```
    创建四元数图像。
    
    参数
    
    img - 自动生成
    
    qimg - 自动生成
  - qconj
```
public static void qconj(Mat qimg,
                         Mat qcimg)
```
    计算四元数图像的共轭。
    
    参数
    
    qimg - 自动生成
    
    qcimg - 自动生成
  - qunitary
```
public static void qunitary(Mat qimg,
                            Mat qnimg)
```
    将每个元素除以其模数。
    
    参数
    
    qimg - 自动生成
    
    qnimg - 自动生成
  - qmultiply
```
public static void qmultiply(Mat src1,
                             Mat src2,
                             Mat dst)
```
    计算两个数组的逐元素四元数积
    
    参数
    
    src1 - 自动生成
    
    src2 - 自动生成
    
    dst - 自动生成
  - qdft
```
public static void qdft(Mat img,
                        Mat qimg,
                        int flags,
                        boolean sideLeft)
```
    对二维四元数数组执行正向或逆向离散四元数傅里叶变换。
    
    参数
    
    img - 自动生成
    
    qimg - 自动生成
    
    flags - 自动生成
    
    sideLeft - 自动生成
  - colorMatchTemplate
```
public static void colorMatchTemplate(Mat img,
                                      Mat templ,
                                      Mat result)
```
    比较彩色模板与重叠的彩色图像区域。
    
    参数
    
    img - 自动生成
    
    templ - 自动生成
    
    result - 自动生成
  - createSuperpixelSEEDS
```
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width,
                                                    int image_height,
                                                    int image_channels,
                                                    int num_superpixels,
                                                    int num_levels,
                                                    int prior,
                                                    int histogram_bins,
                                                    boolean double_step)
```
    初始化 SuperpixelSEEDS 对象。
    
    参数
    
    image_width - 图像宽度。
    
    image_height - 图像高度。
    
    image_channels - 图像的通道数。
    
    num_superpixels - 所需的超像素数量。请注意，由于限制（取决于图像大小和 num_levels），实际数量可能会更小。使用 getNumberOfSuperpixels() 获取实际数量。
    
    num_levels - 块层数。层数越多，分割越准确，但需要更多的内存和 CPU 时间。
    
    prior - 如果 >0，启用 3x3 形状平滑项。值越大，形状越平滑。prior 必须在 [0, 5] 范围内。
    
    histogram_bins - 直方图 bin 数量。
    
    double_step - 如果为 true，则每个块级别迭代两次以获得更高的精度。该函数为输入图像初始化一个 SuperpixelSEEDS 对象。它存储图像的参数：image_width、image_height 和 image_channels。它还设置 SEEDS 超像素算法的参数，即：num_superpixels、num_levels、use_prior、histogram_bins 和 double_step。num_levels 中的层数定义了算法在优化中使用的块级别数量。初始化是一个网格，其中超像素在图像的宽度和高度上均匀分布。较大的块对应于超像素大小，而较小块的级别是通过将较大的块递归地划分为 2x2 像素块，直到最小块级别。下图说明了 4 个块级别的初始化示例。![image](pics/superpixels_blocks.png)
    
    返回
    
    自动生成
  - createSuperpixelSEEDS
```
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width,
                                                    int image_height,
                                                    int image_channels,
                                                    int num_superpixels,
                                                    int num_levels,
                                                    int prior,
                                                    int histogram_bins)
```
    初始化 SuperpixelSEEDS 对象。
    
    参数
    
    image_width - 图像宽度。
    
    image_height - 图像高度。
    
    image_channels - 图像的通道数。
    
    num_superpixels - 所需的超像素数量。请注意，由于限制（取决于图像大小和 num_levels），实际数量可能会更小。使用 getNumberOfSuperpixels() 获取实际数量。
    
    num_levels - 块层数。层数越多，分割越准确，但需要更多的内存和 CPU 时间。
    
    prior - 如果 >0，启用 3x3 形状平滑项。值越大，形状越平滑。prior 必须在 [0, 5] 范围内。
    
    histogram_bins - 直方图 bin 数量。该函数为输入图像初始化一个 SuperpixelSEEDS 对象。它存储图像的参数：image_width、image_height 和 image_channels。它还设置 SEEDS 超像素算法的参数，即：num_superpixels、num_levels、use_prior、histogram_bins 和 double_step。num_levels 中的层数定义了算法在优化中使用的块级别数量。初始化是一个网格，其中超像素在图像的宽度和高度上均匀分布。较大的块对应于超像素大小，而较小块的级别是通过将较大的块递归地划分为 2x2 像素块，直到最小块级别。下图说明了 4 个块级别的初始化示例。![image](pics/superpixels_blocks.png)
    
    返回
    
    自动生成
  - createSuperpixelSEEDS
```
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width,
                                                    int image_height,
                                                    int image_channels,
                                                    int num_superpixels,
                                                    int num_levels,
                                                    int prior)
```
    初始化 SuperpixelSEEDS 对象。
    
    参数
    
    image_width - 图像宽度。
    
    image_height - 图像高度。
    
    image_channels - 图像的通道数。
    
    num_superpixels - 所需的超像素数量。请注意，由于限制（取决于图像大小和 num_levels），实际数量可能会更小。使用 getNumberOfSuperpixels() 获取实际数量。
    
    num_levels - 块层数。层数越多，分割越准确，但需要更多的内存和 CPU 时间。
    
    prior - 如果 >0，启用 3x3 形状平滑项。值越大，形状越平滑。prior 必须在 [0, 5] 范围内。该函数为输入图像初始化一个 SuperpixelSEEDS 对象。它存储图像的参数：image_width、image_height 和 image_channels。它还设置 SEEDS 超像素算法的参数，即：num_superpixels、num_levels、use_prior、histogram_bins 和 double_step。num_levels 中的层数定义了算法在优化中使用的块级别数量。初始化是一个网格，其中超像素在图像的宽度和高度上均匀分布。较大的块对应于超像素大小，而较小块的级别是通过将较大的块递归地划分为 2x2 像素块，直到最小块级别。下图说明了 4 个块级别的初始化示例。![image](pics/superpixels_blocks.png)
    
    返回
    
    自动生成
  - createSuperpixelSEEDS
```
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width,
                                                    int image_height,
                                                    int image_channels,
                                                    int num_superpixels,
                                                    int num_levels)
```
    初始化 SuperpixelSEEDS 对象。
    
    参数
    
    image_width - 图像宽度。
    
    image_height - 图像高度。
    
    image_channels - 图像的通道数。
    
    num_superpixels - 所需的超像素数量。请注意，由于限制（取决于图像大小和 num_levels），实际数量可能会更小。使用 getNumberOfSuperpixels() 获取实际数量。
    
    num_levels - 块层数。层数越多，分割越准确，但需要更多的内存和 CPU 时间。必须在 [0, 5] 范围内。该函数为输入图像初始化一个 SuperpixelSEEDS 对象。它存储图像的参数：image_width、image_height 和 image_channels。它还设置 SEEDS 超像素算法的参数，即：num_superpixels、num_levels、use_prior、histogram_bins 和 double_step。num_levels 中的层数定义了算法在优化中使用的块级别数量。初始化是一个网格，其中超像素在图像的宽度和高度上均匀分布。较大的块对应于超像素大小，而较小块的级别是通过将较大的块递归地划分为 2x2 像素块，直到最小块级别。下图说明了 4 个块级别的初始化示例。![image](pics/superpixels_blocks.png)
    
    返回
    
    自动生成
  - 创建边缘绘制
```
public static EdgeDrawing createEdgeDrawing()
```
    创建 EdgeDrawing 对象的智能指针并进行初始化
    
    返回
    
    自动生成
  - 创建RFFeatureGetter
```
public static RFFeatureGetter createRFFeatureGetter()
```
  - createStructuredEdgeDetection
```
public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model,
                                                                    RFFeatureGetter howToGetFeatures)
```
  - createStructuredEdgeDetection
```
public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model)
```
  - RadonTransform
```
public static void RadonTransform(Mat src,
                                  Mat dst,
                                  double theta,
                                  double start_angle,
                                  double end_angle,
                                  boolean crop,
                                  boolean norm)
```
    计算图像的 Radon 变换。该函数计算给定图像在任何范围内的 Radon 变换。有关详细信息，请参见 https://engineering.purdue.edu/~malcolm/pct/CTI_Ch03.pdf。如果输入类型是 CV_8U，输出将是 CV_32S。如果输入类型是 CV_32F 或 CV_64F，输出将是 CV_64F。输出大小将是 num_of_integral x src_diagonal_length。如果选择裁剪，输入图像将被裁剪成正方形，然后是圆形，输出大小将是 num_of_integral x min_edge。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    theta - 自动生成
    
    start_angle - 自动生成
    
    end_angle - 自动生成
    
    crop - 自动生成
    
    norm - 自动生成
  - RadonTransform
```
public static void RadonTransform(Mat src,
                                  Mat dst,
                                  double theta,
                                  double start_angle,
                                  double end_angle,
                                  boolean crop)
```
    计算图像的 Radon 变换。该函数计算给定图像在任何范围内的 Radon 变换。有关详细信息，请参见 https://engineering.purdue.edu/~malcolm/pct/CTI_Ch03.pdf。如果输入类型是 CV_8U，输出将是 CV_32S。如果输入类型是 CV_32F 或 CV_64F，输出将是 CV_64F。输出大小将是 num_of_integral x src_diagonal_length。如果选择裁剪，输入图像将被裁剪成正方形，然后是圆形，输出大小将是 num_of_integral x min_edge。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    theta - 自动生成
    
    start_angle - 自动生成
    
    end_angle - 自动生成
    
    crop - 自动生成
  - RadonTransform
```
public static void RadonTransform(Mat src,
                                  Mat dst,
                                  double theta,
                                  double start_angle,
                                  double end_angle)
```
    计算图像的 Radon 变换。该函数计算给定图像在任何范围内的 Radon 变换。有关详细信息，请参见 https://engineering.purdue.edu/~malcolm/pct/CTI_Ch03.pdf。如果输入类型是 CV_8U，输出将是 CV_32S。如果输入类型是 CV_32F 或 CV_64F，输出将是 CV_64F。输出大小将是 num_of_integral x src_diagonal_length。如果选择裁剪，输入图像将被裁剪成正方形，然后是圆形，输出大小将是 num_of_integral x min_edge。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    theta - 自动生成
    
    start_angle - 自动生成
    
    end_angle - 自动生成
  - RadonTransform
```
public static void RadonTransform(Mat src,
                                  Mat dst,
                                  double theta,
                                  double start_angle)
```
    计算图像的 Radon 变换。该函数计算给定图像在任何范围内的 Radon 变换。有关详细信息，请参见 https://engineering.purdue.edu/~malcolm/pct/CTI_Ch03.pdf。如果输入类型是 CV_8U，输出将是 CV_32S。如果输入类型是 CV_32F 或 CV_64F，输出将是 CV_64F。输出大小将是 num_of_integral x src_diagonal_length。如果选择裁剪，输入图像将被裁剪成正方形，然后是圆形，输出大小将是 num_of_integral x min_edge。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    theta - 自动生成
    
    start_angle - 自动生成
  - RadonTransform
```
public static void RadonTransform(Mat src,
                                  Mat dst,
                                  double theta)
```
    计算图像的 Radon 变换。该函数计算给定图像在任何范围内的 Radon 变换。有关详细信息，请参见 https://engineering.purdue.edu/~malcolm/pct/CTI_Ch03.pdf。如果输入类型是 CV_8U，输出将是 CV_32S。如果输入类型是 CV_32F 或 CV_64F，输出将是 CV_64F。输出大小将是 num_of_integral x src_diagonal_length。如果选择裁剪，输入图像将被裁剪成正方形，然后是圆形，输出大小将是 num_of_integral x min_edge。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    theta - 自动生成
  - RadonTransform
```
public static void RadonTransform(Mat src,
                                  Mat dst)
```
    计算图像的 Radon 变换。该函数计算给定图像在任何范围内的 Radon 变换。有关详细信息，请参见 https://engineering.purdue.edu/~malcolm/pct/CTI_Ch03.pdf。如果输入类型是 CV_8U，输出将是 CV_32S。如果输入类型是 CV_32F 或 CV_64F，输出将是 CV_64F。输出大小将是 num_of_integral x src_diagonal_length。如果选择裁剪，输入图像将被裁剪成正方形，然后是圆形，输出大小将是 num_of_integral x min_edge。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
  - 创建边缘感知插值器
```
public static EdgeAwareInterpolator createEdgeAwareInterpolator()
```
    创建 EdgeAwareInterpolator 实例的工厂方法。
    
    返回
    
    自动生成
  - 创建RIC插值器
```
public static RICInterpolator createRICInterpolator()
```
    创建 RICInterpolator 实例的工厂方法。
    
    返回
    
    自动生成
  - weightedMedianFilter
```
public static void weightedMedianFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int r,
                                        double sigma,
                                        int weightType,
                                        Mat mask)
```
    对图像应用加权中值滤波器。有关此实现的更多详细信息，请参见 CITE: zhang2014100+。在维护联合直方图时，该像素将被忽略。这对于光流遮挡处理等应用非常有用。SEE: medianBlur, jointBilateralFilter
    
    参数
    
    joint - 自动生成
    
    src - 自动生成
    
    dst - 自动生成
    
    r - 自动生成
    
    sigma - 自动生成
    
    weightType - 自动生成
    
    mask - 自动生成
  - weightedMedianFilter
```
public static void weightedMedianFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int r,
                                        double sigma,
                                        int weightType)
```
    对图像应用加权中值滤波器。有关此实现的更多详细信息，请参见 CITE: zhang2014100+。在维护联合直方图时，该像素将被忽略。这对于光流遮挡处理等应用非常有用。SEE: medianBlur, jointBilateralFilter
    
    参数
    
    joint - 自动生成
    
    src - 自动生成
    
    dst - 自动生成
    
    r - 自动生成
    
    sigma - 自动生成
    
    weightType - 自动生成
  - weightedMedianFilter
```
public static void weightedMedianFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int r,
                                        double sigma)
```
    对图像应用加权中值滤波器。有关此实现的更多详细信息，请参见 CITE: zhang2014100+。在维护联合直方图时，该像素将被忽略。这对于光流遮挡处理等应用非常有用。SEE: medianBlur, jointBilateralFilter
    
    参数
    
    joint - 自动生成
    
    src - 自动生成
    
    dst - 自动生成
    
    r - 自动生成
    
    sigma - 自动生成
  - weightedMedianFilter
```
public static void weightedMedianFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int r)
```
    对图像应用加权中值滤波器。有关此实现的更多详细信息，请参见 CITE: zhang2014100+。在维护联合直方图时，该像素将被忽略。这对于光流遮挡处理等应用非常有用。SEE: medianBlur, jointBilateralFilter
    
    参数
    
    joint - 自动生成
    
    src - 自动生成
    
    dst - 自动生成
    
    r - 自动生成
  - createGraphSegmentation
```
public static GraphSegmentation createGraphSegmentation(double sigma,
                                                        float k,
                                                        int min_size)
```
    创建基于图的分割器
    
    参数
    
    sigma - 用于平滑图像的 sigma 参数
    
    k - 算法的 k 参数
    
    min_size - 线段的最小尺寸
    
    返回
    
    自动生成
  - createGraphSegmentation
```
public static GraphSegmentation createGraphSegmentation(double sigma,
                                                        float k)
```
    创建基于图的分割器
    
    参数
    
    sigma - 用于平滑图像的 sigma 参数
    
    k - 算法的 k 参数
    
    返回
    
    自动生成
  - createGraphSegmentation
```
public static GraphSegmentation createGraphSegmentation(double sigma)
```
    创建基于图的分割器
    
    参数
    
    sigma - 用于平滑图像的 sigma 参数
    
    返回
    
    自动生成
  - createGraphSegmentation
```
public static GraphSegmentation createGraphSegmentation()
```
    创建基于图的分割器
    
    返回
    
    自动生成
  - createSelectiveSearchSegmentationStrategyColor
```
public static SelectiveSearchSegmentationStrategyColor createSelectiveSearchSegmentationStrategyColor()
```
    创建新的基于颜色的策略
    
    返回
    
    自动生成
  - createSelectiveSearchSegmentationStrategySize
```
public static SelectiveSearchSegmentationStrategySize createSelectiveSearchSegmentationStrategySize()
```
    创建新的基于大小的策略
    
    返回
    
    自动生成
  - createSelectiveSearchSegmentationStrategyTexture
```
public static SelectiveSearchSegmentationStrategyTexture createSelectiveSearchSegmentationStrategyTexture()
```
    创建新的基于大小的策略
    
    返回
    
    自动生成
  - createSelectiveSearchSegmentationStrategyFill
```
public static SelectiveSearchSegmentationStrategyFill createSelectiveSearchSegmentationStrategyFill()
```
    创建新的基于填充的策略
    
    返回
    
    自动生成
  - createSelectiveSearchSegmentationStrategyMultiple
```
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple()
```
    创建新的多重策略
    
    返回
    
    自动生成
  - createSelectiveSearchSegmentationStrategyMultiple
```
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1)
```
    创建新的多重策略并设置一个子策略
    
    参数
    
    s1 - 第一种策略
    
    返回
    
    自动生成
  - createSelectiveSearchSegmentationStrategyMultiple
```
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1,
                                                                                                            SelectiveSearchSegmentationStrategy s2)
```
    创建一个新的多策略并设置两个子策略，权重相等
    
    参数
    
    s1 - 第一种策略
    
    s2 - 第二种策略
    
    返回
    
    自动生成
  - createSelectiveSearchSegmentationStrategyMultiple
```
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1,
                                                                                                            SelectiveSearchSegmentationStrategy s2,
                                                                                                            SelectiveSearchSegmentationStrategy s3)
```
    创建一个新的多策略并设置三个子策略，权重相等
    
    参数
    
    s1 - 第一种策略
    
    s2 - 第二种策略
    
    s3 - 第三种策略
    
    返回
    
    自动生成
  - createSelectiveSearchSegmentationStrategyMultiple
```
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1,
                                                                                                            SelectiveSearchSegmentationStrategy s2,
                                                                                                            SelectiveSearchSegmentationStrategy s3,
                                                                                                            SelectiveSearchSegmentationStrategy s4)
```
    创建一个新的多策略并设置四个子策略，权重相等
    
    参数
    
    s1 - 第一种策略
    
    s2 - 第二种策略
    
    s3 - 第三种策略
    
    s4 - 第四种策略
    
    返回
    
    自动生成
  - createSelectiveSearchSegmentation
```
public static SelectiveSearchSegmentation createSelectiveSearchSegmentation()
```
    创建新的 SelectiveSearchSegmentation 类。
    
    返回
    
    自动生成
  - findEllipses
```
public static void findEllipses(Mat image,
                                Mat ellipses,
                                float scoreThreshold,
                                float reliabilityThreshold,
                                float centerDistanceThreshold)
```
    使用投影不变剪枝在图像中快速查找椭圆。该函数使用投影不变剪枝在图像中检测椭圆。有关此实现的更多详细信息，请参见 CITE: jia2017fast Jia, Qi 等人 (2017)。《一种使用投影不变剪枝的快速椭圆检测器》。IEEE Transactions on Image Processing。
    
    参数
    
    image - 输入图像，可以是灰度图或彩色图。
    
    ellipses - 找到的椭圆的输出向量。每个向量编码为五个浮点数 $x, y, a, b, radius, score$。
    
    scoreThreshold - 浮点数，椭圆得分的阈值。
    
    reliabilityThreshold - 浮点数，可靠性阈值。
    
    centerDistanceThreshold - 浮点数，中心距离阈值。
  - findEllipses
```
public static void findEllipses(Mat image,
                                Mat ellipses,
                                float scoreThreshold,
                                float reliabilityThreshold)
```
    使用投影不变剪枝在图像中快速查找椭圆。该函数使用投影不变剪枝在图像中检测椭圆。有关此实现的更多详细信息，请参见 CITE: jia2017fast Jia, Qi 等人 (2017)。《一种使用投影不变剪枝的快速椭圆检测器》。IEEE Transactions on Image Processing。
    
    参数
    
    image - 输入图像，可以是灰度图或彩色图。
    
    ellipses - 找到的椭圆的输出向量。每个向量编码为五个浮点数 $x, y, a, b, radius, score$。
    
    scoreThreshold - 浮点数，椭圆得分的阈值。
    
    reliabilityThreshold - 浮点数，可靠性阈值。
  - findEllipses
```
public static void findEllipses(Mat image,
                                Mat ellipses,
                                float scoreThreshold)
```
    使用投影不变剪枝在图像中快速查找椭圆。该函数使用投影不变剪枝在图像中检测椭圆。有关此实现的更多详细信息，请参见 CITE: jia2017fast Jia, Qi 等人 (2017)。《一种使用投影不变剪枝的快速椭圆检测器》。IEEE Transactions on Image Processing。
    
    参数
    
    image - 输入图像，可以是灰度图或彩色图。
    
    ellipses - 找到的椭圆的输出向量。每个向量编码为五个浮点数 $x, y, a, b, radius, score$。
    
    scoreThreshold - 浮点数，椭圆得分的阈值。
  - findEllipses
```
public static void findEllipses(Mat image,
                                Mat ellipses)
```
    使用投影不变剪枝在图像中快速查找椭圆。该函数使用投影不变剪枝在图像中检测椭圆。有关此实现的更多详细信息，请参见 CITE: jia2017fast Jia, Qi 等人 (2017)。《一种使用投影不变剪枝的快速椭圆检测器》。IEEE Transactions on Image Processing。
    
    参数
    
    image - 输入图像，可以是灰度图或彩色图。
    
    ellipses - 找到的椭圆的输出向量。每个向量编码为五个浮点数 $x, y, a, b, radius, score$。
  - createDisparityWLSFilter
```
public static DisparityWLSFilter createDisparityWLSFilter(StereoMatcher matcher_left)
```
    便捷工厂方法，创建 DisparityWLSFilter 实例并根据匹配器实例自动设置所有相关过滤器参数。目前仅支持 StereoBM 和 StereoSGBM。
    
    参数
    
    matcher_left - 将与过滤器一起使用的立体匹配器实例
    
    返回
    
    自动生成
  - createRightMatcher
```
public static StereoMatcher createRightMatcher(StereoMatcher matcher_left)
```
    便捷方法，用于设置匹配器以计算右视图视差图，这在带置信度滤波的情况下是必需的。
    
    参数
    
    matcher_left - 将与过滤器一起使用的主要立体匹配器实例
    
    返回
    
    自动生成
  - createDisparityWLSFilterGeneric
```
public static DisparityWLSFilter createDisparityWLSFilterGeneric(boolean use_confidence)
```
    更通用的工厂方法，创建 DisparityWLSFilter 实例并执行基本初始化例程。使用此方法时，您需要自行设置 ROI、匹配器和其他参数。
    
    参数
    
    use_confidence - 带置信度滤波需要两个视差图（左右视图），速度大约慢两倍。然而，质量通常明显更好。
    
    返回
    
    自动生成
  - readGT
```
public static int readGT(java.lang.String src_path,
                         Mat dst)
```
    用于读取真实视差图的函数。支持基本的 Middlebury 和 MPI-Sintel 格式。请注意，生成的视差图按 16 倍缩放。
    
    参数
    
    src_path - 包含真实视差图的图像路径
    
    dst - 输出视差图，CV_16S 深度
    
    返回
    
    输出视差图，CV_16S 深度
  - computeMSE
```
public static double computeMSE(Mat GT,
                                Mat src,
                                Rect ROI)
```
    计算视差图均方误差的函数
    
    参数
    
    GT - 真实视差图
    
    src - 要评估的视差图
    
    ROI - 感兴趣区域
    
    返回
    
    返回 GT 和 src 之间的均方误差
  - computeBadPixelPercent
```
public static double computeBadPixelPercent(Mat GT,
                                            Mat src,
                                            Rect ROI,
                                            int thresh)
```
    用于计算视差图中“坏”像素百分比的函数（错误高于指定阈值的像素）
    
    参数
    
    GT - 真实视差图
    
    src - 要评估的视差图
    
    ROI - 感兴趣区域
    
    thresh - 用于确定“坏”像素的阈值
    
    返回
    
    返回 GT 和 src 之间的均方误差
  - computeBadPixelPercent
```
public static double computeBadPixelPercent(Mat GT,
                                            Mat src,
                                            Rect ROI)
```
    用于计算视差图中“坏”像素百分比的函数（错误高于指定阈值的像素）
    
    参数
    
    GT - 真实视差图
    
    src - 要评估的视差图
    
    ROI - 感兴趣区域
    
    返回
    
    返回 GT 和 src 之间的均方误差
  - getDisparityVis
```
public static void getDisparityVis(Mat src,
                                   Mat dst,
                                   double scale)
```
    用于创建视差图可视化（钳制 CV_8U 图像）的函数
    
    参数
    
    src - 输入视差图（CV_16S 深度）
    
    dst - 输出可视化
    
    scale - 视差图将乘以该值进行可视化
  - getDisparityVis
```
public static void getDisparityVis(Mat src,
                                   Mat dst)
```
    用于创建视差图可视化（钳制 CV_8U 图像）的函数
    
    参数
    
    src - 输入视差图（CV_16S 深度）
    
    dst - 输出可视化
  - covarianceEstimation
```
public static void covarianceEstimation(Mat src,
                                        Mat dst,
                                        int windowRows,
                                        int windowCols)
```
    使用滑动窗口公式计算图像的估计协方差矩阵。
    
    参数
    
    src - 源图像。输入图像必须是复数类型。
    
    dst - 目标估计协方差矩阵。输出矩阵的大小将为 (windowRows*windowCols, windowRows*windowCols)。
    
    windowRows - 窗口中的行数。
    
    windowCols - 窗口中的列数。窗口大小参数控制估计的准确性。滑动窗口从图像的左上角移动到右下角。窗口的每个位置代表一个样本。如果窗口与图像大小相同，则给出精确的协方差矩阵。对于所有其他情况，窗口的大小将影响样本数量和估计协方差矩阵中的元素数量。
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                      float distance_threshold,
                                                      double canny_th1,
                                                      double canny_th2,
                                                      int canny_aperture_size,
                                                      boolean do_merge)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 比此值短的线段将被丢弃
    
    distance_threshold - 距离假设线段超过此值的点将被视为离群值
    
    canny_th1 - Canny() 中滞后过程的第一个阈值
    
    canny_th2 - Canny() 中滞后过程的第二个阈值
    
    canny_aperture_size - Canny() 中 Sobel 算子的孔径大小。如果为零，则不应用 Canny()，并将输入图像视为边缘图像。
    
    do_merge - 如果为 true，将执行线段的增量合并
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                      float distance_threshold,
                                                      double canny_th1,
                                                      double canny_th2,
                                                      int canny_aperture_size)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 比此值短的线段将被丢弃
    
    distance_threshold - 距离假设线段超过此值的点将被视为离群值
    
    canny_th1 - Canny() 中滞后过程的第一个阈值
    
    canny_th2 - Canny() 中滞后过程的第二个阈值
    
    canny_aperture_size - Canny() 中 Sobel 算子的孔径大小。如果为零，则不应用 Canny()，并将输入图像视为边缘图像。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                      float distance_threshold,
                                                      double canny_th1,
                                                      double canny_th2)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 比此值短的线段将被丢弃
    
    distance_threshold - 距离假设线段超过此值的点将被视为离群值
    
    canny_th1 - Canny() 中滞后过程的第一个阈值
    
    canny_th2 - Canny() 中滞后过程的第二个阈值。如果为零，则不应用 Canny()，并将输入图像视为边缘图像。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                      float distance_threshold,
                                                      double canny_th1)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 比此值短的线段将被丢弃
    
    distance_threshold - 距离假设线段超过此值的点将被视为离群值
    
    canny_th1 - Canny() 中滞后过程的第一个阈值。如果为零，则不应用 Canny()，并将输入图像视为边缘图像。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                      float distance_threshold)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 比此值短的线段将被丢弃
    
    distance_threshold - 距离假设线段超过此值的点将被视为离群值。如果为零，则不应用 Canny()，并将输入图像视为边缘图像。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 比此值短的线段将被丢弃。超过此距离的线段将被视为离群值。如果为零，则不应用 Canny()，并将输入图像视为边缘图像。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector()
```
    创建 FastLineDetector 对象的智能指针并进行初始化。超过此距离的线段将被视为离群值。如果为零，则不应用 Canny()，并将输入图像视为边缘图像。
    
    返回
    
    自动生成
  - edgePreservingFilter
```
public static void edgePreservingFilter(Mat src,
                                        Mat dst,
                                        int d,
                                        double threshold)
```
    使用保边滤波器平滑图像。该函数平滑高斯噪声以及椒盐噪声。有关此实现的更多详细信息，请参见 [ReiWoe18] Reich, S. 和 Wörgötter, F. 和 Dellen, B. (2018)。《一种实时保边去噪滤波器》。第 13 届计算机视觉、图像处理和计算机图形理论与应用国际联合会议 (VISIGRAPP) 会议录：Visapp, 85-94, 4. DOI: 10.5220/0006509000850094。
    
    参数
    
    src - 源 8 位 3 通道图像。
    
    dst - 与源图像大小和类型相同的目标图像。
    
    d - 过滤期间使用的每个像素邻域的直径。必须大于或等于 3。
    
    threshold - 阈值，用于区分噪声、离群值和数据。
  - GradientDericheY
```
public static void GradientDericheY(Mat op,
                                    Mat dst,
                                    double alpha,
                                    double omega)
```
    对图像应用 Y Deriche 滤波器。有关此实现的更多详细信息，请参见 http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.476.5736&rep=rep1&type=pdf
    
    参数
    
    op - 自动生成
    
    dst - 自动生成
    
    alpha - 自动生成
    
    omega - 自动生成
  - GradientDericheX
```
public static void GradientDericheX(Mat op,
                                    Mat dst,
                                    double alpha,
                                    double omega)
```
    对图像应用 X Deriche 滤波器。有关此实现的更多详细信息，请参见 http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.476.5736&rep=rep1&type=pdf
    
    参数
    
    op - 自动生成
    
    dst - 自动生成
    
    alpha - 自动生成
    
    omega - 自动生成
  - createScanSegment
```
public static ScanSegment createScanSegment(int image_width,
                                            int image_height,
                                            int num_superpixels,
                                            int slices,
                                            boolean merge_small)
```
    初始化 ScanSegment 对象。该函数为输入图像初始化一个 ScanSegment 对象。它存储图像的参数：image_width 和 image_height。它还设置 F-DBSCAN 超像素算法的参数，即：num_superpixels、threads 和 merge_small。
    
    参数
    
    image_width - 图像宽度。
    
    image_height - 图像高度。
    
    num_superpixels - 所需的超像素数量。请注意，由于限制（取决于图像大小），实际数量可能会更小。使用 getNumberOfSuperpixels() 获取实际数量。
    
    slices - 用于并行化的处理线程数。设置为 -1 表示使用最大线程数。实际上，对于较小的图像，四个线程就足够了，对于较大的图像，八个线程就足够了。
    
    merge_small - 合并小段以达到所需的超像素数量。不合并处理速度更快，但图像中会留下许多小段。
    
    返回
    
    自动生成
  - createScanSegment
```
public static ScanSegment createScanSegment(int image_width,
                                            int image_height,
                                            int num_superpixels,
                                            int slices)
```
    初始化 ScanSegment 对象。该函数为输入图像初始化一个 ScanSegment 对象。它存储图像的参数：image_width 和 image_height。它还设置 F-DBSCAN 超像素算法的参数，即：num_superpixels、threads 和 merge_small。
    
    参数
    
    image_width - 图像宽度。
    
    image_height - 图像高度。
    
    num_superpixels - 所需的超像素数量。请注意，由于限制（取决于图像大小），实际数量可能会更小。使用 getNumberOfSuperpixels() 获取实际数量。
    
    slices - 用于并行化的处理线程数。设置为 -1 表示使用最大线程数。实际上，对于较小的图像，四个线程就足够了，对于较大的图像，八个线程就足够了。不合并处理速度更快，但图像中会留下许多小段。
    
    返回
    
    自动生成
  - createScanSegment
```
public static ScanSegment createScanSegment(int image_width,
                                            int image_height,
                                            int num_superpixels)
```
    初始化 ScanSegment 对象。该函数为输入图像初始化一个 ScanSegment 对象。它存储图像的参数：image_width 和 image_height。它还设置 F-DBSCAN 超像素算法的参数，即：num_superpixels、threads 和 merge_small。
    
    参数
    
    image_width - 图像宽度。
    
    image_height - 图像高度。
    
    num_superpixels - 所需的超像素数量。请注意，由于限制（取决于图像大小），实际数量可能会更小。线程数。实际上，对于较小的图像，四个线程就足够了，对于较大的图像，八个线程就足够了。不合并处理速度更快，但图像中会留下许多小段。
    
    返回
    
    自动生成
  - PeiLinNormalization
```
public static void PeiLinNormalization(Mat I,
                                       Mat T)
```
  - createDTFilter
```
public static DTFilter createDTFilter(Mat guide,
                                      double sigmaSpatial,
                                      double sigmaColor,
                                      int mode,
                                      int numIters)
```
    工厂方法，创建 DTFilter 实例并执行初始化例程。
    
    参数
    
    guide - 引导图像（用于构建变换距离，描述引导图像的边缘结构）。
    
    sigmaSpatial - 原始文章中的 ${\sigma}_H$ 参数，类似于 bilateralFilter 中坐标空间中的 sigma。
    
    sigmaColor - 原始文章中的 ${\sigma}_r$ 参数，类似于 bilateralFilter 中颜色空间中的 sigma。
    
    mode - DTF_NC、DTF_RF 和 DTF_IC 三种模式之一，对应文章中用于过滤二维信号的三种模式。
    
    numIters - 可选的过滤迭代次数，3 次通常足够。有关域变换滤波器参数的更多详细信息，请参见原始文章 CITE: Gastal11 和 [域变换滤波器主页](http://www.inf.ufrgs.br/~eslgastal/DomainTransform/)。
    
    返回
    
    自动生成
  - createDTFilter
```
public static DTFilter createDTFilter(Mat guide,
                                      double sigmaSpatial,
                                      double sigmaColor,
                                      int mode)
```
    工厂方法，创建 DTFilter 实例并执行初始化例程。
    
    参数
    
    guide - 引导图像（用于构建变换距离，描述引导图像的边缘结构）。
    
    sigmaSpatial - 原始文章中的 ${\sigma}_H$ 参数，类似于 bilateralFilter 中坐标空间中的 sigma。
    
    sigmaColor - 原始文章中的 ${\sigma}_r$ 参数，类似于 bilateralFilter 中颜色空间中的 sigma。
    
    mode - DTF_NC、DTF_RF 和 DTF_IC 三种模式之一，对应文章中用于过滤二维信号的三种模式。有关域变换滤波器参数的更多详细信息，请参见原始文章 CITE: Gastal11 和 [域变换滤波器主页](http://www.inf.ufrgs.br/~eslgastal/DomainTransform/)。
    
    返回
    
    自动生成
  - createDTFilter
```
public static DTFilter createDTFilter(Mat guide,
                                      double sigmaSpatial,
                                      double sigmaColor)
```
    工厂方法，创建 DTFilter 实例并执行初始化例程。
    
    参数
    
    guide - 引导图像（用于构建变换距离，描述引导图像的边缘结构）。
    
    sigmaSpatial - 原始文章中的 ${\sigma}_H$ 参数，类似于 bilateralFilter 中坐标空间中的 sigma。
    
    sigmaColor - 原始文章中的 ${\sigma}_r$ 参数，类似于 bilateralFilter 中颜色空间中的 sigma。过滤二维信号。有关域变换滤波器参数的更多详细信息，请参见原始文章 CITE: Gastal11 和 [域变换滤波器主页](http://www.inf.ufrgs.br/~eslgastal/DomainTransform/)。
    
    返回
    
    自动生成
  - dtFilter
```
public static void dtFilter(Mat guide,
                            Mat src,
                            Mat dst,
                            double sigmaSpatial,
                            double sigmaColor,
                            int mode,
                            int numIters)
```
    简单的单行域变换滤波器调用。如果需要用相同的引导图像过滤多个图像，则使用 DTFilter 接口以避免初始化阶段的额外计算。
    
    参数
    
    guide - 引导图像（也称为联合图像），具有无符号 8 位或浮点 32 位深度，最多 4 个通道。
    
    src - 过滤图像，具有无符号 8 位或浮点 32 位深度，最多 4 个通道。
    
    dst - 目标图像
    
    sigmaSpatial - 原始文章中的 ${\sigma}_H$ 参数，类似于 bilateralFilter 中坐标空间中的 sigma。
    
    sigmaColor - 原始文章中的 ${\sigma}_r$ 参数，类似于 bilateralFilter 中颜色空间中的 sigma。
    
    mode - DTF_NC、DTF_RF 和 DTF_IC 三种模式之一，对应文章中用于过滤二维信号的三种模式。
    
    numIters - 可选的过滤迭代次数，3 次通常足够。SEE: bilateralFilter, guidedFilter, amFilter
  - dtFilter
```
public static void dtFilter(Mat guide,
                            Mat src,
                            Mat dst,
                            double sigmaSpatial,
                            double sigmaColor,
                            int mode)
```
    简单的单行域变换滤波器调用。如果需要用相同的引导图像过滤多个图像，则使用 DTFilter 接口以避免初始化阶段的额外计算。
    
    参数
    
    guide - 引导图像（也称为联合图像），具有无符号 8 位或浮点 32 位深度，最多 4 个通道。
    
    src - 过滤图像，具有无符号 8 位或浮点 32 位深度，最多 4 个通道。
    
    dst - 目标图像
    
    sigmaSpatial - 原始文章中的 ${\sigma}_H$ 参数，类似于 bilateralFilter 中坐标空间中的 sigma。
    
    sigmaColor - 原始文章中的 ${\sigma}_r$ 参数，类似于 bilateralFilter 中颜色空间中的 sigma。
    
    mode - DTF_NC、DTF_RF 和 DTF_IC 三种模式之一，对应文章中用于过滤二维信号的三种模式。SEE: bilateralFilter, guidedFilter, amFilter
  - dtFilter
```
public static void dtFilter(Mat guide,
                            Mat src,
                            Mat dst,
                            double sigmaSpatial,
                            double sigmaColor)
```
    简单的单行域变换滤波器调用。如果需要用相同的引导图像过滤多个图像，则使用 DTFilter 接口以避免初始化阶段的额外计算。
    
    参数
    
    guide - 引导图像（也称为联合图像），具有无符号 8 位或浮点 32 位深度，最多 4 个通道。
    
    src - 过滤图像，具有无符号 8 位或浮点 32 位深度，最多 4 个通道。
    
    dst - 目标图像
    
    sigmaSpatial - 原始文章中的 ${\sigma}_H$ 参数，类似于 bilateralFilter 中坐标空间中的 sigma。
    
    sigmaColor - 原始文章中的 ${\sigma}_r$ 参数，类似于 bilateralFilter 中颜色空间中的 sigma。过滤二维信号。SEE: bilateralFilter, guidedFilter, amFilter
  - createGuidedFilter
```
public static GuidedFilter createGuidedFilter(Mat guide,
                                              int radius,
                                              double eps,
                                              double scale)
```
    工厂方法，创建 GuidedFilter 实例并执行初始化例程。
    
    参数
    
    guide - 引导图像（或图像数组），最多 3 个通道，如果超过 3 个通道则只使用前 3 个通道。
    
    radius - 引导滤波器的半径。
    
    eps - 引导滤波器的正则化项。${eps}^2$ 类似于 bilateralFilter 中颜色空间中的 sigma。
    
    scale - 快速引导滤波器的下采样因子，使用小于 1 的比例尺可以显著加快计算速度，几乎没有可见的质量下降。（例如，scale==0.5 会使滤波器内部的图像缩小 2 倍）有关（快速）引导滤波器参数的更多详细信息，请参见原始文章 CITE: Kaiming10 CITE: Kaiming15 。
    
    返回
    
    自动生成
  - createGuidedFilter
```
public static GuidedFilter createGuidedFilter(Mat guide,
                                              int radius,
                                              double eps)
```
    工厂方法，创建 GuidedFilter 实例并执行初始化例程。
    
    参数
    
    guide - 引导图像（或图像数组），最多 3 个通道，如果超过 3 个通道则只使用前 3 个通道。
    
    radius - 引导滤波器的半径。
    
    eps - 引导滤波器的正则化项。${eps}^2$ 类似于 bilateralFilter 中颜色空间中的 sigma。几乎没有可见的质量下降。（例如，scale==0.5 会使滤波器内部的图像缩小 2 倍）有关（快速）引导滤波器参数的更多详细信息，请参见原始文章 CITE: Kaiming10 CITE: Kaiming15 。
    
    返回
    
    自动生成
  - guidedFilter
```
public static void guidedFilter(Mat guide,
                                Mat src,
                                Mat dst,
                                int radius,
                                double eps,
                                int dDepth,
                                double scale)
```
    简单的单行（快速）引导滤波器调用。如果需要用相同的引导图像过滤多个图像，则使用 GuidedFilter 接口以避免初始化阶段的额外计算。
    
    参数
    
    guide - 引导图像（或图像数组），最多 3 个通道，如果超过 3 个通道则只使用前 3 个通道。
    
    src - 具有任意数量通道的过滤图像。
    
    dst - 输出图像。
    
    radius - 引导滤波器的半径。
    
    eps - 引导滤波器的正则化项。${eps}^2$ 类似于 bilateralFilter 中颜色空间中的 sigma。
    
    dDepth - 输出图像的可选深度。
    
    scale - 快速引导滤波器的下采样因子，使用小于 1 的比例尺可以显著加快计算速度，几乎没有可见的质量下降。（例如，scale==0.5 会使滤波器内部的图像缩小 2 倍）SEE: bilateralFilter, dtFilter, amFilter
  - guidedFilter
```
public static void guidedFilter(Mat guide,
                                Mat src,
                                Mat dst,
                                int radius,
                                double eps,
                                int dDepth)
```
    简单的单行（快速）引导滤波器调用。如果需要用相同的引导图像过滤多个图像，则使用 GuidedFilter 接口以避免初始化阶段的额外计算。
    
    参数
    
    guide - 引导图像（或图像数组），最多 3 个通道，如果超过 3 个通道则只使用前 3 个通道。
    
    src - 具有任意数量通道的过滤图像。
    
    dst - 输出图像。
    
    radius - 引导滤波器的半径。
    
    eps - 引导滤波器的正则化项。${eps}^2$ 类似于 bilateralFilter 中颜色空间中的 sigma。
    
    dDepth - 输出图像的可选深度。几乎没有可见的质量下降。（例如，scale==0.5 会使滤波器内部的图像缩小 2 倍）SEE: bilateralFilter, dtFilter, amFilter
  - guidedFilter
```
public static void guidedFilter(Mat guide,
                                Mat src,
                                Mat dst,
                                int radius,
                                double eps)
```
    简单的单行（快速）引导滤波器调用。如果需要用相同的引导图像过滤多个图像，则使用 GuidedFilter 接口以避免初始化阶段的额外计算。
    
    参数
    
    guide - 引导图像（或图像数组），最多 3 个通道，如果超过 3 个通道则只使用前 3 个通道。
    
    src - 具有任意数量通道的过滤图像。
    
    dst - 输出图像。
    
    radius - 引导滤波器的半径。
    
    eps - 引导滤波器的正则化项。${eps}^2$ 类似于 bilateralFilter 中颜色空间中的 sigma。几乎没有可见的质量下降。（例如，scale==0.5 会使滤波器内部的图像缩小 2 倍）SEE: bilateralFilter, dtFilter, amFilter
  - createAMFilter
```
public static AdaptiveManifoldFilter createAMFilter(double sigma_s,
                                                    double sigma_r,
                                                    boolean adjust_outliers)
```
    工厂方法，创建 AdaptiveManifoldFilter 实例并执行一些初始化例程。
    
    参数
    
    sigma_s - 空间标准差。
    
    sigma_r - 颜色空间标准差，类似于 bilateralFilter 中颜色空间中的 sigma。
    
    adjust_outliers - 可选，指定是否执行离群值调整操作，即原始论文中的（公式 9）。有关自适应流形滤波器参数的更多详细信息，请参见原始文章 CITE: Gastal12。注意：深度为 CV_8U 和 CV_16U 的联合图像在处理前会转换为深度为 CV_32F 且颜色范围为 [0; 1] 的图像。因此，颜色空间 sigma sigma_r 必须在 [0; 1] 范围内，这与 bilateralFilter 和 dtFilter 函数中的 sigma 不同。
    
    返回
    
    自动生成
  - createAMFilter
```
public static AdaptiveManifoldFilter createAMFilter(double sigma_s,
                                                    double sigma_r)
```
    工厂方法，创建 AdaptiveManifoldFilter 实例并执行一些初始化例程。
    
    参数
    
    sigma_s - 空间标准差。
    
    sigma_r - 颜色空间标准差，类似于 bilateralFilter 中颜色空间中的 sigma。原始论文。有关自适应流形滤波器参数的更多详细信息，请参见原始文章 CITE: Gastal12。注意：深度为 CV_8U 和 CV_16U 的联合图像在处理前会转换为深度为 CV_32F 且颜色范围为 [0; 1] 的图像。因此，颜色空间 sigma sigma_r 必须在 [0; 1] 范围内，这与 bilateralFilter 和 dtFilter 函数中的 sigma 不同。
    
    返回
    
    自动生成
  - amFilter
```
public static void amFilter(Mat joint,
                            Mat src,
                            Mat dst,
                            double sigma_s,
                            double sigma_r,
                            boolean adjust_outliers)
```
    简单的单行自适应流形滤波器调用。
    
    参数
    
    joint - 联合（也称为引导）图像或任意数量通道的图像数组。
    
    src - 具有任意数量通道的过滤图像。
    
    dst - 输出图像。
    
    sigma_s - 空间标准差。
    
    sigma_r - 颜色空间标准差，类似于 bilateralFilter 中颜色空间中的 sigma。
    
    adjust_outliers - 可选，指定是否执行离群值调整操作，即原始论文中的（公式 9）。注意：深度为 CV_8U 和 CV_16U 的联合图像在处理前会转换为深度为 CV_32F 且颜色范围为 [0; 1] 的图像。因此，颜色空间 sigma sigma_r 必须在 [0; 1] 范围内，这与 bilateralFilter 和 dtFilter 函数中的 sigma 不同。SEE: bilateralFilter, dtFilter, guidedFilter
  - amFilter
```
public static void amFilter(Mat joint,
                            Mat src,
                            Mat dst,
                            double sigma_s,
                            double sigma_r)
```
    简单的单行自适应流形滤波器调用。
    
    参数
    
    joint - 联合（也称为引导）图像或任意数量通道的图像数组。
    
    src - 具有任意数量通道的过滤图像。
    
    dst - 输出图像。
    
    sigma_s - 空间标准差。
    
    sigma_r - 颜色空间标准差，类似于 bilateralFilter 中颜色空间中的 sigma。原始论文。注意：深度为 CV_8U 和 CV_16U 的联合图像在处理前会转换为深度为 CV_32F 且颜色范围为 [0; 1] 的图像。因此，颜色空间 sigma sigma_r 必须在 [0; 1] 范围内，这与 bilateralFilter 和 dtFilter 函数中的 sigma 不同。SEE: bilateralFilter, dtFilter, guidedFilter
  - jointBilateralFilter
```
public static void jointBilateralFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int d,
                                        double sigmaColor,
                                        double sigmaSpace,
                                        int borderType)
```
    将联合双边滤波器应用于图像。
    
    参数
    
    joint - 联合 8 位或浮点，1 通道或 3 通道图像。
    
    src - 源 8 位或浮点，1 通道或 3 通道图像，与联合图像具有相同的深度。
    
    dst - 与源图像大小和类型相同的目标图像。
    
    d - 过滤期间使用的每个像素邻域的直径。如果为非正值，则根据 sigmaSpace 计算。
    
    sigmaColor - 颜色空间中的滤波器 sigma。参数值越大意味着像素邻域（参见 sigmaSpace）内颜色相距越远的像素也将混合在一起，从而产生更大的半均匀颜色区域。
    
    sigmaSpace - 坐标空间中的滤波器 sigma。参数值越大意味着只要颜色足够接近（参见 sigmaColor），距离较远的像素也会相互影响。当 d>0 时，它指定邻域大小，而与 sigmaSpace 无关。否则，d 与 sigmaSpace 成比例。
    
    borderType - 注意： bilateralFilter 和 jointBilateralFilter 使用 L1 范数计算颜色之间的差异。SEE: bilateralFilter, amFilter
  - jointBilateralFilter
```
public static void jointBilateralFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int d,
                                        double sigmaColor,
                                        double sigmaSpace)
```
    将联合双边滤波器应用于图像。
    
    参数
    
    joint - 联合 8 位或浮点，1 通道或 3 通道图像。
    
    src - 源 8 位或浮点，1 通道或 3 通道图像，与联合图像具有相同的深度。
    
    dst - 与源图像大小和类型相同的目标图像。
    
    d - 过滤期间使用的每个像素邻域的直径。如果为非正值，则根据 sigmaSpace 计算。
    
    sigmaColor - 颜色空间中的滤波器 sigma。参数值越大意味着像素邻域（参见 sigmaSpace）内颜色相距越远的像素也将混合在一起，从而产生更大的半均匀颜色区域。
    
    sigmaSpace - 坐标空间中的滤波器sigma。该参数值越大，意味着只要像素颜色足够接近（参见sigmaColor），距离更远的像素也会相互影响。当d>0时，它指定了邻域大小，而与sigmaSpace无关。否则，d与sigmaSpace成比例。注意：bilateralFilter和jointBilateralFilter使用L1范数来计算颜色差异。参见：bilateralFilter, amFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst,
                                          int fr,
                                          int numIter,
                                          double sigmaAlpha,
                                          double sigmaAvg)
```
    将双边纹理滤波器应用于图像。它执行结构保留纹理滤波。有关此滤波器的更多详细信息，请参见CITE: Cho2014。
    
    参数
    
    src - 源图像，其深度为8位无符号整型（UINT）或32位浮点型（FLOAT）
    
    dst - 与源图像大小和类型相同的目标图像。
    
    fr - 用于滤波的核半径。它应该是一个正整数
    
    numIter - 算法的迭代次数。它应该是一个正整数
    
    sigmaAlpha - 控制从边缘到平滑/纹理区域的权重过渡的锐度，值越大表示过渡越锐利。当值为负时，将自动计算。
    
    sigmaAvg - 用于纹理模糊的范围模糊参数。值越大，结果越模糊。当值为负时，将按照论文中的描述自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst,
                                          int fr,
                                          int numIter,
                                          double sigmaAlpha)
```
    将双边纹理滤波器应用于图像。它执行结构保留纹理滤波。有关此滤波器的更多详细信息，请参见CITE: Cho2014。
    
    参数
    
    src - 源图像，其深度为8位无符号整型（UINT）或32位浮点型（FLOAT）
    
    dst - 与源图像大小和类型相同的目标图像。
    
    fr - 用于滤波的核半径。它应该是一个正整数
    
    numIter - 算法的迭代次数。它应该是一个正整数
    
    sigmaAlpha - 控制从边缘到平滑/纹理区域的权重过渡的锐度，值越大表示过渡越锐利。当值为负时，将自动计算。当值为负时，将按照论文中的描述自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst,
                                          int fr,
                                          int numIter)
```
    将双边纹理滤波器应用于图像。它执行结构保留纹理滤波。有关此滤波器的更多详细信息，请参见CITE: Cho2014。
    
    参数
    
    src - 源图像，其深度为8位无符号整型（UINT）或32位浮点型（FLOAT）
    
    dst - 与源图像大小和类型相同的目标图像。
    
    fr - 用于滤波的核半径。它应该是一个正整数
    
    numIter - 算法的迭代次数，它应该是一个正整数，值越大表示过渡越锐利。当值为负时，将自动计算。当值为负时，将按照论文中的描述自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst,
                                          int fr)
```
    将双边纹理滤波器应用于图像。它执行结构保留纹理滤波。有关此滤波器的更多详细信息，请参见CITE: Cho2014。
    
    参数
    
    src - 源图像，其深度为8位无符号整型（UINT）或32位浮点型（FLOAT）
    
    dst - 与源图像大小和类型相同的目标图像。
    
    fr - 用于滤波的核半径。它应该是一个正整数，值越大表示过渡越锐利。当值为负时，将自动计算。当值为负时，将按照论文中的描述自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst)
```
    将双边纹理滤波器应用于图像。它执行结构保留纹理滤波。有关此滤波器的更多详细信息，请参见CITE: Cho2014。
    
    参数
    
    src - 源图像，其深度为8位无符号整型（UINT）或32位浮点型（FLOAT）
    
    dst - 目标图像，与源图像大小和类型相同。值越大表示过渡越锐利。当值为负时，将自动计算。当值为负时，将按照论文中的描述自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst,
                                         int d,
                                         double sigmaColor,
                                         double sigmaSpace,
                                         int numOfIter,
                                         int borderType)
```
    将滚动引导滤波器应用于图像。更多详情，请参见CITE: zhang2014rolling
    
    参数
    
    src - 源8位或浮点，1通道或3通道图像。
    
    dst - 与源图像大小和类型相同的目标图像。
    
    d - 过滤期间使用的每个像素邻域的直径。如果为非正值，则根据 sigmaSpace 计算。
    
    sigmaColor - 颜色空间中的滤波器 sigma。参数值越大意味着像素邻域（参见 sigmaSpace）内颜色相距越远的像素也将混合在一起，从而产生更大的半均匀颜色区域。
    
    sigmaSpace - 坐标空间中的滤波器 sigma。参数值越大意味着只要颜色足够接近（参见 sigmaColor），距离较远的像素也会相互影响。当 d>0 时，它指定邻域大小，而与 sigmaSpace 无关。否则，d 与 sigmaSpace 成比例。
    
    numOfIter - 应用于源图像的联合边缘保留滤波的迭代次数。
    
    borderType - 注意：rollingGuidanceFilter使用jointBilateralFilter作为边缘保留滤波器。参见：jointBilateralFilter, bilateralFilter, amFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst,
                                         int d,
                                         double sigmaColor,
                                         double sigmaSpace,
                                         int numOfIter)
```
    将滚动引导滤波器应用于图像。更多详情，请参见CITE: zhang2014rolling
    
    参数
    
    src - 源8位或浮点，1通道或3通道图像。
    
    dst - 与源图像大小和类型相同的目标图像。
    
    d - 过滤期间使用的每个像素邻域的直径。如果为非正值，则根据 sigmaSpace 计算。
    
    sigmaColor - 颜色空间中的滤波器 sigma。参数值越大意味着像素邻域（参见 sigmaSpace）内颜色相距越远的像素也将混合在一起，从而产生更大的半均匀颜色区域。
    
    sigmaSpace - 坐标空间中的滤波器 sigma。参数值越大意味着只要颜色足够接近（参见 sigmaColor），距离较远的像素也会相互影响。当 d>0 时，它指定邻域大小，而与 sigmaSpace 无关。否则，d 与 sigmaSpace 成比例。
    
    numOfIter - 应用于源图像的联合边缘保留滤波的迭代次数。注意：rollingGuidanceFilter使用jointBilateralFilter作为边缘保留滤波器。参见：jointBilateralFilter, bilateralFilter, amFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst,
                                         int d,
                                         double sigmaColor,
                                         double sigmaSpace)
```
    将滚动引导滤波器应用于图像。更多详情，请参见CITE: zhang2014rolling
    
    参数
    
    src - 源8位或浮点，1通道或3通道图像。
    
    dst - 与源图像大小和类型相同的目标图像。
    
    d - 过滤期间使用的每个像素邻域的直径。如果为非正值，则根据 sigmaSpace 计算。
    
    sigmaColor - 颜色空间中的滤波器 sigma。参数值越大意味着像素邻域（参见 sigmaSpace）内颜色相距越远的像素也将混合在一起，从而产生更大的半均匀颜色区域。
    
    sigmaSpace - 坐标空间中的滤波器sigma。该参数值越大，意味着只要像素颜色足够接近（参见sigmaColor），距离更远的像素也会相互影响。当d>0时，它指定了邻域大小，而与sigmaSpace无关。否则，d与sigmaSpace成比例。注意：rollingGuidanceFilter使用jointBilateralFilter作为边缘保留滤波器。参见：jointBilateralFilter, bilateralFilter, amFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst,
                                         int d,
                                         double sigmaColor)
```
    将滚动引导滤波器应用于图像。更多详情，请参见CITE: zhang2014rolling
    
    参数
    
    src - 源8位或浮点，1通道或3通道图像。
    
    dst - 与源图像大小和类型相同的目标图像。
    
    d - 过滤期间使用的每个像素邻域的直径。如果为非正值，则根据 sigmaSpace 计算。
    
    sigmaColor - 颜色空间中的滤波器sigma。该参数值越大，意味着像素邻域内（参见sigmaSpace）距离更远的颜色会混合在一起，从而产生更大的半相等颜色区域。只要像素颜色足够接近（参见sigmaColor），距离更远的像素也会相互影响。当d>0时，它指定了邻域大小，而与sigmaSpace无关。否则，d与sigmaSpace成比例。注意：rollingGuidanceFilter使用jointBilateralFilter作为边缘保留滤波器。参见：jointBilateralFilter, bilateralFilter, amFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst,
                                         int d)
```
    将滚动引导滤波器应用于图像。更多详情，请参见CITE: zhang2014rolling
    
    参数
    
    src - 源8位或浮点，1通道或3通道图像。
    
    dst - 与源图像大小和类型相同的目标图像。
    
    d - 滤波期间使用的每个像素邻域的直径。如果它非正，则从sigmaSpace计算。像素邻域内（参见sigmaSpace）距离更远的颜色会混合在一起，从而产生更大的半相等颜色区域。只要像素颜色足够接近（参见sigmaColor），距离更远的像素也会相互影响。当d>0时，它指定了邻域大小，而与sigmaSpace无关。否则，d与sigmaSpace成比例。注意：rollingGuidanceFilter使用jointBilateralFilter作为边缘保留滤波器。参见：jointBilateralFilter, bilateralFilter, amFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst)
```
    将滚动引导滤波器应用于图像。更多详情，请参见CITE: zhang2014rolling
    
    参数
    
    src - 源8位或浮点，1通道或3通道图像。
    
    dst - 目标图像，与源图像大小和类型相同。它从sigmaSpace计算。像素邻域内（参见sigmaSpace）距离更远的颜色会混合在一起，从而产生更大的半相等颜色区域。只要像素颜色足够接近（参见sigmaColor），距离更远的像素也会相互影响。当d>0时，它指定了邻域大小，而与sigmaSpace无关。否则，d与sigmaSpace成比例。注意：rollingGuidanceFilter使用jointBilateralFilter作为边缘保留滤波器。参见：jointBilateralFilter, bilateralFilter, amFilter
  - createFastBilateralSolverFilter
```
public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma,
                                                                        double lambda,
                                                                        int num_iter,
                                                                        double max_tol)
```
    工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化例程。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    sigma_spatial - 参数，类似于bilateralFilter中的空间sigma（带宽）。
    
    sigma_luma - 参数，类似于bilateralFilter中的亮度空间sigma（带宽）。
    
    sigma_chroma - 参数，类似于bilateralFilter中的色度空间sigma（带宽）。
    
    lambda - 求解器的平滑强度参数。
    
    num_iter - 求解器使用的迭代次数，通常25次就足够了。
    
    max_tol - 求解器使用的收敛容差。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。
    
    返回
    
    自动生成
  - createFastBilateralSolverFilter
```
public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma,
                                                                        double lambda,
                                                                        int num_iter)
```
    工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化例程。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    sigma_spatial - 参数，类似于bilateralFilter中的空间sigma（带宽）。
    
    sigma_luma - 参数，类似于bilateralFilter中的亮度空间sigma（带宽）。
    
    sigma_chroma - 参数，类似于bilateralFilter中的色度空间sigma（带宽）。
    
    lambda - 求解器的平滑强度参数。
    
    num_iter - 求解器使用的迭代次数，通常25次就足够了。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。
    
    返回
    
    自动生成
  - createFastBilateralSolverFilter
```
public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma,
                                                                        double lambda)
```
    工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化例程。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    sigma_spatial - 参数，类似于bilateralFilter中的空间sigma（带宽）。
    
    sigma_luma - 参数，类似于bilateralFilter中的亮度空间sigma（带宽）。
    
    sigma_chroma - 参数，类似于bilateralFilter中的色度空间sigma（带宽）。
    
    lambda - 求解器的平滑强度参数。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。
    
    返回
    
    自动生成
  - createFastBilateralSolverFilter
```
public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma)
```
    工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化例程。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    sigma_spatial - 参数，类似于bilateralFilter中的空间sigma（带宽）。
    
    sigma_luma - 参数，类似于bilateralFilter中的亮度空间sigma（带宽）。
    
    sigma_chroma - 参数，类似于bilateralFilter中的色度空间sigma（带宽）。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。
    
    返回
    
    自动生成
  - fastBilateralSolverFilter
```
public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma,
                                             double sigma_chroma,
                                             double lambda,
                                             int num_iter,
                                             double max_tol)
```
    简单的单行快速双边求解器滤波器调用。如果您有多个图像需要使用相同的引导图像进行滤波，那么请使用FastBilateralSolverFilter接口以避免额外的计算。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或32位浮点型，最多4通道。
    
    confidence - 置信度图像，其置信度为无符号8位或32位浮点型，且为1通道。
    
    dst - 目标图像。
    
    sigma_spatial - 参数，类似于bilateralFilter中的空间sigma（带宽）。
    
    sigma_luma - 参数，类似于bilateralFilter中的亮度空间sigma（带宽）。
    
    sigma_chroma - 参数，类似于bilateralFilter中的色度空间sigma（带宽）。
    
    lambda - 求解器的平滑强度参数。
    
    num_iter - 求解器使用的迭代次数，通常25次就足够了。
    
    max_tol - 求解器使用的收敛容差。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。注意：深度为CV_8U的置信度图像应在[0, 255]范围内，而CV_32F应在[0, 1]范围内。
  - fastBilateralSolverFilter
```
public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma,
                                             double sigma_chroma,
                                             double lambda,
                                             int num_iter)
```
    简单的单行快速双边求解器滤波器调用。如果您有多个图像需要使用相同的引导图像进行滤波，那么请使用FastBilateralSolverFilter接口以避免额外的计算。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或32位浮点型，最多4通道。
    
    confidence - 置信度图像，其置信度为无符号8位或32位浮点型，且为1通道。
    
    dst - 目标图像。
    
    sigma_spatial - 参数，类似于bilateralFilter中的空间sigma（带宽）。
    
    sigma_luma - 参数，类似于bilateralFilter中的亮度空间sigma（带宽）。
    
    sigma_chroma - 参数，类似于bilateralFilter中的色度空间sigma（带宽）。
    
    lambda - 求解器的平滑强度参数。
    
    num_iter - 求解器使用的迭代次数，通常25次就足够了。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。注意：深度为CV_8U的置信度图像应在[0, 255]范围内，而CV_32F应在[0, 1]范围内。
  - fastBilateralSolverFilter
```
public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma,
                                             double sigma_chroma,
                                             double lambda)
```
    简单的单行快速双边求解器滤波器调用。如果您有多个图像需要使用相同的引导图像进行滤波，那么请使用FastBilateralSolverFilter接口以避免额外的计算。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或32位浮点型，最多4通道。
    
    confidence - 置信度图像，其置信度为无符号8位或32位浮点型，且为1通道。
    
    dst - 目标图像。
    
    sigma_spatial - 参数，类似于bilateralFilter中的空间sigma（带宽）。
    
    sigma_luma - 参数，类似于bilateralFilter中的亮度空间sigma（带宽）。
    
    sigma_chroma - 参数，类似于bilateralFilter中的色度空间sigma（带宽）。
    
    lambda - 求解器的平滑强度参数。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。注意：深度为CV_8U的置信度图像应在[0, 255]范围内，而CV_32F应在[0, 1]范围内。
  - fastBilateralSolverFilter
```
public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma,
                                             double sigma_chroma)
```
    简单的单行快速双边求解器滤波器调用。如果您有多个图像需要使用相同的引导图像进行滤波，那么请使用FastBilateralSolverFilter接口以避免额外的计算。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或32位浮点型，最多4通道。
    
    confidence - 置信度图像，其置信度为无符号8位或32位浮点型，且为1通道。
    
    dst - 目标图像。
    
    sigma_spatial - 参数，类似于bilateralFilter中的空间sigma（带宽）。
    
    sigma_luma - 参数，类似于bilateralFilter中的亮度空间sigma（带宽）。
    
    sigma_chroma - 参数，类似于bilateralFilter中的色度空间sigma（带宽）。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。注意：深度为CV_8U的置信度图像应在[0, 255]范围内，而CV_32F应在[0, 1]范围内。
  - fastBilateralSolverFilter
```
public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma)
```
    简单的单行快速双边求解器滤波器调用。如果您有多个图像需要使用相同的引导图像进行滤波，那么请使用FastBilateralSolverFilter接口以避免额外的计算。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或32位浮点型，最多4通道。
    
    confidence - 置信度图像，其置信度为无符号8位或32位浮点型，且为1通道。
    
    dst - 目标图像。
    
    sigma_spatial - 参数，类似于bilateralFilter中的空间sigma（带宽）。
    
    sigma_luma - 参数，类似于bilateralFilter中的亮度空间sigma（带宽）。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。注意：深度为CV_8U的置信度图像应在[0, 255]范围内，而CV_32F应在[0, 1]范围内。
  - fastBilateralSolverFilter
```
public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial)
```
    简单的单行快速双边求解器滤波器调用。如果您有多个图像需要使用相同的引导图像进行滤波，那么请使用FastBilateralSolverFilter接口以避免额外的计算。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或32位浮点型，最多4通道。
    
    confidence - 置信度图像，其置信度为无符号8位或32位浮点型，且为1通道。
    
    dst - 目标图像。
    
    sigma_spatial - 参数，类似于bilateralFilter中的空间sigma（带宽）。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。注意：深度为CV_8U的置信度图像应在[0, 255]范围内，而CV_32F应在[0, 1]范围内。
  - fastBilateralSolverFilter
```
public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst)
```
    简单的单行快速双边求解器滤波器调用。如果您有多个图像需要使用相同的引导图像进行滤波，那么请使用FastBilateralSolverFilter接口以避免额外的计算。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或32位浮点型，最多4通道。
    
    confidence - 置信度图像，其置信度为无符号8位或32位浮点型，且为1通道。
    
    dst - 目标图像。有关快速双边求解器参数的更多详细信息，请参见原始论文CITE: BarronPoole2016。注意：深度为CV_8U的置信度图像应在[0, 255]范围内，而CV_32F应在[0, 1]范围内。
  - createFastGlobalSmootherFilter
```
public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(Mat guide,
                                                                      double lambda,
                                                                      double sigma_color,
                                                                      double lambda_attenuation,
                                                                      int num_iter)
```
    工厂方法，创建 FastGlobalSmootherFilter 实例并执行初始化例程。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    lambda - 定义正则化量的参数
    
    sigma_color - 参数，类似于bilateralFilter中的颜色空间sigma。
    
    lambda_attenuation - 内部参数，定义每次迭代后lambda减少的量。通常，它应该是0.25。将其设置为1.0可能会导致条纹伪影。
    
    num_iter - 用于滤波的迭代次数，通常3次就足够了。有关快速全局平滑器参数的更多详细信息，请参见原始论文CITE: Min2014。但是，请注意存在一些差异。论文中描述的Lambda衰减实现方式略有不同，因此不要期望结果与论文中的结果完全相同；论文中的sigma_color值应乘以255.0才能达到相同的效果。此外，在源图像和引导图像相同的情况下进行图像滤波时，作者建议在每次迭代后动态更新引导图像。为了最大限度地提高性能，此处未实现此功能。
    
    返回
    
    自动生成
  - createFastGlobalSmootherFilter
```
public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(Mat guide,
                                                                      double lambda,
                                                                      double sigma_color,
                                                                      double lambda_attenuation)
```
    工厂方法，创建 FastGlobalSmootherFilter 实例并执行初始化例程。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    lambda - 定义正则化量的参数
    
    sigma_color - 参数，类似于bilateralFilter中的颜色空间sigma。
    
    lambda_attenuation - 内部参数，定义每次迭代后lambda减少的量。通常，它应该是0.25。将其设置为1.0可能会导致条纹伪影。有关快速全局平滑器参数的更多详细信息，请参见原始论文CITE: Min2014。但是，请注意存在一些差异。论文中描述的Lambda衰减实现方式略有不同，因此不要期望结果与论文中的结果完全相同；论文中的sigma_color值应乘以255.0才能达到相同的效果。此外，在源图像和引导图像相同的情况下进行图像滤波时，作者建议在每次迭代后动态更新引导图像。为了最大限度地提高性能，此处未实现此功能。
    
    返回
    
    自动生成
  - createFastGlobalSmootherFilter
```
public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(Mat guide,
                                                                      double lambda,
                                                                      double sigma_color)
```
    工厂方法，创建 FastGlobalSmootherFilter 实例并执行初始化例程。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    lambda - 定义正则化量的参数
    
    sigma_color - 参数，类似于bilateralFilter中的颜色空间sigma。它应该是0.25。将其设置为1.0可能会导致条纹伪影。有关快速全局平滑器参数的更多详细信息，请参见原始论文CITE: Min2014。但是，请注意存在一些差异。论文中描述的Lambda衰减实现方式略有不同，因此不要期望结果与论文中的结果完全相同；论文中的sigma_color值应乘以255.0才能达到相同的效果。此外，在源图像和引导图像相同的情况下进行图像滤波时，作者建议在每次迭代后动态更新引导图像。为了最大限度地提高性能，此处未实现此功能。
    
    返回
    
    自动生成
  - fastGlobalSmootherFilter
```
public static void fastGlobalSmootherFilter(Mat guide,
                                            Mat src,
                                            Mat dst,
                                            double lambda,
                                            double sigma_color,
                                            double lambda_attenuation,
                                            int num_iter)
```
    简单的单行快速全局平滑器滤波器调用。如果您有多个图像需要使用相同的引导图像进行滤波，那么请使用FastGlobalSmootherFilter接口以避免额外的计算。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或32位浮点型，最多4通道。
    
    dst - 目标图像。
    
    lambda - 定义正则化量的参数
    
    sigma_color - 参数，类似于bilateralFilter中的颜色空间sigma。
    
    lambda_attenuation - 内部参数，定义每次迭代后lambda减少的量。通常，它应该是0.25。将其设置为1.0可能会导致条纹伪影。
    
    num_iter - 用于滤波的迭代次数，通常3次就足够了。
  - fastGlobalSmootherFilter
```
public static void fastGlobalSmootherFilter(Mat guide,
                                            Mat src,
                                            Mat dst,
                                            double lambda,
                                            double sigma_color,
                                            double lambda_attenuation)
```
    简单的单行快速全局平滑器滤波器调用。如果您有多个图像需要使用相同的引导图像进行滤波，那么请使用FastGlobalSmootherFilter接口以避免额外的计算。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或32位浮点型，最多4通道。
    
    dst - 目标图像。
    
    lambda - 定义正则化量的参数
    
    sigma_color - 参数，类似于bilateralFilter中的颜色空间sigma。
    
    lambda_attenuation - 内部参数，定义每次迭代后lambda减少的量。通常，它应该是0.25。将其设置为1.0可能会导致条纹伪影。
  - fastGlobalSmootherFilter
```
public static void fastGlobalSmootherFilter(Mat guide,
                                            Mat src,
                                            Mat dst,
                                            double lambda,
                                            double sigma_color)
```
    简单的单行快速全局平滑器滤波器调用。如果您有多个图像需要使用相同的引导图像进行滤波，那么请使用FastGlobalSmootherFilter接口以避免额外的计算。
    
    参数
    
    guide - 用作滤波引导的图像。它应该具有8位深度，并且是1通道或3通道。
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或32位浮点型，最多4通道。
    
    dst - 目标图像。
    
    lambda - 定义正则化量的参数
    
    sigma_color - 参数，类似于bilateralFilter中的颜色空间sigma。它应该是0.25。将其设置为1.0可能会导致条纹伪影。
  - l0Smooth
```
public static void l0Smooth(Mat src,
                            Mat dst,
                            double lambda,
                            double kappa)
```
    通过 L0 梯度最小化进行全局图像平滑。
    
    参数
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或浮点型。
    
    dst - 目标图像。
    
    lambda - 定义平滑项权重的参数。
    
    kappa - 定义梯度数据项权重增加因子的参数。有关L0平滑器的更多详细信息，请参见原始论文CITE: xu2011image。
  - l0Smooth
```
public static void l0Smooth(Mat src,
                            Mat dst,
                            double lambda)
```
    通过 L0 梯度最小化进行全局图像平滑。
    
    参数
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或浮点型。
    
    dst - 目标图像。
    
    lambda - 定义平滑项权重的参数。有关L0平滑器的更多详细信息，请参见原始论文CITE: xu2011image。
  - l0Smooth
```
public static void l0Smooth(Mat src,
                            Mat dst)
```
    通过 L0 梯度最小化进行全局图像平滑。
    
    参数
    
    src - 用于滤波的源图像，深度为无符号8位、有符号16位或浮点型。
    
    dst - 目标图像。有关L0平滑器的更多详细信息，请参见原始论文CITE: xu2011image。

类 Ximgproc

字段摘要

构造函数摘要

方法摘要

从类继承的方法 java.lang.Object

字段详细信息

ARO_0_45

ARO_45_90

ARO_90_135

ARO_315_0

ARO_315_45

ARO_45_135

ARO_315_135

ARO_CTR_HOR

ARO_CTR_VER

DTF_NC

DTF_IC

DTF_RF

GUIDED_FILTER

AM_FILTER

HDO_RAW

HDO_DESKEW

FHT_MIN

FHT_MAX

FHT_ADD

FHT_AVE

BINARIZATION_NIBLACK

BINARIZATION_SAUVOLA

BINARIZATION_WOLF

BINARIZATION_NICK

SLIC

SLICO

MSLIC

THINNING_ZHANGSUEN

THINNING_GUOHALL

WMF_EXP

WMF_IV1

WMF_IV2

WMF_COS

WMF_JAC

WMF_OFF

构造函数详细信息

Ximgproc

方法详细信息

niBlackThreshold

niBlackThreshold

niBlackThreshold

thinning

thinning

anisotropicDiffusion

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createSuperpixelSLIC

createSuperpixelSLIC

createSuperpixelSLIC

createSuperpixelSLIC

FastHoughTransform

FastHoughTransform

FastHoughTransform

FastHoughTransform

fourierDescriptor

fourierDescriptor

fourierDescriptor

transformFD

transformFD

contourSampling

createContourFitting

createContourFitting

createContourFitting