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`	`RO_IGNORE_BORDERS (忽略边界)`
`static int`	`RO_STRICT (严格模式)`
`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)`	简单的单行自适应流形滤波器 (Adaptive Manifold Filter) 调用。
`static void`	`amFilter(Mat joint, Mat src, Mat dst, double sigma_s, double sigma_r, boolean adjust_outliers)`	简单的单行自适应流形滤波器 (Adaptive Manifold Filter) 调用。
`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)`	创建基于图的分割器
`static GuidedFilter`	`createGuidedFilter(Mat guide, int radius, double eps)`	工厂方法，创建 GuidedFilter 实例并执行初始化程序。
`static GuidedFilter`	`createGuidedFilter(Mat guide, int radius, double eps, double scale)`	工厂方法，创建 GuidedFilter 实例并执行初始化程序。
`static void`	`createQuaternionImage(Mat img, Mat qimg)`	创建四元数图像。
`static RFFeatureGetter`	`createRFFeatureGetter()`
`static RICInterpolator`	`createRICInterpolator()`	创建 RICInterpolator 实例的工厂方法。
`static StereoMatcher`	`createRightMatcher(StereoMatcher matcher_left)`	便捷方法，用于设置匹配器以计算右视图视差图，这在进行置信度滤波时是必需的。
`static ScanSegment`	`createScanSegment(int image_width, int image_height, int num_superpixels)`	初始化 ScanSegment 对象。
`static ScanSegment`	`createScanSegment(int image_width, int image_height, int num_superpixels, int slices)`	初始化 ScanSegment 对象。
`static ScanSegment`	`createScanSegment(int image_width, int image_height, int num_superpixels, int slices, boolean merge_small)`	初始化 ScanSegment 对象。
`static SelectiveSearchSegmentation`	`createSelectiveSearchSegmentation()`	创建一个新的 SelectiveSearchSegmentation 类。
`static SelectiveSearchSegmentationStrategyColor`	`createSelectiveSearchSegmentationStrategyColor()`	创建一个新的基于颜色的策略
`static SelectiveSearchSegmentationStrategyFill`	`createSelectiveSearchSegmentationStrategyFill()`	创建一个新的基于填充的策略
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple()`	创建一个新的组合策略
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1)`	创建一个新的组合策略并设置一个子策略
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2)`	创建一个新的组合策略并设置两个具有相等权重的子策略
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2, SelectiveSearchSegmentationStrategy s3)`	创建一个新的组合策略并设置三个具有相等权重的子策略
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2, SelectiveSearchSegmentationStrategy s3, SelectiveSearchSegmentationStrategy s4)`	创建一个新的组合策略并设置四个具有相等权重的子策略
`static SelectiveSearchSegmentationStrategySize`	`createSelectiveSearchSegmentationStrategySize()`	创建一个新的基于尺寸的策略
`static SelectiveSearchSegmentationStrategyTexture`	`createSelectiveSearchSegmentationStrategyTexture()`	创建一个新的基于尺寸的策略
`static StructuredEdgeDetection`	`createStructuredEdgeDetection(java.lang.String model)`
`static StructuredEdgeDetection`	`createStructuredEdgeDetection(java.lang.String model, RFFeatureGetter howToGetFeatures)`
`static SuperpixelLSC`	`createSuperpixelLSC(Mat image)`	实现 LSC（线性光谱聚类）超像素的类
`static SuperpixelLSC`	`createSuperpixelLSC(Mat image, int region_size)`	实现 LSC（线性光谱聚类）超像素的类
`static SuperpixelLSC`	`createSuperpixelLSC(Mat image, int region_size, float ratio)`	实现 LSC（线性光谱聚类）超像素的类
`static SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels)`	初始化 SuperpixelSEEDS 对象。
`static SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior)`	初始化 SuperpixelSEEDS 对象。
`static SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior, int histogram_bins)`	初始化 SuperpixelSEEDS 对象。
`static SuperpixelSEEDS`	`createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior, int histogram_bins, boolean double_step)`	初始化 SuperpixelSEEDS 对象。
`static SuperpixelSLIC`	`createSuperpixelSLIC(Mat image)`	初始化 SuperpixelSLIC 对象
`static SuperpixelSLIC`	`createSuperpixelSLIC(Mat image, int algorithm)`	初始化 SuperpixelSLIC 对象
`static SuperpixelSLIC`	`createSuperpixelSLIC(Mat image, int algorithm, int region_size)`	初始化 SuperpixelSLIC 对象
`static SuperpixelSLIC`	`createSuperpixelSLIC(Mat image, int algorithm, int region_size, float ruler)`	初始化 SuperpixelSLIC 对象
`static void`	`dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor)`	简单的单行域变换滤波器 (Domain Transform filter) 调用。
`static void`	`dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor, int mode)`	简单的单行域变换滤波器 (Domain Transform filter) 调用。
`static void`	`dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor, int mode, int numIters)`	简单的单行域变换滤波器 (Domain Transform filter) 调用。
`static void`	`edgePreservingFilter(Mat src, Mat dst, int d, double threshold)`	使用边缘保留滤波器平滑图像。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst)`	简单的单行快速双边解算器滤波器 (Fast Bilateral Solver filter) 调用。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial)`	简单的单行快速双边解算器滤波器 (Fast Bilateral Solver filter) 调用。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma)`	简单的单行快速双边解算器滤波器 (Fast Bilateral Solver filter) 调用。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma)`	简单的单行快速双边解算器滤波器 (Fast Bilateral Solver filter) 调用。
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda)`	简单的单行快速双边解算器滤波器 (Fast Bilateral Solver filter) 调用。
`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)`	简单的单行快速双边解算器滤波器 (Fast Bilateral Solver filter) 调用。
`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)`	简单的单行快速双边解算器滤波器 (Fast Bilateral Solver filter) 调用。
`static void`	`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color)`	简单的单行快速全局平滑滤波器 (Fast Global Smoother filter) 调用。
`static void`	`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation)`	简单的单行快速全局平滑滤波器 (Fast Global Smoother filter) 调用。
`static void`	`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation, int num_iter)`	简单的单行快速全局平滑滤波器 (Fast Global Smoother filter) 调用。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth)`	计算图像的二维快速霍夫变换 (Fast Hough transform)。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange)`	计算图像的二维快速霍夫变换 (Fast Hough transform)。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op)`	计算图像的二维快速霍夫变换 (Fast Hough transform)。
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op, int makeSkew)`	计算图像的二维快速霍夫变换 (Fast Hough transform)。
`static void`	`findEllipses(Mat image, Mat ellipses)`	使用投影不变修剪 (projective invariant pruning) 快速查找图像中的椭圆。
`static void`	`findEllipses(Mat image, Mat ellipses, float scoreThreshold)`	使用投影不变修剪 (projective invariant pruning) 快速查找图像中的椭圆。
`static void`	`findEllipses(Mat image, Mat ellipses, float scoreThreshold, float reliabilityThreshold)`	使用投影不变修剪 (projective invariant pruning) 快速查找图像中的椭圆。
`static void`	`findEllipses(Mat image, Mat ellipses, float scoreThreshold, float reliabilityThreshold, float centerDistanceThreshold)`	使用投影不变修剪 (projective invariant pruning) 快速查找图像中的椭圆。
`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)`	简单的单行（快速）导向滤波器 (Guided Filter) 调用。
`static void`	`guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps, int dDepth)`	简单的单行（快速）导向滤波器 (Guided Filter) 调用。
`static void`	`guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps, int dDepth, double scale)`	简单的单行（快速）导向滤波器 (Guided Filter) 调用。
`static int[]`	`HoughPoint2Line(Point houghPoint, Mat srcImgInfo)`	计算霍夫空间中点所对应的线段坐标。
`static int[]`	`HoughPoint2Line(Point houghPoint, Mat srcImgInfo, int angleRange)`	计算霍夫空间中点所对应的线段坐标。
`static int[]`	`HoughPoint2Line(Point houghPoint, Mat srcImgInfo, int angleRange, int makeSkew)`	计算霍夫空间中点所对应的线段坐标。
`static int[]`	`HoughPoint2Line(Point houghPoint, Mat srcImgInfo, int angleRange, int makeSkew, int rules)`	计算霍夫空间中点所对应的线段坐标。
`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)`	用于读取地面真值 (ground truth) 视差图的函数。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst)`	对图像应用滚动导向滤波器 (rolling guidance filter)。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d)`	对图像应用滚动导向滤波器 (rolling guidance filter)。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor)`	对图像应用滚动导向滤波器 (rolling guidance filter)。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace)`	对图像应用滚动导向滤波器 (rolling guidance filter)。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter)`	对图像应用滚动导向滤波器 (rolling guidance filter)。
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter, int borderType)`	对图像应用滚动导向滤波器 (rolling guidance filter)。
`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

