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)`	将彩色模板与重叠的彩色图像区域进行比较。
`static double`	`computeBadPixelPercent(Mat GT, Mat src, Rect ROI)`	用于计算视差图中“不良”像素百分比的函数（像素误差高于指定阈值）。
`static double`	`computeBadPixelPercent(Mat GT, Mat src, Rect ROI, int thresh)`	用于计算视差图中“不良”像素百分比的函数（像素误差高于指定阈值）。
`static double`	`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`	`createEdgeAwareInterpolator()`	工厂方法，创建一个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`	`createEdgeDrawing()`	创建一个指向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)`	创建一个基于图的分割器。
`静态 GuidedFilter`	`createGuidedFilter(Mat guide, int radius, double eps)`	工厂方法，创建 GuidedFilter 实例并执行初始化例程。
`静态 GuidedFilter`	`createGuidedFilter(Mat guide, int radius, double eps, double scale)`	工厂方法，创建 GuidedFilter 实例并执行初始化例程。
`static void`	`createQuaternionImage(Mat img, Mat qimg)`	创建四元数图像。
`静态 RFFeatureGetter`	`createRFFeatureGetter()`
`静态 RICInterpolator`	`createRICInterpolator()`	创建 RICInterpolator 实例的工厂方法。
`静态 StereoMatcher`	`createRightMatcher(StereoMatcher matcher_left)`	便捷方法，用于设置匹配器，以计算在需要置信度过滤的情况下所需的右视图视差图。
`静态 ScanSegment`	`createScanSegment(int image_width, int image_height, int num_superpixels)`	初始化 ScanSegment 对象。
`静态 ScanSegment`	`createScanSegment(int image_width, int image_height, int num_superpixels, int slices)`	初始化 ScanSegment 对象。
`静态 ScanSegment`	`createScanSegment(int image_width, int image_height, int num_superpixels, int slices, boolean merge_small)`	初始化 ScanSegment 对象。
`静态 SelectiveSearchSegmentation`	`createSelectiveSearchSegmentation()`	创建一个新的 SelectiveSearchSegmentation 类。
`静态 SelectiveSearchSegmentationStrategyColor`	`createSelectiveSearchSegmentationStrategyColor()`	创建一个新的基于颜色的策略
`静态 SelectiveSearchSegmentationStrategyFill`	`createSelectiveSearchSegmentationStrategyFill()`	创建一个新的基于填充的策略
`静态 SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple()`	创建一个新的多策略
`静态 SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1)`	创建一个新的多策略并设置一个子策略
`静态 SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2)`	创建一个新的多策略并设置两个子策略，权重相等
`静态 SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2, SelectiveSearchSegmentationStrategy s3)`	创建一个新的多策略并设置三个子策略，权重相等
`静态 SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2, SelectiveSearchSegmentationStrategy s3, SelectiveSearchSegmentationStrategy s4)`	创建一个新的多策略并设置四个子策略，权重相等
`静态 SelectiveSearchSegmentationStrategySize`	`createSelectiveSearchSegmentationStrategySize()`	创建一个新的基于大小的策略
`静态 SelectiveSearchSegmentationStrategyTexture`	`createSelectiveSearchSegmentationStrategyTexture()`	创建一个新的基于大小的策略
`静态 StructuredEdgeDetection`	`createStructuredEdgeDetection(java.lang.String model)`
`静态 StructuredEdgeDetection`	`createStructuredEdgeDetection(java.lang.String model, RFFeatureGetter howToGetFeatures)`
`静态 SuperpixelLSC`	`createSuperpixelLSC(Mat image)`	实现 LSC（线性谱聚类）超像素的类
`静态 SuperpixelLSC`	`createSuperpixelLSC(Mat image, int region_size)`	实现 LSC（线性谱聚类）超像素的类
`静态 SuperpixelLSC`	`createSuperpixelLSC(Mat image, int region_size, float ratio)`	实现 LSC（线性谱聚类）超像素的类
`静态 SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels)`	初始化 SuperpixelSEEDS 对象。
`静态 SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior)`	初始化 SuperpixelSEEDS 对象。
`静态 SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior, int histogram_bins)`	初始化 SuperpixelSEEDS 对象。
`静态 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 对象。
`静态 SuperpixelSLIC`	`createSuperpixelSLIC(Mat image)`	初始化 SuperpixelSLIC 对象
`静态 SuperpixelSLIC`	`createSuperpixelSLIC(Mat image, int algorithm)`	初始化 SuperpixelSLIC 对象
`静态 SuperpixelSLIC`	`createSuperpixelSLIC(Mat image, int algorithm, int region_size)`	初始化 SuperpixelSLIC 对象
`静态 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)`	计算图像的二维快速霍夫变换。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange)`	计算图像的二维快速霍夫变换。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op)`	计算图像的二维快速霍夫变换。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op, int makeSkew)`	计算图像的二维快速霍夫变换。
`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方法，它是均值减去$ k $ 倍的$\texttt{blockSize} \times\texttt{blockSize}$ 邻域的标准差$(x, y)$。该函数无法就地处理图像。
    参数
    
    _src - 源8位单通道图像。
    
    _dst - 与src大小和类型相同的目标图像。
    
    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技术使用的用户可调整参数。这是标准偏差的动态范围。参见：阈值，自适应阈值
  - 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方法，它是均值减去$ k $ 倍的$\texttt{blockSize} \times\texttt{blockSize}$ 邻域的标准差$(x, y)$。该函数无法就地处理图像。
    参数
    
    _src - 源8位单通道图像。
    
    _dst - 与src大小和类型相同的目标图像。
    
    maxValue - 为满足条件的像素分配的非零值，与THRESH_BINARY和THRESH_BINARY_INV阈值类型一起使用。
    
    type - 阈值类型，参见cv::ThresholdTypes。
    
    blockSize - 用于计算像素阈值的像素邻域大小：3、5、7等。
    
    k - Niblack和受其启发的技术使用的用户可调整参数。对于Niblack，这通常是0到1之间的值，乘以标准差并从均值中减去。
    
    binarizationMethod - 要使用的二值化方法。默认情况下，使用Niblack技术。可以指定其他技术，参见cv::ximgproc::LocalBinarizationMethods。标准差的动态范围。参见：阈值，自适应阈值
  - 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方法，它是均值减去$ k $ 倍的$\texttt{blockSize} \times\texttt{blockSize}$ 邻域的标准差$(x, y)$。该函数无法就地处理图像。
    参数
    
    _src - 源8位单通道图像。
    
    _dst - 与src大小和类型相同的目标图像。
    
    maxValue - 为满足条件的像素分配的非零值，与THRESH_BINARY和THRESH_BINARY_INV阈值类型一起使用。
    
    type - 阈值类型，参见cv::ThresholdTypes。
    
    blockSize - 用于计算像素阈值的像素邻域大小：3、5、7等。
    
    k - Niblack和受其启发的技术使用的用户可调整参数。对于Niblack，这通常是0到1之间的值，乘以标准差并从均值中减去。可以指定其他技术，参见cv::ximgproc::LocalBinarizationMethods。标准差的动态范围。参见：阈值，自适应阈值
  - thinning
