opencv_ximgproc (JavaCPP Presets for OpenCV 4.10.0-1.5.11 API)

java.lang.Object
- org.bytedeco.opencv.presets.opencv_ximgproc
- - org.bytedeco.opencv.global.opencv_ximgproc

All Implemented Interfaces:: InfoMapper

public class opencv_ximgproc
extends opencv_ximgproc

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`AM_FILTER` enum cv::ximgproc::EdgeAwareFiltersList
`static int`	`ARO_0_45` enum cv::ximgproc::AngleRangeOption
`static int`	`ARO_315_0` enum cv::ximgproc::AngleRangeOption
`static int`	`ARO_315_135` enum cv::ximgproc::AngleRangeOption
`static int`	`ARO_315_45` enum cv::ximgproc::AngleRangeOption
`static int`	`ARO_45_135` enum cv::ximgproc::AngleRangeOption
`static int`	`ARO_45_90` enum cv::ximgproc::AngleRangeOption
`static int`	`ARO_90_135` enum cv::ximgproc::AngleRangeOption
`static int`	`ARO_CTR_HOR` enum cv::ximgproc::AngleRangeOption
`static int`	`ARO_CTR_VER` enum cv::ximgproc::AngleRangeOption
`static int`	`BINARIZATION_NIBLACK` enum cv::ximgproc::LocalBinarizationMethods
`static int`	`BINARIZATION_NICK` enum cv::ximgproc::LocalBinarizationMethods
`static int`	`BINARIZATION_SAUVOLA` enum cv::ximgproc::LocalBinarizationMethods
`static int`	`BINARIZATION_WOLF` enum cv::ximgproc::LocalBinarizationMethods
`static int`	`DTF_IC` enum cv::ximgproc::EdgeAwareFiltersList
`static int`	`DTF_NC` enum cv::ximgproc::EdgeAwareFiltersList
`static int`	`DTF_RF` enum cv::ximgproc::EdgeAwareFiltersList
`static int`	`FHT_ADD` enum cv::ximgproc::HoughOp
`static int`	`FHT_AVE` enum cv::ximgproc::HoughOp
`static int`	`FHT_MAX` enum cv::ximgproc::HoughOp
`static int`	`FHT_MIN` enum cv::ximgproc::HoughOp
`static int`	`GUIDED_FILTER` enum cv::ximgproc::EdgeAwareFiltersList
`static int`	`HDO_DESKEW` enum cv::ximgproc::HoughDeskewOption
`static int`	`HDO_RAW` enum cv::ximgproc::HoughDeskewOption
`static int`	`MSLIC` enum cv::ximgproc::SLICType
`static int`	`RO_IGNORE_BORDERS` enum cv::ximgproc::RulesOption
`static int`	`RO_STRICT` enum cv::ximgproc::RulesOption
`static int`	`SLIC` enum cv::ximgproc::SLICType
`static int`	`SLICO` enum cv::ximgproc::SLICType
`static int`	`THINNING_GUOHALL` enum cv::ximgproc::ThinningTypes
`static int`	`THINNING_ZHANGSUEN` enum cv::ximgproc::ThinningTypes
`static int`	`WMF_COS` enum cv::ximgproc::WMFWeightType
`static int`	`WMF_EXP` enum cv::ximgproc::WMFWeightType
`static int`	`WMF_IV1` enum cv::ximgproc::WMFWeightType
`static int`	`WMF_IV2` enum cv::ximgproc::WMFWeightType
`static int`	`WMF_JAC` enum cv::ximgproc::WMFWeightType
`static int`	`WMF_OFF` enum cv::ximgproc::WMFWeightType

Constructor Summary

Constructors
Constructor and Description

opencv_ximgproc()