- 字段详情
  - RO_STRICT (严格模式)
```
public static final int RO_STRICT
```
    另请参阅
    
    常量字段值
  - RO_IGNORE_BORDERS (忽略边界)
```
public static final int RO_IGNORE_BORDERS
```
    另请参阅
    
    常量字段值
  - 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}}{如果 \(src(x,y) > T(x,y)$}{0}{否则}\)
    
    THRESH_BINARY_INV $dst(x,y) = \fork{0}{如果 \(src(x,y) > T(x,y)$}{\texttt{maxValue}}{否则}\) 其中 $T(x,y)$ 是为每个像素单独计算的阈值。
    
    阈值 $T(x, y)$ 根据所选的二值化方法确定。对于经典 Niblack，它是 $(x, y)$ 邻域 $\texttt{blockSize} \times\texttt{blockSize}$ 的均值减去 $ k $ 倍标准差。该函数不能进行就地 (in-place) 处理。
    参数
    
    _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 技术使用的用户可调参数。这是标准差的动态范围。参见：threshold, adaptiveThreshold
  - niBlackThreshold
```
public static void niBlackThreshold(Mat _src,
                                    Mat _dst,
                                    double maxValue,
                                    int type,
                                    int blockSize,
                                    double k,
                                    int binarizationMethod)
```
    使用 Niblack 技术或其启发的一些流行变体对输入图像执行二值化。该函数根据公式将灰度图像转换为二值图像
    
    THRESH_BINARY $dst(x,y) = \fork{\texttt{maxValue}}{如果 \(src(x,y) > T(x,y)$}{0}{否则}\)
    
    THRESH_BINARY_INV $dst(x,y) = \fork{0}{如果 \(src(x,y) > T(x,y)$}{\texttt{maxValue}}{否则}\) 其中 $T(x,y)$ 是为每个像素单独计算的阈值。
    
    阈值 $T(x, y)$ 根据所选的二值化方法确定。对于经典 Niblack，它是 $(x, y)$ 邻域 $\texttt{blockSize} \times\texttt{blockSize}$ 的均值减去 $ k $ 倍标准差。该函数不能进行就地 (in-place) 处理。
    参数
    
    _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（标准差）。参见：threshold, adaptiveThreshold
  - niBlackThreshold
```
public static void niBlackThreshold(Mat _src,
                                    Mat _dst,
                                    double maxValue,
                                    int type,
                                    int blockSize,
                                    double k)
```
    使用 Niblack 技术或其启发的一些流行变体对输入图像执行二值化。该函数根据公式将灰度图像转换为二值图像
    
    THRESH_BINARY $dst(x,y) = \fork{\texttt{maxValue}}{如果 \(src(x,y) > T(x,y)$}{0}{否则}\)
    
    THRESH_BINARY_INV $dst(x,y) = \fork{0}{如果 \(src(x,y) > T(x,y)$}{\texttt{maxValue}}{否则}\) 其中 $T(x,y)$ 是为每个像素单独计算的阈值。
    
    阈值 $T(x, y)$ 根据所选的二值化方法确定。对于经典 Niblack，它是 $(x, y)$ 邻域 $\texttt{blockSize} \times\texttt{blockSize}$ 的均值减去 $ k $ 倍标准差。该函数不能进行就地 (in-place) 处理。
    参数
    
    _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（标准差）。参见：threshold, adaptiveThreshold
  - 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 - 迭代次数
  - RadonTransform (Radon 变换)
```
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。输出尺寸将为积分数量 x 源图像对角线长度。如果选择了裁剪 (crop)，输入图像将被裁剪为正方形再切为圆形，输出尺寸将为积分数量 x 最小边长。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    theta - 自动生成
    
    start_angle - 自动生成
    
    end_angle - 自动生成
    
    crop - 自动生成
    
    norm - 自动生成
  - RadonTransform (Radon 变换)
```
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。输出尺寸将为积分数量 x 源图像对角线长度。如果选择了裁剪 (crop)，输入图像将被裁剪为正方形再切为圆形，输出尺寸将为积分数量 x 最小边长。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    theta - 自动生成
    
    start_angle - 自动生成
    
    end_angle - 自动生成
    
    crop - 自动生成
  - RadonTransform (Radon 变换)