```
public static void thinning(Mat src,
                            Mat dst,
                            int thinningType)
```
    应用二值斑点细化操作，以实现输入图像的细化。该函数使用Zhang-Suen技术将二值斑点图像转换为细化形式。
    
    参数
    
    src - 源8位单通道图像，包含二值斑点，斑点具有255像素值。
    
    dst - 与src大小和类型相同的目标图像。该函数可以就地工作。
    
    thinningType - 定义应使用哪个细化算法的值。参见cv::ximgproc::ThinningTypes
  - thinning
```
public static void thinning(Mat src,
                            Mat dst)
```
    应用二值斑点细化操作，以实现输入图像的细化。该函数使用Zhang-Suen技术将二值斑点图像转换为细化形式。
    
    参数
    
    src - 源8位单通道图像，包含二值斑点，斑点具有255像素值。
    
    dst - 与src大小和类型相同的目标图像。该函数可以就地工作。
  - 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 - 与src大小和通道数相同的目标图像。
    
    alpha - 每次迭代向前推进的时间量（通常在0到1之间）。
    
    K - 对边缘的敏感性
    
    niters - 迭代次数
  - 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 - 如果为真，将执行线段的增量合并
    
    返回值
    
    自动生成
  - 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()，并使用输入图像作为边缘图像。
    
    返回值
    
    自动生成
  - FastHoughTransform