Constructors
Constructor and Description
`opencv_ximgproc()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`amFilter(GpuMat joint, GpuMat src, GpuMat dst, double sigma_s, double sigma_r)`
`static void`	`amFilter(GpuMat joint, GpuMat src, GpuMat dst, double sigma_s, double sigma_r, boolean adjust_outliers)`
`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)` \brief Simple one-line Adaptive Manifold Filter call.
`static void`	`amFilter(UMat joint, UMat src, UMat dst, double sigma_s, double sigma_r)`
`static void`	`amFilter(UMat joint, UMat src, UMat dst, double sigma_s, double sigma_r, boolean adjust_outliers)`
`static void`	`anisotropicDiffusion(GpuMat src, GpuMat dst, float alpha, float K, int niters)`
`static void`	`anisotropicDiffusion(Mat src, Mat dst, float alpha, float K, int niters)` \brief Performs anisotropic diffusion on an image.
`static void`	`anisotropicDiffusion(UMat src, UMat dst, float alpha, float K, int niters)`
`static void`	`bilateralTextureFilter(GpuMat src, GpuMat dst)`
`static void`	`bilateralTextureFilter(GpuMat src, GpuMat dst, int fr, int numIter, double sigmaAlpha, double sigmaAvg)`
`static void`	`bilateralTextureFilter(Mat src, Mat dst)`
`static void`	`bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter, double sigmaAlpha, double sigmaAvg)` \brief Applies the bilateral texture filter to an image.
`static void`	`bilateralTextureFilter(UMat src, UMat dst)`
`static void`	`bilateralTextureFilter(UMat src, UMat dst, int fr, int numIter, double sigmaAlpha, double sigmaAvg)`
`static void`	`BrightEdges(Mat _original, Mat _edgeview)`
`static void`	`BrightEdges(Mat _original, Mat _edgeview, int contrast, int shortrange, int longrange)` \}
`static void`	`colorMatchTemplate(GpuMat img, GpuMat templ, GpuMat result)`
`static void`	`colorMatchTemplate(Mat img, Mat templ, Mat result)` \brief Compares a color template against overlapped color image regions.
`static void`	`colorMatchTemplate(UMat img, UMat templ, UMat result)`
`static double`	`computeBadPixelPercent(GpuMat GT, GpuMat src, Rect ROI)`
`static double`	`computeBadPixelPercent(GpuMat GT, GpuMat src, Rect ROI, int thresh)`
`static double`	`computeBadPixelPercent(Mat GT, Mat src, Rect ROI)`
`static double`	`computeBadPixelPercent(Mat GT, Mat src, Rect ROI, int thresh)` \brief Function for computing the percent of "bad" pixels in the disparity map (pixels where error is higher than a specified threshold)
`static double`	`computeBadPixelPercent(UMat GT, UMat src, Rect ROI)`
`static double`	`computeBadPixelPercent(UMat GT, UMat src, Rect ROI, int thresh)`
`static double`	`computeMSE(GpuMat GT, GpuMat src, Rect ROI)`
`static double`	`computeMSE(Mat GT, Mat src, Rect ROI)` \brief Function for computing mean square error for disparity maps
`static double`	`computeMSE(UMat GT, UMat src, Rect ROI)`
`static void`	`contourSampling(GpuMat src, GpuMat out, int nbElt)`
`static void`	`contourSampling(Mat src, Mat out, int nbElt)` \brief Contour sampling .
`static void`	`contourSampling(UMat src, UMat out, int nbElt)`
`static void`	`covarianceEstimation(GpuMat src, GpuMat dst, int windowRows, int windowCols)`
`static void`	`covarianceEstimation(Mat src, Mat dst, int windowRows, int windowCols)` \brief Computes the estimated covariance matrix of an image using the sliding window forumlation.
`static void`	`covarianceEstimation(UMat src, UMat 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)` \brief Factory method, create instance of AdaptiveManifoldFilter and produce some initialization routines.
`static ContourFitting`	`createContourFitting()`
`static ContourFitting`	`createContourFitting(int ctr, int fd)` \brief create ContourFitting algorithm object
`static DisparityWLSFilter`	`createDisparityWLSFilter(StereoMatcher matcher_left)` \brief Convenience factory method that creates an instance of DisparityWLSFilter and sets up all the relevant filter parameters automatically based on the matcher instance.
`static DisparityWLSFilter`	`createDisparityWLSFilterGeneric(boolean use_confidence)` \brief More generic factory method, create instance of DisparityWLSFilter and execute basic initialization routines.
`static DTFilter`	`createDTFilter(GpuMat guide, double sigmaSpatial, double sigmaColor)`
`static DTFilter`	`createDTFilter(GpuMat guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)`
`static DTFilter`	`createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor)`
`static DTFilter`	`createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)` \brief Factory method, create instance of DTFilter and produce initialization routines.
`static DTFilter`	`createDTFilter(UMat guide, double sigmaSpatial, double sigmaColor)`
`static DTFilter`	`createDTFilter(UMat guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)`
`static EdgeAwareInterpolator`	`createEdgeAwareInterpolator()` \brief Factory method that creates an instance of the EdgeAwareInterpolator.
`static EdgeBoxes`	`createEdgeBoxes()`
`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)` \brief Creates a Edgeboxes
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(GpuMat guide, double sigma_spatial, double sigma_luma, double sigma_chroma)`
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(GpuMat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)`
`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, int num_iter, double max_tol)` \brief Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines.
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(UMat guide, double sigma_spatial, double sigma_luma, double sigma_chroma)`
`static FastBilateralSolverFilter`	`createFastBilateralSolverFilter(UMat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)`
`static FastGlobalSmootherFilter`	`createFastGlobalSmootherFilter(GpuMat guide, double lambda, double sigma_color)`
`static FastGlobalSmootherFilter`	`createFastGlobalSmootherFilter(GpuMat guide, double lambda, double sigma_color, double lambda_attenuation, int num_iter)`
`static FastGlobalSmootherFilter`	`createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color)`
`static FastGlobalSmootherFilter`	`createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color, double lambda_attenuation, int num_iter)` \brief Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines.
`static FastGlobalSmootherFilter`	`createFastGlobalSmootherFilter(UMat guide, double lambda, double sigma_color)`
`static FastGlobalSmootherFilter`	`createFastGlobalSmootherFilter(UMat guide, double lambda, double sigma_color, double lambda_attenuation, int num_iter)`
`static FastLineDetector`	`createFastLineDetector()`
`static FastLineDetector`	`createFastLineDetector(int length_threshold, float distance_threshold, double canny_th1, double canny_th2, int canny_aperture_size, boolean do_merge)` \brief Creates a smart pointer to a FastLineDetector object and initializes it
`static GraphSegmentation`	`createGraphSegmentation()`
`static GraphSegmentation`	`createGraphSegmentation(double sigma, float k, int min_size)` \brief Creates a graph based segmentor
`static GuidedFilter`	`createGuidedFilter(GpuMat guide, int radius, double eps)`
`static GuidedFilter`	`createGuidedFilter(GpuMat guide, int radius, double eps, double scale)`
`static GuidedFilter`	`createGuidedFilter(Mat guide, int radius, double eps)`
`static GuidedFilter`	`createGuidedFilter(Mat guide, int radius, double eps, double scale)` \brief Factory method, create instance of GuidedFilter and produce initialization routines.
`static GuidedFilter`	`createGuidedFilter(UMat guide, int radius, double eps)`
`static GuidedFilter`	`createGuidedFilter(UMat guide, int radius, double eps, double scale)`
`static void`	`createQuaternionImage(GpuMat img, GpuMat qimg)`
`static void`	`createQuaternionImage(Mat img, Mat qimg)` \addtogroup ximgproc_filters \{
`static void`	`createQuaternionImage(UMat img, UMat qimg)`
`static RFFeatureGetter`	`createRFFeatureGetter()` \file \date Jun 17, 2014
`static RICInterpolator`	`createRICInterpolator()` \brief Factory method that creates an instance of the RICInterpolator.
`static StereoMatcher`	`createRightMatcher(StereoMatcher matcher_left)` \brief Convenience method to set up the matcher for computing the right-view disparity map that is required in case of filtering with confidence.
`static void`	`createRLEImage(Point3iVector runs, GpuMat res)`
`static void`	`createRLEImage(Point3iVector runs, GpuMat res, Size size)`
`static void`	`createRLEImage(Point3iVector runs, Mat res)`
`static void`	`createRLEImage(Point3iVector runs, Mat res, Size size)` \brief Creates a run-length encoded image from a vector of runs (column begin, column end, row)
`static void`	`createRLEImage(Point3iVector runs, UMat res)`
`static void`	`createRLEImage(Point3iVector runs, UMat res, Size size)`
`static SelectiveSearchSegmentation`	`createSelectiveSearchSegmentation()` \brief Create a new SelectiveSearchSegmentation class.
`static SelectiveSearchSegmentationStrategyColor`	`createSelectiveSearchSegmentationStrategyColor()` \brief Create a new color-based strategy
`static SelectiveSearchSegmentationStrategyFill`	`createSelectiveSearchSegmentationStrategyFill()` \brief Create a new fill-based strategy
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple()` \brief Create a new multiple strategy
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1)` \brief Create a new multiple strategy and set one subtrategy
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2)` \brief Create a new multiple strategy and set two subtrategies, with equal weights
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2, SelectiveSearchSegmentationStrategy s3)` \brief Create a new multiple strategy and set three subtrategies, with equal weights
`static SelectiveSearchSegmentationStrategyMultiple`	`createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2, SelectiveSearchSegmentationStrategy s3, SelectiveSearchSegmentationStrategy s4)` \brief Create a new multiple strategy and set four subtrategies, with equal weights
`static SelectiveSearchSegmentationStrategySize`	`createSelectiveSearchSegmentationStrategySize()` \brief Create a new size-based strategy
`static SelectiveSearchSegmentationStrategyTexture`	`createSelectiveSearchSegmentationStrategyTexture()` \brief Create a new size-based strategy
`static StructuredEdgeDetection`	`createStructuredEdgeDetection(BytePointer model)`
`static StructuredEdgeDetection`	`createStructuredEdgeDetection(BytePointer model, RFFeatureGetter howToGetFeatures)` The only constructor
`static StructuredEdgeDetection`	`createStructuredEdgeDetection(String model)`
`static StructuredEdgeDetection`	`createStructuredEdgeDetection(String model, RFFeatureGetter howToGetFeatures)`
`static SuperpixelLSC`	`createSuperpixelLSC(GpuMat image)`
`static SuperpixelLSC`	`createSuperpixelLSC(GpuMat image, int region_size, float ratio)`
`static SuperpixelLSC`	`createSuperpixelLSC(Mat image)`
`static SuperpixelLSC`	`createSuperpixelLSC(Mat image, int region_size, float ratio)` \brief Class implementing the LSC (Linear Spectral Clustering) superpixels
`static SuperpixelLSC`	`createSuperpixelLSC(UMat image)`
`static SuperpixelLSC`	`createSuperpixelLSC(UMat 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, int histogram_bins, boolean double_step)` \brief Initializes a SuperpixelSEEDS object.
`static SuperpixelSLIC`	`createSuperpixelSLIC(GpuMat image)`
`static SuperpixelSLIC`	`createSuperpixelSLIC(GpuMat image, int algorithm, int region_size, float ruler)`
`static SuperpixelSLIC`	`createSuperpixelSLIC(Mat image)`
`static SuperpixelSLIC`	`createSuperpixelSLIC(Mat image, int algorithm, int region_size, float ruler)` \brief Initialize a SuperpixelSLIC object
`static SuperpixelSLIC`	`createSuperpixelSLIC(UMat image)`
`static SuperpixelSLIC`	`createSuperpixelSLIC(UMat image, int algorithm, int region_size, float ruler)`
`static void`	`dilate(GpuMat rlSrc, GpuMat rlDest, GpuMat rlKernel)`
`static void`	`dilate(GpuMat rlSrc, GpuMat rlDest, GpuMat rlKernel, Point anchor)`
`static void`	`dilate(Mat rlSrc, Mat rlDest, Mat rlKernel)`
`static void`	`dilate(Mat rlSrc, Mat rlDest, Mat rlKernel, Point anchor)` \brief Dilates an run-length encoded binary image by using a specific structuring element.
`static void`	`dilate(UMat rlSrc, UMat rlDest, UMat rlKernel)`
`static void`	`dilate(UMat rlSrc, UMat rlDest, UMat rlKernel, Point anchor)`
`static void`	`dtFilter(GpuMat guide, GpuMat src, GpuMat dst, double sigmaSpatial, double sigmaColor)`
`static void`	`dtFilter(GpuMat guide, GpuMat src, GpuMat dst, double sigmaSpatial, double sigmaColor, int mode, int numIters)`
`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, int numIters)` \brief Simple one-line Domain Transform filter call.
`static void`	`dtFilter(UMat guide, UMat src, UMat dst, double sigmaSpatial, double sigmaColor)`
`static void`	`dtFilter(UMat guide, UMat src, UMat dst, double sigmaSpatial, double sigmaColor, int mode, int numIters)`
`static void`	`edgePreservingFilter(GpuMat src, GpuMat dst, int d, double threshold)`
`static void`	`edgePreservingFilter(Mat src, Mat dst, int d, double threshold)` \addtogroup ximgproc \{
`static void`	`edgePreservingFilter(UMat src, UMat dst, int d, double threshold)`
`static void`	`erode(GpuMat rlSrc, GpuMat rlDest, GpuMat rlKernel)`
`static void`	`erode(GpuMat rlSrc, GpuMat rlDest, GpuMat rlKernel, boolean bBoundaryOn, Point anchor)`
`static void`	`erode(Mat rlSrc, Mat rlDest, Mat rlKernel)`
`static void`	`erode(Mat rlSrc, Mat rlDest, Mat rlKernel, boolean bBoundaryOn, Point anchor)` \brief Erodes an run-length encoded binary image by using a specific structuring element.
`static void`	`erode(UMat rlSrc, UMat rlDest, UMat rlKernel)`
`static void`	`erode(UMat rlSrc, UMat rlDest, UMat rlKernel, boolean bBoundaryOn, Point anchor)`
`static void`	`fastBilateralSolverFilter(GpuMat guide, GpuMat src, GpuMat confidence, GpuMat dst)`
`static void`	`fastBilateralSolverFilter(GpuMat guide, GpuMat src, GpuMat confidence, GpuMat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)`
`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, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)` \brief Simple one-line Fast Bilateral Solver filter call.
`static void`	`fastBilateralSolverFilter(UMat guide, UMat src, UMat confidence, UMat dst)`
`static void`	`fastBilateralSolverFilter(UMat guide, UMat src, UMat confidence, UMat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)`
`static void`	`fastGlobalSmootherFilter(GpuMat guide, GpuMat src, GpuMat dst, double lambda, double sigma_color)`
`static void`	`fastGlobalSmootherFilter(GpuMat guide, GpuMat src, GpuMat dst, double lambda, double sigma_color, double lambda_attenuation, int num_iter)`
`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, int num_iter)` \brief Simple one-line Fast Global Smoother filter call.
`static void`	`fastGlobalSmootherFilter(UMat guide, UMat src, UMat dst, double lambda, double sigma_color)`
`static void`	`fastGlobalSmootherFilter(UMat guide, UMat src, UMat dst, double lambda, double sigma_color, double lambda_attenuation, int num_iter)`
`static void`	`FastHoughTransform(GpuMat src, GpuMat dst, int dstMatDepth)`
`static void`	`FastHoughTransform(GpuMat src, GpuMat dst, int dstMatDepth, int angleRange, int op, int makeSkew)`
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth)`
`static void`	`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op, int makeSkew)` \brief Calculates 2D Fast Hough transform of an image.
`static void`	`FastHoughTransform(UMat src, UMat dst, int dstMatDepth)`
`static void`	`FastHoughTransform(UMat src, UMat dst, int dstMatDepth, int angleRange, int op, int makeSkew)`
`static void`	`findEllipses(GpuMat image, GpuMat ellipses)`
`static void`	`findEllipses(GpuMat image, GpuMat ellipses, float scoreThreshold, float reliabilityThreshold, float centerDistanceThreshold)`
`static void`	`findEllipses(Mat image, Mat ellipses)`
`static void`	`findEllipses(Mat image, Mat ellipses, float scoreThreshold, float reliabilityThreshold, float centerDistanceThreshold)` \addtogroup ximgproc \{
`static void`	`findEllipses(UMat image, UMat ellipses)`
`static void`	`findEllipses(UMat image, UMat ellipses, float scoreThreshold, float reliabilityThreshold, float centerDistanceThreshold)`
`static void`	`fourierDescriptor(GpuMat src, GpuMat dst)`
`static void`	`fourierDescriptor(GpuMat src, GpuMat dst, int nbElt, int nbFD)`
`static void`	`fourierDescriptor(Mat src, Mat dst)`
`static void`	`fourierDescriptor(Mat src, Mat dst, int nbElt, int nbFD)` \brief Fourier descriptors for planed closed curves For more details about this implementation, please see \cite PersoonFu1977
`static void`	`fourierDescriptor(UMat src, UMat dst)`
`static void`	`fourierDescriptor(UMat src, UMat dst, int nbElt, int nbFD)`
`static void`	`getDisparityVis(GpuMat src, GpuMat dst)`
`static void`	`getDisparityVis(GpuMat src, GpuMat dst, double scale)`
`static void`	`getDisparityVis(Mat src, Mat dst)`
`static void`	`getDisparityVis(Mat src, Mat dst, double scale)` \brief Function for creating a disparity map visualization (clamped CV_8U image)
`static void`	`getDisparityVis(UMat src, UMat dst)`
`static void`	`getDisparityVis(UMat src, UMat dst, double scale)`
`static Mat`	`getStructuringElement(int shape, Size ksize)` \brief Returns a run length encoded structuring element of the specified size and shape.
`static void`	`GradientDericheX(GpuMat op, GpuMat dst, double alpha, double omega)`
`static void`	`GradientDericheX(Mat op, Mat dst, double alpha, double omega)` \brief Applies X Deriche filter to an image.
`static void`	`GradientDericheX(UMat op, UMat dst, double alpha, double omega)`
`static void`	`GradientDericheY(GpuMat op, GpuMat dst, double alpha, double omega)`
`static void`	`GradientDericheY(Mat op, Mat dst, double alpha, double omega)` \addtogroup ximgproc_filters \{
`static void`	`GradientDericheY(UMat op, UMat dst, double alpha, double omega)`
`static void`	`GradientPaillouX(GpuMat op, GpuMat _dst, double alpha, double omega)`
`static void`	`GradientPaillouX(Mat op, Mat _dst, double alpha, double omega)`
`static void`	`GradientPaillouX(UMat op, UMat _dst, double alpha, double omega)`
`static void`	`GradientPaillouY(GpuMat op, GpuMat _dst, double alpha, double omega)`
`static void`	`GradientPaillouY(Mat op, Mat _dst, double alpha, double omega)` \addtogroup ximgproc_filters \{
`static void`	`GradientPaillouY(UMat op, UMat _dst, double alpha, double omega)`
`static void`	`guidedFilter(GpuMat guide, GpuMat src, GpuMat dst, int radius, double eps)`
`static void`	`guidedFilter(GpuMat guide, GpuMat src, GpuMat dst, int radius, double eps, int dDepth, double scale)`
`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, double scale)` \brief Simple one-line (Fast) Guided Filter call.
`static void`	`guidedFilter(UMat guide, UMat src, UMat dst, int radius, double eps)`
`static void`	`guidedFilter(UMat guide, UMat src, UMat dst, int radius, double eps, int dDepth, double scale)`
`static Scalar4i`	`HoughPoint2Line(Point houghPoint, GpuMat srcImgInfo)`
`static Scalar4i`	`HoughPoint2Line(Point houghPoint, GpuMat srcImgInfo, int angleRange, int makeSkew, int rules)`
`static Scalar4i`	`HoughPoint2Line(Point houghPoint, Mat srcImgInfo)`
`static Scalar4i`	`HoughPoint2Line(Point houghPoint, Mat srcImgInfo, int angleRange, int makeSkew, int rules)` \brief Calculates coordinates of line segment corresponded by point in Hough space.
`static Scalar4i`	`HoughPoint2Line(Point houghPoint, UMat srcImgInfo)`
`static Scalar4i`	`HoughPoint2Line(Point houghPoint, UMat srcImgInfo, int angleRange, int makeSkew, int rules)`
`static boolean`	`isRLMorphologyPossible(GpuMat rlStructuringElement)`
`static boolean`	`isRLMorphologyPossible(Mat rlStructuringElement)` \brief Check whether a custom made structuring element can be used with run length morphological operations.
`static boolean`	`isRLMorphologyPossible(UMat rlStructuringElement)`
`static void`	`jointBilateralFilter(GpuMat joint, GpuMat src, GpuMat dst, int d, double sigmaColor, double sigmaSpace)`
`static void`	`jointBilateralFilter(GpuMat joint, GpuMat src, GpuMat dst, int d, double sigmaColor, double sigmaSpace, int borderType)`
`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)` \brief Applies the joint bilateral filter to an image.
`static void`	`jointBilateralFilter(UMat joint, UMat src, UMat dst, int d, double sigmaColor, double sigmaSpace)`
`static void`	`jointBilateralFilter(UMat joint, UMat src, UMat dst, int d, double sigmaColor, double sigmaSpace, int borderType)`
`static void`	`l0Smooth(GpuMat src, GpuMat dst)`
`static void`	`l0Smooth(GpuMat src, GpuMat dst, double lambda, double kappa)`
`static void`	`l0Smooth(Mat src, Mat dst)`
`static void`	`l0Smooth(Mat src, Mat dst, double lambda, double kappa)` \brief Global image smoothing via L0 gradient minimization.
`static void`	`l0Smooth(UMat src, UMat dst)`
`static void`	`l0Smooth(UMat src, UMat dst, double lambda, double kappa)`
`static void`	`morphologyEx(GpuMat rlSrc, GpuMat rlDest, int op, GpuMat rlKernel)`
`static void`	`morphologyEx(GpuMat rlSrc, GpuMat rlDest, int op, GpuMat rlKernel, boolean bBoundaryOnForErosion, Point anchor)`
`static void`	`morphologyEx(Mat rlSrc, Mat rlDest, int op, Mat rlKernel)`
`static void`	`morphologyEx(Mat rlSrc, Mat rlDest, int op, Mat rlKernel, boolean bBoundaryOnForErosion, Point anchor)` \brief Applies a morphological operation to a run-length encoded binary image.
`static void`	`morphologyEx(UMat rlSrc, UMat rlDest, int op, UMat rlKernel)`
`static void`	`morphologyEx(UMat rlSrc, UMat rlDest, int op, UMat rlKernel, boolean bBoundaryOnForErosion, Point anchor)`
`static void`	`niBlackThreshold(GpuMat _src, GpuMat _dst, double maxValue, int type, int blockSize, double k)`
`static void`	`niBlackThreshold(GpuMat _src, GpuMat _dst, double maxValue, int type, int blockSize, double k, int binarizationMethod, double r)`
`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, double r)` \brief Performs thresholding on input images using Niblack's technique or some of the popular variations it inspired.
`static void`	`niBlackThreshold(UMat _src, UMat _dst, double maxValue, int type, int blockSize, double k)`
`static void`	`niBlackThreshold(UMat _src, UMat _dst, double maxValue, int type, int blockSize, double k, int binarizationMethod, double r)`
`static void`	`paint(GpuMat image, GpuMat rlSrc, Scalar value)`
`static void`	`paint(Mat image, Mat rlSrc, Scalar value)` \brief Paint run length encoded binary image into an image.
`static void`	`paint(UMat image, UMat rlSrc, Scalar value)`
`static DoublePointer`	`PeiLinNormalization(GpuMat I)`
`static void`	`PeiLinNormalization(GpuMat I, GpuMat T)`
`static DoublePointer`	`PeiLinNormalization(Mat I)` \addtogroup ximgproc \{
`static void`	`PeiLinNormalization(Mat I, Mat T)` \overload
`static DoublePointer`	`PeiLinNormalization(UMat I)`
`static void`	`PeiLinNormalization(UMat I, UMat T)`
`static void`	`qconj(GpuMat qimg, GpuMat qcimg)`
`static void`	`qconj(Mat qimg, Mat qcimg)` \brief calculates conjugate of a quaternion image.
`static void`	`qconj(UMat qimg, UMat qcimg)`
`static void`	`qdft(GpuMat img, GpuMat qimg, int flags, boolean sideLeft)`
`static void`	`qdft(Mat img, Mat qimg, int flags, boolean sideLeft)` \brief Performs a forward or inverse Discrete quaternion Fourier transform of a 2D quaternion array.
`static void`	`qdft(UMat img, UMat qimg, int flags, boolean sideLeft)`
`static void`	`qmultiply(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`qmultiply(Mat src1, Mat src2, Mat dst)` \brief Calculates the per-element quaternion product of two arrays
`static void`	`qmultiply(UMat src1, UMat src2, UMat dst)`
`static void`	`qunitary(GpuMat qimg, GpuMat qnimg)`
`static void`	`qunitary(Mat qimg, Mat qnimg)` \brief divides each element by its modulus.
`static void`	`qunitary(UMat qimg, UMat qnimg)`
`static void`	`RadonTransform(GpuMat src, GpuMat dst)`
`static void`	`RadonTransform(GpuMat src, GpuMat dst, double theta, double start_angle, double end_angle, boolean crop, boolean norm)`
`static void`	`RadonTransform(Mat src, Mat dst)`
`static void`	`RadonTransform(Mat src, Mat dst, double theta, double start_angle, double end_angle, boolean crop, boolean norm)` \brief Calculate Radon Transform of an image.
`static void`	`RadonTransform(UMat src, UMat dst)`
`static void`	`RadonTransform(UMat src, UMat dst, double theta, double start_angle, double end_angle, boolean crop, boolean norm)`
`static int`	`readGT(BytePointer src_path, GpuMat dst)`
`static int`	`readGT(BytePointer src_path, Mat dst)` \brief Function for reading ground truth disparity maps.
`static int`	`readGT(BytePointer src_path, UMat dst)`
`static int`	`readGT(String src_path, GpuMat dst)`
`static int`	`readGT(String src_path, Mat dst)`
`static int`	`readGT(String src_path, UMat dst)`
`static void`	`rollingGuidanceFilter(GpuMat src, GpuMat dst)`
`static void`	`rollingGuidanceFilter(GpuMat src, GpuMat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter, int borderType)`
`static void`	`rollingGuidanceFilter(Mat src, Mat dst)`
`static void`	`rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter, int borderType)` \brief Applies the rolling guidance filter to an image.
`static void`	`rollingGuidanceFilter(UMat src, UMat dst)`
`static void`	`rollingGuidanceFilter(UMat src, UMat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter, int borderType)`
`static void`	`thinning(GpuMat src, GpuMat dst)`
`static void`	`thinning(GpuMat src, GpuMat dst, int thinningType)`
`static void`	`thinning(Mat src, Mat dst)`
`static void`	`thinning(Mat src, Mat dst, int thinningType)` \brief Applies a binary blob thinning operation, to achieve a skeletization of the input image.
`static void`	`thinning(UMat src, UMat dst)`
`static void`	`thinning(UMat src, UMat dst, int thinningType)`
`static void`	`threshold(GpuMat src, GpuMat rlDest, double thresh, int type)`
`static void`	`threshold(Mat src, Mat rlDest, double thresh, int type)` \addtogroup ximgproc_run_length_morphology \{
`static void`	`threshold(UMat src, UMat rlDest, double thresh, int type)`
`static void`	`transformFD(GpuMat src, GpuMat t, GpuMat dst)`
`static void`	`transformFD(GpuMat src, GpuMat t, GpuMat dst, boolean fdContour)`
`static void`	`transformFD(Mat src, Mat t, Mat dst)`
`static void`	`transformFD(Mat src, Mat t, Mat dst, boolean fdContour)` \brief transform a contour
`static void`	`transformFD(UMat src, UMat t, UMat dst)`
`static void`	`transformFD(UMat src, UMat t, UMat dst, boolean fdContour)`
`static void`	`weightedMedianFilter(GpuMat joint, GpuMat src, GpuMat dst, int r)`
`static void`	`weightedMedianFilter(GpuMat joint, GpuMat src, GpuMat dst, int r, double sigma, int weightType, GpuMat mask)`
`static void`	`weightedMedianFilter(Mat joint, Mat src, Mat dst, int r)`
`static void`	`weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma, int weightType, Mat mask)` \brief Applies weighted median filter to an image.
`static void`	`weightedMedianFilter(UMat joint, UMat src, UMat dst, int r)`
`static void`	`weightedMedianFilter(UMat joint, UMat src, UMat dst, int r, double sigma, int weightType, UMat mask)`

Methods inherited from class org.bytedeco.opencv.presets.opencv_ximgproc
map

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
```
  enum cv::ximgproc::ThinningTypes
  
  See Also:
  
  Constant Field Values
- THINNING_GUOHALL
```
public static final int THINNING_GUOHALL
```
  enum cv::ximgproc::ThinningTypes
  
  See Also:
  
  Constant Field Values
- BINARIZATION_NIBLACK
```
public static final int BINARIZATION_NIBLACK
```
  enum cv::ximgproc::LocalBinarizationMethods
  
  See Also:
  
  Constant Field Values
- BINARIZATION_SAUVOLA
```
public static final int BINARIZATION_SAUVOLA
```
  enum cv::ximgproc::LocalBinarizationMethods
  
  See Also:
  
  Constant Field Values
- BINARIZATION_WOLF
```
public static final int BINARIZATION_WOLF
```
  enum cv::ximgproc::LocalBinarizationMethods
  
  See Also:
  
  Constant Field Values
- BINARIZATION_NICK
```
public static final int BINARIZATION_NICK
```
  enum cv::ximgproc::LocalBinarizationMethods
  
  See Also:
  
  Constant Field Values
- DTF_NC
```
public static final int DTF_NC
```
  enum cv::ximgproc::EdgeAwareFiltersList
  
  See Also:
  
  Constant Field Values
- DTF_IC
```
public static final int DTF_IC
```
  enum cv::ximgproc::EdgeAwareFiltersList
  
  See Also:
  
  Constant Field Values
- DTF_RF
```
public static final int DTF_RF
```
  enum cv::ximgproc::EdgeAwareFiltersList
  
  See Also:
  
  Constant Field Values
- GUIDED_FILTER
```
public static final int GUIDED_FILTER
```
  enum cv::ximgproc::EdgeAwareFiltersList
  
  See Also:
  
  Constant Field Values
- AM_FILTER
```
public static final int AM_FILTER
```
  enum cv::ximgproc::EdgeAwareFiltersList
  
  See Also:
  
  Constant Field Values
- ARO_0_45
```
public static final int ARO_0_45
```
  enum cv::ximgproc::AngleRangeOption
  
  See Also:
  
  Constant Field Values
- ARO_45_90
```
public static final int ARO_45_90
```
  enum cv::ximgproc::AngleRangeOption
  
  See Also:
  
  Constant Field Values
- ARO_90_135
```
public static final int ARO_90_135
```
  enum cv::ximgproc::AngleRangeOption
  
  See Also:
  
  Constant Field Values
- ARO_315_0
```
public static final int ARO_315_0
```
  enum cv::ximgproc::AngleRangeOption
  
  See Also:
  
  Constant Field Values
- ARO_315_45
```
public static final int ARO_315_45
```
  enum cv::ximgproc::AngleRangeOption
  
  See Also:
  
  Constant Field Values
- ARO_45_135
```
public static final int ARO_45_135
```
  enum cv::ximgproc::AngleRangeOption
  
  See Also:
  
  Constant Field Values
- ARO_315_135
```
public static final int ARO_315_135
```
  enum cv::ximgproc::AngleRangeOption
  
  See Also:
  
  Constant Field Values
- ARO_CTR_HOR
```
public static final int ARO_CTR_HOR
```
  enum cv::ximgproc::AngleRangeOption
  
  See Also:
  
  Constant Field Values
- ARO_CTR_VER
```
public static final int ARO_CTR_VER
```
  enum cv::ximgproc::AngleRangeOption
  
  See Also:
  
  Constant Field Values
- FHT_MIN
```
public static final int FHT_MIN
```
  enum cv::ximgproc::HoughOp
  
  See Also:
  
  Constant Field Values
- FHT_MAX
```
public static final int FHT_MAX
```
  enum cv::ximgproc::HoughOp
  
  See Also:
  
  Constant Field Values
- FHT_ADD
```
public static final int FHT_ADD
```
  enum cv::ximgproc::HoughOp
  
  See Also:
  
  Constant Field Values
- FHT_AVE
```
public static final int FHT_AVE
```
  enum cv::ximgproc::HoughOp
  
  See Also:
  
  Constant Field Values
- HDO_RAW
```
public static final int HDO_RAW
```
  enum cv::ximgproc::HoughDeskewOption
  
  See Also:
  
  Constant Field Values
- HDO_DESKEW
```
public static final int HDO_DESKEW
```
  enum cv::ximgproc::HoughDeskewOption
  
  See Also:
  
  Constant Field Values
- RO_STRICT
```
public static final int RO_STRICT
```
  enum cv::ximgproc::RulesOption
  
  See Also:
  
  Constant Field Values
- RO_IGNORE_BORDERS
```
public static final int RO_IGNORE_BORDERS
```
  enum cv::ximgproc::RulesOption
  
  See Also:
  
  Constant Field Values
- WMF_EXP
```
public static final int WMF_EXP
```
  enum cv::ximgproc::WMFWeightType
  
  See Also:
  
  Constant Field Values
- WMF_IV1
```
public static final int WMF_IV1
```
  enum cv::ximgproc::WMFWeightType
  
  See Also:
  
  Constant Field Values
- WMF_IV2
```
public static final int WMF_IV2
```
  enum cv::ximgproc::WMFWeightType
  
  See Also:
  
  Constant Field Values
- WMF_COS
```
public static final int WMF_COS
```
  enum cv::ximgproc::WMFWeightType
  
  See Also:
  
  Constant Field Values
- WMF_JAC
```
public static final int WMF_JAC
```
  enum cv::ximgproc::WMFWeightType
  
  See Also:
  
  Constant Field Values
- WMF_OFF
```
public static final int WMF_OFF
```
  enum cv::ximgproc::WMFWeightType
  
  See Also:
  
  Constant Field Values
- SLIC
```
public static final int SLIC
```
  enum cv::ximgproc::SLICType
  
  See Also:
  
  Constant Field Values
- SLICO
```
public static final int SLICO
```
  enum cv::ximgproc::SLICType
  
  See Also:
  
  Constant Field Values
- MSLIC
```
public static final int MSLIC
```
  enum cv::ximgproc::SLICType
  
  See Also:
  
  Constant Field Values

Constructor Detail
- opencv_ximgproc
```
public opencv_ximgproc()
```

Method Detail

niBlackThreshold
```
@Namespace(value="cv::ximgproc")
public static void niBlackThreshold(@ByVal
                                                                      Mat _src,
                                                                      @ByVal
                                                                      Mat _dst,
                                                                      double maxValue,
                                                                      int type,
                                                                      int blockSize,
                                                                      double k,
                                                                      int binarizationMethod,
                                                                      double r)
```
\brief Performs thresholding on input images using Niblack's technique or some of the popular variations it inspired.
The function transforms a grayscale image to a binary image according to the formulae: - **THRESH_BINARY**
```
 \[dst(x,y) =  \fork{\texttt{maxValue}}{if $src(x,y) > T(x,y)$}{0}{otherwise}\]
```
- **THRESH_BINARY_INV**
```
 \[dst(x,y) =  \fork{0}{if $src(x,y) > T(x,y)$}{\texttt{maxValue}}{otherwise}\]
```
where T(x,y) is a threshold calculated individually for each pixel.
The threshold value T(x, y) is determined based on the binarization method chosen. For classic Niblack, it is the mean minus k times standard deviation of \texttt{blockSize} \times\texttt{blockSize} neighborhood of (x, y).
The function can't process the image in-place.
Parameters:

_src - Source 8-bit single-channel image.

_dst - Destination image of the same size and the same type as src.

maxValue - Non-zero value assigned to the pixels for which the condition is satisfied, used with the THRESH_BINARY and THRESH_BINARY_INV thresholding types.

type - Thresholding type, see cv::ThresholdTypes.

blockSize - Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.

k - The user-adjustable parameter used by Niblack and inspired techniques. For Niblack, this is normally a value between 0 and 1 that is multiplied with the standard deviation and subtracted from the mean.

binarizationMethod - Binarization method to use. By default, Niblack's technique is used. Other techniques can be specified, see cv::ximgproc::LocalBinarizationMethods.

r - The user-adjustable parameter used by Sauvola's technique. This is the dynamic range of standard deviation.

See Also:

threshold, adaptiveThreshold

niBlackThreshold

@Namespace(value="cv::ximgproc")
public static void niBlackThreshold(@ByVal
                                                                      Mat _src,
                                                                      @ByVal
                                                                      Mat _dst,
                                                                      double maxValue,
                                                                      int type,
                                                                      int blockSize,
                                                                      double k)

niBlackThreshold

@Namespace(value="cv::ximgproc")
public static void niBlackThreshold(@ByVal
                                                                      UMat _src,
                                                                      @ByVal
                                                                      UMat _dst,
                                                                      double maxValue,
                                                                      int type,
                                                                      int blockSize,
                                                                      double k,
                                                                      int binarizationMethod,
                                                                      double r)

niBlackThreshold

@Namespace(value="cv::ximgproc")
public static void niBlackThreshold(@ByVal
                                                                      UMat _src,
                                                                      @ByVal
                                                                      UMat _dst,
                                                                      double maxValue,
                                                                      int type,
                                                                      int blockSize,
                                                                      double k)

niBlackThreshold

@Namespace(value="cv::ximgproc")
public static void niBlackThreshold(@ByVal
                                                                      GpuMat _src,
                                                                      @ByVal
                                                                      GpuMat _dst,
                                                                      double maxValue,
                                                                      int type,
                                                                      int blockSize,
                                                                      double k,
                                                                      int binarizationMethod,
                                                                      double r)

niBlackThreshold

@Namespace(value="cv::ximgproc")
public static void niBlackThreshold(@ByVal
                                                                      GpuMat _src,
                                                                      @ByVal
                                                                      GpuMat _dst,
                                                                      double maxValue,
                                                                      int type,
                                                                      int blockSize,
                                                                      double k)

thinning

@Namespace(value="cv::ximgproc")
public static void thinning(@ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat dst,
                                                              int thinningType)

\brief Applies a binary blob thinning operation, to achieve a skeletization of the input image.

The function transforms a binary blob image into a skeletized form using the technique of Zhang-Suen.

Parameters:: src - Source 8-bit single-channel image, containing binary blobs, with blobs having 255 pixel values.; dst - Destination image of the same size and the same type as src. The function can work in-place.; thinningType - Value that defines which thinning algorithm should be used. See cv::ximgproc::ThinningTypes

thinning

@Namespace(value="cv::ximgproc")
public static void thinning(@ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat dst)

thinning

@Namespace(value="cv::ximgproc")
public static void thinning(@ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat dst,
                                                              int thinningType)

thinning

@Namespace(value="cv::ximgproc")
public static void thinning(@ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat dst)

thinning

@Namespace(value="cv::ximgproc")
public static void thinning(@ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat dst,
                                                              int thinningType)

thinning

@Namespace(value="cv::ximgproc")
public static void thinning(@ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat dst)

anisotropicDiffusion

@Namespace(value="cv::ximgproc")
public static void anisotropicDiffusion(@ByVal
                                                                          Mat src,
                                                                          @ByVal
                                                                          Mat dst,
                                                                          float alpha,
                                                                          float K,
                                                                          int niters)

\brief Performs anisotropic diffusion on an image.

The function applies Perona-Malik anisotropic diffusion to an image. This is the solution to the partial differential equation:

 \[{\frac  {\partial I}{\partial t}}={\mathrm  {div}}\left(c(x,y,t)\nabla I\right)=\nabla c\cdot \nabla I+c(x,y,t)\Delta I\]

Suggested functions for c(x,y,t) are:

 \[c\left(\|\nabla I\|\right)=e^{{-\left(\|\nabla I\|/K\right)^{2}}}\]

 \[ c\left(\|\nabla I\|\right)={\frac {1}{1+\left({\frac  {\|\nabla I\|}{K}}\right)^{2}}} \]

Parameters:: src - Source image with 3 channels.; dst - Destination image of the same size and the same number of channels as src .; alpha - The amount of time to step forward by on each iteration (normally, it's between 0 and 1).; K - sensitivity to the edges; niters - The number of iterations

anisotropicDiffusion

@Namespace(value="cv::ximgproc")
public static void anisotropicDiffusion(@ByVal
                                                                          UMat src,
                                                                          @ByVal
                                                                          UMat dst,
                                                                          float alpha,
                                                                          float K,
                                                                          int niters)

anisotropicDiffusion

@Namespace(value="cv::ximgproc")
public static void anisotropicDiffusion(@ByVal
                                                                          GpuMat src,
                                                                          @ByVal
                                                                          GpuMat dst,
                                                                          float alpha,
                                                                          float K,
                                                                          int niters)

createDTFilter
```
@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static DTFilter createDTFilter(@ByVal
                                                                                           Mat guide,
                                                                                           double sigmaSpatial,
                                                                                           double sigmaColor,
                                                                                           int mode,
                                                                                           int numIters)
```
\brief Factory method, create instance of DTFilter and produce initialization routines.

Parameters:

guide - guided image (used to build transformed distance, which describes edge structure of guided image).

sigmaSpatial - {\sigma}_H parameter in the original article, it's similar to the sigma in the coordinate space into bilateralFilter.

sigmaColor - {\sigma}_r parameter in the original article, it's similar to the sigma in the color space into bilateralFilter.

mode - one form three modes DTF_NC, DTF_RF and DTF_IC which corresponds to three modes for filtering 2D signals in the article.

numIters - optional number of iterations used for filtering, 3 is quite enough.
For more details about Domain Transform filter parameters, see the original article \cite Gastal11 and [Domain Transform filter homepage](http://www.inf.ufrgs.br/~eslgastal/DomainTransform/).

createDTFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static DTFilter createDTFilter(@ByVal
                                                                                           Mat guide,
                                                                                           double sigmaSpatial,
                                                                                           double sigmaColor)

createDTFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static DTFilter createDTFilter(@ByVal
                                                                                           UMat guide,
                                                                                           double sigmaSpatial,
                                                                                           double sigmaColor,
                                                                                           int mode,
                                                                                           int numIters)

createDTFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static DTFilter createDTFilter(@ByVal
                                                                                           UMat guide,
                                                                                           double sigmaSpatial,
                                                                                           double sigmaColor)

createDTFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static DTFilter createDTFilter(@ByVal
                                                                                           GpuMat guide,
                                                                                           double sigmaSpatial,
                                                                                           double sigmaColor,
                                                                                           int mode,
                                                                                           int numIters)

createDTFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static DTFilter createDTFilter(@ByVal
                                                                                           GpuMat guide,
                                                                                           double sigmaSpatial,
                                                                                           double sigmaColor)

dtFilter

@Namespace(value="cv::ximgproc")
public static void dtFilter(@ByVal
                                                              Mat guide,
                                                              @ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat dst,
                                                              double sigmaSpatial,
                                                              double sigmaColor,
                                                              int mode,
                                                              int numIters)

\brief Simple one-line Domain Transform filter call. If you have multiple images to filter with the same guided image then use DTFilter interface to avoid extra computations on initialization stage.

Parameters:: guide - guided image (also called as joint image) with unsigned 8-bit or floating-point 32-bit depth and up to 4 channels.; src - filtering image with unsigned 8-bit or floating-point 32-bit depth and up to 4 channels.; dst - destination image; sigmaSpatial - {\sigma}_H parameter in the original article, it's similar to the sigma in the coordinate space into bilateralFilter.; sigmaColor - {\sigma}_r parameter in the original article, it's similar to the sigma in the color space into bilateralFilter.; mode - one form three modes DTF_NC, DTF_RF and DTF_IC which corresponds to three modes for filtering 2D signals in the article.; numIters - optional number of iterations used for filtering, 3 is quite enough.
See Also:: bilateralFilter, guidedFilter, amFilter

dtFilter

@Namespace(value="cv::ximgproc")
public static void dtFilter(@ByVal
                                                              Mat guide,
                                                              @ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat dst,
                                                              double sigmaSpatial,
                                                              double sigmaColor)

dtFilter

@Namespace(value="cv::ximgproc")
public static void dtFilter(@ByVal
                                                              UMat guide,
                                                              @ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat dst,
                                                              double sigmaSpatial,
                                                              double sigmaColor,
                                                              int mode,
                                                              int numIters)

dtFilter

@Namespace(value="cv::ximgproc")
public static void dtFilter(@ByVal
                                                              UMat guide,
                                                              @ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat dst,
                                                              double sigmaSpatial,
                                                              double sigmaColor)

dtFilter

@Namespace(value="cv::ximgproc")
public static void dtFilter(@ByVal
                                                              GpuMat guide,
                                                              @ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat dst,
                                                              double sigmaSpatial,
                                                              double sigmaColor,
                                                              int mode,
                                                              int numIters)

dtFilter

@Namespace(value="cv::ximgproc")
public static void dtFilter(@ByVal
                                                              GpuMat guide,
                                                              @ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat dst,
                                                              double sigmaSpatial,
                                                              double sigmaColor)

createGuidedFilter
```
@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static GuidedFilter createGuidedFilter(@ByVal
                                                                                                   Mat guide,
                                                                                                   int radius,
                                                                                                   double eps,
                                                                                                   double scale)
```
\brief Factory method, create instance of GuidedFilter and produce initialization routines.

Parameters:

guide - guided image (or array of images) with up to 3 channels, if it have more then 3 channels then only first 3 channels will be used.

radius - radius of Guided Filter.

eps - regularization term of Guided Filter. {eps}^2 is similar to the sigma in the color space into bilateralFilter.

scale - subsample factor of Fast Guided Filter, use a scale less than 1 to speeds up computation with almost no visible degradation. (e.g. scale==0.5 shrinks the image by 2x inside the filter)
For more details about (Fast) Guided Filter parameters, see the original articles \cite Kaiming10 \cite Kaiming15 .

createGuidedFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static GuidedFilter createGuidedFilter(@ByVal
                                                                                                   Mat guide,
                                                                                                   int radius,
                                                                                                   double eps)

createGuidedFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static GuidedFilter createGuidedFilter(@ByVal
                                                                                                   UMat guide,
                                                                                                   int radius,
                                                                                                   double eps,
                                                                                                   double scale)

createGuidedFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static GuidedFilter createGuidedFilter(@ByVal
                                                                                                   UMat guide,
                                                                                                   int radius,
                                                                                                   double eps)

createGuidedFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static GuidedFilter createGuidedFilter(@ByVal
                                                                                                   GpuMat guide,
                                                                                                   int radius,
                                                                                                   double eps,
                                                                                                   double scale)

createGuidedFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static GuidedFilter createGuidedFilter(@ByVal
                                                                                                   GpuMat guide,
                                                                                                   int radius,
                                                                                                   double eps)

guidedFilter

@Namespace(value="cv::ximgproc")
public static void guidedFilter(@ByVal
                                                                  Mat guide,
                                                                  @ByVal
                                                                  Mat src,
                                                                  @ByVal
                                                                  Mat dst,
                                                                  int radius,
                                                                  double eps,
                                                                  int dDepth,
                                                                  double scale)

\brief Simple one-line (Fast) Guided Filter call.

If you have multiple images to filter with the same guided image then use GuidedFilter interface to avoid extra computations on initialization stage.

Parameters:: guide - guided image (or array of images) with up to 3 channels, if it have more then 3 channels then only first 3 channels will be used.; src - filtering image with any numbers of channels.; dst - output image.; radius - radius of Guided Filter.; eps - regularization term of Guided Filter. {eps}^2 is similar to the sigma in the color space into bilateralFilter.; dDepth - optional depth of the output image.; scale - subsample factor of Fast Guided Filter, use a scale less than 1 to speeds up computation with almost no visible degradation. (e.g. scale==0.5 shrinks the image by 2x inside the filter)
See Also:: bilateralFilter, dtFilter, amFilter

guidedFilter

@Namespace(value="cv::ximgproc")
public static void guidedFilter(@ByVal
                                                                  Mat guide,
                                                                  @ByVal
                                                                  Mat src,
                                                                  @ByVal
                                                                  Mat dst,
                                                                  int radius,
                                                                  double eps)

guidedFilter

@Namespace(value="cv::ximgproc")
public static void guidedFilter(@ByVal
                                                                  UMat guide,
                                                                  @ByVal
                                                                  UMat src,
                                                                  @ByVal
                                                                  UMat dst,
                                                                  int radius,
                                                                  double eps,
                                                                  int dDepth,
                                                                  double scale)

guidedFilter

@Namespace(value="cv::ximgproc")
public static void guidedFilter(@ByVal
                                                                  UMat guide,
                                                                  @ByVal
                                                                  UMat src,
                                                                  @ByVal
                                                                  UMat dst,
                                                                  int radius,
                                                                  double eps)

guidedFilter

@Namespace(value="cv::ximgproc")
public static void guidedFilter(@ByVal
                                                                  GpuMat guide,
                                                                  @ByVal
                                                                  GpuMat src,
                                                                  @ByVal
                                                                  GpuMat dst,
                                                                  int radius,
                                                                  double eps,
                                                                  int dDepth,
                                                                  double scale)

guidedFilter

@Namespace(value="cv::ximgproc")
public static void guidedFilter(@ByVal
                                                                  GpuMat guide,
                                                                  @ByVal
                                                                  GpuMat src,
                                                                  @ByVal
                                                                  GpuMat dst,
                                                                  int radius,
                                                                  double eps)

createAMFilter
```
@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static AdaptiveManifoldFilter createAMFilter(double sigma_s,
                                                                                                         double sigma_r,
                                                                                                         @Cast(value="bool")
                                                                                                         boolean adjust_outliers)
```
\brief Factory method, create instance of AdaptiveManifoldFilter and produce some initialization routines.

Parameters:

sigma_s - spatial standard deviation.

sigma_r - color space standard deviation, it is similar to the sigma in the color space into bilateralFilter.

adjust_outliers - optional, specify perform outliers adjust operation or not, (Eq. 9) in the original paper.
For more details about Adaptive Manifold Filter parameters, see the original article \cite Gastal12 .
\note Joint images with CV_8U and CV_16U depth converted to images with CV_32F depth and [0; 1] color range before processing. Hence color space sigma sigma_r must be in [0; 1] range, unlike same sigmas in bilateralFilter and dtFilter functions.

createAMFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static AdaptiveManifoldFilter createAMFilter(double sigma_s,
                                                                                                         double sigma_r)

amFilter

@Namespace(value="cv::ximgproc")
public static void amFilter(@ByVal
                                                              Mat joint,
                                                              @ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat dst,
                                                              double sigma_s,
                                                              double sigma_r,
                                                              @Cast(value="bool")
                                                              boolean adjust_outliers)

\brief Simple one-line Adaptive Manifold Filter call.

Parameters:: joint - joint (also called as guided) image or array of images with any numbers of channels.; src - filtering image with any numbers of channels.; dst - output image.; sigma_s - spatial standard deviation.; sigma_r - color space standard deviation, it is similar to the sigma in the color space into bilateralFilter.; adjust_outliers - optional, specify perform outliers adjust operation or not, (Eq. 9) in the original paper.
\note Joint images with CV_8U and CV_16U depth converted to images with CV_32F depth and [0; 1] color range before processing. Hence color space sigma sigma_r must be in [0; 1] range, unlike same sigmas in bilateralFilter and dtFilter functions. @see bilateralFilter, dtFilter, guidedFilter

amFilter

@Namespace(value="cv::ximgproc")
public static void amFilter(@ByVal
                                                              Mat joint,
                                                              @ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat dst,
                                                              double sigma_s,
                                                              double sigma_r)

amFilter

@Namespace(value="cv::ximgproc")
public static void amFilter(@ByVal
                                                              UMat joint,
                                                              @ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat dst,
                                                              double sigma_s,
                                                              double sigma_r,
                                                              @Cast(value="bool")
                                                              boolean adjust_outliers)

amFilter

@Namespace(value="cv::ximgproc")
public static void amFilter(@ByVal
                                                              UMat joint,
                                                              @ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat dst,
                                                              double sigma_s,
                                                              double sigma_r)

amFilter

@Namespace(value="cv::ximgproc")
public static void amFilter(@ByVal
                                                              GpuMat joint,
                                                              @ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat dst,
                                                              double sigma_s,
                                                              double sigma_r,
                                                              @Cast(value="bool")
                                                              boolean adjust_outliers)

amFilter

@Namespace(value="cv::ximgproc")
public static void amFilter(@ByVal
                                                              GpuMat joint,
                                                              @ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat dst,
                                                              double sigma_s,
                                                              double sigma_r)

jointBilateralFilter

@Namespace(value="cv::ximgproc")
public static void jointBilateralFilter(@ByVal
                                                                          Mat joint,
                                                                          @ByVal
                                                                          Mat src,
                                                                          @ByVal
                                                                          Mat dst,
                                                                          int d,
                                                                          double sigmaColor,
                                                                          double sigmaSpace,
                                                                          int borderType)

\brief Applies the joint bilateral filter to an image.

Parameters:

joint - Joint 8-bit or floating-point, 1-channel or 3-channel image.

src - Source 8-bit or floating-point, 1-channel or 3-channel image with the same depth as joint image.

dst - Destination image of the same size and type as src .

d - Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace .

sigmaColor - Filter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in larger areas of semi-equal color.

sigmaSpace - Filter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d\>0 , it specifies the neighborhood size regardless of sigmaSpace . Otherwise, d is proportional to sigmaSpace .

borderType -

\note bilateralFilter and jointBilateralFilter use L1 norm to compute difference between colors.

See Also:

bilateralFilter, amFilter

jointBilateralFilter

@Namespace(value="cv::ximgproc")
public static void jointBilateralFilter(@ByVal
                                                                          Mat joint,
                                                                          @ByVal
                                                                          Mat src,
                                                                          @ByVal
                                                                          Mat dst,
                                                                          int d,
                                                                          double sigmaColor,
                                                                          double sigmaSpace)

jointBilateralFilter

@Namespace(value="cv::ximgproc")
public static void jointBilateralFilter(@ByVal
                                                                          UMat joint,
                                                                          @ByVal
                                                                          UMat src,
                                                                          @ByVal
                                                                          UMat dst,
                                                                          int d,
                                                                          double sigmaColor,
                                                                          double sigmaSpace,
                                                                          int borderType)

jointBilateralFilter

@Namespace(value="cv::ximgproc")
public static void jointBilateralFilter(@ByVal
                                                                          UMat joint,
                                                                          @ByVal
                                                                          UMat src,
                                                                          @ByVal
                                                                          UMat dst,
                                                                          int d,
                                                                          double sigmaColor,
                                                                          double sigmaSpace)

jointBilateralFilter

@Namespace(value="cv::ximgproc")
public static void jointBilateralFilter(@ByVal
                                                                          GpuMat joint,
                                                                          @ByVal
                                                                          GpuMat src,
                                                                          @ByVal
                                                                          GpuMat dst,
                                                                          int d,
                                                                          double sigmaColor,
                                                                          double sigmaSpace,
                                                                          int borderType)

jointBilateralFilter

@Namespace(value="cv::ximgproc")
public static void jointBilateralFilter(@ByVal
                                                                          GpuMat joint,
                                                                          @ByVal
                                                                          GpuMat src,
                                                                          @ByVal
                                                                          GpuMat dst,
                                                                          int d,
                                                                          double sigmaColor,
                                                                          double sigmaSpace)

bilateralTextureFilter

@Namespace(value="cv::ximgproc")
public static void bilateralTextureFilter(@ByVal
                                                                            Mat src,
                                                                            @ByVal
                                                                            Mat dst,
                                                                            int fr,
                                                                            int numIter,
                                                                            double sigmaAlpha,
                                                                            double sigmaAvg)

\brief Applies the bilateral texture filter to an image. It performs structure-preserving texture filter. For more details about this filter see \cite Cho2014.

Parameters:: src - Source image whose depth is 8-bit UINT or 32-bit FLOAT; dst - Destination image of the same size and type as src.; fr - Radius of kernel to be used for filtering. It should be positive integer; numIter - Number of iterations of algorithm, It should be positive integer; sigmaAlpha - Controls the sharpness of the weight transition from edges to smooth/texture regions, where a bigger value means sharper transition. When the value is negative, it is automatically calculated.; sigmaAvg - Range blur parameter for texture blurring. Larger value makes result to be more blurred. When the value is negative, it is automatically calculated as described in the paper.
See Also:: rollingGuidanceFilter, bilateralFilter

bilateralTextureFilter

@Namespace(value="cv::ximgproc")
public static void bilateralTextureFilter(@ByVal
                                                                            Mat src,
                                                                            @ByVal
                                                                            Mat dst)

bilateralTextureFilter

@Namespace(value="cv::ximgproc")
public static void bilateralTextureFilter(@ByVal
                                                                            UMat src,
                                                                            @ByVal
                                                                            UMat dst,
                                                                            int fr,
                                                                            int numIter,
                                                                            double sigmaAlpha,
                                                                            double sigmaAvg)

bilateralTextureFilter

@Namespace(value="cv::ximgproc")
public static void bilateralTextureFilter(@ByVal
                                                                            UMat src,
                                                                            @ByVal
                                                                            UMat dst)

bilateralTextureFilter

@Namespace(value="cv::ximgproc")
public static void bilateralTextureFilter(@ByVal
                                                                            GpuMat src,
                                                                            @ByVal
                                                                            GpuMat dst,
                                                                            int fr,
                                                                            int numIter,
                                                                            double sigmaAlpha,
                                                                            double sigmaAvg)

bilateralTextureFilter

@Namespace(value="cv::ximgproc")
public static void bilateralTextureFilter(@ByVal
                                                                            GpuMat src,
                                                                            @ByVal
                                                                            GpuMat dst)

rollingGuidanceFilter
```
@Namespace(value="cv::ximgproc")
public static void rollingGuidanceFilter(@ByVal
                                                                           Mat src,
                                                                           @ByVal
                                                                           Mat dst,
                                                                           int d,
                                                                           double sigmaColor,
                                                                           double sigmaSpace,
                                                                           int numOfIter,
                                                                           int borderType)
```
\brief Applies the rolling guidance filter to an image.
For more details, please see \cite zhang2014rolling

Parameters:

src - Source 8-bit or floating-point, 1-channel or 3-channel image.

dst - Destination image of the same size and type as src.

d - Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace .

sigmaColor - Filter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in larger areas of semi-equal color.

sigmaSpace - Filter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d\>0 , it specifies the neighborhood size regardless of sigmaSpace . Otherwise, d is proportional to sigmaSpace .

numOfIter - Number of iterations of joint edge-preserving filtering applied on the source image.

borderType -
\note rollingGuidanceFilter uses jointBilateralFilter as the edge-preserving filter.

See Also:

jointBilateralFilter, bilateralFilter, amFilter

rollingGuidanceFilter

@Namespace(value="cv::ximgproc")
public static void rollingGuidanceFilter(@ByVal
                                                                           Mat src,
                                                                           @ByVal
                                                                           Mat dst)

rollingGuidanceFilter

@Namespace(value="cv::ximgproc")
public static void rollingGuidanceFilter(@ByVal
                                                                           UMat src,
                                                                           @ByVal
                                                                           UMat dst,
                                                                           int d,
                                                                           double sigmaColor,
                                                                           double sigmaSpace,
                                                                           int numOfIter,
                                                                           int borderType)

rollingGuidanceFilter

@Namespace(value="cv::ximgproc")
public static void rollingGuidanceFilter(@ByVal
                                                                           UMat src,
                                                                           @ByVal
                                                                           UMat dst)

rollingGuidanceFilter

@Namespace(value="cv::ximgproc")
public static void rollingGuidanceFilter(@ByVal
                                                                           GpuMat src,
                                                                           @ByVal
                                                                           GpuMat dst,
                                                                           int d,
                                                                           double sigmaColor,
                                                                           double sigmaSpace,
                                                                           int numOfIter,
                                                                           int borderType)

rollingGuidanceFilter

@Namespace(value="cv::ximgproc")
public static void rollingGuidanceFilter(@ByVal
                                                                           GpuMat src,
                                                                           @ByVal
                                                                           GpuMat dst)

createFastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastBilateralSolverFilter createFastBilateralSolverFilter(@ByVal
                                                                                                                             Mat guide,
                                                                                                                             double sigma_spatial,
                                                                                                                             double sigma_luma,
                                                                                                                             double sigma_chroma,
                                                                                                                             double lambda,
                                                                                                                             int num_iter,
                                                                                                                             double max_tol)

\brief Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines.

Parameters:

guide - image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.

sigma_spatial - parameter, that is similar to spatial space sigma (bandwidth) in bilateralFilter.

sigma_luma - parameter, that is similar to luma space sigma (bandwidth) in bilateralFilter.

sigma_chroma - parameter, that is similar to chroma space sigma (bandwidth) in bilateralFilter.

lambda - smoothness strength parameter for solver.

num_iter - number of iterations used for solver, 25 is usually enough.

max_tol - convergence tolerance used for solver.

For more details about the Fast Bilateral Solver parameters, see the original paper \cite BarronPoole2016.

createFastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastBilateralSolverFilter createFastBilateralSolverFilter(@ByVal
                                                                                                                             Mat guide,
                                                                                                                             double sigma_spatial,
                                                                                                                             double sigma_luma,
                                                                                                                             double sigma_chroma)

createFastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastBilateralSolverFilter createFastBilateralSolverFilter(@ByVal
                                                                                                                             UMat guide,
                                                                                                                             double sigma_spatial,
                                                                                                                             double sigma_luma,
                                                                                                                             double sigma_chroma,
                                                                                                                             double lambda,
                                                                                                                             int num_iter,
                                                                                                                             double max_tol)

createFastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastBilateralSolverFilter createFastBilateralSolverFilter(@ByVal
                                                                                                                             UMat guide,
                                                                                                                             double sigma_spatial,
                                                                                                                             double sigma_luma,
                                                                                                                             double sigma_chroma)

createFastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastBilateralSolverFilter createFastBilateralSolverFilter(@ByVal
                                                                                                                             GpuMat guide,
                                                                                                                             double sigma_spatial,
                                                                                                                             double sigma_luma,
                                                                                                                             double sigma_chroma,
                                                                                                                             double lambda,
                                                                                                                             int num_iter,
                                                                                                                             double max_tol)

createFastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastBilateralSolverFilter createFastBilateralSolverFilter(@ByVal
                                                                                                                             GpuMat guide,
                                                                                                                             double sigma_spatial,
                                                                                                                             double sigma_luma,
                                                                                                                             double sigma_chroma)

fastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
public static void fastBilateralSolverFilter(@ByVal
                                                                               Mat guide,
                                                                               @ByVal
                                                                               Mat src,
                                                                               @ByVal
                                                                               Mat confidence,
                                                                               @ByVal
                                                                               Mat dst,
                                                                               double sigma_spatial,
                                                                               double sigma_luma,
                                                                               double sigma_chroma,
                                                                               double lambda,
                                                                               int num_iter,
                                                                               double max_tol)

\brief Simple one-line Fast Bilateral Solver filter call. If you have multiple images to filter with the same guide then use FastBilateralSolverFilter interface to avoid extra computations.

Parameters:

guide - image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.

src - source image for filtering with unsigned 8-bit or signed 16-bit or floating-point 32-bit depth and up to 4 channels.

confidence - confidence image with unsigned 8-bit or floating-point 32-bit confidence and 1 channel.

dst - destination image.

sigma_spatial - parameter, that is similar to spatial space sigma (bandwidth) in bilateralFilter.

sigma_luma - parameter, that is similar to luma space sigma (bandwidth) in bilateralFilter.

sigma_chroma - parameter, that is similar to chroma space sigma (bandwidth) in bilateralFilter.

lambda - smoothness strength parameter for solver.

num_iter - number of iterations used for solver, 25 is usually enough.

max_tol - convergence tolerance used for solver.

For more details about the Fast Bilateral Solver parameters, see the original paper \cite BarronPoole2016.

\note Confidence images with CV_8U depth are expected to in [0, 255] and CV_32F in [0, 1] range.

fastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
public static void fastBilateralSolverFilter(@ByVal
                                                                               Mat guide,
                                                                               @ByVal
                                                                               Mat src,
                                                                               @ByVal
                                                                               Mat confidence,
                                                                               @ByVal
                                                                               Mat dst)

fastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
public static void fastBilateralSolverFilter(@ByVal
                                                                               UMat guide,
                                                                               @ByVal
                                                                               UMat src,
                                                                               @ByVal
                                                                               UMat confidence,
                                                                               @ByVal
                                                                               UMat dst,
                                                                               double sigma_spatial,
                                                                               double sigma_luma,
                                                                               double sigma_chroma,
                                                                               double lambda,
                                                                               int num_iter,
                                                                               double max_tol)

fastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
public static void fastBilateralSolverFilter(@ByVal
                                                                               UMat guide,
                                                                               @ByVal
                                                                               UMat src,
                                                                               @ByVal
                                                                               UMat confidence,
                                                                               @ByVal
                                                                               UMat dst)

fastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
public static void fastBilateralSolverFilter(@ByVal
                                                                               GpuMat guide,
                                                                               @ByVal
                                                                               GpuMat src,
                                                                               @ByVal
                                                                               GpuMat confidence,
                                                                               @ByVal
                                                                               GpuMat dst,
                                                                               double sigma_spatial,
                                                                               double sigma_luma,
                                                                               double sigma_chroma,
                                                                               double lambda,
                                                                               int num_iter,
                                                                               double max_tol)

fastBilateralSolverFilter

@Namespace(value="cv::ximgproc")
public static void fastBilateralSolverFilter(@ByVal
                                                                               GpuMat guide,
                                                                               @ByVal
                                                                               GpuMat src,
                                                                               @ByVal
                                                                               GpuMat confidence,
                                                                               @ByVal
                                                                               GpuMat dst)

createFastGlobalSmootherFilter
```
@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(@ByVal
                                                                                                                           Mat guide,
                                                                                                                           double lambda,
                                                                                                                           double sigma_color,
                                                                                                                           double lambda_attenuation,
                                                                                                                           int num_iter)
```
\brief Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines.

Parameters:

guide - image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.

lambda - parameter defining the amount of regularization

sigma_color - parameter, that is similar to color space sigma in bilateralFilter.

lambda_attenuation - internal parameter, defining how much lambda decreases after each iteration. Normally, it should be 0.25. Setting it to 1.0 may lead to streaking artifacts.

num_iter - number of iterations used for filtering, 3 is usually enough.
For more details about Fast Global Smoother parameters, see the original paper \cite Min2014. However, please note that there are several differences. Lambda attenuation described in the paper is implemented a bit differently so do not expect the results to be identical to those from the paper; sigma_color values from the paper should be multiplied by 255.0 to achieve the same effect. Also, in case of image filtering where source and guide image are the same, authors propose to dynamically update the guide image after each iteration. To maximize the performance this feature was not implemented here.

createFastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(@ByVal
                                                                                                                           Mat guide,
                                                                                                                           double lambda,
                                                                                                                           double sigma_color)

createFastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(@ByVal
                                                                                                                           UMat guide,
                                                                                                                           double lambda,
                                                                                                                           double sigma_color,
                                                                                                                           double lambda_attenuation,
                                                                                                                           int num_iter)

createFastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(@ByVal
                                                                                                                           UMat guide,
                                                                                                                           double lambda,
                                                                                                                           double sigma_color)

createFastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(@ByVal
                                                                                                                           GpuMat guide,
                                                                                                                           double lambda,
                                                                                                                           double sigma_color,
                                                                                                                           double lambda_attenuation,
                                                                                                                           int num_iter)

createFastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(@ByVal
                                                                                                                           GpuMat guide,
                                                                                                                           double lambda,
                                                                                                                           double sigma_color)

fastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
public static void fastGlobalSmootherFilter(@ByVal
                                                                              Mat guide,
                                                                              @ByVal
                                                                              Mat src,
                                                                              @ByVal
                                                                              Mat dst,
                                                                              double lambda,
                                                                              double sigma_color,
                                                                              double lambda_attenuation,
                                                                              int num_iter)

\brief Simple one-line Fast Global Smoother filter call. If you have multiple images to filter with the same guide then use FastGlobalSmootherFilter interface to avoid extra computations.

Parameters:: guide - image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.; src - source image for filtering with unsigned 8-bit or signed 16-bit or floating-point 32-bit depth and up to 4 channels.; dst - destination image.; lambda - parameter defining the amount of regularization; sigma_color - parameter, that is similar to color space sigma in bilateralFilter.; lambda_attenuation - internal parameter, defining how much lambda decreases after each iteration. Normally, it should be 0.25. Setting it to 1.0 may lead to streaking artifacts.; num_iter - number of iterations used for filtering, 3 is usually enough.

fastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
public static void fastGlobalSmootherFilter(@ByVal
                                                                              Mat guide,
                                                                              @ByVal
                                                                              Mat src,
                                                                              @ByVal
                                                                              Mat dst,
                                                                              double lambda,
                                                                              double sigma_color)

fastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
public static void fastGlobalSmootherFilter(@ByVal
                                                                              UMat guide,
                                                                              @ByVal
                                                                              UMat src,
                                                                              @ByVal
                                                                              UMat dst,
                                                                              double lambda,
                                                                              double sigma_color,
                                                                              double lambda_attenuation,
                                                                              int num_iter)

fastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
public static void fastGlobalSmootherFilter(@ByVal
                                                                              UMat guide,
                                                                              @ByVal
                                                                              UMat src,
                                                                              @ByVal
                                                                              UMat dst,
                                                                              double lambda,
                                                                              double sigma_color)

fastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
public static void fastGlobalSmootherFilter(@ByVal
                                                                              GpuMat guide,
                                                                              @ByVal
                                                                              GpuMat src,
                                                                              @ByVal
                                                                              GpuMat dst,
                                                                              double lambda,
                                                                              double sigma_color,
                                                                              double lambda_attenuation,
                                                                              int num_iter)

fastGlobalSmootherFilter

@Namespace(value="cv::ximgproc")
public static void fastGlobalSmootherFilter(@ByVal
                                                                              GpuMat guide,
                                                                              @ByVal
                                                                              GpuMat src,
                                                                              @ByVal
                                                                              GpuMat dst,
                                                                              double lambda,
                                                                              double sigma_color)

l0Smooth

@Namespace(value="cv::ximgproc")
public static void l0Smooth(@ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat dst,
                                                              double lambda,
                                                              double kappa)

\brief Global image smoothing via L0 gradient minimization.

Parameters:: src - source image for filtering with unsigned 8-bit or signed 16-bit or floating-point depth.; dst - destination image.; lambda - parameter defining the smooth term weight.; kappa - parameter defining the increasing factor of the weight of the gradient data term.
For more details about L0 Smoother, see the original paper \cite xu2011image.

l0Smooth

@Namespace(value="cv::ximgproc")
public static void l0Smooth(@ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat dst)

l0Smooth

@Namespace(value="cv::ximgproc")
public static void l0Smooth(@ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat dst,
                                                              double lambda,
                                                              double kappa)

l0Smooth

@Namespace(value="cv::ximgproc")
public static void l0Smooth(@ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat dst)

l0Smooth

@Namespace(value="cv::ximgproc")
public static void l0Smooth(@ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat dst,
                                                              double lambda,
                                                              double kappa)

l0Smooth

@Namespace(value="cv::ximgproc")
public static void l0Smooth(@ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat dst)

createDisparityWLSFilter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static DisparityWLSFilter createDisparityWLSFilter(@opencv_core.Ptr
                                                                                                               StereoMatcher matcher_left)

\brief Convenience factory method that creates an instance of DisparityWLSFilter and sets up all the relevant filter parameters automatically based on the matcher instance. Currently supports only StereoBM and StereoSGBM.

Parameters:: matcher_left - stereo matcher instance that will be used with the filter

createRightMatcher

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static StereoMatcher createRightMatcher(@opencv_core.Ptr
                                                                                                    StereoMatcher matcher_left)

\brief Convenience method to set up the matcher for computing the right-view disparity map that is required in case of filtering with confidence.

Parameters:: matcher_left - main stereo matcher instance that will be used with the filter

createDisparityWLSFilterGeneric
```
@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static DisparityWLSFilter createDisparityWLSFilterGeneric(@Cast(value="bool")
                                                                                                                      boolean use_confidence)
```
\brief More generic factory method, create instance of DisparityWLSFilter and execute basic initialization routines. When using this method you will need to set-up the ROI, matchers and other parameters by yourself.

Parameters:

use_confidence - filtering with confidence requires two disparity maps (for the left and right views) and is approximately two times slower. However, quality is typically significantly better.

readGT

@Namespace(value="cv::ximgproc")
public static int readGT(@opencv_core.Str
                                                           BytePointer src_path,
                                                           @ByVal
                                                           Mat dst)

\brief Function for reading ground truth disparity maps. Supports basic Middlebury and MPI-Sintel formats. Note that the resulting disparity map is scaled by 16.

Parameters:: src_path - path to the image, containing ground-truth disparity map; dst - output disparity map, CV_16S depth
Returns:: returns zero if successfully read the ground truth

readGT

@Namespace(value="cv::ximgproc")
public static int readGT(@opencv_core.Str
                                                           String src_path,
                                                           @ByVal
                                                           Mat dst)

readGT

@Namespace(value="cv::ximgproc")
public static int readGT(@opencv_core.Str
                                                           String src_path,
                                                           @ByVal
                                                           UMat dst)

readGT

@Namespace(value="cv::ximgproc")
public static int readGT(@opencv_core.Str
                                                           BytePointer src_path,
                                                           @ByVal
                                                           UMat dst)

readGT

@Namespace(value="cv::ximgproc")
public static int readGT(@opencv_core.Str
                                                           BytePointer src_path,
                                                           @ByVal
                                                           GpuMat dst)

readGT

@Namespace(value="cv::ximgproc")
public static int readGT(@opencv_core.Str
                                                           String src_path,
                                                           @ByVal
                                                           GpuMat dst)

computeMSE

@Namespace(value="cv::ximgproc")
public static double computeMSE(@ByVal
                                                                  Mat GT,
                                                                  @ByVal
                                                                  Mat src,
                                                                  @ByVal
                                                                  Rect ROI)

\brief Function for computing mean square error for disparity maps

Parameters:: GT - ground truth disparity map; src - disparity map to evaluate; ROI - region of interest
Returns:: returns mean square error between GT and src

computeMSE

@Namespace(value="cv::ximgproc")
public static double computeMSE(@ByVal
                                                                  UMat GT,
                                                                  @ByVal
                                                                  UMat src,
                                                                  @ByVal
                                                                  Rect ROI)

computeMSE

@Namespace(value="cv::ximgproc")
public static double computeMSE(@ByVal
                                                                  GpuMat GT,
                                                                  @ByVal
                                                                  GpuMat src,
                                                                  @ByVal
                                                                  Rect ROI)

computeBadPixelPercent

@Namespace(value="cv::ximgproc")
public static double computeBadPixelPercent(@ByVal
                                                                              Mat GT,
                                                                              @ByVal
                                                                              Mat src,
                                                                              @ByVal
                                                                              Rect ROI,
                                                                              int thresh)

\brief Function for computing the percent of "bad" pixels in the disparity map (pixels where error is higher than a specified threshold)

Parameters:: GT - ground truth disparity map; src - disparity map to evaluate; ROI - region of interest; thresh - threshold used to determine "bad" pixels
Returns:: returns mean square error between GT and src

computeBadPixelPercent

@Namespace(value="cv::ximgproc")
public static double computeBadPixelPercent(@ByVal
                                                                              Mat GT,
                                                                              @ByVal
                                                                              Mat src,
                                                                              @ByVal
                                                                              Rect ROI)

computeBadPixelPercent

@Namespace(value="cv::ximgproc")
public static double computeBadPixelPercent(@ByVal
                                                                              UMat GT,
                                                                              @ByVal
                                                                              UMat src,
                                                                              @ByVal
                                                                              Rect ROI,
                                                                              int thresh)

computeBadPixelPercent

@Namespace(value="cv::ximgproc")
public static double computeBadPixelPercent(@ByVal
                                                                              UMat GT,
                                                                              @ByVal
                                                                              UMat src,
                                                                              @ByVal
                                                                              Rect ROI)

computeBadPixelPercent

@Namespace(value="cv::ximgproc")
public static double computeBadPixelPercent(@ByVal
                                                                              GpuMat GT,
                                                                              @ByVal
                                                                              GpuMat src,
                                                                              @ByVal
                                                                              Rect ROI,
                                                                              int thresh)

computeBadPixelPercent

@Namespace(value="cv::ximgproc")
public static double computeBadPixelPercent(@ByVal
                                                                              GpuMat GT,
                                                                              @ByVal
                                                                              GpuMat src,
                                                                              @ByVal
                                                                              Rect ROI)

getDisparityVis

@Namespace(value="cv::ximgproc")
public static void getDisparityVis(@ByVal
                                                                     Mat src,
                                                                     @ByVal
                                                                     Mat dst,
                                                                     double scale)

\brief Function for creating a disparity map visualization (clamped CV_8U image)

Parameters:: src - input disparity map (CV_16S depth); dst - output visualization; scale - disparity map will be multiplied by this value for visualization

getDisparityVis

@Namespace(value="cv::ximgproc")
public static void getDisparityVis(@ByVal
                                                                     Mat src,
                                                                     @ByVal
                                                                     Mat dst)

getDisparityVis

@Namespace(value="cv::ximgproc")
public static void getDisparityVis(@ByVal
                                                                     UMat src,
                                                                     @ByVal
                                                                     UMat dst,
                                                                     double scale)

getDisparityVis

@Namespace(value="cv::ximgproc")
public static void getDisparityVis(@ByVal
                                                                     UMat src,
                                                                     @ByVal
                                                                     UMat dst)

getDisparityVis

@Namespace(value="cv::ximgproc")
public static void getDisparityVis(@ByVal
                                                                     GpuMat src,
                                                                     @ByVal
                                                                     GpuMat dst,
                                                                     double scale)

getDisparityVis

@Namespace(value="cv::ximgproc")
public static void getDisparityVis(@ByVal
                                                                     GpuMat src,
                                                                     @ByVal
                                                                     GpuMat dst)

createEdgeAwareInterpolator

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static EdgeAwareInterpolator createEdgeAwareInterpolator()

\brief Factory method that creates an instance of the EdgeAwareInterpolator.

createRICInterpolator

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static RICInterpolator createRICInterpolator()

\brief Factory method that creates an instance of the RICInterpolator.

createRFFeatureGetter

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static RFFeatureGetter createRFFeatureGetter()

\file \date Jun 17, 2014

createStructuredEdgeDetection

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static StructuredEdgeDetection createStructuredEdgeDetection(@opencv_core.Str
                                                                                                                         BytePointer model,
                                                                                                                         @Const @opencv_core.Ptr
                                                                                                                         RFFeatureGetter howToGetFeatures)

The only constructor

Parameters:: model - : name of the file where the model is stored; howToGetFeatures - : optional object inheriting from RFFeatureGetter. You need it only if you would like to train your own forest, pass NULL otherwise

createStructuredEdgeDetection

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static StructuredEdgeDetection createStructuredEdgeDetection(@opencv_core.Str
                                                                                                                         BytePointer model)

createStructuredEdgeDetection

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static StructuredEdgeDetection createStructuredEdgeDetection(@opencv_core.Str
                                                                                                                         String model,
                                                                                                                         @Const @opencv_core.Ptr
                                                                                                                         RFFeatureGetter howToGetFeatures)

createStructuredEdgeDetection

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static StructuredEdgeDetection createStructuredEdgeDetection(@opencv_core.Str
                                                                                                                         String model)

createEdgeBoxes

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
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)

\brief Creates a Edgeboxes

Parameters:: alpha - step size of sliding window search.; beta - nms threshold for object proposals.; eta - adaptation rate for nms threshold.; minScore - min score of boxes to detect.; maxBoxes - max number of boxes to detect.; edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.; edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.; clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.; maxAspectRatio - max aspect ratio of boxes.; minBoxArea - minimum area of boxes.; gamma - affinity sensitivity.; kappa - scale sensitivity.

createEdgeBoxes

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static EdgeBoxes createEdgeBoxes()

createSuperpixelSEEDS
```
@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width,
                                                                                                         int image_height,
                                                                                                         int image_channels,
                                                                                                         int num_superpixels,
                                                                                                         int num_levels,
                                                                                                         int prior,
                                                                                                         int histogram_bins,
                                                                                                         @Cast(value="bool")
                                                                                                         boolean double_step)
```
\brief Initializes a SuperpixelSEEDS object.

Parameters:

image_width - Image width.

image_height - Image height.

image_channels - Number of channels of the image.

num_superpixels - Desired number of superpixels. Note that the actual number may be smaller due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to get the actual number.

num_levels - Number of block levels. The more levels, the more accurate is the segmentation, but needs more memory and CPU time.

prior - enable 3x3 shape smoothing term if \>0. A larger value leads to smoother shapes. prior must be in the range [0, 5].

histogram_bins - Number of histogram bins.

double_step - If true, iterate each block level twice for higher accuracy.
The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and double_step.
The number of levels in num_levels defines the amount of block levels that the algorithm use in the optimization. The initialization is a grid, in which the superpixels are equally distributed through the width and the height of the image. The larger blocks correspond to the superpixel size, and the levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels, recursively until the smaller block level. An example of initialization of 4 block levels is illustrated in the following figure.
![image](pics/superpixels_blocks.png)

createSuperpixelSEEDS

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width,
                                                                                                         int image_height,
                                                                                                         int image_channels,
                                                                                                         int num_superpixels,
                                                                                                         int num_levels)

createGraphSegmentation

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static GraphSegmentation createGraphSegmentation(double sigma,
                                                                                                                           float k,
                                                                                                                           int min_size)

\brief Creates a graph based segmentor

Parameters:: sigma - The sigma parameter, used to smooth image; k - The k parameter of the algorythm; min_size - The minimum size of segments

createGraphSegmentation

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static GraphSegmentation createGraphSegmentation()

createSelectiveSearchSegmentationStrategyColor

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static SelectiveSearchSegmentationStrategyColor createSelectiveSearchSegmentationStrategyColor()

\brief Create a new color-based strategy

createSelectiveSearchSegmentationStrategySize

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static SelectiveSearchSegmentationStrategySize createSelectiveSearchSegmentationStrategySize()

\brief Create a new size-based strategy

createSelectiveSearchSegmentationStrategyTexture

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static SelectiveSearchSegmentationStrategyTexture createSelectiveSearchSegmentationStrategyTexture()

\brief Create a new size-based strategy

createSelectiveSearchSegmentationStrategyFill

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static SelectiveSearchSegmentationStrategyFill createSelectiveSearchSegmentationStrategyFill()

\brief Create a new fill-based strategy

createSelectiveSearchSegmentationStrategyMultiple

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple()

\brief Create a new multiple strategy

createSelectiveSearchSegmentationStrategyMultiple

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(@opencv_core.Ptr
                                                                                                                                                                               SelectiveSearchSegmentationStrategy s1)

\brief Create a new multiple strategy and set one subtrategy

Parameters:: s1 - The first strategy

createSelectiveSearchSegmentationStrategyMultiple

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(@opencv_core.Ptr
                                                                                                                                                                               SelectiveSearchSegmentationStrategy s1,
                                                                                                                                                                               @opencv_core.Ptr
                                                                                                                                                                               SelectiveSearchSegmentationStrategy s2)

\brief Create a new multiple strategy and set two subtrategies, with equal weights

Parameters:: s1 - The first strategy; s2 - The second strategy

createSelectiveSearchSegmentationStrategyMultiple

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(@opencv_core.Ptr
                                                                                                                                                                               SelectiveSearchSegmentationStrategy s1,
                                                                                                                                                                               @opencv_core.Ptr
                                                                                                                                                                               SelectiveSearchSegmentationStrategy s2,
                                                                                                                                                                               @opencv_core.Ptr
                                                                                                                                                                               SelectiveSearchSegmentationStrategy s3)

\brief Create a new multiple strategy and set three subtrategies, with equal weights

Parameters:: s1 - The first strategy; s2 - The second strategy; s3 - The third strategy

createSelectiveSearchSegmentationStrategyMultiple

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(@opencv_core.Ptr
                                                                                                                                                                               SelectiveSearchSegmentationStrategy s1,
                                                                                                                                                                               @opencv_core.Ptr
                                                                                                                                                                               SelectiveSearchSegmentationStrategy s2,
                                                                                                                                                                               @opencv_core.Ptr
                                                                                                                                                                               SelectiveSearchSegmentationStrategy s3,
                                                                                                                                                                               @opencv_core.Ptr
                                                                                                                                                                               SelectiveSearchSegmentationStrategy s4)

\brief Create a new multiple strategy and set four subtrategies, with equal weights

Parameters:: s1 - The first strategy; s2 - The second strategy; s3 - The third strategy; s4 - The forth strategy

createSelectiveSearchSegmentation

@Namespace(value="cv::ximgproc::segmentation")
 @opencv_core.Ptr
public static SelectiveSearchSegmentation createSelectiveSearchSegmentation()

\brief Create a new SelectiveSearchSegmentation class.

FastHoughTransform

@Namespace(value="cv::ximgproc")
public static void FastHoughTransform(@ByVal
                                                                        Mat src,
                                                                        @ByVal
                                                                        Mat dst,
                                                                        int dstMatDepth,
                                                                        int angleRange,
                                                                        int op,
                                                                        int makeSkew)

\brief Calculates 2D Fast Hough transform of an image.

Parameters:: dst - The destination image, result of transformation.; src - The source (input) image.; dstMatDepth - The depth of destination image; op - The operation to be applied, see cv::HoughOp; angleRange - The part of Hough space to calculate, see cv::AngleRangeOption; makeSkew - Specifies to do or not to do image skewing, see cv::HoughDeskewOption The function calculates the fast Hough transform for full, half or quarter range of angles.

FastHoughTransform

@Namespace(value="cv::ximgproc")
public static void FastHoughTransform(@ByVal
                                                                        Mat src,
                                                                        @ByVal
                                                                        Mat dst,
                                                                        int dstMatDepth)

FastHoughTransform

@Namespace(value="cv::ximgproc")
public static void FastHoughTransform(@ByVal
                                                                        UMat src,
                                                                        @ByVal
                                                                        UMat dst,
                                                                        int dstMatDepth,
                                                                        int angleRange,
                                                                        int op,
                                                                        int makeSkew)

FastHoughTransform

@Namespace(value="cv::ximgproc")
public static void FastHoughTransform(@ByVal
                                                                        UMat src,
                                                                        @ByVal
                                                                        UMat dst,
                                                                        int dstMatDepth)

FastHoughTransform

@Namespace(value="cv::ximgproc")
public static void FastHoughTransform(@ByVal
                                                                        GpuMat src,
                                                                        @ByVal
                                                                        GpuMat dst,
                                                                        int dstMatDepth,
                                                                        int angleRange,
                                                                        int op,
                                                                        int makeSkew)

FastHoughTransform

@Namespace(value="cv::ximgproc")
public static void FastHoughTransform(@ByVal
                                                                        GpuMat src,
                                                                        @ByVal
                                                                        GpuMat dst,
                                                                        int dstMatDepth)

HoughPoint2Line

@Namespace(value="cv::ximgproc")
 @ByVal
 @Cast(value="cv::Vec4i*")
public static Scalar4i HoughPoint2Line(@Const @ByRef
                                                                                                              Point houghPoint,
                                                                                                              @ByVal
                                                                                                              Mat srcImgInfo,
                                                                                                              int angleRange,
                                                                                                              int makeSkew,
                                                                                                              int rules)

\brief Calculates coordinates of line segment corresponded by point in Hough space.

Parameters:: houghPoint - Point in Hough space.; srcImgInfo - The source (input) image of Hough transform.; angleRange - The part of Hough space where point is situated, see cv::AngleRangeOption; makeSkew - Specifies to do or not to do image skewing, see cv::HoughDeskewOption; rules - Specifies strictness of line segment calculating, see cv::RulesOption \retval [Vec4i] Coordinates of line segment corresponded by point in Hough space. \remarks If rules parameter set to RO_STRICT then returned line cut along the border of source image. \remarks If rules parameter set to RO_WEAK then in case of point, which belongs the incorrect part of Hough image, returned line will not intersect source image. The function calculates coordinates of line segment corresponded by point in Hough space.

HoughPoint2Line

@Namespace(value="cv::ximgproc")
 @ByVal
 @Cast(value="cv::Vec4i*")
public static Scalar4i HoughPoint2Line(@Const @ByRef
                                                                                                              Point houghPoint,
                                                                                                              @ByVal
                                                                                                              Mat srcImgInfo)

HoughPoint2Line

@Namespace(value="cv::ximgproc")
 @ByVal
 @Cast(value="cv::Vec4i*")
public static Scalar4i HoughPoint2Line(@Const @ByRef
                                                                                                              Point houghPoint,
                                                                                                              @ByVal
                                                                                                              UMat srcImgInfo,
                                                                                                              int angleRange,
                                                                                                              int makeSkew,
                                                                                                              int rules)

HoughPoint2Line

@Namespace(value="cv::ximgproc")
 @ByVal
 @Cast(value="cv::Vec4i*")
public static Scalar4i HoughPoint2Line(@Const @ByRef
                                                                                                              Point houghPoint,
                                                                                                              @ByVal
                                                                                                              UMat srcImgInfo)

HoughPoint2Line

@Namespace(value="cv::ximgproc")
 @ByVal
 @Cast(value="cv::Vec4i*")
public static Scalar4i HoughPoint2Line(@Const @ByRef
                                                                                                              Point houghPoint,
                                                                                                              @ByVal
                                                                                                              GpuMat srcImgInfo,
                                                                                                              int angleRange,
                                                                                                              int makeSkew,
                                                                                                              int rules)

HoughPoint2Line

@Namespace(value="cv::ximgproc")
 @ByVal
 @Cast(value="cv::Vec4i*")
public static Scalar4i HoughPoint2Line(@Const @ByRef
                                                                                                              Point houghPoint,
                                                                                                              @ByVal
                                                                                                              GpuMat srcImgInfo)

covarianceEstimation
```
@Namespace(value="cv::ximgproc")
public static void covarianceEstimation(@ByVal
                                                                          Mat src,
                                                                          @ByVal
                                                                          Mat dst,
                                                                          int windowRows,
                                                                          int windowCols)
```
\brief Computes the estimated covariance matrix of an image using the sliding window forumlation.

Parameters:

src - The source image. Input image must be of a complex type.

dst - The destination estimated covariance matrix. Output matrix will be size (windowRows*windowCols, windowRows*windowCols).

windowRows - The number of rows in the window.

windowCols - The number of cols in the window. The window size parameters control the accuracy of the estimation. The sliding window moves over the entire image from the top-left corner to the bottom right corner. Each location of the window represents a sample. If the window is the size of the image, then this gives the exact covariance matrix. For all other cases, the sizes of the window will impact the number of samples and the number of elements in the estimated covariance matrix.

covarianceEstimation

@Namespace(value="cv::ximgproc")
public static void covarianceEstimation(@ByVal
                                                                          UMat src,
                                                                          @ByVal
                                                                          UMat dst,
                                                                          int windowRows,
                                                                          int windowCols)

covarianceEstimation

@Namespace(value="cv::ximgproc")
public static void covarianceEstimation(@ByVal
                                                                          GpuMat src,
                                                                          @ByVal
                                                                          GpuMat dst,
                                                                          int windowRows,
                                                                          int windowCols)

weightedMedianFilter

@Namespace(value="cv::ximgproc")
public static void weightedMedianFilter(@ByVal
                                                                          Mat joint,
                                                                          @ByVal
                                                                          Mat src,
                                                                          @ByVal
                                                                          Mat dst,
                                                                          int r,
                                                                          double sigma,
                                                                          int weightType,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          Mat mask)

\brief Applies weighted median filter to an image. For more details about this implementation, please see \cite zhang2014100+

Parameters:: joint - Joint 8-bit, 1-channel or 3-channel image.; src - Source 8-bit or floating-point, 1-channel or 3-channel image.; dst - Destination image.; r - Radius of filtering kernel, should be a positive integer.; sigma - Filter range standard deviation for the joint image.; weightType - weightType The type of weight definition, see WMFWeightType; mask - A 0-1 mask that has the same size with I. This mask is used to ignore the effect of some pixels. If the pixel value on mask is 0, the pixel will be ignored when maintaining the joint-histogram. This is useful for applications like optical flow occlusion handling.
See Also:: medianBlur, jointBilateralFilter

weightedMedianFilter

@Namespace(value="cv::ximgproc")
public static void weightedMedianFilter(@ByVal
                                                                          Mat joint,
                                                                          @ByVal
                                                                          Mat src,
                                                                          @ByVal
                                                                          Mat dst,
                                                                          int r)

weightedMedianFilter

@Namespace(value="cv::ximgproc")
public static void weightedMedianFilter(@ByVal
                                                                          UMat joint,
                                                                          @ByVal
                                                                          UMat src,
                                                                          @ByVal
                                                                          UMat dst,
                                                                          int r,
                                                                          double sigma,
                                                                          int weightType,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          UMat mask)

weightedMedianFilter

@Namespace(value="cv::ximgproc")
public static void weightedMedianFilter(@ByVal
                                                                          UMat joint,
                                                                          @ByVal
                                                                          UMat src,
                                                                          @ByVal
                                                                          UMat dst,
                                                                          int r)

weightedMedianFilter

@Namespace(value="cv::ximgproc")
public static void weightedMedianFilter(@ByVal
                                                                          GpuMat joint,
                                                                          @ByVal
                                                                          GpuMat src,
                                                                          @ByVal
                                                                          GpuMat dst,
                                                                          int r,
                                                                          double sigma,
                                                                          int weightType,
                                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                          GpuMat mask)

weightedMedianFilter

@Namespace(value="cv::ximgproc")
public static void weightedMedianFilter(@ByVal
                                                                          GpuMat joint,
                                                                          @ByVal
                                                                          GpuMat src,
                                                                          @ByVal
                                                                          GpuMat dst,
                                                                          int r)

createSuperpixelSLIC
```
@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelSLIC createSuperpixelSLIC(@ByVal
                                                                                                       Mat image,
                                                                                                       int algorithm,
                                                                                                       int region_size,
                                                                                                       float ruler)
```
\brief Initialize a SuperpixelSLIC object

Parameters:

image - Image to segment

algorithm - Chooses the algorithm variant to use: SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor, while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels.

region_size - Chooses an average superpixel size measured in pixels

ruler - Chooses the enforcement of superpixel smoothness factor of superpixel
The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future computing iterations over the given image. For enanched results it is recommended for color images to preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture.
![image](pics/superpixels_slic.png)

createSuperpixelSLIC

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelSLIC createSuperpixelSLIC(@ByVal
                                                                                                       Mat image)

createSuperpixelSLIC

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelSLIC createSuperpixelSLIC(@ByVal
                                                                                                       UMat image,
                                                                                                       int algorithm,
                                                                                                       int region_size,
                                                                                                       float ruler)

createSuperpixelSLIC

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelSLIC createSuperpixelSLIC(@ByVal
                                                                                                       UMat image)

createSuperpixelSLIC

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelSLIC createSuperpixelSLIC(@ByVal
                                                                                                       GpuMat image,
                                                                                                       int algorithm,
                                                                                                       int region_size,
                                                                                                       float ruler)

createSuperpixelSLIC

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelSLIC createSuperpixelSLIC(@ByVal
                                                                                                       GpuMat image)

createSuperpixelLSC
```
@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelLSC createSuperpixelLSC(@ByVal
                                                                                                     Mat image,
                                                                                                     int region_size,
                                                                                                     float ratio)
```
\brief Class implementing the LSC (Linear Spectral Clustering) superpixels

Parameters:

image - Image to segment

region_size - Chooses an average superpixel size measured in pixels

ratio - Chooses the enforcement of superpixel compactness factor of superpixel
The function initializes a SuperpixelLSC object for the input image. It sets the parameters of superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future computing iterations over the given image. An example of LSC is ilustrated in the following picture. For enanched results it is recommended for color images to preprocess image with little gaussian blur with a small 3 x 3 kernel and additional conversion into CieLAB color space.
![image](pics/superpixels_lsc.png)

createSuperpixelLSC

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelLSC createSuperpixelLSC(@ByVal
                                                                                                     Mat image)

createSuperpixelLSC

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelLSC createSuperpixelLSC(@ByVal
                                                                                                     UMat image,
                                                                                                     int region_size,
                                                                                                     float ratio)

createSuperpixelLSC

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelLSC createSuperpixelLSC(@ByVal
                                                                                                     UMat image)

createSuperpixelLSC

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelLSC createSuperpixelLSC(@ByVal
                                                                                                     GpuMat image,
                                                                                                     int region_size,
                                                                                                     float ratio)

createSuperpixelLSC

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static SuperpixelLSC createSuperpixelLSC(@ByVal
                                                                                                     GpuMat image)

GradientPaillouY

@Namespace(value="cv::ximgproc")
public static void GradientPaillouY(@ByVal
                                                                      Mat op,
                                                                      @ByVal
                                                                      Mat _dst,
                                                                      double alpha,
                                                                      double omega)

\addtogroup ximgproc_filters \{

/** \brief Applies Paillou filter to an image. For more details about this implementation, please see \cite paillou1997detecting

Parameters:: op - Source CV_8U(S) or CV_16U(S), 1-channel or 3-channels image.; _dst - result CV_32F image with same number of channel than op.; omega - double see paper; alpha - double see paper
See Also:: GradientPaillouX, GradientPaillouY

GradientPaillouY

@Namespace(value="cv::ximgproc")
public static void GradientPaillouY(@ByVal
                                                                      UMat op,
                                                                      @ByVal
                                                                      UMat _dst,
                                                                      double alpha,
                                                                      double omega)

GradientPaillouY

@Namespace(value="cv::ximgproc")
public static void GradientPaillouY(@ByVal
                                                                      GpuMat op,
                                                                      @ByVal
                                                                      GpuMat _dst,
                                                                      double alpha,
                                                                      double omega)

GradientPaillouX

@Namespace(value="cv::ximgproc")
public static void GradientPaillouX(@ByVal
                                                                      Mat op,
                                                                      @ByVal
                                                                      Mat _dst,
                                                                      double alpha,
                                                                      double omega)

GradientPaillouX

@Namespace(value="cv::ximgproc")
public static void GradientPaillouX(@ByVal
                                                                      UMat op,
                                                                      @ByVal
                                                                      UMat _dst,
                                                                      double alpha,
                                                                      double omega)

GradientPaillouX

@Namespace(value="cv::ximgproc")
public static void GradientPaillouX(@ByVal
                                                                      GpuMat op,
                                                                      @ByVal
                                                                      GpuMat _dst,
                                                                      double alpha,
                                                                      double omega)

createFastLineDetector

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastLineDetector createFastLineDetector(int length_threshold,
                                                                                                           float distance_threshold,
                                                                                                           double canny_th1,
                                                                                                           double canny_th2,
                                                                                                           int canny_aperture_size,
                                                                                                           @Cast(value="bool")
                                                                                                           boolean do_merge)

\brief Creates a smart pointer to a FastLineDetector object and initializes it

Parameters:: length_threshold - Segment shorter than this will be discarded; distance_threshold - A point placed from a hypothesis line segment farther than this will be regarded as an outlier; canny_th1 - First threshold for hysteresis procedure in Canny(); canny_th2 - Second threshold for hysteresis procedure in Canny(); canny_aperture_size - Aperturesize for the sobel operator in Canny(). If zero, Canny() is not applied and the input image is taken as an edge image.; do_merge - If true, incremental merging of segments will be performed

createFastLineDetector

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static FastLineDetector createFastLineDetector()

GradientDericheY

@Namespace(value="cv::ximgproc")
public static void GradientDericheY(@ByVal
                                                                      Mat op,
                                                                      @ByVal
                                                                      Mat dst,
                                                                      double alpha,
                                                                      double omega)

\addtogroup ximgproc_filters \{

/** \brief Applies Y Deriche filter to an image. For more details about this implementation, please see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.476.5736&rep=rep1&type=pdf

Parameters:: op - Source 8-bit or 16bit image, 1-channel or 3-channel image.; dst - result CV_32FC image with same number of channel than _op.; alpha - double see paper; omega - double see paper

GradientDericheY

@Namespace(value="cv::ximgproc")
public static void GradientDericheY(@ByVal
                                                                      UMat op,
                                                                      @ByVal
                                                                      UMat dst,
                                                                      double alpha,
                                                                      double omega)

GradientDericheY

@Namespace(value="cv::ximgproc")
public static void GradientDericheY(@ByVal
                                                                      GpuMat op,
                                                                      @ByVal
                                                                      GpuMat dst,
                                                                      double alpha,
                                                                      double omega)

GradientDericheX

@Namespace(value="cv::ximgproc")
public static void GradientDericheX(@ByVal
                                                                      Mat op,
                                                                      @ByVal
                                                                      Mat dst,
                                                                      double alpha,
                                                                      double omega)

\brief Applies X Deriche filter to an image. For more details about this implementation, please see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.476.5736&rep=rep1&type=pdf

Parameters:: op - Source 8-bit or 16bit image, 1-channel or 3-channel image.; dst - result CV_32FC image with same number of channel than _op.; alpha - double see paper; omega - double see paper

GradientDericheX

@Namespace(value="cv::ximgproc")
public static void GradientDericheX(@ByVal
                                                                      UMat op,
                                                                      @ByVal
                                                                      UMat dst,
                                                                      double alpha,
                                                                      double omega)

GradientDericheX

@Namespace(value="cv::ximgproc")
public static void GradientDericheX(@ByVal
                                                                      GpuMat op,
                                                                      @ByVal
                                                                      GpuMat dst,
                                                                      double alpha,
                                                                      double omega)

PeiLinNormalization
```
@Namespace(value="cv::ximgproc")
 @ByVal
 @Cast(value="cv::Matx23d*")
public static DoublePointer PeiLinNormalization(@ByVal
                                                                                                                         Mat I)
```
\addtogroup ximgproc \{
/** \brief Calculates an affine transformation that normalize given image using Pei&Lin Normalization. Assume given image I=T(\bar{I}) where \bar{I} is a normalized image and T is an affine transformation distorting this image by translation, rotation, scaling and skew. The function returns an affine transformation matrix corresponding to the transformation T^{-1} described in [PeiLin95]. For more details about this implementation, please see [PeiLin95] Soo-Chang Pei and Chao-Nan Lin. Image normalization for pattern recognition. Image and Vision Computing, Vol. 13, N.10, pp. 711-723, 1995.

Parameters:

I - Given transformed image.

Returns:

Transformation matrix corresponding to inversed image transformation

PeiLinNormalization

@Namespace(value="cv::ximgproc")
 @ByVal
 @Cast(value="cv::Matx23d*")
public static DoublePointer PeiLinNormalization(@ByVal
                                                                                                                         UMat I)

PeiLinNormalization

@Namespace(value="cv::ximgproc")
 @ByVal
 @Cast(value="cv::Matx23d*")
public static DoublePointer PeiLinNormalization(@ByVal
                                                                                                                         GpuMat I)

PeiLinNormalization

@Namespace(value="cv::ximgproc")
public static void PeiLinNormalization(@ByVal
                                                                         Mat I,
                                                                         @ByVal
                                                                         Mat T)

\overload

PeiLinNormalization

@Namespace(value="cv::ximgproc")
public static void PeiLinNormalization(@ByVal
                                                                         UMat I,
                                                                         @ByVal
                                                                         UMat T)

PeiLinNormalization

@Namespace(value="cv::ximgproc")
public static void PeiLinNormalization(@ByVal
                                                                         GpuMat I,
                                                                         @ByVal
                                                                         GpuMat T)

fourierDescriptor

@Namespace(value="cv::ximgproc")
public static void fourierDescriptor(@ByVal
                                                                       Mat src,
                                                                       @ByVal
                                                                       Mat dst,
                                                                       int nbElt,
                                                                       int nbFD)

\brief Fourier descriptors for planed closed curves For more details about this implementation, please see \cite PersoonFu1977

Parameters:: src - contour type vector , vector or vector; dst - Mat of type CV_64FC2 and nbElt rows A VERIFIER; nbElt - number of rows in dst or getOptimalDFTSize rows if nbElt=-1; nbFD - number of FD return in dst dst = [FD(1...nbFD/2) FD(nbFD/2-nbElt+1...:nbElt)]

fourierDescriptor

@Namespace(value="cv::ximgproc")
public static void fourierDescriptor(@ByVal
                                                                       Mat src,
                                                                       @ByVal
                                                                       Mat dst)

fourierDescriptor

@Namespace(value="cv::ximgproc")
public static void fourierDescriptor(@ByVal
                                                                       UMat src,
                                                                       @ByVal
                                                                       UMat dst,
                                                                       int nbElt,
                                                                       int nbFD)

fourierDescriptor

@Namespace(value="cv::ximgproc")
public static void fourierDescriptor(@ByVal
                                                                       UMat src,
                                                                       @ByVal
                                                                       UMat dst)

fourierDescriptor

@Namespace(value="cv::ximgproc")
public static void fourierDescriptor(@ByVal
                                                                       GpuMat src,
                                                                       @ByVal
                                                                       GpuMat dst,
                                                                       int nbElt,
                                                                       int nbFD)

fourierDescriptor

@Namespace(value="cv::ximgproc")
public static void fourierDescriptor(@ByVal
                                                                       GpuMat src,
                                                                       @ByVal
                                                                       GpuMat dst)

transformFD

@Namespace(value="cv::ximgproc")
public static void transformFD(@ByVal
                                                                 Mat src,
                                                                 @ByVal
                                                                 Mat t,
                                                                 @ByVal
                                                                 Mat dst,
                                                                 @Cast(value="bool")
                                                                 boolean fdContour)

\brief transform a contour

Parameters:: src - contour or Fourier Descriptors if fd is true; t - transform Mat given by estimateTransformation; dst - Mat of type CV_64FC2 and nbElt rows; fdContour - true src are Fourier Descriptors. fdContour false src is a contour

transformFD

@Namespace(value="cv::ximgproc")
public static void transformFD(@ByVal
                                                                 Mat src,
                                                                 @ByVal
                                                                 Mat t,
                                                                 @ByVal
                                                                 Mat dst)

transformFD

@Namespace(value="cv::ximgproc")
public static void transformFD(@ByVal
                                                                 UMat src,
                                                                 @ByVal
                                                                 UMat t,
                                                                 @ByVal
                                                                 UMat dst,
                                                                 @Cast(value="bool")
                                                                 boolean fdContour)

transformFD

@Namespace(value="cv::ximgproc")
public static void transformFD(@ByVal
                                                                 UMat src,
                                                                 @ByVal
                                                                 UMat t,
                                                                 @ByVal
                                                                 UMat dst)

transformFD

@Namespace(value="cv::ximgproc")
public static void transformFD(@ByVal
                                                                 GpuMat src,
                                                                 @ByVal
                                                                 GpuMat t,
                                                                 @ByVal
                                                                 GpuMat dst,
                                                                 @Cast(value="bool")
                                                                 boolean fdContour)

transformFD

@Namespace(value="cv::ximgproc")
public static void transformFD(@ByVal
                                                                 GpuMat src,
                                                                 @ByVal
                                                                 GpuMat t,
                                                                 @ByVal
                                                                 GpuMat dst)

contourSampling

@Namespace(value="cv::ximgproc")
public static void contourSampling(@ByVal
                                                                     Mat src,
                                                                     @ByVal
                                                                     Mat out,
                                                                     int nbElt)

\brief Contour sampling .

Parameters:: src - contour type vector , vector or vector; out - Mat of type CV_64FC2 and nbElt rows; nbElt - number of points in out contour

contourSampling

@Namespace(value="cv::ximgproc")
public static void contourSampling(@ByVal
                                                                     UMat src,
                                                                     @ByVal
                                                                     UMat out,
                                                                     int nbElt)

contourSampling

@Namespace(value="cv::ximgproc")
public static void contourSampling(@ByVal
                                                                     GpuMat src,
                                                                     @ByVal
                                                                     GpuMat out,
                                                                     int nbElt)

createContourFitting

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static ContourFitting createContourFitting(int ctr,
                                                                                                       int fd)

\brief create ContourFitting algorithm object

Parameters:: ctr - number of Fourier descriptors equal to number of contour points after resampling.; fd - Contour defining second shape (Target).

createContourFitting

@Namespace(value="cv::ximgproc")
 @opencv_core.Ptr
public static ContourFitting createContourFitting()

BrightEdges

@Namespace(value="cv::ximgproc")
public static void BrightEdges(@ByRef
                                                                 Mat _original,
                                                                 @ByRef
                                                                 Mat _edgeview,
                                                                 int contrast,
                                                                 int shortrange,
                                                                 int longrange)

BrightEdges

@Namespace(value="cv::ximgproc")
public static void BrightEdges(@ByRef
                                                                 Mat _original,
                                                                 @ByRef
                                                                 Mat _edgeview)

threshold

@Namespace(value="cv::ximgproc::rl")
public static void threshold(@ByVal
                                                                   Mat src,
                                                                   @ByVal
                                                                   Mat rlDest,
                                                                   double thresh,
                                                                   int type)

\addtogroup ximgproc_run_length_morphology \{

/** \brief Applies a fixed-level threshold to each array element.

Parameters:: src - input array (single-channel).; rlDest - resulting run length encoded image.; thresh - threshold value.; type - thresholding type (only cv::THRESH_BINARY and cv::THRESH_BINARY_INV are supported)

threshold

@Namespace(value="cv::ximgproc::rl")
public static void threshold(@ByVal
                                                                   UMat src,
                                                                   @ByVal
                                                                   UMat rlDest,
                                                                   double thresh,
                                                                   int type)

threshold

@Namespace(value="cv::ximgproc::rl")
public static void threshold(@ByVal
                                                                   GpuMat src,
                                                                   @ByVal
                                                                   GpuMat rlDest,
                                                                   double thresh,
                                                                   int type)

dilate

@Namespace(value="cv::ximgproc::rl")
public static void dilate(@ByVal
                                                                Mat rlSrc,
                                                                @ByVal
                                                                Mat rlDest,
                                                                @ByVal
                                                                Mat rlKernel,
                                                                @ByVal(nullValue="cv::Point(0, 0)")
                                                                Point anchor)

\brief Dilates an run-length encoded binary image by using a specific structuring element.

Parameters:: rlSrc - input image; rlDest - result; rlKernel - kernel; anchor - position of the anchor within the element; default value (0, 0) is usually the element center.

dilate

@Namespace(value="cv::ximgproc::rl")
public static void dilate(@ByVal
                                                                Mat rlSrc,
                                                                @ByVal
                                                                Mat rlDest,
                                                                @ByVal
                                                                Mat rlKernel)

dilate

@Namespace(value="cv::ximgproc::rl")
public static void dilate(@ByVal
                                                                UMat rlSrc,
                                                                @ByVal
                                                                UMat rlDest,
                                                                @ByVal
                                                                UMat rlKernel,
                                                                @ByVal(nullValue="cv::Point(0, 0)")
                                                                Point anchor)

dilate

@Namespace(value="cv::ximgproc::rl")
public static void dilate(@ByVal
                                                                UMat rlSrc,
                                                                @ByVal
                                                                UMat rlDest,
                                                                @ByVal
                                                                UMat rlKernel)

dilate

@Namespace(value="cv::ximgproc::rl")
public static void dilate(@ByVal
                                                                GpuMat rlSrc,
                                                                @ByVal
                                                                GpuMat rlDest,
                                                                @ByVal
                                                                GpuMat rlKernel,
                                                                @ByVal(nullValue="cv::Point(0, 0)")
                                                                Point anchor)

dilate

@Namespace(value="cv::ximgproc::rl")
public static void dilate(@ByVal
                                                                GpuMat rlSrc,
                                                                @ByVal
                                                                GpuMat rlDest,
                                                                @ByVal
                                                                GpuMat rlKernel)

erode

@Namespace(value="cv::ximgproc::rl")
public static void erode(@ByVal
                                                               Mat rlSrc,
                                                               @ByVal
                                                               Mat rlDest,
                                                               @ByVal
                                                               Mat rlKernel,
                                                               @Cast(value="bool")
                                                               boolean bBoundaryOn,
                                                               @ByVal(nullValue="cv::Point(0, 0)")
                                                               Point anchor)

\brief Erodes an run-length encoded binary image by using a specific structuring element.

Parameters:: rlSrc - input image; rlDest - result; rlKernel - kernel; bBoundaryOn - indicates whether pixel outside the image boundary are assumed to be on (True: works in the same way as the default of cv::erode, False: is a little faster); anchor - position of the anchor within the element; default value (0, 0) is usually the element center.

erode

@Namespace(value="cv::ximgproc::rl")
public static void erode(@ByVal
                                                               Mat rlSrc,
                                                               @ByVal
                                                               Mat rlDest,
                                                               @ByVal
                                                               Mat rlKernel)

erode

@Namespace(value="cv::ximgproc::rl")
public static void erode(@ByVal
                                                               UMat rlSrc,
                                                               @ByVal
                                                               UMat rlDest,
                                                               @ByVal
                                                               UMat rlKernel,
                                                               @Cast(value="bool")
                                                               boolean bBoundaryOn,
                                                               @ByVal(nullValue="cv::Point(0, 0)")
                                                               Point anchor)

erode

@Namespace(value="cv::ximgproc::rl")
public static void erode(@ByVal
                                                               UMat rlSrc,
                                                               @ByVal
                                                               UMat rlDest,
                                                               @ByVal
                                                               UMat rlKernel)

erode

@Namespace(value="cv::ximgproc::rl")
public static void erode(@ByVal
                                                               GpuMat rlSrc,
                                                               @ByVal
                                                               GpuMat rlDest,
                                                               @ByVal
                                                               GpuMat rlKernel,
                                                               @Cast(value="bool")
                                                               boolean bBoundaryOn,
                                                               @ByVal(nullValue="cv::Point(0, 0)")
                                                               Point anchor)

erode

@Namespace(value="cv::ximgproc::rl")
public static void erode(@ByVal
                                                               GpuMat rlSrc,
                                                               @ByVal
                                                               GpuMat rlDest,
                                                               @ByVal
                                                               GpuMat rlKernel)

getStructuringElement

@Namespace(value="cv::ximgproc::rl")
 @ByVal
public static Mat getStructuringElement(int shape,
                                                                                       @ByVal
                                                                                       Size ksize)

\brief Returns a run length encoded structuring element of the specified size and shape.

Parameters:: shape - Element shape that can be one of cv::MorphShapes; ksize - Size of the structuring element.

paint

@Namespace(value="cv::ximgproc::rl")
public static void paint(@ByVal
                                                               Mat image,
                                                               @ByVal
                                                               Mat rlSrc,
                                                               @Const @ByRef
                                                               Scalar value)

\brief Paint run length encoded binary image into an image.

Parameters:: image - image to paint into (currently only single channel images).; rlSrc - run length encoded image; value - all foreground pixel of the binary image are set to this value

paint

@Namespace(value="cv::ximgproc::rl")
public static void paint(@ByVal
                                                               UMat image,
                                                               @ByVal
                                                               UMat rlSrc,
                                                               @Const @ByRef
                                                               Scalar value)

paint

@Namespace(value="cv::ximgproc::rl")
public static void paint(@ByVal
                                                               GpuMat image,
                                                               @ByVal
                                                               GpuMat rlSrc,
                                                               @Const @ByRef
                                                               Scalar value)

isRLMorphologyPossible

@Namespace(value="cv::ximgproc::rl")
 @Cast(value="bool")
public static boolean isRLMorphologyPossible(@ByVal
                                                                                                         Mat rlStructuringElement)

\brief Check whether a custom made structuring element can be used with run length morphological operations. (It must consist of a continuous array of single runs per row)

Parameters:: rlStructuringElement - mask to be tested

isRLMorphologyPossible

@Namespace(value="cv::ximgproc::rl")
 @Cast(value="bool")
public static boolean isRLMorphologyPossible(@ByVal
                                                                                                         UMat rlStructuringElement)

isRLMorphologyPossible

@Namespace(value="cv::ximgproc::rl")
 @Cast(value="bool")
public static boolean isRLMorphologyPossible(@ByVal
                                                                                                         GpuMat rlStructuringElement)

createRLEImage

@Namespace(value="cv::ximgproc::rl")
public static void createRLEImage(@Cast(value="const std::vector<cv::Point3i>*") @ByRef
                                                                        Point3iVector runs,
                                                                        @ByVal
                                                                        Mat res,
                                                                        @ByVal(nullValue="cv::Size(0, 0)")
                                                                        Size size)

\brief Creates a run-length encoded image from a vector of runs (column begin, column end, row)

Parameters:: runs - vector of runs; res - result; size - image size (to be used if an "on" boundary should be used in erosion, using the default means that the size is computed from the extension of the input)

createRLEImage

@Namespace(value="cv::ximgproc::rl")
public static void createRLEImage(@Cast(value="const std::vector<cv::Point3i>*") @ByRef
                                                                        Point3iVector runs,
                                                                        @ByVal
                                                                        Mat res)

createRLEImage

@Namespace(value="cv::ximgproc::rl")
public static void createRLEImage(@Cast(value="const std::vector<cv::Point3i>*") @ByRef
                                                                        Point3iVector runs,
                                                                        @ByVal
                                                                        UMat res,
                                                                        @ByVal(nullValue="cv::Size(0, 0)")
                                                                        Size size)

createRLEImage

@Namespace(value="cv::ximgproc::rl")
public static void createRLEImage(@Cast(value="const std::vector<cv::Point3i>*") @ByRef
                                                                        Point3iVector runs,
                                                                        @ByVal
                                                                        UMat res)

createRLEImage

@Namespace(value="cv::ximgproc::rl")
public static void createRLEImage(@Cast(value="const std::vector<cv::Point3i>*") @ByRef
                                                                        Point3iVector runs,
                                                                        @ByVal
                                                                        GpuMat res,
                                                                        @ByVal(nullValue="cv::Size(0, 0)")
                                                                        Size size)

createRLEImage

@Namespace(value="cv::ximgproc::rl")
public static void createRLEImage(@Cast(value="const std::vector<cv::Point3i>*") @ByRef
                                                                        Point3iVector runs,
                                                                        @ByVal
                                                                        GpuMat res)

morphologyEx

@Namespace(value="cv::ximgproc::rl")
public static void morphologyEx(@ByVal
                                                                      Mat rlSrc,
                                                                      @ByVal
                                                                      Mat rlDest,
                                                                      int op,
                                                                      @ByVal
                                                                      Mat rlKernel,
                                                                      @Cast(value="bool")
                                                                      boolean bBoundaryOnForErosion,
                                                                      @ByVal(nullValue="cv::Point(0,0)")
                                                                      Point anchor)

\brief Applies a morphological operation to a run-length encoded binary image.

Parameters:: rlSrc - input image; rlDest - result; op - all operations supported by cv::morphologyEx (except cv::MORPH_HITMISS); rlKernel - kernel; bBoundaryOnForErosion - indicates whether pixel outside the image boundary are assumed to be on for erosion operations (True: works in the same way as the default of cv::erode, False: is a little faster); anchor - position of the anchor within the element; default value (0, 0) is usually the element center.

morphologyEx

@Namespace(value="cv::ximgproc::rl")
public static void morphologyEx(@ByVal
                                                                      Mat rlSrc,
                                                                      @ByVal
                                                                      Mat rlDest,
                                                                      int op,
                                                                      @ByVal
                                                                      Mat rlKernel)

morphologyEx

@Namespace(value="cv::ximgproc::rl")
public static void morphologyEx(@ByVal
                                                                      UMat rlSrc,
                                                                      @ByVal
                                                                      UMat rlDest,
                                                                      int op,
                                                                      @ByVal
                                                                      UMat rlKernel,
                                                                      @Cast(value="bool")
                                                                      boolean bBoundaryOnForErosion,
                                                                      @ByVal(nullValue="cv::Point(0,0)")
                                                                      Point anchor)

morphologyEx

@Namespace(value="cv::ximgproc::rl")
public static void morphologyEx(@ByVal
                                                                      UMat rlSrc,
                                                                      @ByVal
                                                                      UMat rlDest,
                                                                      int op,
                                                                      @ByVal
                                                                      UMat rlKernel)

morphologyEx

@Namespace(value="cv::ximgproc::rl")
public static void morphologyEx(@ByVal
                                                                      GpuMat rlSrc,
                                                                      @ByVal
                                                                      GpuMat rlDest,
                                                                      int op,
                                                                      @ByVal
                                                                      GpuMat rlKernel,
                                                                      @Cast(value="bool")
                                                                      boolean bBoundaryOnForErosion,
                                                                      @ByVal(nullValue="cv::Point(0,0)")
                                                                      Point anchor)

morphologyEx

@Namespace(value="cv::ximgproc::rl")
public static void morphologyEx(@ByVal
                                                                      GpuMat rlSrc,
                                                                      @ByVal
                                                                      GpuMat rlDest,
                                                                      int op,
                                                                      @ByVal
                                                                      GpuMat rlKernel)

edgePreservingFilter
```
@Namespace(value="cv::ximgproc")
public static void edgePreservingFilter(@ByVal
                                                                          Mat src,
                                                                          @ByVal
                                                                          Mat dst,
                                                                          int d,
                                                                          double threshold)
```
\addtogroup ximgproc \{
/** \brief Smoothes an image using the Edge-Preserving filter. The function smoothes Gaussian noise as well as salt & pepper noise. For more details about this implementation, please see [ReiWoe18] Reich, S. and WÃ¶rgÃ¶tter, F. and Dellen, B. (2018). A Real-Time Edge-Preserving Denoising Filter. Proceedings of the 13th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications (VISIGRAPP): Visapp, 85-94, 4. DOI: 10.5220/0006509000850094.

Parameters:

src - Source 8-bit 3-channel image.

dst - Destination image of the same size and type as src.

d - Diameter of each pixel neighborhood that is used during filtering. Must be greater or equal 3.

threshold - Threshold, which distinguishes between noise, outliers, and data.

edgePreservingFilter

@Namespace(value="cv::ximgproc")
public static void edgePreservingFilter(@ByVal
                                                                          UMat src,
                                                                          @ByVal
                                                                          UMat dst,
                                                                          int d,
                                                                          double threshold)

edgePreservingFilter

@Namespace(value="cv::ximgproc")
public static void edgePreservingFilter(@ByVal
                                                                          GpuMat src,
                                                                          @ByVal
                                                                          GpuMat dst,
                                                                          int d,
                                                                          double threshold)

createQuaternionImage

@Namespace(value="cv::ximgproc")
public static void createQuaternionImage(@ByVal
                                                                           Mat img,
                                                                           @ByVal
                                                                           Mat qimg)

\addtogroup ximgproc_filters \{

/** \brief creates a quaternion image.

Parameters:: img - Source 8-bit, 32-bit or 64-bit image, with 3-channel image.; qimg - result CV_64FC4 a quaternion image( 4 chanels zero channel and B,G,R).

createQuaternionImage

@Namespace(value="cv::ximgproc")
public static void createQuaternionImage(@ByVal
                                                                           UMat img,
                                                                           @ByVal
                                                                           UMat qimg)

createQuaternionImage

@Namespace(value="cv::ximgproc")
public static void createQuaternionImage(@ByVal
                                                                           GpuMat img,
                                                                           @ByVal
                                                                           GpuMat qimg)

qconj

@Namespace(value="cv::ximgproc")
public static void qconj(@ByVal
                                                           Mat qimg,
                                                           @ByVal
                                                           Mat qcimg)

\brief calculates conjugate of a quaternion image.

Parameters:: qimg - quaternion image.; qcimg - conjugate of qimg

qconj

@Namespace(value="cv::ximgproc")
public static void qconj(@ByVal
                                                           UMat qimg,
                                                           @ByVal
                                                           UMat qcimg)

qconj

@Namespace(value="cv::ximgproc")
public static void qconj(@ByVal
                                                           GpuMat qimg,
                                                           @ByVal
                                                           GpuMat qcimg)

qunitary

@Namespace(value="cv::ximgproc")
public static void qunitary(@ByVal
                                                              Mat qimg,
                                                              @ByVal
                                                              Mat qnimg)

\brief divides each element by its modulus.

Parameters:: qimg - quaternion image.; qnimg - conjugate of qimg

qunitary

@Namespace(value="cv::ximgproc")
public static void qunitary(@ByVal
                                                              UMat qimg,
                                                              @ByVal
                                                              UMat qnimg)

qunitary

@Namespace(value="cv::ximgproc")
public static void qunitary(@ByVal
                                                              GpuMat qimg,
                                                              @ByVal
                                                              GpuMat qnimg)

qmultiply

@Namespace(value="cv::ximgproc")
public static void qmultiply(@ByVal
                                                               Mat src1,
                                                               @ByVal
                                                               Mat src2,
                                                               @ByVal
                                                               Mat dst)

\brief Calculates the per-element quaternion product of two arrays

Parameters:: src1 - quaternion image.; src2 - quaternion image.; dst - product dst(I)=src1(I) . src2(I)

qmultiply

@Namespace(value="cv::ximgproc")
public static void qmultiply(@ByVal
                                                               UMat src1,
                                                               @ByVal
                                                               UMat src2,
                                                               @ByVal
                                                               UMat dst)

qmultiply

@Namespace(value="cv::ximgproc")
public static void qmultiply(@ByVal
                                                               GpuMat src1,
                                                               @ByVal
                                                               GpuMat src2,
                                                               @ByVal
                                                               GpuMat dst)

qdft

@Namespace(value="cv::ximgproc")
public static void qdft(@ByVal
                                                          Mat img,
                                                          @ByVal
                                                          Mat qimg,
                                                          int flags,
                                                          @Cast(value="bool")
                                                          boolean sideLeft)

\brief Performs a forward or inverse Discrete quaternion Fourier transform of a 2D quaternion array.

Parameters:: img - quaternion image.; qimg - quaternion image in dual space.; flags - quaternion image in dual space. only DFT_INVERSE flags is supported; sideLeft - true the hypercomplex exponential is to be multiplied on the left (false on the right ).

qdft

@Namespace(value="cv::ximgproc")
public static void qdft(@ByVal
                                                          UMat img,
                                                          @ByVal
                                                          UMat qimg,
                                                          int flags,
                                                          @Cast(value="bool")
                                                          boolean sideLeft)

qdft

@Namespace(value="cv::ximgproc")
public static void qdft(@ByVal
                                                          GpuMat img,
                                                          @ByVal
                                                          GpuMat qimg,
                                                          int flags,
                                                          @Cast(value="bool")
                                                          boolean sideLeft)

colorMatchTemplate

@Namespace(value="cv::ximgproc")
public static void colorMatchTemplate(@ByVal
                                                                        Mat img,
                                                                        @ByVal
                                                                        Mat templ,
                                                                        @ByVal
                                                                        Mat result)

\brief Compares a color template against overlapped color image regions.

Parameters:: img - Image where the search is running. It must be 3 channels image; templ - Searched template. It must be not greater than the source image and have 3 channels; result - Map of comparison results. It must be single-channel 64-bit floating-point

colorMatchTemplate

@Namespace(value="cv::ximgproc")
public static void colorMatchTemplate(@ByVal
                                                                        UMat img,
                                                                        @ByVal
                                                                        UMat templ,
                                                                        @ByVal
                                                                        UMat result)

colorMatchTemplate

@Namespace(value="cv::ximgproc")
public static void colorMatchTemplate(@ByVal
                                                                        GpuMat img,
                                                                        @ByVal
                                                                        GpuMat templ,
                                                                        @ByVal
                                                                        GpuMat result)

RadonTransform

@Namespace(value="cv::ximgproc")
public static void RadonTransform(@ByVal
                                                                    Mat src,
                                                                    @ByVal
                                                                    Mat dst,
                                                                    double theta,
                                                                    double start_angle,
                                                                    double end_angle,
                                                                    @Cast(value="bool")
                                                                    boolean crop,
                                                                    @Cast(value="bool")
                                                                    boolean norm)

\brief Calculate Radon Transform of an image.

Parameters:: src - The source (input) image.; dst - The destination image, result of transformation.; theta - Angle resolution of the transform in degrees.; start_angle - Start angle of the transform in degrees.; end_angle - End angle of the transform in degrees.; crop - Crop the source image into a circle.; norm - Normalize the output Mat to grayscale and convert type to CV_8U This function calculates the Radon Transform of a given image in any range. See https://engineering.purdue.edu/~malcolm/pct/CTI_Ch03.pdf for detail. If the input type is CV_8U, the output will be CV_32S. If the input type is CV_32F or CV_64F, the output will be CV_64F The output size will be num_of_integral x src_diagonal_length. If crop is selected, the input image will be crop into square then circle, and output size will be num_of_integral x min_edge.

RadonTransform

@Namespace(value="cv::ximgproc")
public static void RadonTransform(@ByVal
                                                                    Mat src,
                                                                    @ByVal
                                                                    Mat dst)

RadonTransform

@Namespace(value="cv::ximgproc")
public static void RadonTransform(@ByVal
                                                                    UMat src,
                                                                    @ByVal
                                                                    UMat dst,
                                                                    double theta,
                                                                    double start_angle,
                                                                    double end_angle,
                                                                    @Cast(value="bool")
                                                                    boolean crop,
                                                                    @Cast(value="bool")
                                                                    boolean norm)

RadonTransform

@Namespace(value="cv::ximgproc")
public static void RadonTransform(@ByVal
                                                                    UMat src,
                                                                    @ByVal
                                                                    UMat dst)

RadonTransform

@Namespace(value="cv::ximgproc")
public static void RadonTransform(@ByVal
                                                                    GpuMat src,
                                                                    @ByVal
                                                                    GpuMat dst,
                                                                    double theta,
                                                                    double start_angle,
                                                                    double end_angle,
                                                                    @Cast(value="bool")
                                                                    boolean crop,
                                                                    @Cast(value="bool")
                                                                    boolean norm)

RadonTransform

@Namespace(value="cv::ximgproc")
public static void RadonTransform(@ByVal
                                                                    GpuMat src,
                                                                    @ByVal
                                                                    GpuMat dst)

findEllipses

@Namespace(value="cv::ximgproc")
public static void findEllipses(@ByVal
                                                                  Mat image,
                                                                  @ByVal
                                                                  Mat ellipses,
                                                                  float scoreThreshold,
                                                                  float reliabilityThreshold,
                                                                  float centerDistanceThreshold)

\addtogroup ximgproc \{

/** \brief Finds ellipses fastly in an image using projective invariant pruning. The function detects ellipses in images using projective invariant pruning. For more details about this implementation, please see \cite jia2017fast Jia, Qi et al, (2017). A Fast Ellipse Detector using Projective Invariant Pruning. IEEE Transactions on Image Processing.

Parameters:: image - input image, could be gray or color.; ellipses - output vector of found ellipses. each vector is encoded as five float $x, y, a, b, radius, score$.; scoreThreshold - float, the threshold of ellipse score.; reliabilityThreshold - float, the threshold of reliability.; centerDistanceThreshold - float, the threshold of center distance.

findEllipses

@Namespace(value="cv::ximgproc")
public static void findEllipses(@ByVal
                                                                  Mat image,
                                                                  @ByVal
                                                                  Mat ellipses)

findEllipses

@Namespace(value="cv::ximgproc")
public static void findEllipses(@ByVal
                                                                  UMat image,
                                                                  @ByVal
                                                                  UMat ellipses,
                                                                  float scoreThreshold,
                                                                  float reliabilityThreshold,
                                                                  float centerDistanceThreshold)

findEllipses

@Namespace(value="cv::ximgproc")
public static void findEllipses(@ByVal
                                                                  UMat image,
                                                                  @ByVal
                                                                  UMat ellipses)

findEllipses

@Namespace(value="cv::ximgproc")
public static void findEllipses(@ByVal
                                                                  GpuMat image,
                                                                  @ByVal
                                                                  GpuMat ellipses,
                                                                  float scoreThreshold,
                                                                  float reliabilityThreshold,
                                                                  float centerDistanceThreshold)

findEllipses

@Namespace(value="cv::ximgproc")
public static void findEllipses(@ByVal
                                                                  GpuMat image,
                                                                  @ByVal
                                                                  GpuMat ellipses)

Class opencv_ximgproc

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.opencv.presets.opencv_ximgproc

Methods inherited from class java.lang.Object

Field Detail

THINNING_ZHANGSUEN

THINNING_GUOHALL

BINARIZATION_NIBLACK

BINARIZATION_SAUVOLA

BINARIZATION_WOLF

BINARIZATION_NICK

DTF_NC

DTF_IC

DTF_RF

GUIDED_FILTER

AM_FILTER

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

FHT_MIN

FHT_MAX

FHT_ADD

FHT_AVE

HDO_RAW

HDO_DESKEW

RO_STRICT

RO_IGNORE_BORDERS

WMF_EXP

WMF_IV1

WMF_IV2

WMF_COS

WMF_JAC

WMF_OFF

SLIC

SLICO

MSLIC

Constructor Detail

opencv_ximgproc

Method Detail

niBlackThreshold

niBlackThreshold

niBlackThreshold

niBlackThreshold

niBlackThreshold

niBlackThreshold

thinning

thinning

thinning

thinning

thinning

thinning

anisotropicDiffusion

anisotropicDiffusion

anisotropicDiffusion

createDTFilter

createDTFilter

createDTFilter

createDTFilter

createDTFilter

createDTFilter

dtFilter

dtFilter

dtFilter

dtFilter

dtFilter

dtFilter

createGuidedFilter

createGuidedFilter

createGuidedFilter

createGuidedFilter

createGuidedFilter

createGuidedFilter