```
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。输出尺寸将为积分数量 x 源图像对角线长度。如果选择了裁剪 (crop)，输入图像将被裁剪为正方形再切为圆形，输出尺寸将为积分数量 x 最小边长。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    theta - 自动生成
    
    start_angle - 自动生成
    
    end_angle - 自动生成
  - RadonTransform (Radon 变换)
```
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。输出尺寸将为积分数量 x 源图像对角线长度。如果选择了裁剪 (crop)，输入图像将被裁剪为正方形再切为圆形，输出尺寸将为积分数量 x 最小边长。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    theta - 自动生成
    
    start_angle - 自动生成
  - RadonTransform (Radon 变换)
```
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。输出尺寸将为积分数量 x 源图像对角线长度。如果选择了裁剪 (crop)，输入图像将被裁剪为正方形再切为圆形，输出尺寸将为积分数量 x 最小边长。
    
    参数
    
    src - 自动生成
    
    dst - 自动生成
    
    theta - 自动生成
  - RadonTransform (Radon 变换)
```
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。输出尺寸将为积分数量 x 源图像对角线长度。如果选择了裁剪 (crop)，输入图像将被裁剪为正方形再切为圆形，输出尺寸将为积分数量 x 最小边长。
    
    参数
    
    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 对象
    
    返回
    
    自动生成
  - 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 - 如果为 true，则对每个块层级迭代两次以获得更高的准确度。该函数为输入图像初始化一个 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)
    
    返回
    
    自动生成
  - 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 - 找到的椭圆的输出向量。每个向量编码为五个 float：$x, y, a, b, radius, score$。
    
    scoreThreshold - float，椭圆得分阈值。
    
    reliabilityThreshold - float，可靠性阈值。
    
    centerDistanceThreshold - float，中心距离阈值。
  - 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 - 找到的椭圆的输出向量。每个向量编码为五个 float：$x, y, a, b, radius, score$。
    
    scoreThreshold - float，椭圆得分阈值。
    
    reliabilityThreshold - float，可靠性阈值。
  - 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 - 找到的椭圆的输出向量。每个向量编码为五个 float：$x, y, a, b, radius, score$。
    
    scoreThreshold - float，椭圆得分阈值。
  - 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 - 找到的椭圆的输出向量。每个向量编码为五个 float：$x, y, a, b, radius, score$。
  - 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() 获取实际数量（线程）。在实践中，对于较小的图像四个线程足够，较大的图像八个线程足够。不合并处理速度快得多，但图像中会留下许多小片段。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                      float distance_threshold,
                                                      double canny_th1,
                                                      double canny_th2,
                                                      int canny_aperture_size,
                                                      boolean do_merge)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 短于此值的片段将被丢弃
    
    distance_threshold - 距离假设线段超过此值的点将被视为离群值
    
    canny_th1 - Canny() 中滞后过程的第一个阈值
    
    canny_th2 - Canny() 中滞后过程的第二个阈值
    
    canny_aperture_size - Canny() 中 Sobel 算子的孔径大小。如果为零，则不应用 Canny()，输入图像被视为边缘图像。
    
    do_merge - 如果为 true，将执行片段的增量合并
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                      float distance_threshold,
                                                      double canny_th1,
                                                      double canny_th2,
                                                      int canny_aperture_size)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 短于此值的片段将被丢弃
    
    distance_threshold - 距离假设线段超过此值的点将被视为离群值
    
    canny_th1 - Canny() 中滞后过程的第一个阈值
    
    canny_th2 - Canny() 中滞后过程的第二个阈值
    
    canny_aperture_size - Canny() 中 Sobel 算子的孔径大小。如果为零，则不应用 Canny()，输入图像被视为边缘图像。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                      float distance_threshold,
                                                      double canny_th1,
                                                      double canny_th2)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 短于此值的片段将被丢弃
    
    distance_threshold - 距离假设线段超过此值的点将被视为离群值
    
    canny_th1 - Canny() 中滞后过程的第一个阈值
    
    canny_th2 - Canny() 中滞后过程的第二个阈值。如果为零，则不应用 Canny()，输入图像被视为边缘图像。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                      float distance_threshold,
                                                      double canny_th1)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 短于此值的片段将被丢弃
    
    distance_threshold - 距离假设线段超过此值的点将被视为离群值
    
    canny_th1 - Canny() 中滞后过程的第一个阈值。如果为零，则不应用 Canny()，输入图像被视为边缘图像。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                      float distance_threshold)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 短于此值的片段将被丢弃
    
    distance_threshold - 距离假设线段超过此值的点将被视为离群值。如果为零，则不应用 Canny()，输入图像被视为边缘图像。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector(int length_threshold)
```
    创建 FastLineDetector 对象的智能指针并进行初始化
    
    参数
    
    length_threshold - 短于此值的片段将被丢弃。距离假设线段超过此值的点将被视为离群值。如果为零，则不应用 Canny()，输入图像被视为边缘图像。
    
    返回
    
    自动生成
  - createFastLineDetector
```
public static FastLineDetector createFastLineDetector()
```
    创建并初始化 FastLineDetector 对象的智能指针。距离假设线段超过此值的点将被视为离群值。如果为零，则不应用 Canny()，输入图像被视为边缘图像。
    
    返回
    
    自动生成
  - covarianceEstimation (协方差估计)
```
public static void covarianceEstimation(Mat src,
                                        Mat dst,
                                        int windowRows,
                                        int windowCols)
```
    使用滑动窗口公式计算图像的估计协方差矩阵。
    
    参数
    
    src - 源图像。输入图像必须是复数类型。
    
    dst - 目标估计协方差矩阵。输出矩阵大小为 (windowRows*windowCols, windowRows*windowCols)。
    
    windowRows - 窗口中的行数。
    
    windowCols - 窗口中的列数。窗口大小参数控制估计的准确性。滑动窗口从左上角到右下角在整个图像上移动。窗口的每个位置代表一个样本。如果窗口大小与图像相同，则得到精确的协方差矩阵。在所有其他情况下，窗口大小将影响样本数量和估计协方差矩阵中的元素数量。
  - 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 - 自动生成
  - HoughPoint2Line
```
public static int[] HoughPoint2Line(Point houghPoint,
                                    Mat srcImgInfo,
                                    int angleRange,
                                    int makeSkew,
                                    int rules)
```
    计算霍夫空间中点所对应的线段坐标。
    
    参数
    
    houghPoint - 自动生成
    
    srcImgInfo - 自动生成
    
    angleRange - 自动生成
    
    makeSkew - 自动生成
    
    rules - 自动生成
    
    返回
    
    自动生成
  - HoughPoint2Line
```
public static int[] HoughPoint2Line(Point houghPoint,
                                    Mat srcImgInfo,
                                    int angleRange,
                                    int makeSkew)
```
    计算霍夫空间中点所对应的线段坐标。
    
    参数
    
    houghPoint - 自动生成
    
    srcImgInfo - 自动生成
    
    angleRange - 自动生成
    
    makeSkew - 自动生成
    
    返回
    
    自动生成
  - HoughPoint2Line
```
public static int[] HoughPoint2Line(Point houghPoint,
                                    Mat srcImgInfo,
                                    int angleRange)