```
public static void FastHoughTransform(Mat src,
                                      Mat dst,
                                      int dstMatDepth,
                                      int angleRange,
                                      int op,
                                      int makeSkew)
```
    计算图像的二维快速霍夫变换。该函数计算全角度范围、半角度范围或四分之一角度范围的快速霍夫变换。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    dstMatDepth - 自动生成
    
    angleRange - 自动生成
    
    op - 自动生成
    
    makeSkew - 自动生成
  - FastHoughTransform
```
public static void FastHoughTransform(Mat src,
                                      Mat dst,
                                      int dstMatDepth,
                                      int angleRange,
                                      int op)
```
    计算图像的二维快速霍夫变换。该函数计算全角度范围、半角度范围或四分之一角度范围的快速霍夫变换。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    dstMatDepth - 自动生成
    
    angleRange - 自动生成
    
    op - 自动生成
  - FastHoughTransform
```
public static void FastHoughTransform(Mat src,
                                      Mat dst,
                                      int dstMatDepth,
                                      int angleRange)
```
    计算图像的二维快速霍夫变换。该函数计算全角度范围、半角度范围或四分之一角度范围的快速霍夫变换。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    dstMatDepth - 自动生成
    
    angleRange - 自动生成
  - FastHoughTransform
```
public static void FastHoughTransform(Mat src,
                                      Mat dst,
                                      int dstMatDepth)
```
    计算图像的二维快速霍夫变换。该函数计算全角度范围、半角度范围或四分之一角度范围的快速霍夫变换。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    dstMatDepth - 自动生成
  - 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 类。
    
    返回值
    
    自动生成
  - weightedMedianFilter
```
public static void weightedMedianFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int r,
                                        double sigma,
                                        int weightType,
                                        Mat mask)
```
    将加权中值滤波器应用于图像。有关此实现的更多详细信息，请参见 CITE: zhang2014100+ 在维护联合直方图时，将忽略该像素。这对于光流遮挡处理等应用非常有用。参见：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+ 在维护联合直方图时，将忽略该像素。这对于光流遮挡处理等应用非常有用。参见：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+ 在维护联合直方图时，将忽略该像素。这对于光流遮挡处理等应用非常有用。参见：medianBlur、jointBilateralFilter
    
    参数
    
    joint - 自动生成
    
    src - 自动生成
    
    dst - 自动生成
    
    r - 自动生成
    
    sigma - 自动生成
  - weightedMedianFilter
```
public static void weightedMedianFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int r)
```
    将加权中值滤波器应用于图像。有关此实现的更多详细信息，请参见 CITE: zhang2014100+ 在维护联合直方图时，将忽略该像素。这对于光流遮挡处理等应用非常有用。参见：medianBlur、jointBilateralFilter
    
    参数
    
    joint - 自动生成
    
    src - 自动生成
    
    dst - 自动生成
    
    r - 自动生成
  - findEllipses
