Class Ximgproc


  • public class Ximgproc
    extends java.lang.Object
    • Constructor Detail

      • Ximgproc

        public Ximgproc()
    • Method Detail

      • createAMFilter

        public static AdaptiveManifoldFilter createAMFilter​(double sigma_s,
                                                            double sigma_r,
                                                            boolean adjust_outliers)
      • 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)
      • createDisparityWLSFilterGeneric

        public static DisparityWLSFilter createDisparityWLSFilterGeneric​(boolean use_confidence)
      • 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()
      • 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)