```
    计算霍夫空间中点所对应的线段坐标。
    
    参数
    
    houghPoint - 自动生成
    
    srcImgInfo - 自动生成
    
    angleRange - 自动生成
    
    返回
    
    自动生成
  - HoughPoint2Line
```
public static int[] HoughPoint2Line(Point houghPoint,
                                    Mat srcImgInfo)
```
    计算霍夫空间中点所对应的线段坐标。
    
    参数
    
    houghPoint - 自动生成
    
    srcImgInfo - 自动生成
    
    返回
    
    自动生成
  - createRFFeatureGetter
```
public static RFFeatureGetter createRFFeatureGetter()
```
  - createStructuredEdgeDetection
```
public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model,
                                                                    RFFeatureGetter howToGetFeatures)
```
  - createStructuredEdgeDetection
```
public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model)
```
  - 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 - 自动生成
  - PeiLinNormalization
```
public static void PeiLinNormalization(Mat I,
                                       Mat T)
```
  - 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 - 自动生成
  - 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 - 自动生成
  - createSuperpixelLSC
```
public static SuperpixelLSC createSuperpixelLSC(Mat image,
                                                int region_size,
                                                float ratio)
```
    实现 LSC（线性光谱聚类）超像素的类
    
    参数
    
    image - 要分割的图像
    
    region_size - 选择以像素为单位测量的平均超像素大小
    
    ratio - 选择超像素紧凑因子的强制程度。该函数为输入图像初始化一个 SuperpixelLSC 对象。它设置超像素算法的参数：region_size 和 ruler。它会预先分配一些缓冲区，用于将来在给定图像上进行的计算迭代。下图说明了 LSC 的一个示例。为了获得增强的结果，建议对彩色图像进行预处理，使用小的 3 x 3 核进行轻微的高斯模糊，并额外转换到 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 的一个示例。为了获得增强的结果，建议对彩色图像进行预处理，使用小的 3 x 3 核进行轻微的高斯模糊，并额外转换到 CieLAB 颜色空间。 ![image](pics/superpixels_lsc.png)
    
    返回
    
    自动生成
  - createSuperpixelLSC
```
public static SuperpixelLSC createSuperpixelLSC(Mat image)
```
    实现 LSC（线性光谱聚类）超像素的类
    
    参数
    
    image - 待分割图像。该函数为输入图像初始化一个 SuperpixelLSC 对象。它设置了超像素算法的参数：region_size 和 ruler。它预分配了一些缓冲区，用于后续在给定图像上的计算迭代。下图展示了一个 LSC 的示例。为了获得更好的效果，对于彩色图像，建议先使用 3 x 3 的小内核进行高斯模糊预处理，并额外转换为 CieLAB 颜色空间。![image](pics/superpixels_lsc.png)
    
    返回
    
    自动生成
  - createDisparityWLSFilter
```
public static DisparityWLSFilter createDisparityWLSFilter(StereoMatcher matcher_left)
```
    便捷的工厂方法，用于创建一个 DisparityWLSFilter 实例，并根据匹配器（matcher）实例自动设置所有相关的滤波器参数。目前仅支持 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)
```
    用于读取地面真值（Ground Truth）视差图的函数。支持基础的 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 之间的均方误差（MSE）
  - computeBadPixelPercent
```
public static double computeBadPixelPercent(Mat GT,
                                            Mat src,
                                            Rect ROI,
                                            int thresh)
```
    用于计算视差图中“坏”像素百分比的函数（误差高于指定阈值的像素）
    
    参数
    
    GT - 地面真值视差图
    
    src - 待评估的视差图
    
    ROI - 感兴趣区域
    
    thresh - 用于判定“坏”像素的阈值
    
    返回
    
    返回 GT 和 src 之间的均方误差（MSE）
  - computeBadPixelPercent
```
public static double computeBadPixelPercent(Mat GT,
                                            Mat src,
                                            Rect ROI)
```
    用于计算视差图中“坏”像素百分比的函数（误差高于指定阈值的像素）
    
    参数
    
    GT - 地面真值视差图
    
    src - 待评估的视差图
    
    ROI - 感兴趣区域
    
    返回
    
    返回 GT 和 src 之间的均方误差（MSE）
  - 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 - 输出可视化图像
  - createEdgeAwareInterpolator
```
public static EdgeAwareInterpolator createEdgeAwareInterpolator()
```
    创建 EdgeAwareInterpolator 实例的工厂方法。
    
    返回
    
    自动生成
  - createRICInterpolator
```
public static RICInterpolator createRICInterpolator()
```
    创建 RICInterpolator 实例的工厂方法。
    
    返回
    
    自动生成
  - createDTFilter