```
public static void findEllipses(Mat image,
                                Mat ellipses,
                                float scoreThreshold,
                                float reliabilityThreshold,
                                float centerDistanceThreshold)
```
    使用投影不变性剪枝快速查找图像中的椭圆。该函数使用投影不变性剪枝检测图像中的椭圆。有关此实现的更多详细信息，请参见 CITE: jia2017fast Jia, Qi et al, (2017). A Fast Ellipse Detector using Projective Invariant Pruning. 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 et al, (2017). A Fast Ellipse Detector using Projective Invariant Pruning. 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 et al, (2017). A Fast Ellipse Detector using Projective Invariant Pruning. 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 et al, (2017). A Fast Ellipse Detector using Projective Invariant Pruning. IEEE Transactions on Image Processing.
    
    参数
    
    image - 输入图像，可以是灰度图像或彩色图像。
    
    ellipses - 找到的椭圆的输出向量。每个向量都编码为五个浮点数：$x, y, a, b, radius, score$。
  - 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 - 直方图箱数。
    
    double_step - 如果为真，则为更高的精度迭代每个块级别两次。该函数为输入图像初始化一个 SuperpixelSEEDS 对象。它存储图像的参数：image_width、image_height 和 image_channels。它还设置 SEEDS 超像素算法的参数，这些参数包括：num_superpixels、num_levels、use_prior、histogram_bins 和 double_step。num_levels 中的级别数定义了算法在优化中使用的块级别数。初始化是一个网格，其中超像素均匀地分布在图像的宽度和高度上。较大的块对应于超像素大小，较小块的级别是通过将较大的块递归地分成 2 x 2 像素块来形成的，直到较小的块级别。下图显示了 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 - 直方图箱数。该函数为输入图像初始化一个 SuperpixelSEEDS 对象。它存储图像的参数：image_width、image_height 和 image_channels。它还设置 SEEDS 超像素算法的参数，这些参数包括：num_superpixels、num_levels、use_prior、histogram_bins 和 double_step。num_levels 中的级别数定义了算法在优化中使用的块级别数。初始化是一个网格，其中超像素均匀地分布在图像的宽度和高度上。较大的块对应于超像素大小，较小块的级别是通过将较大的块递归地分成 2 x 2 像素块来形成的，直到较小的块级别。下图显示了 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 中的级别数定义了算法在优化中使用的块级别数。初始化是一个网格，其中超像素均匀地分布在图像的宽度和高度上。较大的块对应于超像素大小，较小块的级别是通过将较大的块递归地分成 2 x 2 像素块来形成的，直到较小的块级别。下图显示了 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 中的级别数定义了算法在优化中使用的块级别数。初始化是一个网格，其中超像素均匀地分布在图像的宽度和高度上。较大的块对应于超像素大小，较小块的级别是通过将较大的块递归地分成 2 x 2 像素块来形成的，直到较小的块级别。下图显示了 4 个块级别的初始化示例。![image](pics/superpixels_blocks.png)
    
    返回值
    
    自动生成
  - 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。它为将来对给定图像进行计算迭代预分配一些缓冲区。为了获得更好的结果，建议对彩色图像使用小的 3 x 3 核进行少量高斯模糊预处理，并额外转换为 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。它为将来对给定图像进行计算迭代预分配一些缓冲区。为了获得更好的结果，建议对彩色图像使用小的 3 x 3 核进行少量高斯模糊预处理，并额外转换为 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。它为将来对给定图像进行计算迭代预分配一些缓冲区。为了获得更好的结果，建议对彩色图像使用小的 3 x 3 核进行少量高斯模糊预处理，并额外转换为 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。它为将来对给定图像进行计算迭代预分配一些缓冲区。为了获得更好的结果，建议对彩色图像使用小的 3 x 3 核进行少量高斯模糊预处理，并额外转换为 CieLAB 颜色空间。下图显示了 SLIC、SLICO 和 MSLIC 的示例。![image](pics/superpixels_slic.png)
    
    返回值
    
    自动生成
  - createRFFeatureGetter
```
public static RFFeatureGetter createRFFeatureGetter()
```
  - 创建结构化边缘检测器
```
public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model,
                                                                    RFFeatureGetter howToGetFeatures)
```
  - 创建结构化边缘检测器
```
public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model)
```
  - 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 - 自动生成
  - 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 - 自动生成
  - 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。
    
    返回值
    
    自动生成
  - 创建DT滤波器
```
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/)。
    
    返回值
    
    自动生成
  - 创建DT滤波器
```
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/)。
    
    返回值
    
    自动生成
  - 创建DT滤波器
```
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 次就足够了。参见：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 之一，对应于文章中过滤二维信号的三种模式。参见：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$参数，类似于双边滤波器中颜色空间的sigma值。对论文中的二维信号进行滤波。参见：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$类似于双边滤波器中颜色空间的sigma值。
    
    scale - 快速引导滤波器的下采样因子，使用小于1的scale值可以加快计算速度，几乎不会造成可见的降质。（例如，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$类似于双边滤波器中颜色空间的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$类似于双边滤波器中颜色空间的sigma值。
    
    dDepth - 输出图像的可选深度。
    
    scale - 快速引导滤波器的下采样因子，使用小于1的scale值可以加快计算速度，几乎不会造成可见的降质。（例如，scale==0.5 将图像在滤波器内部缩小2倍）参见：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$类似于双边滤波器中颜色空间的sigma值。
    
    dDepth - 输出图像的可选深度。几乎不会造成可见的降质。（例如，scale==0.5 将图像在滤波器内部缩小2倍）参见：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$类似于双边滤波器中颜色空间的sigma值。几乎不会造成可见的降质。（例如，scale==0.5 将图像在滤波器内部缩小2倍）参见：bilateralFilter, dtFilter, amFilter
  - createAMFilter
```
public static AdaptiveManifoldFilter createAMFilter(double sigma_s,
                                                    double sigma_r,
                                                    boolean adjust_outliers)
