org.opencv.ximgproc

## Class Ximgproc

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

-     public class Ximgproc
      extends java.lang.Object

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `AM_FILTER`
    `static int` | `ARO_0_45`
    `static int` | `ARO_315_0`
    `static int` | `ARO_315_135`
    `static int` | `ARO_315_45`
    `static int` | `ARO_45_135`
    `static int` | `ARO_45_90`
    `static int` | `ARO_90_135`
    `static int` | `ARO_CTR_HOR`
    `static int` | `ARO_CTR_VER`
    `static int` | `BINARIZATION_NIBLACK`
    `static int` | `BINARIZATION_NICK`
    `static int` | `BINARIZATION_SAUVOLA`
    `static int` | `BINARIZATION_WOLF`
    `static int` | `DTF_IC`
    `static int` | `DTF_NC`
    `static int` | `DTF_RF`
    `static int` | `FHT_ADD`
    `static int` | `FHT_AVE`
    `static int` | `FHT_MAX`
    `static int` | `FHT_MIN`
    `static int` | `GUIDED_FILTER`
    `static int` | `HDO_DESKEW`
    `static int` | `HDO_RAW`
    `static int` | `MSLIC`
    `static int` | `SLIC`
    `static int` | `SLICO`
    `static int` | `THINNING_GUOHALL`
    `static int` | `THINNING_ZHANGSUEN`
    `static int` | `WMF_COS`
    `static int` | `WMF_EXP`
    `static int` | `WMF_IV1`
    `static int` | `WMF_IV2`
    `static int` | `WMF_JAC`
    `static int` | `WMF_OFF`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Ximgproc()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static void` | `amFilter(Mat joint, Mat src, Mat dst, double sigma_s, double sigma_r)`
    `static void` | `amFilter(Mat joint, Mat src, Mat dst, double sigma_s, double sigma_r, boolean adjust_outliers)`
    `static void` | `anisotropicDiffusion(Mat src, Mat dst, float alpha, float K, int niters)`
    `static void` | `bilateralTextureFilter(Mat src, Mat dst)`
    `static void` | `bilateralTextureFilter(Mat src, Mat dst, int fr)`
    `static void` | `bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter)`
    `static void` | `bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter, double sigmaAlpha)`
    `static void` | `bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter, double sigmaAlpha, double sigmaAvg)`
    `static void` | `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)`
    `static AdaptiveManifoldFilter` | `createAMFilter(double sigma_s, double sigma_r, boolean adjust_outliers)`
    `static ContourFitting` | `createContourFitting()`
    `static ContourFitting` | `createContourFitting(int ctr)`
    `static ContourFitting` | `createContourFitting(int ctr, int fd)`
    `static DisparityWLSFilter` | `createDisparityWLSFilter(StereoMatcher matcher_left)`
    `static DisparityWLSFilter` | `createDisparityWLSFilterGeneric(boolean use_confidence)`
    `static DTFilter` | `createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor)`
    `static DTFilter` | `createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor, int mode)`
    `static DTFilter` | `createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)`
    `static EdgeAwareInterpolator` | `createEdgeAwareInterpolator()`
    `static EdgeBoxes` | `createEdgeBoxes()`
    `static EdgeBoxes` | `createEdgeBoxes(float alpha)`
    `static EdgeBoxes` | `createEdgeBoxes(float alpha, float beta)`
    `static EdgeBoxes` | `createEdgeBoxes(float alpha, float beta, float eta)`
    `static EdgeBoxes` | `createEdgeBoxes(float alpha, float beta, float eta, float minScore)`
    `static EdgeBoxes` | `createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes)`
    `static EdgeBoxes` | `createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag)`
    `static EdgeBoxes` | `createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr)`
    `static EdgeBoxes` | `createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag)`
    `static EdgeBoxes` | `createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag, float maxAspectRatio)`
    `static EdgeBoxes` | `createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag, float maxAspectRatio, float minBoxArea)`
    `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)`
    `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)`
    `static FastGlobalSmootherFilter` | `createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color)`
    `static FastGlobalSmootherFilter` | `createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color, double lambda_attenuation)`
    `static FastGlobalSmootherFilter` | `createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color, double lambda_attenuation, int num_iter)`
    `static FastLineDetector` | `createFastLineDetector()`
    `static FastLineDetector` | `createFastLineDetector(int _length_threshold)`
    `static FastLineDetector` | `createFastLineDetector(int _length_threshold, float _distance_threshold)`
    `static FastLineDetector` | `createFastLineDetector(int _length_threshold, float _distance_threshold, double _canny_th1)`
    `static FastLineDetector` | `createFastLineDetector(int _length_threshold, float _distance_threshold, double _canny_th1, double _canny_th2)`
    `static FastLineDetector` | `createFastLineDetector(int _length_threshold, float _distance_threshold, double _canny_th1, double _canny_th2, int _canny_aperture_size)`
    `static FastLineDetector` | `createFastLineDetector(int _length_threshold, float _distance_threshold, double _canny_th1, double _canny_th2, int _canny_aperture_size, boolean _do_merge)`
    `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)`
    `static RFFeatureGetter` | `createRFFeatureGetter()`
    `static StereoMatcher` | `createRightMatcher(StereoMatcher matcher_left)`
    `static SelectiveSearchSegmentation` | `createSelectiveSearchSegmentation()`
    `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)`
    `static SuperpixelLSC` | `createSuperpixelLSC(Mat image, int region_size)`
    `static SuperpixelLSC` | `createSuperpixelLSC(Mat image, int region_size, float ratio)`
    `static SuperpixelSEEDS` | `createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels)`
    `static SuperpixelSEEDS` | `createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior)`
    `static SuperpixelSEEDS` | `createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior, int histogram_bins)`
    `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)`
    `static SuperpixelSLIC` | `createSuperpixelSLIC(Mat image)`
    `static SuperpixelSLIC` | `createSuperpixelSLIC(Mat image, int algorithm)`
    `static SuperpixelSLIC` | `createSuperpixelSLIC(Mat image, int algorithm, int region_size)`
    `static SuperpixelSLIC` | `createSuperpixelSLIC(Mat image, int algorithm, int region_size, float ruler)`
    `static void` | `dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor)`
    `static void` | `dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor, int mode)`
    `static void` | `dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor, int mode, int numIters)`
    `static void` | `fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color)`
    `static void` | `fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation)`
    `static void` | `fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation, int num_iter)`
    `static void` | `FastHoughTransform(Mat src, Mat dst, int dstMatDepth)`
    `static void` | `FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange)`
    `static void` | `FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op)`
    `static void` | `FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op, int makeSkew)`
    `static void` | `fourierDescriptor(Mat src, Mat dst)`
    `static void` | `fourierDescriptor(Mat src, Mat dst, int nbElt)`
    `static void` | `fourierDescriptor(Mat src, Mat dst, int nbElt, int nbFD)`
    `static void` | `guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps)`
    `static void` | `guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps, int dDepth)`
    `static void` | `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)`
    `static void` | `l0Smooth(Mat src, Mat dst, double lambda)`
    `static void` | `l0Smooth(Mat src, Mat dst, double lambda, double kappa)`
    `static void` | `niBlackThreshold(Mat _src, Mat _dst, double maxValue, int type, int blockSize, double k)`
    `static void` | `niBlackThreshold(Mat _src, Mat _dst, double maxValue, int type, int blockSize, double k, int binarizationMethod)`
    `static void` | `PeiLinNormalization(Mat I, Mat T)`
    `static void` | `rollingGuidanceFilter(Mat src, Mat dst)`
    `static void` | `rollingGuidanceFilter(Mat src, Mat dst, int d)`
    `static void` | `rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor)`
    `static void` | `rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace)`
    `static void` | `rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter)`
    `static void` | `rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter, int borderType)`
    `static void` | `thinning(Mat src, Mat dst)`
    `static void` | `thinning(Mat src, Mat dst, int thinningType)`
    `static void` | `transformFD(Mat src, Mat t, Mat dst)`
    `static void` | `transformFD(Mat src, Mat t, Mat dst, boolean fdContour)`
    `static void` | `weightedMedianFilter(Mat joint, Mat src, Mat dst, int r)`
    `static void` | `weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma)`
    `static void` | `weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma, int weightType)`
    `static void` | `weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma, int weightType, Mat mask)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### THINNING_ZHANGSUEN

          public static final int THINNING_ZHANGSUEN

      See Also:
        Constant Field Values

    - #### THINNING_GUOHALL

          public static final int THINNING_GUOHALL

      See Also:
        Constant Field Values

    - #### BINARIZATION_NIBLACK

          public static final int BINARIZATION_NIBLACK

      See Also:
        Constant Field Values

    - #### BINARIZATION_SAUVOLA

          public static final int BINARIZATION_SAUVOLA

      See Also:
        Constant Field Values

    - #### BINARIZATION_WOLF

          public static final int BINARIZATION_WOLF

      See Also:
        Constant Field Values

    - #### BINARIZATION_NICK

          public static final int BINARIZATION_NICK

      See Also:
        Constant Field Values

    - #### DTF_NC

          public static final int DTF_NC

      See Also:
        Constant Field Values

    - #### DTF_IC

          public static final int DTF_IC

      See Also:
        Constant Field Values

    - #### DTF_RF

          public static final int DTF_RF

      See Also:
        Constant Field Values

    - #### GUIDED_FILTER

          public static final int GUIDED_FILTER

      See Also:
        Constant Field Values

    - #### AM_FILTER

          public static final int AM_FILTER

      See Also:
        Constant Field Values

    - #### WMF_EXP

          public static final int WMF_EXP

      See Also:
        Constant Field Values

    - #### WMF_IV1

          public static final int WMF_IV1

      See Also:
        Constant Field Values

    - #### WMF_IV2

          public static final int WMF_IV2

      See Also:
        Constant Field Values

    - #### WMF_COS

          public static final int WMF_COS

      See Also:
        Constant Field Values

    - #### WMF_JAC

          public static final int WMF_JAC

      See Also:
        Constant Field Values

    - #### WMF_OFF

          public static final int WMF_OFF

      See Also:
        Constant Field Values

    - #### ARO_0_45

          public static final int ARO_0_45

      See Also:
        Constant Field Values

    - #### ARO_45_90

          public static final int ARO_45_90

      See Also:
        Constant Field Values

    - #### ARO_90_135

          public static final int ARO_90_135

      See Also:
        Constant Field Values

    - #### ARO_315_0

          public static final int ARO_315_0

      See Also:
        Constant Field Values

    - #### ARO_315_45

          public static final int ARO_315_45

      See Also:
        Constant Field Values

    - #### ARO_45_135

          public static final int ARO_45_135

      See Also:
        Constant Field Values

    - #### ARO_315_135

          public static final int ARO_315_135

      See Also:
        Constant Field Values

    - #### ARO_CTR_HOR

          public static final int ARO_CTR_HOR

      See Also:
        Constant Field Values

    - #### ARO_CTR_VER

          public static final int ARO_CTR_VER

      See Also:
        Constant Field Values

    - #### FHT_MIN

          public static final int FHT_MIN

      See Also:
        Constant Field Values

    - #### FHT_MAX

          public static final int FHT_MAX

      See Also:
        Constant Field Values

    - #### FHT_ADD

          public static final int FHT_ADD

      See Also:
        Constant Field Values

    - #### FHT_AVE

          public static final int FHT_AVE

      See Also:
        Constant Field Values

    - #### HDO_RAW

          public static final int HDO_RAW

      See Also:
        Constant Field Values

    - #### HDO_DESKEW

          public static final int HDO_DESKEW

      See Also:
        Constant Field Values

    - #### SLIC

          public static final int SLIC

      See Also:
        Constant Field Values

    - #### SLICO

          public static final int SLICO

      See Also:
        Constant Field Values

    - #### MSLIC

          public static final int MSLIC

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### Ximgproc

          public Ximgproc()

  - ### Method Detail

    - #### createAMFilter

          public static AdaptiveManifoldFilter createAMFilter(double sigma_s,
                                                              double sigma_r,
                                                              boolean adjust_outliers)

    - #### createAMFilter

          public static AdaptiveManifoldFilter createAMFilter(double sigma_s,
                                                              double sigma_r)

    - #### createContourFitting

          public static ContourFitting createContourFitting(int ctr,
                                                            int fd)

    - #### createContourFitting

          public static ContourFitting createContourFitting(int ctr)

    - #### createContourFitting

          public static ContourFitting createContourFitting()

    - #### createDTFilter

          public static DTFilter createDTFilter(Mat guide,
                                                double sigmaSpatial,
                                                double sigmaColor,
                                                int mode,
                                                int numIters)

    - #### createDTFilter

          public static DTFilter createDTFilter(Mat guide,
                                                double sigmaSpatial,
                                                double sigmaColor,
                                                int mode)

    - #### createDTFilter

          public static DTFilter createDTFilter(Mat guide,
                                                double sigmaSpatial,
                                                double sigmaColor)

    - #### createDisparityWLSFilter

          public static DisparityWLSFilter createDisparityWLSFilter(StereoMatcher matcher_left)

    - #### createDisparityWLSFilterGeneric

          public static DisparityWLSFilter createDisparityWLSFilterGeneric(boolean use_confidence)

    - #### createEdgeAwareInterpolator

          public static EdgeAwareInterpolator createEdgeAwareInterpolator()

    - #### 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)

    - #### 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)

    - #### 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)

    - #### createEdgeBoxes

          public static EdgeBoxes createEdgeBoxes(float alpha,
                                                  float beta,
                                                  float eta,
                                                  float minScore,
                                                  int maxBoxes,
                                                  float edgeMinMag,
                                                  float edgeMergeThr,
                                                  float clusterMinMag,
                                                  float maxAspectRatio)

    - #### createEdgeBoxes

          public static EdgeBoxes createEdgeBoxes(float alpha,
                                                  float beta,
                                                  float eta,
                                                  float minScore,
                                                  int maxBoxes,
                                                  float edgeMinMag,
                                                  float edgeMergeThr,
                                                  float clusterMinMag)

    - #### createEdgeBoxes

          public static EdgeBoxes createEdgeBoxes(float alpha,
                                                  float beta,
                                                  float eta,
                                                  float minScore,
                                                  int maxBoxes,
                                                  float edgeMinMag,
                                                  float edgeMergeThr)

    - #### createEdgeBoxes

          public static EdgeBoxes createEdgeBoxes(float alpha,
                                                  float beta,
                                                  float eta,
                                                  float minScore,
                                                  int maxBoxes,
                                                  float edgeMinMag)

    - #### createEdgeBoxes

          public static EdgeBoxes createEdgeBoxes(float alpha,
                                                  float beta,
                                                  float eta,
                                                  float minScore,
                                                  int maxBoxes)

    - #### createEdgeBoxes

          public static EdgeBoxes createEdgeBoxes(float alpha,
                                                  float beta,
                                                  float eta,
                                                  float minScore)

    - #### createEdgeBoxes

          public static EdgeBoxes createEdgeBoxes(float alpha,
                                                  float beta,
                                                  float eta)

    - #### createEdgeBoxes

          public static EdgeBoxes createEdgeBoxes(float alpha,
                                                  float beta)

    - #### createEdgeBoxes

          public static EdgeBoxes createEdgeBoxes(float alpha)

    - #### createEdgeBoxes

          public static EdgeBoxes createEdgeBoxes()

    - #### createFastGlobalSmootherFilter

          public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(Mat guide,
                                                                                double lambda,
                                                                                double sigma_color,
                                                                                double lambda_attenuation,
                                                                                int num_iter)

    - #### createFastGlobalSmootherFilter

          public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(Mat guide,
                                                                                double lambda,
                                                                                double sigma_color,
                                                                                double lambda_attenuation)

    - #### createFastGlobalSmootherFilter

          public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(Mat guide,
                                                                                double lambda,
                                                                                double sigma_color)

    - #### createFastLineDetector

          public static FastLineDetector createFastLineDetector(int _length_threshold,
                                                                float _distance_threshold,
                                                                double _canny_th1,
                                                                double _canny_th2,
                                                                int _canny_aperture_size,
                                                                boolean _do_merge)

    - #### createFastLineDetector

          public static FastLineDetector createFastLineDetector(int _length_threshold,
                                                                float _distance_threshold,
                                                                double _canny_th1,
                                                                double _canny_th2,
                                                                int _canny_aperture_size)

    - #### createFastLineDetector

          public static FastLineDetector createFastLineDetector(int _length_threshold,
                                                                float _distance_threshold,
                                                                double _canny_th1,
                                                                double _canny_th2)

    - #### createFastLineDetector

          public static FastLineDetector createFastLineDetector(int _length_threshold,
                                                                float _distance_threshold,
                                                                double _canny_th1)

    - #### createFastLineDetector

          public static FastLineDetector createFastLineDetector(int _length_threshold,
                                                                float _distance_threshold)

    - #### createFastLineDetector

          public static FastLineDetector createFastLineDetector(int _length_threshold)

    - #### createFastLineDetector

          public static FastLineDetector createFastLineDetector()

    - #### createGraphSegmentation

          public static GraphSegmentation createGraphSegmentation(double sigma,
                                                                  float k,
                                                                  int min_size)

    - #### createGraphSegmentation

          public static GraphSegmentation createGraphSegmentation(double sigma,
                                                                  float k)

    - #### createGraphSegmentation

          public static GraphSegmentation createGraphSegmentation(double sigma)

    - #### createGraphSegmentation

          public static GraphSegmentation createGraphSegmentation()

    - #### createGuidedFilter

          public static GuidedFilter createGuidedFilter(Mat guide,
                                                        int radius,
                                                        double eps)

    - #### createRFFeatureGetter

          public static RFFeatureGetter createRFFeatureGetter()

    - #### createSelectiveSearchSegmentation

          public static SelectiveSearchSegmentation createSelectiveSearchSegmentation()

    - #### createSelectiveSearchSegmentationStrategyColor

          public static SelectiveSearchSegmentationStrategyColor createSelectiveSearchSegmentationStrategyColor()

    - #### createSelectiveSearchSegmentationStrategyFill

          public static SelectiveSearchSegmentationStrategyFill createSelectiveSearchSegmentationStrategyFill()

    - #### createSelectiveSearchSegmentationStrategyMultiple

          public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1,
                                                                                                                      SelectiveSearchSegmentationStrategy s2,
                                                                                                                      SelectiveSearchSegmentationStrategy s3,
                                                                                                                      SelectiveSearchSegmentationStrategy s4)

    - #### createSelectiveSearchSegmentationStrategyMultiple

          public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1,
                                                                                                                      SelectiveSearchSegmentationStrategy s2,
                                                                                                                      SelectiveSearchSegmentationStrategy s3)

    - #### createSelectiveSearchSegmentationStrategyMultiple

          public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1,
                                                                                                                      SelectiveSearchSegmentationStrategy s2)

    - #### createSelectiveSearchSegmentationStrategyMultiple

          public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1)

    - #### createSelectiveSearchSegmentationStrategyMultiple

          public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple()

    - #### createSelectiveSearchSegmentationStrategySize

          public static SelectiveSearchSegmentationStrategySize createSelectiveSearchSegmentationStrategySize()

    - #### createSelectiveSearchSegmentationStrategyTexture

          public static SelectiveSearchSegmentationStrategyTexture createSelectiveSearchSegmentationStrategyTexture()

    - #### createRightMatcher

          public static StereoMatcher createRightMatcher(StereoMatcher matcher_left)

    - #### createStructuredEdgeDetection

          public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model,
                                                                              RFFeatureGetter howToGetFeatures)

    - #### createStructuredEdgeDetection

          public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model)

    - #### createSuperpixelLSC

          public static SuperpixelLSC createSuperpixelLSC(Mat image,
                                                          int region_size,
                                                          float ratio)

    - #### createSuperpixelLSC

          public static SuperpixelLSC createSuperpixelLSC(Mat image,
                                                          int region_size)

    - #### createSuperpixelLSC

          public static SuperpixelLSC createSuperpixelLSC(Mat image)

    - #### 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)

    - #### 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)

    - #### createSuperpixelSEEDS

          public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width,
                                                              int image_height,
                                                              int image_channels,
                                                              int num_superpixels,
                                                              int num_levels,
                                                              int prior)

    - #### createSuperpixelSEEDS

          public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width,
                                                              int image_height,
                                                              int image_channels,
                                                              int num_superpixels,
                                                              int num_levels)

    - #### createSuperpixelSLIC

          public static SuperpixelSLIC createSuperpixelSLIC(Mat image,
                                                            int algorithm,
                                                            int region_size,
                                                            float ruler)

    - #### createSuperpixelSLIC

          public static SuperpixelSLIC createSuperpixelSLIC(Mat image,
                                                            int algorithm,
                                                            int region_size)

    - #### createSuperpixelSLIC

          public static SuperpixelSLIC createSuperpixelSLIC(Mat image,
                                                            int algorithm)

    - #### createSuperpixelSLIC

          public static SuperpixelSLIC createSuperpixelSLIC(Mat image)

    - #### FastHoughTransform

          public static void FastHoughTransform(Mat src,
                                                Mat dst,
                                                int dstMatDepth,
                                                int angleRange,
                                                int op,
                                                int makeSkew)

    - #### FastHoughTransform

          public static void FastHoughTransform(Mat src,
                                                Mat dst,
                                                int dstMatDepth,
                                                int angleRange,
                                                int op)

    - #### FastHoughTransform

          public static void FastHoughTransform(Mat src,
                                                Mat dst,
                                                int dstMatDepth,
                                                int angleRange)

    - #### FastHoughTransform

          public static void FastHoughTransform(Mat src,
                                                Mat dst,
                                                int dstMatDepth)

    - #### PeiLinNormalization

          public static void PeiLinNormalization(Mat I,
                                                 Mat T)

    - #### amFilter

          public static void amFilter(Mat joint,
                                      Mat src,
                                      Mat dst,
                                      double sigma_s,
                                      double sigma_r,
                                      boolean adjust_outliers)

    - #### amFilter

          public static void amFilter(Mat joint,
                                      Mat src,
                                      Mat dst,
                                      double sigma_s,
                                      double sigma_r)

    - #### anisotropicDiffusion

          public static void anisotropicDiffusion(Mat src,
                                                  Mat dst,
                                                  float alpha,
                                                  float K,
                                                  int niters)

    - #### bilateralTextureFilter

          public static void bilateralTextureFilter(Mat src,
                                                    Mat dst,
                                                    int fr,
                                                    int numIter,
                                                    double sigmaAlpha,
                                                    double sigmaAvg)

    - #### bilateralTextureFilter

          public static void bilateralTextureFilter(Mat src,
                                                    Mat dst,
                                                    int fr,
                                                    int numIter,
                                                    double sigmaAlpha)

    - #### bilateralTextureFilter

          public static void bilateralTextureFilter(Mat src,
                                                    Mat dst,
                                                    int fr,
                                                    int numIter)

    - #### bilateralTextureFilter

          public static void bilateralTextureFilter(Mat src,
                                                    Mat dst,
                                                    int fr)

    - #### bilateralTextureFilter

          public static void bilateralTextureFilter(Mat src,
                                                    Mat dst)

    - #### contourSampling

          public static void contourSampling(Mat src,
                                             Mat out,
                                             int nbElt)

    - #### covarianceEstimation

          public static void covarianceEstimation(Mat src,
                                                  Mat dst,
                                                  int windowRows,
                                                  int windowCols)

    - #### dtFilter

          public static void dtFilter(Mat guide,
                                      Mat src,
                                      Mat dst,
                                      double sigmaSpatial,
                                      double sigmaColor,
                                      int mode,
                                      int numIters)

    - #### dtFilter

          public static void dtFilter(Mat guide,
                                      Mat src,
                                      Mat dst,
                                      double sigmaSpatial,
                                      double sigmaColor,
                                      int mode)

    - #### dtFilter

          public static void dtFilter(Mat guide,
                                      Mat src,
                                      Mat dst,
                                      double sigmaSpatial,
                                      double sigmaColor)

    - #### fastGlobalSmootherFilter

          public static void fastGlobalSmootherFilter(Mat guide,
                                                      Mat src,
                                                      Mat dst,
                                                      double lambda,
                                                      double sigma_color,
                                                      double lambda_attenuation,
                                                      int num_iter)

    - #### fastGlobalSmootherFilter

          public static void fastGlobalSmootherFilter(Mat guide,
                                                      Mat src,
                                                      Mat dst,
                                                      double lambda,
                                                      double sigma_color,
                                                      double lambda_attenuation)

    - #### fastGlobalSmootherFilter

          public static void fastGlobalSmootherFilter(Mat guide,
                                                      Mat src,
                                                      Mat dst,
                                                      double lambda,
                                                      double sigma_color)

    - #### fourierDescriptor

          public static void fourierDescriptor(Mat src,
                                               Mat dst,
                                               int nbElt,
                                               int nbFD)

    - #### fourierDescriptor

          public static void fourierDescriptor(Mat src,
                                               Mat dst,
                                               int nbElt)

    - #### fourierDescriptor

          public static void fourierDescriptor(Mat src,
                                               Mat dst)

    - #### guidedFilter

          public static void guidedFilter(Mat guide,
                                          Mat src,
                                          Mat dst,
                                          int radius,
                                          double eps,
                                          int dDepth)

    - #### guidedFilter

          public static void guidedFilter(Mat guide,
                                          Mat src,
                                          Mat dst,
                                          int radius,
                                          double eps)

    - #### jointBilateralFilter

          public static void jointBilateralFilter(Mat joint,
                                                  Mat src,
                                                  Mat dst,
                                                  int d,
                                                  double sigmaColor,
                                                  double sigmaSpace,
                                                  int borderType)

    - #### jointBilateralFilter

          public static void jointBilateralFilter(Mat joint,
                                                  Mat src,
                                                  Mat dst,
                                                  int d,
                                                  double sigmaColor,
                                                  double sigmaSpace)

    - #### l0Smooth

          public static void l0Smooth(Mat src,
                                      Mat dst,
                                      double lambda,
                                      double kappa)

    - #### l0Smooth

          public static void l0Smooth(Mat src,
                                      Mat dst,
                                      double lambda)

    - #### l0Smooth

          public static void l0Smooth(Mat src,
                                      Mat dst)

    - #### niBlackThreshold

          public static void niBlackThreshold(Mat _src,
                                              Mat _dst,
                                              double maxValue,
                                              int type,
                                              int blockSize,
                                              double k,
                                              int binarizationMethod)

    - #### niBlackThreshold

          public static void niBlackThreshold(Mat _src,
                                              Mat _dst,
                                              double maxValue,
                                              int type,
                                              int blockSize,
                                              double k)

    - #### rollingGuidanceFilter

          public static void rollingGuidanceFilter(Mat src,
                                                   Mat dst,
                                                   int d,
                                                   double sigmaColor,
                                                   double sigmaSpace,
                                                   int numOfIter,
                                                   int borderType)

    - #### rollingGuidanceFilter

          public static void rollingGuidanceFilter(Mat src,
                                                   Mat dst,
                                                   int d,
                                                   double sigmaColor,
                                                   double sigmaSpace,
                                                   int numOfIter)

    - #### rollingGuidanceFilter

          public static void rollingGuidanceFilter(Mat src,
                                                   Mat dst,
                                                   int d,
                                                   double sigmaColor,
                                                   double sigmaSpace)

    - #### rollingGuidanceFilter

          public static void rollingGuidanceFilter(Mat src,
                                                   Mat dst,
                                                   int d,
                                                   double sigmaColor)

    - #### rollingGuidanceFilter

          public static void rollingGuidanceFilter(Mat src,
                                                   Mat dst,
                                                   int d)

    - #### rollingGuidanceFilter

          public static void rollingGuidanceFilter(Mat src,
                                                   Mat dst)

    - #### thinning

          public static void thinning(Mat src,
                                      Mat dst,
                                      int thinningType)

    - #### thinning

          public static void thinning(Mat src,
                                      Mat dst)

    - #### transformFD

          public static void transformFD(Mat src,
                                         Mat t,
                                         Mat dst,
                                         boolean fdContour)

    - #### transformFD

          public static void transformFD(Mat src,
                                         Mat t,
                                         Mat dst)

    - #### weightedMedianFilter

          public static void weightedMedianFilter(Mat joint,
                                                  Mat src,
                                                  Mat dst,
                                                  int r,
                                                  double sigma,
                                                  int weightType,
                                                  Mat mask)

    - #### weightedMedianFilter

          public static void weightedMedianFilter(Mat joint,
                                                  Mat src,
                                                  Mat dst,
                                                  int r,
                                                  double sigma,
                                                  int weightType)

    - #### weightedMedianFilter

          public static void weightedMedianFilter(Mat joint,
                                                  Mat src,
                                                  Mat dst,
                                                  int r,
                                                  double sigma)

    - #### weightedMedianFilter

          public static void weightedMedianFilter(Mat joint,
                                                  Mat src,
                                                  Mat dst,
                                                  int r)

Generated on Wed Aug 29 2018 10:29:57 UTC / OpenCV 3.4.3