```
public static DTFilter createDTFilter(Mat guide,
                                      double sigmaSpatial,
                                      double sigmaColor,
                                      int mode,
                                      int numIters)
```
    工厂方法，创建 DTFilter 实例并执行初始化程序。
    
    参数
    
    guide - 引导图像（用于构建描述引导图像边缘结构的变换距离）。
    
    sigmaSpatial - 原文中的 ${\sigma}_H$ 参数，类似于 bilateralFilter（双边滤波）中坐标空间的 sigma。
    
    sigmaColor - 原文中的 ${\sigma}_r$ 参数，类似于 bilateralFilter 中颜色空间的 sigma。
    
    mode - DTF_NC、DTF_RF 和 DTF_IC 三种模式之一，对应文中过滤二维信号的三种模式。
    
    numIters - 可选的滤波迭代次数，3 次通常足够。有关域变换（Domain Transform）滤波器参数的更多详情，请参阅原文 CITE: Gastal11 和 [域变换滤波器主页](http://www.inf.ufrgs.br/~eslgastal/DomainTransform/)。
    
    返回
    
    自动生成
  - createDTFilter
```
public static DTFilter createDTFilter(Mat guide,
                                      double sigmaSpatial,
                                      double sigmaColor,
                                      int mode)
```
    工厂方法，创建 DTFilter 实例并执行初始化程序。
    
    参数
    
    guide - 引导图像（用于构建描述引导图像边缘结构的变换距离）。
    
    sigmaSpatial - 原文中的 ${\sigma}_H$ 参数，类似于 bilateralFilter（双边滤波）中坐标空间的 sigma。
    
    sigmaColor - 原文中的 ${\sigma}_r$ 参数，类似于 bilateralFilter 中颜色空间的 sigma。
    
    mode - DTF_NC、DTF_RF 和 DTF_IC 三种模式之一，对应文中过滤二维信号的三种模式。有关域变换（Domain Transform）滤波器参数的更多详情，请参阅原文 CITE: Gastal11 和 [域变换滤波器主页](http://www.inf.ufrgs.br/~eslgastal/DomainTransform/)。
    
    返回
    
    自动生成
  - createDTFilter
```
public static DTFilter createDTFilter(Mat guide,
                                      double sigmaSpatial,
                                      double sigmaColor)
```
    工厂方法，创建 DTFilter 实例并执行初始化程序。
    
    参数
    
    guide - 引导图像（用于构建描述引导图像边缘结构的变换距离）。
    
    sigmaSpatial - 原文中的 ${\sigma}_H$ 参数，类似于 bilateralFilter（双边滤波）中坐标空间的 sigma。
    
    sigmaColor - 原文中的 ${\sigma}_r$ 参数，类似于 bilateralFilter 中颜色空间的 sigma。有关域变换滤波器参数的更多详情，请参阅原文 CITE: Gastal11 和 [域变换滤波器主页](http://www.inf.ufrgs.br/~eslgastal/DomainTransform/)。
    
    返回
    
    自动生成
  - dtFilter
```
public static void dtFilter(Mat guide,
                            Mat src,
                            Mat dst,
                            double sigmaSpatial,
                            double sigmaColor,
                            int mode,
                            int numIters)
```
    简单的一行式域变换（Domain Transform）滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 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)
```
    简单的一行式域变换（Domain Transform）滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 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)
```
    简单的一行式域变换（Domain Transform）滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 DTFilter 接口以避免初始化阶段的额外计算。
    
    参数
    
    guide - 引导图像（也称为联合图像），支持无符号 8 位或 32 位浮点深度，最多 4 个通道。
    
    src - 待滤波图像，支持无符号 8 位或 32 位浮点深度，最多 4 个通道。
    
    dst - 目标图像
    
    sigmaSpatial - 原文中的 ${\sigma}_H$ 参数，类似于 bilateralFilter（双边滤波）中坐标空间的 sigma。
    
    sigmaColor - 原文中的 ${\sigma}_r$ 参数，类似于 bilateralFilter 中颜色空间的 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$ 类似于 bilateralFilter 中颜色空间的 sigma。
    
    scale - 快速引导滤波器的下采样因子，使用小于 1 的比例可加速计算，且几乎没有肉眼可见的降质。（例如 scale==0.5 会在滤波器内部将图像缩小 2 倍）有关（快速）引导滤波器参数的更多详情，请参阅原文 CITE: Kaiming10 CITE: Kaiming15 。
    
    返回
    
    自动生成
  - createGuidedFilter
```
public static GuidedFilter createGuidedFilter(Mat guide,
                                              int radius,
                                              double eps)
```
    工厂方法，创建 GuidedFilter 实例并执行初始化程序。
    
    参数
    
    guide - 引导图像（或图像数组），最多支持 3 个通道，如果超过 3 个通道，则仅使用前 3 个通道。
    
    radius - 引导滤波器的半径。
    
    eps - 引导滤波器的正则化项。${eps}^2$ 类似于 bilateralFilter 中颜色空间的 sigma。下采样几乎没有可见降质。有关（快速）引导滤波器参数的更多详情，请参阅原文 CITE: Kaiming10 CITE: Kaiming15 。
    
    返回
    
    自动生成
  - guidedFilter
```
public static void guidedFilter(Mat guide,
                                Mat src,
                                Mat dst,
                                int radius,
                                double eps,
                                int dDepth,
                                double scale)
```
    简单的一行式（快速）引导滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 GuidedFilter 接口以避免初始化阶段的额外计算。
    
    参数
    
    guide - 引导图像（或图像数组），最多支持 3 个通道，如果超过 3 个通道，则仅使用前 3 个通道。
    
    src - 任意通道数的待滤波图像。
    
    dst - 输出图像。
    
    radius - 引导滤波器的半径。
    
    eps - 引导滤波器的正则化项。${eps}^2$ 类似于 bilateralFilter 中颜色空间的 sigma。
    
    dDepth - 可选的输出图像深度。
    
    scale - 快速引导滤波器的下采样因子，使用小于 1 的比例可加速计算，且几乎没有肉眼可见的降质。（例如 scale==0.5 会在滤波器内部将图像缩小 2 倍）参见：bilateralFilter, dtFilter, amFilter
  - guidedFilter
```
public static void guidedFilter(Mat guide,
                                Mat src,
                                Mat dst,
                                int radius,
                                double eps,
                                int dDepth)
```
    简单的一行式（快速）引导滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 GuidedFilter 接口以避免初始化阶段的额外计算。
    
    参数
    
    guide - 引导图像（或图像数组），最多支持 3 个通道，如果超过 3 个通道，则仅使用前 3 个通道。
    
    src - 任意通道数的待滤波图像。
    
    dst - 输出图像。
    
    radius - 引导滤波器的半径。
    
    eps - 引导滤波器的正则化项。${eps}^2$ 类似于 bilateralFilter 中颜色空间的 sigma。
    
    dDepth - 可选的输出图像深度。使用小于 1 的比例几乎没有肉眼可见的降质。参见：bilateralFilter, dtFilter, amFilter
  - guidedFilter
```
public static void guidedFilter(Mat guide,
                                Mat src,
                                Mat dst,
                                int radius,
                                double eps)
```
    简单的一行式（快速）引导滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 GuidedFilter 接口以避免初始化阶段的额外计算。
    
    参数
    
    guide - 引导图像（或图像数组），最多支持 3 个通道，如果超过 3 个通道，则仅使用前 3 个通道。
    
    src - 任意通道数的待滤波图像。
    
    dst - 输出图像。
    
    radius - 引导滤波器的半径。
    
    eps - 引导滤波器的正则化项。${eps}^2$ 类似于 bilateralFilter 中颜色空间的 sigma。参见：bilateralFilter, dtFilter, amFilter
  - createAMFilter
```
public static AdaptiveManifoldFilter createAMFilter(double sigma_s,
                                                    double sigma_r,
                                                    boolean adjust_outliers)
```
    工厂方法，创建 AdaptiveManifoldFilter 实例并执行一些初始化程序。
    
    参数
    
    sigma_s - 空间标准差。
    
    sigma_r - 颜色空间标准差，类似于 bilateralFilter 中颜色空间的 sigma。
    
    adjust_outliers - 可选，指定是否执行离群值调整操作，见原论文（式 9）。有关自适应流形滤波器（Adaptive Manifold Filter）参数的更多详情，请参阅原文 CITE: Gastal12。注意： CV_8U 和 CV_16U 深度的联合图像在处理前会被转换为 CV_32F 深度且颜色范围在 [0; 1] 之间的图像。因此，颜色空间 sigma (sigma_r) 必须在 [0; 1] 范围内，这与 bilateralFilter 和 dtFilter 函数中的相同参数不同。
    
    返回
    
    自动生成
  - createAMFilter
```
public static AdaptiveManifoldFilter createAMFilter(double sigma_s,
                                                    double sigma_r)
```
    工厂方法，创建 AdaptiveManifoldFilter 实例并执行一些初始化程序。
    
    参数
    
    sigma_s - 空间标准差。
    
    sigma_r - 颜色空间标准差，类似于 bilateralFilter 中颜色空间的 sigma。有关自适应流形滤波器参数的更多详情，请参阅原文 CITE: Gastal12。注意： CV_8U 和 CV_16U 深度的联合图像在处理前会被转换为 CV_32F 深度且颜色范围在 [0; 1] 之间的图像。因此，颜色空间 sigma (sigma_r) 必须在 [0; 1] 范围内。
    
    返回
    
    自动生成
  - amFilter
```
public static void amFilter(Mat joint,
                            Mat src,
                            Mat dst,
                            double sigma_s,
                            double sigma_r,
                            boolean adjust_outliers)
```
    简单的单行自适应流形滤波器 (Adaptive Manifold Filter) 调用。
    
    参数
    
    joint - 任意通道数的联合图像（也称为引导图像）或图像数组。
    
    src - 任意通道数的待滤波图像。
    
    dst - 输出图像。
    
    sigma_s - 空间标准差。
    
    sigma_r - 颜色空间标准差，类似于 bilateralFilter 中颜色空间的 sigma。
    
    adjust_outliers - 可选，指定是否执行离群值调整操作（式 9）。注意： CV_8U 和 CV_16U 深度的联合图像在处理前会被转换为 CV_32F 深度且颜色范围在 [0; 1] 之间。因此，颜色空间 sigma_r 必须在 [0; 1] 范围内。参见：bilateralFilter, dtFilter, guidedFilter
  - amFilter
```
public static void amFilter(Mat joint,
                            Mat src,
                            Mat dst,
                            double sigma_s,
                            double sigma_r)
```
    简单的单行自适应流形滤波器 (Adaptive Manifold Filter) 调用。
    
    参数
    
    joint - 任意通道数的联合图像（也称为引导图像）或图像数组。
    
    src - 任意通道数的待滤波图像。
    
    dst - 输出图像。
    
    sigma_s - 空间标准差。
    
    sigma_r - 颜色空间标准差，类似于 bilateralFilter 中颜色空间的 sigma。注意： 联合图像在处理前会转换为 [0; 1] 范围。因此，颜色空间 sigma_r 必须在 [0; 1] 范围内。参见：bilateralFilter, dtFilter, guidedFilter
  - jointBilateralFilter
```
public static void jointBilateralFilter(Mat joint,
                                        Mat src,
                                        Mat dst,
                                        int d,
                                        double sigmaColor,
                                        double sigmaSpace,
                                        int borderType)
```
    对图像应用联合双边滤波器。
    
    参数
    
    joint - 联合图像，8 位或浮点型，1 通道或 3 通道。
    
    src - 源图像，8 位或浮点型，1 通道或 3 通道，深度与 joint 图像相同。
    
    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 位或浮点型，1 通道或 3 通道。
    
    src - 源图像，8 位或浮点型，1 通道或 3 通道，深度与 joint 图像相同。
    
    dst - 目标图像，与 src 具有相同的尺寸和类型。
    
    d - 滤波过程中使用的每个像素邻域的直径。如果为非正数，则从 sigmaSpace 计算得出。
    
    sigmaColor - 颜色空间中的滤波器 sigma。该参数值越大，意味着像素邻域内较远的颜色（见 sigmaSpace）会被混合在一起，从而产生更大的半均色区域。
    
    sigmaSpace - 坐标空间中的滤波器 sigma。该参数值越大，较远的像素就会相互影响。注意： bilateralFilter 和 jointBilateralFilter 使用 L1 范数来计算颜色差异。参见：bilateralFilter, amFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst,
                                          int fr,
                                          int numIter,
                                          double sigmaAlpha,
                                          double sigmaAvg)
```
    对图像应用双边纹理滤波。它执行保持结构的纹理滤波。有关此滤波器的更多详情，请参阅 CITE: Cho2014。
    
    参数
    
    src - 源图像，深度为 8 位 UINT 或 32 位 FLOAT
    
    dst - 目标图像，与 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 位 UINT 或 32 位 FLOAT
    
    dst - 目标图像，与 src 具有相同的尺寸和类型。
    
    fr - 用于滤波的内核半径。应为正整数
    
    numIter - 算法迭代次数。应为正整数
    
    sigmaAlpha - 控制权重过渡的锐度。当该值为负时，将按照论文所述自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst,
                                          int fr,
                                          int numIter)
```
    对图像应用双边纹理滤波。它执行保持结构的纹理滤波。有关此滤波器的更多详情，请参阅 CITE: Cho2014。
    
    参数
    
    src - 源图像，深度为 8 位 UINT 或 32 位 FLOAT
    
    dst - 目标图像，与 src 具有相同的尺寸和类型。
    
    fr - 用于滤波的内核半径。应为正整数
    
    numIter - 算法迭代次数。当该值为负时，将按照论文所述自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst,
                                          int fr)