```
    工厂方法，创建 AdaptiveManifoldFilter 实例并执行一些初始化例程。
    
    参数
    
    sigma_s - 空间标准差。
    
    sigma_r - 颜色空间标准差，类似于双边滤波器中颜色空间的sigma值。
    
    adjust_outliers - 可选，指定是否执行异常值调整操作，（原文中的公式9）。有关自适应流形滤波器参数的更多详细信息，请参见原文 CITE: Gastal12 。注意：处理前，将深度为CV_8U和CV_16U的联合图像转换为深度为CV_32F且颜色范围为[0; 1]的图像。因此，颜色空间sigma sigma_r必须在[0; 1]范围内，这与双边滤波器和dtFilter函数中的相同sigma不同。
    
    返回值
    
    自动生成
  - createAMFilter
```
public static AdaptiveManifoldFilter createAMFilter(double sigma_s,
                                                    double sigma_r)
```
    工厂方法，创建 AdaptiveManifoldFilter 实例并执行一些初始化例程。
    
    参数
    
    sigma_s - 空间标准差。
    
    sigma_r - 颜色空间标准差，类似于双边滤波器中颜色空间的sigma值。原文。有关自适应流形滤波器参数的更多详细信息，请参见原文 CITE: Gastal12 。注意：处理前，将深度为CV_8U和CV_16U的联合图像转换为深度为CV_32F且颜色范围为[0; 1]的图像。因此，颜色空间sigma sigma_r必须在[0; 1]范围内，这与双边滤波器和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 - 颜色空间标准差，类似于双边滤波器中颜色空间的sigma值。
    
    adjust_outliers - 可选，指定是否执行异常值调整操作，（原文中的公式9）。注意：处理前，将深度为CV_8U和CV_16U的联合图像转换为深度为CV_32F且颜色范围为[0; 1]的图像。因此，颜色空间sigma sigma_r必须在[0; 1]范围内，这与双边滤波器和dtFilter函数中的相同sigma不同。参见：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 - 颜色空间标准差，类似于双边滤波器中颜色空间的sigma值。原文。注意：处理前，将深度为CV_8U和CV_16U的联合图像转换为深度为CV_32F且颜色范围为[0; 1]的图像。因此，颜色空间sigma sigma_r必须在[0; 1]范围内，这与双边滤波器和dtFilter函数中的相同sigma不同。参见：bilateralFilter, dtFilter, guidedFilter
  - jointBilateralFilter
```
public static void jointBilateralFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int d,
                                        double sigmaColor,
                                        double sigmaSpace,
                                        int borderType)
```
    将联合双边滤波器应用于图像。
    
    参数
    
    joint - 联合的8位或浮点型，单通道或三通道图像。
    
    src - 源8位或浮点型，单通道或三通道图像，与联合图像具有相同的深度。
    
    dst - 与src大小和类型相同的目标图像。
    
    d - 滤波过程中使用的每个像素邻域的直径。如果它是非正数，则根据sigmaSpace计算。
    
    sigmaColor - 颜色空间中的滤波器sigma值。参数值越大，像素邻域内（参见sigmaSpace）越远的颜色将混合在一起，导致更大的半等色区域。
    
    sigmaSpace - 坐标空间中的滤波器sigma值。参数值越大，只要颜色足够接近（参见sigmaColor），则越远的像素将相互影响。当d>0时，它指定邻域大小，而不管sigmaSpace。否则，d与sigmaSpace成比例。
    
    borderType - 注意：bilateralFilter和jointBilateralFilter使用L1范数来计算颜色之间的差异。参见：bilateralFilter, amFilter
  - jointBilateralFilter
```
public static void jointBilateralFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int d,
                                        double sigmaColor,
                                        double sigmaSpace)
