Ximgproc (OpenCV 4.0.0 Java documentation)

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

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`	`colorMatchTemplate(Mat img, Mat templ, Mat result)`
`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 FastBilateralSolverFilter`	`createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma)`
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda)`
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter)`
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)`
`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 void`	`createQuaternionImage(Mat img, Mat qimg)`
`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`	`edgePreservingFilter(Mat src, Mat dst, int d, double threshold)`
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst)`
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial)`
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma)`
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma)`
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda)`
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter)`
`static void`	`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)`
`static void`	`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color)`
`static void`	`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation)`
`static void`	`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation, int num_iter)`
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth)`
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange)`
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op)`
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op, int makeSkew)`
`static void`	`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`	`GradientDericheX(Mat op, Mat dst, double alpha, double omega)`
`static void`	`GradientDericheY(Mat op, Mat dst, double alpha, double omega)`
`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`	`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`	`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
- 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
- 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
- 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
- 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
- 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
- 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

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

createFastBilateralSolverFilter

public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma,
                                                                        double lambda,
                                                                        int num_iter,
                                                                        double max_tol)

createFastBilateralSolverFilter

public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma,
                                                                        double lambda,
                                                                        int num_iter)

createFastBilateralSolverFilter

public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma,
                                                                        double lambda)

createFastBilateralSolverFilter

public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide,
                                                                        double sigma_spatial,
                                                                        double sigma_luma,
                                                                        double sigma_chroma)

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)

GradientDericheX

public static void GradientDericheX(Mat op,
                                    Mat dst,
                                    double alpha,
                                    double omega)

GradientDericheY

public static void GradientDericheY(Mat op,
                                    Mat dst,
                                    double alpha,
                                    double omega)

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)

colorMatchTemplate

public static void colorMatchTemplate(Mat img,
                                      Mat templ,
                                      Mat result)

contourSampling

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

covarianceEstimation

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

createQuaternionImage

public static void createQuaternionImage(Mat img,
                                         Mat qimg)

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)

edgePreservingFilter

public static void edgePreservingFilter(Mat src,
                                        Mat dst,
                                        int d,
                                        double threshold)

fastBilateralSolverFilter

public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma,
                                             double sigma_chroma,
                                             double lambda,
                                             int num_iter,
                                             double max_tol)

fastBilateralSolverFilter

public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma,
                                             double sigma_chroma,
                                             double lambda,
                                             int num_iter)

fastBilateralSolverFilter

public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma,
                                             double sigma_chroma,
                                             double lambda)

fastBilateralSolverFilter

public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma,
                                             double sigma_chroma)

fastBilateralSolverFilter

public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial,
                                             double sigma_luma)

fastBilateralSolverFilter

public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst,
                                             double sigma_spatial)

fastBilateralSolverFilter

public static void fastBilateralSolverFilter(Mat guide,
                                             Mat src,
                                             Mat confidence,
                                             Mat dst)

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)

qconj

public static void qconj(Mat qimg,
                         Mat qcimg)

qdft

public static void qdft(Mat img,
                        Mat qimg,
                        int flags,
                        boolean sideLeft)

qmultiply

public static void qmultiply(Mat src1,
                             Mat src2,
                             Mat dst)

qunitary

public static void qunitary(Mat qimg,
                            Mat qnimg)

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)

Class Ximgproc

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

THINNING_ZHANGSUEN

THINNING_GUOHALL

SLIC

SLICO

MSLIC

WMF_EXP

WMF_IV1

WMF_IV2

WMF_COS

WMF_JAC

WMF_OFF

FHT_MIN

FHT_MAX

FHT_ADD

FHT_AVE

BINARIZATION_NIBLACK

BINARIZATION_SAUVOLA

BINARIZATION_WOLF

BINARIZATION_NICK

DTF_NC

DTF_IC

DTF_RF

GUIDED_FILTER

AM_FILTER

HDO_RAW

HDO_DESKEW

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

Constructor Detail

Ximgproc

Method Detail

createAMFilter

createAMFilter

createContourFitting

createContourFitting

createContourFitting

createDTFilter

createDTFilter

createDTFilter

createDisparityWLSFilter

createDisparityWLSFilterGeneric

createEdgeAwareInterpolator

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createEdgeBoxes

createFastBilateralSolverFilter

createFastBilateralSolverFilter

createFastBilateralSolverFilter

createFastBilateralSolverFilter

createFastGlobalSmootherFilter

createFastGlobalSmootherFilter

createFastGlobalSmootherFilter

createFastLineDetector

createFastLineDetector

createFastLineDetector

createFastLineDetector

createFastLineDetector