```
    对图像应用双边纹理滤波。它执行保持结构的纹理滤波。有关此滤波器的更多详情，请参阅 CITE: Cho2014。
    
    参数
    
    src - 源图像，深度为 8 位 UINT 或 32 位 FLOAT
    
    dst - 目标图像，与 src 具有相同的尺寸和类型。
    
    fr - 用于滤波的内核半径。当该值为负时，将按照论文所述自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - bilateralTextureFilter
```
public static void bilateralTextureFilter(Mat src,
                                          Mat dst)
```
    对图像应用双边纹理滤波。它执行保持结构的纹理滤波。有关此滤波器的更多详情，请参阅 CITE: Cho2014。
    
    参数
    
    src - 源图像，深度为 8 位 UINT 或 32 位 FLOAT
    
    dst - 目标图像。当该值为负时，将按照论文所述自动计算。参见：rollingGuidanceFilter, bilateralFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst,
                                         int d,
                                         double sigmaColor,
                                         double sigmaSpace,
                                         int numOfIter,
                                         int borderType)
```
    对图像应用滚动引导滤波（Rolling Guidance Filter）。更多详情请参阅 CITE: zhang2014rolling
    
    参数
    
    src - 源图像，8 位或浮点型，1 通道或 3 通道。
    
    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)