```
    将联合双边滤波器应用于图像。
    
    参数
    
    joint - 联合的8位或浮点型，单通道或三通道图像。
    
    src - 源8位或浮点型，单通道或三通道图像，与联合图像具有相同的深度。
    
    dst - 与src大小和类型相同的目标图像。
    
    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位无符号整数或32位浮点数的源图像
    
    dst - 与src大小和类型相同的目标图像。
    
    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位无符号整数或32位浮点数的源图像
    
    dst - 与src大小和类型相同的目标图像。
    
    fr - 用于滤波的核半径。它应该是正整数。
    
    numIter - 算法的迭代次数，它应该是正整数。
    
    sigmaAlpha - 控制从边缘到平滑/纹理区域的权重转换的锐度，较大的值意味着更锐利的转换。当值为负时，会自动计算。值为负时，将根据论文中描述的自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst,
                                          int fr,
                                          int numIter)
```
    将双边纹理滤波器应用于图像。它执行保持结构的纹理滤波。有关此滤波器的更多详细信息，请参见 CITE: Cho2014。
    
    参数
    
    src - 深度为8位无符号整数或32位浮点数的源图像
    
    dst - 与src大小和类型相同的目标图像。
    
    fr - 用于滤波的核半径。它应该是正整数。
    
    numIter - 算法的迭代次数，它应该是正整数。较大的值意味着更锐利的转换。当值为负时，会自动计算。值为负时，将根据论文中描述的自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst,
                                          int fr)
```
    将双边纹理滤波器应用于图像。它执行保持结构的纹理滤波。有关此滤波器的更多详细信息，请参见 CITE: Cho2014。
    
    参数
    
    src - 深度为8位无符号整数或32位浮点数的源图像
    
    dst - 与src大小和类型相同的目标图像。
    
    fr - 用于滤波的核半径。应为正整数，值越大，过渡越锐利。如果值为负数，则根据论文中的描述自动计算。参见：rollingGuidanceFilter，bilateralFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst)
```
    将双边纹理滤波器应用于图像。它执行保持结构的纹理滤波。有关此滤波器的更多详细信息，请参见 CITE: Cho2014。
    
    参数
    
    src - 深度为8位无符号整数或32位浮点数的源图像
    
    dst - 与src大小和类型相同的目标图像。值越大，过渡越锐利。如果值为负数，则根据论文中的描述自动计算。参见：rollingGuidanceFilter，bilateralFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst,
                                         int d,
                                         double sigmaColor,
                                         double sigmaSpace,
                                         int numOfIter,
                                         int borderType)
```
    将滚动引导滤波器应用于图像。更多详情，请参见文献：zhang2014rolling
    
    参数
    
    src - 源8位或浮点型，单通道或三通道图像。
    
    dst - 与src大小和类型相同的目标图像。
    
    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)
```
    将滚动引导滤波器应用于图像。更多详情，请参见文献：zhang2014rolling
    
    参数
    
    src - 源8位或浮点型，单通道或三通道图像。
    
    dst - 与src大小和类型相同的目标图像。
    
    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)
```
    将滚动引导滤波器应用于图像。更多详情，请参见文献：zhang2014rolling
    
    参数
    
    src - 源8位或浮点型，单通道或三通道图像。
    
    dst - 与src大小和类型相同的目标图像。
    
    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)
```
    将滚动引导滤波器应用于图像。更多详情，请参见文献：zhang2014rolling
    
    参数
    
    src - 源8位或浮点型，单通道或三通道图像。
    
    dst - 与src大小和类型相同的目标图像。
    
    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)
```
    将滚动引导滤波器应用于图像。更多详情，请参见文献：zhang2014rolling
    
    参数
    
    src - 源8位或浮点型，单通道或三通道图像。
    
    dst - 与src大小和类型相同的目标图像。
    
    d - 滤波过程中使用的每个像素邻域的直径。如果是非正数，则根据 sigmaSpace 计算。像素邻域内（参见 sigmaSpace）颜色差异较大的像素也会混合在一起，导致更大面积的半等色区域。只要像素颜色足够接近，距离较远的像素也会相互影响（参见 sigmaColor）。当 d>0 时，它指定邻域大小，而与 sigmaSpace 无关。否则，d 与 sigmaSpace 成比例。注意：rollingGuidanceFilter 使用 jointBilateralFilter 作为边缘保持滤波器。参见：jointBilateralFilter，bilateralFilter，amFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst)
```
    将滚动引导滤波器应用于图像。更多详情，请参见文献：zhang2014rolling
    
    参数
    
    src - 源8位或浮点型，单通道或三通道图像。
    
    dst - 与src大小和类型相同的目标图像。根据 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 - 解算器使用的收敛容差。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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 次就足够了。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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 - 解算器的平滑强度参数。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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（带宽）。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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 - 解算器使用的收敛容差。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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 次就足够了。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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 - 解算器的平滑强度参数。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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（带宽）。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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（带宽）。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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（带宽）。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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 - 目标图像。有关快速双边解算器参数的更多详细信息，请参阅原始论文文献：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。
  - 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 深度
    
    返回值
    
    如果成功读取真值，则返回零
  - 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 - 输出可视化结果
  - PeiLinNormalization