```
    对图像应用滚动引导滤波（Rolling Guidance Filter）。更多详情请参阅 CITE: zhang2014rolling
    
    参数
    
    src - 源图像，8 位或浮点型，1 通道或 3 通道。
    
    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)
```
    对图像应用滚动引导滤波（Rolling Guidance Filter）。更多详情请参阅 CITE: zhang2014rolling
    
    参数
    
    src - 源图像，8 位或浮点型，1 通道或 3 通道。
    
    dst - 目标图像，与 src 具有相同的尺寸和类型。
    
    d - 滤波过程中使用的每个像素邻域的直径。如果为非正数，则从 sigmaSpace 计算得出。
    
    sigmaColor - 颜色空间中的滤波器 sigma。该参数值越大，意味着像素邻域内较远的颜色（见 sigmaSpace）会被混合在一起，从而产生更大的半均色区域。
    
    sigmaSpace - 坐标空间中的滤波器 sigma。较大的值意味着较远的像素会相互影响。注意： rollingGuidanceFilter 使用 jointBilateralFilter 作为保边滤波器。参见：jointBilateralFilter, bilateralFilter, amFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst,
                                         int d,
                                         double sigmaColor)
```
    对图像应用滚动引导滤波（Rolling Guidance Filter）。更多详情请参阅 CITE: zhang2014rolling
    
    参数
    
    src - 源图像，8 位或浮点型，1 通道或 3 通道。
    
    dst - 目标图像，与 src 具有相同的尺寸和类型。
    
    d - 滤波过程中使用的每个像素邻域的直径。如果为非正数，则从 sigmaSpace 计算得出。
    
    sigmaColor - 颜色空间中的滤波器 sigma。较大的值意味着像素邻域内较远的颜色会被混合。注意： rollingGuidanceFilter 使用 jointBilateralFilter。参见：jointBilateralFilter, bilateralFilter, amFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst,
                                         int d)
```
    对图像应用滚动引导滤波（Rolling Guidance Filter）。更多详情请参阅 CITE: zhang2014rolling
    
    参数
    
    src - 源图像，8 位或浮点型，1 通道或 3 通道。
    
    dst - 目标图像，与 src 具有相同的尺寸和类型。
    
    d - 像素邻域直径。注意： rollingGuidanceFilter 使用 jointBilateralFilter 作为保边滤波器。参见：jointBilateralFilter, bilateralFilter, amFilter
  - rollingGuidanceFilter
```
public static void rollingGuidanceFilter(Mat src,
                                         Mat dst)
```
    对图像应用滚动引导滤波（Rolling Guidance Filter）。更多详情请参阅 CITE: zhang2014rolling
    
    参数
    
    src - 源图像，8 位或浮点型，1 通道或 3 通道。
    
    dst - 目标图像。注意： 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 - 用于求解器的收敛容差。有关快速双边求解器（Fast Bilateral Solver）参数的更多详情，请参阅原论文 CITE: BarronPoole2016。
    
    返回
    
    自动生成
  - createFastBilateralSolverFilter
```
public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma,
                                                                        double lambda,
                                                                        int num_iter)
```
    工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化程序。
    
    参数
    
    guide - 用作滤波引导的图像。应具有 8 位深度和 1 或 3 个通道。
    
    sigma_spatial - 参数，类似于 bilateralFilter 中的空间 sigma（带宽）。
    
    sigma_luma - 参数，类似于 bilateralFilter 中的亮度 sigma（带宽）。
    
    sigma_chroma - 参数，类似于 bilateralFilter 中的色度 sigma（带宽）。
    
    lambda - 求解器的平滑强度参数。
    
    num_iter - 求解器迭代次数，25 次通常足够。详情请参阅 CITE: BarronPoole2016。
    
    返回
    
    自动生成
  - createFastBilateralSolverFilter
```
public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma,
                                                                        double lambda)
```
    工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化程序。
    
    参数
    
    guide - 用作滤波引导的图像。应具有 8 位深度和 1 或 3 个通道。
    
    sigma_spatial - 参数，类似于 bilateralFilter 中的空间 sigma（带宽）。
    
    sigma_luma - 参数，类似于 bilateralFilter 中的亮度 sigma（带宽）。
    
    sigma_chroma - 参数，类似于 bilateralFilter 中的色度 sigma（带宽）。
    
    lambda - 求解器的平滑强度参数。详情请参阅 CITE: BarronPoole2016。
    
    返回
    
    自动生成
  - createFastBilateralSolverFilter
```
public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma)
```
    工厂方法，创建 FastBilateralSolverFilter 实例并执行初始化程序。
    
    参数
    
    guide - 用作滤波引导的图像。应具有 8 位深度和 1 或 3 个通道。
    
    sigma_spatial - 参数，类似于 bilateralFilter 中的空间 sigma（带宽）。
    
    sigma_luma - 参数，类似于 bilateralFilter 中的亮度 sigma（带宽）。
    
    sigma_chroma - 类似于双边滤波的色度空间 sigma。详情请参阅 CITE: BarronPoole2016。
    
    返回
    
    自动生成
  - fastBilateralSolverFilter
```
public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma,
                                             double sigma_chroma,
                                             double lambda,
                                             int num_iter,
                                             double max_tol)
```
    简单的一行式快速双边求解器（Fast Bilateral Solver）滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 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 - 求解器收敛容差。注意： 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)
```
    简单的一行式快速双边求解器（Fast Bilateral Solver）滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 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 - 求解器迭代次数。注意： 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)
```
    简单的一行式快速双边求解器（Fast Bilateral Solver）滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 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 - 平滑强度参数。注意： 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)
```
    简单的一行式快速双边求解器（Fast Bilateral Solver）滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 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 - 色度空间参数。注意： 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)
```
    简单的一行式快速双边求解器（Fast Bilateral Solver）滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 FastBilateralSolverFilter 接口以避免额外计算。
    
    参数
    
    guide - 用作滤波引导的图像。应具有 8 位深度和 1 或 3 个通道。
    
    src - 待滤波的源图像，支持无符号 8 位、有符号 16 位或 32 位浮点深度，最多 4 个通道。
    
    confidence - 置信度图像，支持无符号 8 位或 32 位浮点型，1 个通道。
    
    dst - 目标图像。
    
    sigma_spatial - 参数，类似于 bilateralFilter 中的空间 sigma（带宽）。
    
    sigma_luma - 亮度空间参数。注意： CV_8U 深度的置信度图像应在 [0, 255] 范围内，CV_32F 在 [0, 1] 范围内。
  - fastBilateralSolverFilter