```
public static void PeiLinNormalization(Mat I,
                                       Mat T)
```
  - createEdgeAwareInterpolator
```
public static EdgeAwareInterpolator createEdgeAwareInterpolator()
```
    工厂方法，创建一个EdgeAwareInterpolator实例。
    
    返回值
    
    自动生成
  - createRICInterpolator
```
public static RICInterpolator createRICInterpolator()
```
    创建 RICInterpolator 实例的工厂方法。
    
    返回值
    
    自动生成
  - 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 - 期望的超像素数量。请注意，由于限制（取决于图像大小），实际数量可能更小。使用 getNumberOfSuperpixels() 获取实际数量。线程数。实际上，对于较小的图像，四个线程就足够了，对于较大的图像，八个线程就足够了。不合并处理速度快得多，但图像中会留下许多小的片段。
    
    返回值
    
    自动生成
  - 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)
    
    返回值
    
    自动生成
  - edgePreservingFilter
```
public static void edgePreservingFilter(Mat src,
                                        Mat dst,
                                        int d,
                                        double threshold)
```
    使用边缘保持滤波器平滑图像。该函数可平滑高斯噪声以及椒盐噪声。有关此实现的更多详细信息，请参见 [ReiWoe18] Reich, S. and Wörgötter, F. and Dellen, B. (2018). A Real-Time Edge-Preserving Denoising Filter. Proceedings of the 13th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications (VISIGRAPP): Visapp, 85-94, 4. DOI: 10.5220/0006509000850094。
    
    参数
    
    src - 源 8 位 3 通道图像。
    
    dst - 与src大小和类型相同的目标图像。
    
    d - 滤波过程中使用的每个像素邻域的直径。必须大于或等于 3。
    
    threshold - 用于区分噪声、异常值和数据的阈值。
  - covarianceEstimation
```
public static void covarianceEstimation(Mat src,
                                        Mat dst,
                                        int windowRows,
                                        int windowCols)
```
    使用滑动窗口公式计算图像的估计协方差矩阵。
    
    参数
    
    src - 源图像。输入图像必须为复数类型。
    
    dst - 目标估计协方差矩阵。输出矩阵大小为 (windowRows*windowCols, windowRows*windowCols)。
    
    windowRows - 窗口的行数。
    
    windowCols - 窗口的列数。窗口大小参数控制估计的精度。滑动窗口从左上角移动到图像的右下角。窗口的每个位置代表一个样本。如果窗口大小与图像大小相同，则会给出精确的协方差矩阵。对于所有其他情况，窗口的大小会影响样本数量和估计协方差矩阵中元素的数量。
  - createEdgeDrawing
```
public static EdgeDrawing createEdgeDrawing()
```
    创建一个指向EdgeDrawing对象的智能指针并对其进行初始化。
    
    返回值
    
    自动生成
  - 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 算法对象
    
    返回值
    
    自动生成
  - 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 - 自动生成

类 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

createFastLineDetector

createFastLineDetector

createFastLineDetector

createFastLineDetector

createFastLineDetector

createFastLineDetector

createFastLineDetector

FastHoughTransform

FastHoughTransform

FastHoughTransform

FastHoughTransform

createGraphSegmentation

createGraphSegmentation

createGraphSegmentation

createGraphSegmentation

createSelectiveSearchSegmentationStrategyColor

createSelectiveSearchSegmentationStrategySize

createSelectiveSearchSegmentationStrategyTexture

createSelectiveSearchSegmentationStrategyFill

createSelectiveSearchSegmentationStrategyMultiple

createSelectiveSearchSegmentationStrategyMultiple

createSelectiveSearchSegmentationStrategyMultiple

createSelectiveSearchSegmentationStrategyMultiple

createSelectiveSearchSegmentationStrategyMultiple

createSelectiveSearchSegmentation

weightedMedianFilter

weightedMedianFilter

weightedMedianFilter

weightedMedianFilter

findEllipses