```
public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial)
```
    简单的一行式快速双边求解器（Fast Bilateral Solver）滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 FastBilateralSolverFilter 接口以避免额外计算。
    
    参数
    
    guide - 用作滤波引导的图像。应具有 8 位深度和 1 或 3 个通道。
    
    src - 待滤波的源图像，支持无符号 8 位、有符号 16 位或 32 位浮点深度，最多 4 个通道。
    
    confidence - 置信度图像，支持无符号 8 位或 32 位浮点型，1 个通道。
    
    dst - 目标图像。
    
    sigma_spatial - 空间参数。注意： CV_8U 深度的置信度图像应在 [0, 255] 范围内，CV_32F 在 [0, 1] 范围内。
  - fastBilateralSolverFilter
```
public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst)
```
    简单的一行式快速双边求解器（Fast Bilateral Solver）滤波器调用。如果您有多张图像需要使用相同的引导图像进行滤波，请使用 FastBilateralSolverFilter 接口以避免额外计算。
    
    参数
    
    guide - 用作滤波引导的图像。应具有 8 位深度和 1 或 3 个通道。
    
    src - 待滤波的源图像，支持无符号 8 位、有符号 16 位或 32 位浮点深度，最多 4 个通道。
    
    confidence - 置信度图像，支持无符号 8 位或 32 位浮点型，1 个通道。
    
    dst - 目标图像。注意： 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 次通常足够。有关快速全局平滑器（Fast Global Smoother）参数的详情，请参阅原论文 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 - 内部参数。通常为 0.25。详情见 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 - 类似于双边滤波的颜色空间 sigma。通常 lambda_attenuation 应为 0.25。详情请参阅 CITE: Min2014。注意：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 - 类似于双边滤波的颜色空间 sigma。lambda_attenuation 通常应为 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 - 定义平滑项权重的参数。更多详情请参阅 CITE: xu2011image。
  - l0Smooth
```
public static void l0Smooth(Mat src,
                            Mat dst)
```
    通过 L0 梯度最小化进行全局图像平滑。
    
    参数
    
    src - 待滤波的源图像，支持无符号 8 位、有符号 16 位或浮点深度。
    
    dst - 目标图像。更多详情请参阅 CITE: xu2011image。
  - 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 算法对象
    
    返回
    
    自动生成
  - createEdgeDrawing
```
public static EdgeDrawing createEdgeDrawing()
```
    创建 EdgeDrawing 对象的智能指针并进行初始化
    
    返回
    
    自动生成
  - createSuperpixelSLIC
```
public static SuperpixelSLIC createSuperpixelSLIC(Mat image,
                                                  int algorithm,
                                                  int region_size,
                                                  float ruler)
```
    初始化 SuperpixelSLIC 对象
    
    参数
    
    image - 要分割的图像
    
    algorithm - 选择要使用的算法变体：SLIC 使用预期的 region_size 分割图像；SLICO 会使用自适应紧凑因子进行优化；而 MSLIC 会使用流形方法进行优化，从而产生对内容更敏感的超像素。
    
    region_size - 选择以像素为单位测量的平均超像素大小
    
    ruler - 选择超像素平滑因子的强制程度。该函数为输入图像初始化一个 SuperpixelSLIC 对象。它设置所选超像素算法的参数：region_size 和 ruler。它预分配了一些缓冲区。为了提升效果，建议对彩色图像预处理 3x3 高斯模糊并转换为 CieLAB。下图展示了 SLIC、SLICO 和 MSLIC 的对比。![image](pics/superpixels_slic.png)
    
    返回
    
    自动生成
  - createSuperpixelSLIC
```
public static SuperpixelSLIC createSuperpixelSLIC(Mat image,
                                                  int algorithm,
                                                  int region_size)
```
    初始化 SuperpixelSLIC 对象
    
    参数
    
    image - 要分割的图像
    
    algorithm - 选择要使用的算法变体：SLIC 使用预期的 region_size 分割图像；SLICO 会使用自适应紧凑因子进行优化；而 MSLIC 会使用流形方法进行优化，从而产生对内容更敏感的超像素。
    
    region_size - 选择以像素为单位的平均超像素大小。该函数初始化 SuperpixelSLIC 对象并设置 region_size 和 ruler。预分配缓冲区用于迭代。彩色图像建议进行高斯模糊并转换为 CieLAB 空间。![image](pics/superpixels_slic.png)
    
    返回
    
    自动生成
  - createSuperpixelSLIC
```
public static SuperpixelSLIC createSuperpixelSLIC(Mat image,
                                                  int algorithm)
```
    初始化 SuperpixelSLIC 对象
    
    参数
    
    image - 要分割的图像
    
    algorithm - 选择算法变体：SLIC、SLICO 或 MSLIC。该函数初始化 SuperpixelSLIC 对象并设置 region_size 和 ruler。预分配缓冲区用于计算。彩色图像建议进行高斯模糊并转换为 CieLAB 空间。![image](pics/superpixels_slic.png)
    
    返回
    
    自动生成
  - createSuperpixelSLIC
```
public static SuperpixelSLIC createSuperpixelSLIC(Mat image)
```
    初始化 SuperpixelSLIC 对象
    
    参数
    
    image - 待分割图像。SLIC 使用 region_size 分割，SLICO 优化紧凑度，MSLIC 使用流形方法。该函数初始化 SuperpixelSLIC 对象并设置参数。彩色图像建议进行高斯模糊并转换为 CieLAB 空间。![image](pics/superpixels_slic.png)
    
    返回
    
    自动生成
  - 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 类。
    
    返回
    
    自动生成
  - edgePreservingFilter
```
public static void edgePreservingFilter(Mat src,
                                        Mat dst,
                                        int d,
                                        double threshold)
```
    使用保边滤波器平滑图像。该函数可以平滑高斯噪声以及椒盐噪声。有关此实现的更多详情，请参阅 [ReiWoe18] Reich, S. 等人的论文 (2018)。一种实时保边去噪滤波器。DOI: 10.5220/0006509000850094。
    
    参数
    
    src - 源 8 位 3 通道图像。
    
    dst - 目标图像，与 src 具有相同的尺寸和类型。
    
    d - 滤波过程中使用的每个像素邻域的直径。必须大于或等于 3。
    
    threshold - 阈值，用于区分噪声、离群值和数据。

类 Ximgproc

字段摘要

构造函数摘要

方法摘要

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

字段详情

RO_STRICT (严格模式)

RO_IGNORE_BORDERS (忽略边界)

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 (各向异性扩散)

RadonTransform (Radon 变换)

RadonTransform (Radon 变换)

RadonTransform (Radon 变换)

RadonTransform (Radon 变换)

RadonTransform (Radon 变换)

RadonTransform (Radon 变换)

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createSuperpixelSEEDS

createSuperpixelSEEDS

createSuperpixelSEEDS

createSuperpixelSEEDS

findEllipses

findEllipses

findEllipses

findEllipses

createScanSegment