public class Ximgproc extends Object
Modifier and Type | Field and Description |
---|---|
static int |
AM_FILTER |
static int |
ARO_0_45 |
static int |
ARO_315_0 |
static int |
ARO_315_135 |
static int |
ARO_315_45 |
static int |
ARO_45_135 |
static int |
ARO_45_90 |
static int |
ARO_90_135 |
static int |
ARO_CTR_HOR |
static int |
ARO_CTR_VER |
static int |
BINARIZATION_NIBLACK |
static int |
BINARIZATION_NICK |
static int |
BINARIZATION_SAUVOLA |
static int |
BINARIZATION_WOLF |
static int |
DTF_IC |
static int |
DTF_NC |
static int |
DTF_RF |
static int |
FHT_ADD |
static int |
FHT_AVE |
static int |
FHT_MAX |
static int |
FHT_MIN |
static int |
GUIDED_FILTER |
static int |
HDO_DESKEW |
static int |
HDO_RAW |
static int |
MSLIC |
static int |
SLIC |
static int |
SLICO |
static int |
THINNING_GUOHALL |
static int |
THINNING_ZHANGSUEN |
static int |
WMF_COS |
static int |
WMF_EXP |
static int |
WMF_IV1 |
static int |
WMF_IV2 |
static int |
WMF_JAC |
static int |
WMF_OFF |
Constructor and Description |
---|
Ximgproc() |
Modifier and Type | Method and Description |
---|---|
static void |
amFilter(Mat joint,
Mat src,
Mat dst,
double sigma_s,
double sigma_r)
Simple one-line Adaptive Manifold Filter call.
|
static void |
amFilter(Mat joint,
Mat src,
Mat dst,
double sigma_s,
double sigma_r,
boolean adjust_outliers)
Simple one-line Adaptive Manifold Filter call.
|
static void |
anisotropicDiffusion(Mat src,
Mat dst,
float alpha,
float K,
int niters)
Performs anisotropic diffusian on an image.
|
static void |
bilateralTextureFilter(Mat src,
Mat dst)
Applies the bilateral texture filter to an image.
|
static void |
bilateralTextureFilter(Mat src,
Mat dst,
int fr)
Applies the bilateral texture filter to an image.
|
static void |
bilateralTextureFilter(Mat src,
Mat dst,
int fr,
int numIter)
Applies the bilateral texture filter to an image.
|
static void |
bilateralTextureFilter(Mat src,
Mat dst,
int fr,
int numIter,
double sigmaAlpha)
Applies the bilateral texture filter to an image.
|
static void |
bilateralTextureFilter(Mat src,
Mat dst,
int fr,
int numIter,
double sigmaAlpha,
double sigmaAvg)
Applies the bilateral texture filter to an image.
|
static void |
colorMatchTemplate(Mat img,
Mat templ,
Mat result)
Compares a color template against overlapped color image regions.
|
static void |
contourSampling(Mat src,
Mat out,
int nbElt)
Contour sampling .
|
static void |
covarianceEstimation(Mat src,
Mat dst,
int windowRows,
int windowCols)
Computes the estimated covariance matrix of an image using the sliding
window forumlation.
|
static AdaptiveManifoldFilter |
createAMFilter(double sigma_s,
double sigma_r)
Factory method, create instance of AdaptiveManifoldFilter and produce some initialization routines.
|
static AdaptiveManifoldFilter |
createAMFilter(double sigma_s,
double sigma_r,
boolean adjust_outliers)
Factory method, create instance of AdaptiveManifoldFilter and produce some initialization routines.
|
static ContourFitting |
createContourFitting()
create ContourFitting algorithm object
|
static ContourFitting |
createContourFitting(int ctr)
create ContourFitting algorithm object
|
static ContourFitting |
createContourFitting(int ctr,
int fd)
create ContourFitting algorithm object
|
static DisparityWLSFilter |
createDisparityWLSFilter(StereoMatcher matcher_left)
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)
More generic factory method, create instance of DisparityWLSFilter and execute basic
initialization routines.
|
static DTFilter |
createDTFilter(Mat guide,
double sigmaSpatial,
double sigmaColor)
Factory method, create instance of DTFilter and produce initialization routines.
|
static DTFilter |
createDTFilter(Mat guide,
double sigmaSpatial,
double sigmaColor,
int mode)
Factory method, create instance of DTFilter and produce initialization routines.
|
static DTFilter |
createDTFilter(Mat guide,
double sigmaSpatial,
double sigmaColor,
int mode,
int numIters)
Factory method, create instance of DTFilter and produce initialization routines.
|
static EdgeAwareInterpolator |
createEdgeAwareInterpolator()
Factory method that creates an instance of the
EdgeAwareInterpolator.
|
static EdgeBoxes |
createEdgeBoxes()
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta,
float eta)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta,
float eta,
float minScore)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta,
float eta,
float minScore,
int maxBoxes)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta,
float eta,
float minScore,
int maxBoxes,
float edgeMinMag)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta,
float eta,
float minScore,
int maxBoxes,
float edgeMinMag,
float edgeMergeThr)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta,
float eta,
float minScore,
int maxBoxes,
float edgeMinMag,
float edgeMergeThr,
float clusterMinMag)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta,
float eta,
float minScore,
int maxBoxes,
float edgeMinMag,
float edgeMergeThr,
float clusterMinMag,
float maxAspectRatio)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta,
float eta,
float minScore,
int maxBoxes,
float edgeMinMag,
float edgeMergeThr,
float clusterMinMag,
float maxAspectRatio,
float minBoxArea)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta,
float eta,
float minScore,
int maxBoxes,
float edgeMinMag,
float edgeMergeThr,
float clusterMinMag,
float maxAspectRatio,
float minBoxArea,
float gamma)
Creates a Edgeboxes
|
static EdgeBoxes |
createEdgeBoxes(float alpha,
float beta,
float eta,
float minScore,
int maxBoxes,
float edgeMinMag,
float edgeMergeThr,
float clusterMinMag,
float maxAspectRatio,
float minBoxArea,
float gamma,
float kappa)
Creates a Edgeboxes
|
static FastBilateralSolverFilter |
createFastBilateralSolverFilter(Mat guide,
double sigma_spatial,
double sigma_luma,
double sigma_chroma)
Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines.
|
static FastBilateralSolverFilter |
createFastBilateralSolverFilter(Mat guide,
double sigma_spatial,
double sigma_luma,
double sigma_chroma,
double lambda)
Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines.
|
static FastBilateralSolverFilter |
createFastBilateralSolverFilter(Mat guide,
double sigma_spatial,
double sigma_luma,
double sigma_chroma,
double lambda,
int num_iter)
Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines.
|
static FastBilateralSolverFilter |
createFastBilateralSolverFilter(Mat guide,
double sigma_spatial,
double sigma_luma,
double sigma_chroma,
double lambda,
int num_iter,
double max_tol)
Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines.
|
static FastGlobalSmootherFilter |
createFastGlobalSmootherFilter(Mat guide,
double lambda,
double sigma_color)
Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines.
|
static FastGlobalSmootherFilter |
createFastGlobalSmootherFilter(Mat guide,
double lambda,
double sigma_color,
double lambda_attenuation)
Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines.
|
static FastGlobalSmootherFilter |
createFastGlobalSmootherFilter(Mat guide,
double lambda,
double sigma_color,
double lambda_attenuation,
int num_iter)
Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines.
|
static FastLineDetector |
createFastLineDetector()
Creates a smart pointer to a FastLineDetector object and initializes it
segment farther than this will be
regarded as an outlier
hysteresis procedure in Canny()
hysteresis procedure in Canny()
operator in Canny()
will be perfomred
|
static FastLineDetector |
createFastLineDetector(int _length_threshold)
Creates a smart pointer to a FastLineDetector object and initializes it
|
static FastLineDetector |
createFastLineDetector(int _length_threshold,
float _distance_threshold)
Creates a smart pointer to a FastLineDetector object and initializes it
|
static FastLineDetector |
createFastLineDetector(int _length_threshold,
float _distance_threshold,
double _canny_th1)
Creates a smart pointer to a FastLineDetector object and initializes it
|
static FastLineDetector |
createFastLineDetector(int _length_threshold,
float _distance_threshold,
double _canny_th1,
double _canny_th2)
Creates a smart pointer to a FastLineDetector object and initializes it
|
static FastLineDetector |
createFastLineDetector(int _length_threshold,
float _distance_threshold,
double _canny_th1,
double _canny_th2,
int _canny_aperture_size)
Creates a smart pointer to a FastLineDetector object and initializes it
|
static FastLineDetector |
createFastLineDetector(int _length_threshold,
float _distance_threshold,
double _canny_th1,
double _canny_th2,
int _canny_aperture_size,
boolean _do_merge)
Creates a smart pointer to a FastLineDetector object and initializes it
|
static GraphSegmentation |
createGraphSegmentation()
Creates a graph based segmentor
|
static GraphSegmentation |
createGraphSegmentation(double sigma)
Creates a graph based segmentor
|
static GraphSegmentation |
createGraphSegmentation(double sigma,
float k)
Creates a graph based segmentor
|
static GraphSegmentation |
createGraphSegmentation(double sigma,
float k,
int min_size)
Creates a graph based segmentor
|
static GuidedFilter |
createGuidedFilter(Mat guide,
int radius,
double eps)
Factory method, create instance of GuidedFilter and produce initialization routines.
|
static void |
createQuaternionImage(Mat img,
Mat qimg)
creates a quaternion image.
|
static RFFeatureGetter |
createRFFeatureGetter() |
static StereoMatcher |
createRightMatcher(StereoMatcher matcher_left)
Convenience method to set up the matcher for computing the right-view disparity map
that is required in case of filtering with confidence.
|
static SelectiveSearchSegmentation |
createSelectiveSearchSegmentation()
Create a new SelectiveSearchSegmentation class.
|
static SelectiveSearchSegmentationStrategyColor |
createSelectiveSearchSegmentationStrategyColor()
Create a new color-based strategy
|
static SelectiveSearchSegmentationStrategyFill |
createSelectiveSearchSegmentationStrategyFill()
Create a new fill-based strategy
|
static SelectiveSearchSegmentationStrategyMultiple |
createSelectiveSearchSegmentationStrategyMultiple()
Create a new multiple strategy
|
static SelectiveSearchSegmentationStrategyMultiple |
createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1)
Create a new multiple strategy and set one subtrategy
|
static SelectiveSearchSegmentationStrategyMultiple |
createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1,
SelectiveSearchSegmentationStrategy s2)
Create a new multiple strategy and set two subtrategies, with equal weights
|
static SelectiveSearchSegmentationStrategyMultiple |
createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1,
SelectiveSearchSegmentationStrategy s2,
SelectiveSearchSegmentationStrategy s3)
Create a new multiple strategy and set three subtrategies, with equal weights
|
static SelectiveSearchSegmentationStrategyMultiple |
createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1,
SelectiveSearchSegmentationStrategy s2,
SelectiveSearchSegmentationStrategy s3,
SelectiveSearchSegmentationStrategy s4)
Create a new multiple strategy and set four subtrategies, with equal weights
|
static SelectiveSearchSegmentationStrategySize |
createSelectiveSearchSegmentationStrategySize()
Create a new size-based strategy
|
static SelectiveSearchSegmentationStrategyTexture |
createSelectiveSearchSegmentationStrategyTexture()
Create a new size-based strategy
|
static StructuredEdgeDetection |
createStructuredEdgeDetection(String model) |
static StructuredEdgeDetection |
createStructuredEdgeDetection(String model,
RFFeatureGetter howToGetFeatures) |
static SuperpixelLSC |
createSuperpixelLSC(Mat image)
Class implementing the LSC (Linear Spectral Clustering) superpixels
|
static SuperpixelLSC |
createSuperpixelLSC(Mat image,
int region_size)
Class implementing the LSC (Linear Spectral Clustering) superpixels
|
static SuperpixelLSC |
createSuperpixelLSC(Mat image,
int region_size,
float ratio)
Class implementing the LSC (Linear Spectral Clustering) superpixels
|
static SuperpixelSEEDS |
createSuperpixelSEEDS(int image_width,
int image_height,
int image_channels,
int num_superpixels,
int num_levels)
Initializes a SuperpixelSEEDS object.
|
static SuperpixelSEEDS |
createSuperpixelSEEDS(int image_width,
int image_height,
int image_channels,
int num_superpixels,
int num_levels,
int prior)
Initializes a SuperpixelSEEDS object.
|
static SuperpixelSEEDS |
createSuperpixelSEEDS(int image_width,
int image_height,
int image_channels,
int num_superpixels,
int num_levels,
int prior,
int histogram_bins)
Initializes a SuperpixelSEEDS object.
|
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)
Initializes a SuperpixelSEEDS object.
|
static SuperpixelSLIC |
createSuperpixelSLIC(Mat image)
Initialize a SuperpixelSLIC object
|
static SuperpixelSLIC |
createSuperpixelSLIC(Mat image,
int algorithm)
Initialize a SuperpixelSLIC object
|
static SuperpixelSLIC |
createSuperpixelSLIC(Mat image,
int algorithm,
int region_size)
Initialize a SuperpixelSLIC object
|
static SuperpixelSLIC |
createSuperpixelSLIC(Mat image,
int algorithm,
int region_size,
float ruler)
Initialize a SuperpixelSLIC object
|
static void |
dtFilter(Mat guide,
Mat src,
Mat dst,
double sigmaSpatial,
double sigmaColor)
Simple one-line Domain Transform filter call.
|
static void |
dtFilter(Mat guide,
Mat src,
Mat dst,
double sigmaSpatial,
double sigmaColor,
int mode)
Simple one-line Domain Transform filter call.
|
static void |
dtFilter(Mat guide,
Mat src,
Mat dst,
double sigmaSpatial,
double sigmaColor,
int mode,
int numIters)
Simple one-line Domain Transform filter call.
|
static void |
edgePreservingFilter(Mat src,
Mat dst,
int d,
double threshold)
Smoothes an image using the Edge-Preserving filter.
|
static void |
fastBilateralSolverFilter(Mat guide,
Mat src,
Mat confidence,
Mat dst)
Simple one-line Fast Bilateral Solver filter call.
|
static void |
fastBilateralSolverFilter(Mat guide,
Mat src,
Mat confidence,
Mat dst,
double sigma_spatial)
Simple one-line Fast Bilateral Solver filter call.
|
static void |
fastBilateralSolverFilter(Mat guide,
Mat src,
Mat confidence,
Mat dst,
double sigma_spatial,
double sigma_luma)
Simple one-line Fast Bilateral Solver filter call.
|
static void |
fastBilateralSolverFilter(Mat guide,
Mat src,
Mat confidence,
Mat dst,
double sigma_spatial,
double sigma_luma,
double sigma_chroma)
Simple one-line Fast Bilateral Solver filter call.
|
static void |
fastBilateralSolverFilter(Mat guide,
Mat src,
Mat confidence,
Mat dst,
double sigma_spatial,
double sigma_luma,
double sigma_chroma,
double lambda)
Simple one-line Fast Bilateral Solver filter call.
|
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)
Simple one-line Fast Bilateral Solver filter call.
|
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)
Simple one-line Fast Bilateral Solver filter call.
|
static void |
fastGlobalSmootherFilter(Mat guide,
Mat src,
Mat dst,
double lambda,
double sigma_color)
Simple one-line Fast Global Smoother filter call.
|
static void |
fastGlobalSmootherFilter(Mat guide,
Mat src,
Mat dst,
double lambda,
double sigma_color,
double lambda_attenuation)
Simple one-line Fast Global Smoother filter call.
|
static void |
fastGlobalSmootherFilter(Mat guide,
Mat src,
Mat dst,
double lambda,
double sigma_color,
double lambda_attenuation,
int num_iter)
Simple one-line Fast Global Smoother filter call.
|
static void |
FastHoughTransform(Mat src,
Mat dst,
int dstMatDepth)
Calculates 2D Fast Hough transform of an image.
|
static void |
FastHoughTransform(Mat src,
Mat dst,
int dstMatDepth,
int angleRange)
Calculates 2D Fast Hough transform of an image.
|
static void |
FastHoughTransform(Mat src,
Mat dst,
int dstMatDepth,
int angleRange,
int op)
Calculates 2D Fast Hough transform of an image.
|
static void |
FastHoughTransform(Mat src,
Mat dst,
int dstMatDepth,
int angleRange,
int op,
int makeSkew)
Calculates 2D Fast Hough transform of an image.
|
static void |
fourierDescriptor(Mat src,
Mat dst)
Fourier descriptors for planed closed curves
For more details about this implementation, please see CITE: PersoonFu1977
|
static void |
fourierDescriptor(Mat src,
Mat dst,
int nbElt)
Fourier descriptors for planed closed curves
For more details about this implementation, please see CITE: PersoonFu1977
|
static void |
fourierDescriptor(Mat src,
Mat dst,
int nbElt,
int nbFD)
Fourier descriptors for planed closed curves
For more details about this implementation, please see CITE: PersoonFu1977
|
static void |
GradientDericheX(Mat op,
Mat dst,
double alpha,
double omega)
Applies X Deriche filter to an image.
|
static void |
GradientDericheY(Mat op,
Mat dst,
double alpha,
double omega)
Applies Y Deriche filter to an image.
|
static void |
guidedFilter(Mat guide,
Mat src,
Mat dst,
int radius,
double eps)
Simple one-line Guided Filter call.
|
static void |
guidedFilter(Mat guide,
Mat src,
Mat dst,
int radius,
double eps,
int dDepth)
Simple one-line Guided Filter call.
|
static void |
jointBilateralFilter(Mat joint,
Mat src,
Mat dst,
int d,
double sigmaColor,
double sigmaSpace)
Applies the joint bilateral filter to an image.
|
static void |
jointBilateralFilter(Mat joint,
Mat src,
Mat dst,
int d,
double sigmaColor,
double sigmaSpace,
int borderType)
Applies the joint bilateral filter to an image.
|
static void |
l0Smooth(Mat src,
Mat dst)
Global image smoothing via L0 gradient minimization.
|
static void |
l0Smooth(Mat src,
Mat dst,
double lambda)
Global image smoothing via L0 gradient minimization.
|
static void |
l0Smooth(Mat src,
Mat dst,
double lambda,
double kappa)
Global image smoothing via L0 gradient minimization.
|
static void |
niBlackThreshold(Mat _src,
Mat _dst,
double maxValue,
int type,
int blockSize,
double k)
Performs thresholding on input images using Niblack's technique or some of the
popular variations it inspired.
|
static void |
niBlackThreshold(Mat _src,
Mat _dst,
double maxValue,
int type,
int blockSize,
double k,
int binarizationMethod)
Performs thresholding on input images using Niblack's technique or some of the
popular variations it inspired.
|
static void |
PeiLinNormalization(Mat I,
Mat T) |
static void |
qconj(Mat qimg,
Mat qcimg)
calculates conjugate of a quaternion image.
|
static void |
qdft(Mat img,
Mat qimg,
int flags,
boolean sideLeft)
Performs a forward or inverse Discrete quaternion Fourier transform of a 2D quaternion array.
|
static void |
qmultiply(Mat src1,
Mat src2,
Mat dst)
Calculates the per-element quaternion product of two arrays
|
static void |
qunitary(Mat qimg,
Mat qnimg)
divides each element by its modulus.
|
static void |
rollingGuidanceFilter(Mat src,
Mat dst)
Applies the rolling guidance filter to an image.
|
static void |
rollingGuidanceFilter(Mat src,
Mat dst,
int d)
Applies the rolling guidance filter to an image.
|
static void |
rollingGuidanceFilter(Mat src,
Mat dst,
int d,
double sigmaColor)
Applies the rolling guidance filter to an image.
|
static void |
rollingGuidanceFilter(Mat src,
Mat dst,
int d,
double sigmaColor,
double sigmaSpace)
Applies the rolling guidance filter to an image.
|
static void |
rollingGuidanceFilter(Mat src,
Mat dst,
int d,
double sigmaColor,
double sigmaSpace,
int numOfIter)
Applies the rolling guidance filter to an image.
|
static void |
rollingGuidanceFilter(Mat src,
Mat dst,
int d,
double sigmaColor,
double sigmaSpace,
int numOfIter,
int borderType)
Applies the rolling guidance filter to an image.
|
static void |
thinning(Mat src,
Mat dst)
Applies a binary blob thinning operation, to achieve a skeletization of the input image.
|
static void |
thinning(Mat src,
Mat dst,
int thinningType)
Applies a binary blob thinning operation, to achieve a skeletization of the input image.
|
static void |
transformFD(Mat src,
Mat t,
Mat dst)
transform a contour
|
static void |
transformFD(Mat src,
Mat t,
Mat dst,
boolean fdContour)
transform a contour
|
static void |
weightedMedianFilter(Mat joint,
Mat src,
Mat dst,
int r)
Applies weighted median filter to an image.
|
static void |
weightedMedianFilter(Mat joint,
Mat src,
Mat dst,
int r,
double sigma)
Applies weighted median filter to an image.
|
static void |
weightedMedianFilter(Mat joint,
Mat src,
Mat dst,
int r,
double sigma,
int weightType)
Applies weighted median filter to an image.
|
static void |
weightedMedianFilter(Mat joint,
Mat src,
Mat dst,
int r,
double sigma,
int weightType,
Mat mask)
Applies weighted median filter to an image.
|
public static final int BINARIZATION_NIBLACK
public static final int BINARIZATION_SAUVOLA
public static final int BINARIZATION_WOLF
public static final int BINARIZATION_NICK
public static final int SLIC
public static final int SLICO
public static final int MSLIC
public static final int FHT_MIN
public static final int FHT_MAX
public static final int FHT_ADD
public static final int FHT_AVE
public static final int ARO_0_45
public static final int ARO_45_90
public static final int ARO_90_135
public static final int ARO_315_0
public static final int ARO_315_45
public static final int ARO_45_135
public static final int ARO_315_135
public static final int ARO_CTR_HOR
public static final int ARO_CTR_VER
public static final int WMF_EXP
public static final int WMF_IV1
public static final int WMF_IV2
public static final int WMF_COS
public static final int WMF_JAC
public static final int WMF_OFF
public static final int THINNING_ZHANGSUEN
public static final int THINNING_GUOHALL
public static final int DTF_NC
public static final int DTF_IC
public static final int DTF_RF
public static final int GUIDED_FILTER
public static final int AM_FILTER
public static final int HDO_RAW
public static final int HDO_DESKEW
public static AdaptiveManifoldFilter createAMFilter(double sigma_s, double sigma_r, boolean adjust_outliers)
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.public static AdaptiveManifoldFilter createAMFilter(double sigma_s, double sigma_r)
sigma_s
- spatial standard deviation.sigma_r
- color space standard deviation, it is similar to the sigma in the color space into
bilateralFilter.
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.public static ContourFitting createContourFitting(int ctr, int fd)
ctr
- number of Fourier descriptors equal to number of contour points after resampling.fd
- Contour defining second shape (Target).public static ContourFitting createContourFitting(int ctr)
ctr
- number of Fourier descriptors equal to number of contour points after resampling.public static ContourFitting createContourFitting()
public static DTFilter createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)
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/).public static DTFilter createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor, int mode)
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.
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/).public static DTFilter createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor)
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.
filtering 2D signals in the article.
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/).public static DisparityWLSFilter createDisparityWLSFilter(StereoMatcher matcher_left)
matcher_left
- stereo matcher instance that will be used with the filterpublic static DisparityWLSFilter createDisparityWLSFilterGeneric(boolean use_confidence)
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.public static EdgeAwareInterpolator createEdgeAwareInterpolator()
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)
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.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)
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.public static EdgeBoxes createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag, float maxAspectRatio, float minBoxArea)
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.public static EdgeBoxes createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag, float maxAspectRatio)
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.public static EdgeBoxes createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr, float clusterMinMag)
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.public static EdgeBoxes createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag, float edgeMergeThr)
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.public static EdgeBoxes createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes, float edgeMinMag)
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.public static EdgeBoxes createEdgeBoxes(float alpha, float beta, float eta, float minScore, int maxBoxes)
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.public static EdgeBoxes createEdgeBoxes(float alpha, float beta, float eta, float minScore)
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.public static EdgeBoxes createEdgeBoxes(float alpha, float beta, float eta)
alpha
- step size of sliding window search.beta
- nms threshold for object proposals.eta
- adaptation rate for nms threshold.public static EdgeBoxes createEdgeBoxes(float alpha, float beta)
alpha
- step size of sliding window search.beta
- nms threshold for object proposals.public static EdgeBoxes createEdgeBoxes(float alpha)
alpha
- step size of sliding window search.public static EdgeBoxes createEdgeBoxes()
public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)
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.public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter)
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.
For more details about the Fast Bilateral Solver parameters, see the original paper CITE: BarronPoole2016.public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda)
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.
For more details about the Fast Bilateral Solver parameters, see the original paper CITE: BarronPoole2016.public static FastBilateralSolverFilter createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma)
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.
For more details about the Fast Bilateral Solver parameters, see the original paper CITE: BarronPoole2016.public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color, double lambda_attenuation, int num_iter)
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 regularizationsigma_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.public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color, double lambda_attenuation)
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 regularizationsigma_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.
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.public static FastGlobalSmootherFilter createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color)
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 regularizationsigma_color
- parameter, that is similar to color space sigma in bilateralFilter.
it should be 0.25. Setting it to 1.0 may lead to streaking artifacts.
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.public static FastLineDetector createFastLineDetector(int _length_threshold, float _distance_threshold, double _canny_th1, double _canny_th2, int _canny_aperture_size, boolean _do_merge)
_length_threshold
- 10 - Segment shorter than this will be discarded_distance_threshold
- 1.41421356 - A point placed from a hypothesis line
segment farther than this will be
regarded as an outlier_canny_th1
- 50 - First threshold for
hysteresis procedure in Canny()_canny_th2
- 50 - Second threshold for
hysteresis procedure in Canny()_canny_aperture_size
- 3 - Aperturesize for the sobel
operator in Canny()_do_merge
- false - If true, incremental merging of segments
will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, float _distance_threshold, double _canny_th1, double _canny_th2, int _canny_aperture_size)
_length_threshold
- 10 - Segment shorter than this will be discarded_distance_threshold
- 1.41421356 - A point placed from a hypothesis line
segment farther than this will be
regarded as an outlier_canny_th1
- 50 - First threshold for
hysteresis procedure in Canny()_canny_th2
- 50 - Second threshold for
hysteresis procedure in Canny()_canny_aperture_size
- 3 - Aperturesize for the sobel
operator in Canny()
will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, float _distance_threshold, double _canny_th1, double _canny_th2)
_length_threshold
- 10 - Segment shorter than this will be discarded_distance_threshold
- 1.41421356 - A point placed from a hypothesis line
segment farther than this will be
regarded as an outlier_canny_th1
- 50 - First threshold for
hysteresis procedure in Canny()_canny_th2
- 50 - Second threshold for
hysteresis procedure in Canny()
operator in Canny()
will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, float _distance_threshold, double _canny_th1)
_length_threshold
- 10 - Segment shorter than this will be discarded_distance_threshold
- 1.41421356 - A point placed from a hypothesis line
segment farther than this will be
regarded as an outlier_canny_th1
- 50 - First threshold for
hysteresis procedure in Canny()
hysteresis procedure in Canny()
operator in Canny()
will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, float _distance_threshold)
_length_threshold
- 10 - Segment shorter than this will be discarded_distance_threshold
- 1.41421356 - A point placed from a hypothesis line
segment farther than this will be
regarded as an outlier
hysteresis procedure in Canny()
hysteresis procedure in Canny()
operator in Canny()
will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold)
_length_threshold
- 10 - Segment shorter than this will be discarded
segment farther than this will be
regarded as an outlier
hysteresis procedure in Canny()
hysteresis procedure in Canny()
operator in Canny()
will be perfomredpublic static FastLineDetector createFastLineDetector()
public static GraphSegmentation createGraphSegmentation(double sigma, float k, int min_size)
sigma
- The sigma parameter, used to smooth imagek
- The k parameter of the algorythmmin_size
- The minimum size of segmentspublic static GraphSegmentation createGraphSegmentation(double sigma, float k)
sigma
- The sigma parameter, used to smooth imagek
- The k parameter of the algorythmpublic static GraphSegmentation createGraphSegmentation(double sigma)
sigma
- The sigma parameter, used to smooth imagepublic static GraphSegmentation createGraphSegmentation()
public static GuidedFilter createGuidedFilter(Mat guide, int radius, double eps)
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.
For more details about Guided Filter parameters, see the original article CITE: Kaiming10 .public static RFFeatureGetter createRFFeatureGetter()
public static SelectiveSearchSegmentation createSelectiveSearchSegmentation()
public static SelectiveSearchSegmentationStrategyColor createSelectiveSearchSegmentationStrategyColor()
public static SelectiveSearchSegmentationStrategyFill createSelectiveSearchSegmentationStrategyFill()
public static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2, SelectiveSearchSegmentationStrategy s3, SelectiveSearchSegmentationStrategy s4)
s1
- The first strategys2
- The second strategys3
- The third strategys4
- The forth strategypublic static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2, SelectiveSearchSegmentationStrategy s3)
s1
- The first strategys2
- The second strategys3
- The third strategypublic static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1, SelectiveSearchSegmentationStrategy s2)
s1
- The first strategys2
- The second strategypublic static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple(SelectiveSearchSegmentationStrategy s1)
s1
- The first strategypublic static SelectiveSearchSegmentationStrategyMultiple createSelectiveSearchSegmentationStrategyMultiple()
public static SelectiveSearchSegmentationStrategySize createSelectiveSearchSegmentationStrategySize()
public static SelectiveSearchSegmentationStrategyTexture createSelectiveSearchSegmentationStrategyTexture()
public static StereoMatcher createRightMatcher(StereoMatcher matcher_left)
matcher_left
- main stereo matcher instance that will be used with the filterpublic static StructuredEdgeDetection createStructuredEdgeDetection(String model, RFFeatureGetter howToGetFeatures)
public static StructuredEdgeDetection createStructuredEdgeDetection(String model)
public static SuperpixelLSC createSuperpixelLSC(Mat image, int region_size, float ratio)
image
- Image to segmentregion_size
- Chooses an average superpixel size measured in pixelsratio
- 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)public static SuperpixelLSC createSuperpixelLSC(Mat image, int region_size)
image
- Image to segmentregion_size
- Chooses an average superpixel size measured in pixels
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)public static SuperpixelLSC createSuperpixelLSC(Mat image)
image
- Image to segment
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)public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior, int histogram_bins, boolean double_step)
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)public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior, int histogram_bins)
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.
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)public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior)
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].
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)public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, int image_height, int image_channels, int num_superpixels, int num_levels)
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.
must be in the range [0, 5].
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)public static SuperpixelSLIC createSuperpixelSLIC(Mat image, int algorithm, int region_size, float ruler)
image
- Image to segmentalgorithm
- 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 pixelsruler
- 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)public static SuperpixelSLIC createSuperpixelSLIC(Mat image, int algorithm, int region_size)
image
- Image to segmentalgorithm
- 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
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)public static SuperpixelSLIC createSuperpixelSLIC(Mat image, int algorithm)
image
- Image to segmentalgorithm
- 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.
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)public static SuperpixelSLIC createSuperpixelSLIC(Mat image)
image
- Image to segment
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.
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)public static void FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op, int makeSkew)
src
- automatically generateddst
- automatically generateddstMatDepth
- automatically generatedangleRange
- automatically generatedop
- automatically generatedmakeSkew
- automatically generatedpublic static void FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op)
src
- automatically generateddst
- automatically generateddstMatDepth
- automatically generatedangleRange
- automatically generatedop
- automatically generatedpublic static void FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange)
src
- automatically generateddst
- automatically generateddstMatDepth
- automatically generatedangleRange
- automatically generatedpublic static void FastHoughTransform(Mat src, Mat dst, int dstMatDepth)
src
- automatically generateddst
- automatically generateddstMatDepth
- automatically generatedpublic static void GradientDericheX(Mat op, Mat dst, double alpha, double omega)
op
- automatically generateddst
- automatically generatedalpha
- automatically generatedomega
- automatically generatedpublic static void GradientDericheY(Mat op, Mat dst, double alpha, double omega)
op
- automatically generateddst
- automatically generatedalpha
- automatically generatedomega
- automatically generatedpublic static void amFilter(Mat joint, Mat src, Mat dst, double sigma_s, double sigma_r, boolean adjust_outliers)
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, guidedFilterpublic static void amFilter(Mat joint, Mat src, Mat dst, double sigma_s, double sigma_r)
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.
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, guidedFilterpublic static void anisotropicDiffusion(Mat src, Mat dst, float alpha, float K, int niters)
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 edgesniters
- The number of iterationspublic static void bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter, double sigmaAlpha, double sigmaAvg)
src
- Source image whose depth is 8-bit UINT or 32-bit FLOATdst
- Destination image of the same size and type as src.fr
- Radius of kernel to be used for filtering. It should be positive integernumIter
- Number of iterations of algorithm, It should be positive integersigmaAlpha
- 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: rollingGuidanceFilter, bilateralFilterpublic static void bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter, double sigmaAlpha)
src
- Source image whose depth is 8-bit UINT or 32-bit FLOATdst
- Destination image of the same size and type as src.fr
- Radius of kernel to be used for filtering. It should be positive integernumIter
- Number of iterations of algorithm, It should be positive integersigmaAlpha
- 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.
value is negative, it is automatically calculated as described in the paper.
SEE: rollingGuidanceFilter, bilateralFilterpublic static void bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter)
src
- Source image whose depth is 8-bit UINT or 32-bit FLOATdst
- Destination image of the same size and type as src.fr
- Radius of kernel to be used for filtering. It should be positive integernumIter
- Number of iterations of algorithm, It should be positive integer
a bigger value means sharper transition. When the value is negative, it is automatically calculated.
value is negative, it is automatically calculated as described in the paper.
SEE: rollingGuidanceFilter, bilateralFilterpublic static void bilateralTextureFilter(Mat src, Mat dst, int fr)
src
- Source image whose depth is 8-bit UINT or 32-bit FLOATdst
- Destination image of the same size and type as src.fr
- Radius of kernel to be used for filtering. It should be positive integer
a bigger value means sharper transition. When the value is negative, it is automatically calculated.
value is negative, it is automatically calculated as described in the paper.
SEE: rollingGuidanceFilter, bilateralFilterpublic static void bilateralTextureFilter(Mat src, Mat dst)
src
- Source image whose depth is 8-bit UINT or 32-bit FLOATdst
- Destination image of the same size and type as src.
a bigger value means sharper transition. When the value is negative, it is automatically calculated.
value is negative, it is automatically calculated as described in the paper.
SEE: rollingGuidanceFilter, bilateralFilterpublic static void colorMatchTemplate(Mat img, Mat templ, Mat result)
img
- automatically generatedtempl
- automatically generatedresult
- automatically generatedpublic static void contourSampling(Mat src, Mat out, int nbElt)
src
- automatically generatedout
- automatically generatednbElt
- automatically generatedpublic static void covarianceEstimation(Mat src, Mat dst, int windowRows, int windowCols)
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.public static void createQuaternionImage(Mat img, Mat qimg)
img
- automatically generatedqimg
- automatically generatedpublic static void dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor, int mode, int numIters)
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 imagesigmaSpatial
- \({\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: bilateralFilter, guidedFilter, amFilterpublic static void dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor, int mode)
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 imagesigmaSpatial
- \({\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.
SEE: bilateralFilter, guidedFilter, amFilterpublic static void dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor)
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 imagesigmaSpatial
- \({\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.
filtering 2D signals in the article.
SEE: bilateralFilter, guidedFilter, amFilterpublic static void edgePreservingFilter(Mat src, Mat dst, int d, double threshold)
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.public static void fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)
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.public static void fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter)
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.
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.public static void fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda)
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.
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.public static void fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma)
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.
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.public static void fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma)
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.
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.public static void fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial)
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.
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.public static void fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst)
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.
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.public static void fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation, int num_iter)
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 regularizationsigma_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.public static void fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation)
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 regularizationsigma_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.public static void fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color)
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 regularizationsigma_color
- parameter, that is similar to color space sigma in bilateralFilter.
it should be 0.25. Setting it to 1.0 may lead to streaking artifacts.public static void fourierDescriptor(Mat src, Mat dst, int nbElt, int nbFD)
src
- automatically generateddst
- automatically generatednbElt
- automatically generatednbFD
- automatically generatedpublic static void fourierDescriptor(Mat src, Mat dst, int nbElt)
src
- automatically generateddst
- automatically generatednbElt
- automatically generatedpublic static void fourierDescriptor(Mat src, Mat dst)
src
- automatically generateddst
- automatically generatedpublic static void guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps, int dDepth)
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.
SEE: bilateralFilter, dtFilter, amFilterpublic static void guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps)
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.
SEE: bilateralFilter, dtFilter, amFilterpublic static void jointBilateralFilter(Mat joint, Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int borderType)
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: bilateralFilter, amFilterpublic static void jointBilateralFilter(Mat joint, Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace)
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 .
Note: bilateralFilter and jointBilateralFilter use L1 norm to compute difference between colors.
SEE: bilateralFilter, amFilterpublic static void l0Smooth(Mat src, Mat dst, double lambda, double kappa)
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.public static void l0Smooth(Mat src, Mat dst, double lambda)
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.
For more details about L0 Smoother, see the original paper CITE: xu2011image.public static void l0Smooth(Mat src, Mat dst)
src
- source image for filtering with unsigned 8-bit or signed 16-bit or floating-point depth.dst
- destination image.
For more details about L0 Smoother, see the original paper CITE: xu2011image.public static void niBlackThreshold(Mat _src, Mat _dst, double maxValue, int type, int blockSize, double k, int binarizationMethod)
_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.
SEE: threshold, adaptiveThresholdpublic static void niBlackThreshold(Mat _src, Mat _dst, double maxValue, int type, int blockSize, double k)
_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.
Other techniques can be specified, see cv::ximgproc::LocalBinarizationMethods.
SEE: threshold, adaptiveThresholdpublic static void qconj(Mat qimg, Mat qcimg)
qimg
- automatically generatedqcimg
- automatically generatedpublic static void qdft(Mat img, Mat qimg, int flags, boolean sideLeft)
img
- automatically generatedqimg
- automatically generatedflags
- automatically generatedsideLeft
- automatically generatedpublic static void qmultiply(Mat src1, Mat src2, Mat dst)
src1
- automatically generatedsrc2
- automatically generateddst
- automatically generatedpublic static void qunitary(Mat qimg, Mat qnimg)
qimg
- automatically generatedqnimg
- automatically generatedpublic static void rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter, int borderType)
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: jointBilateralFilter, bilateralFilter, amFilterpublic static void rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter)
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.
Note: rollingGuidanceFilter uses jointBilateralFilter as the edge-preserving filter.
SEE: jointBilateralFilter, bilateralFilter, amFilterpublic static void rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace)
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 .
Note: rollingGuidanceFilter uses jointBilateralFilter as the edge-preserving filter.
SEE: jointBilateralFilter, bilateralFilter, amFilterpublic static void rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor)
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.
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 .
Note: rollingGuidanceFilter uses jointBilateralFilter as the edge-preserving filter.
SEE: jointBilateralFilter, bilateralFilter, amFilterpublic static void rollingGuidanceFilter(Mat src, Mat dst, int d)
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 .
farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in
larger areas of semi-equal color.
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 .
Note: rollingGuidanceFilter uses jointBilateralFilter as the edge-preserving filter.
SEE: jointBilateralFilter, bilateralFilter, amFilterpublic static void rollingGuidanceFilter(Mat src, Mat dst)
src
- Source 8-bit or floating-point, 1-channel or 3-channel image.dst
- Destination image of the same size and type as src.
it is computed from sigmaSpace .
farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in
larger areas of semi-equal color.
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 .
Note: rollingGuidanceFilter uses jointBilateralFilter as the edge-preserving filter.
SEE: jointBilateralFilter, bilateralFilter, amFilterpublic static void thinning(Mat src, Mat dst, int thinningType)
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::ThinningTypespublic static void thinning(Mat src, Mat dst)
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.public static void transformFD(Mat src, Mat t, Mat dst, boolean fdContour)
src
- automatically generatedt
- automatically generateddst
- automatically generatedfdContour
- automatically generatedpublic static void transformFD(Mat src, Mat t, Mat dst)
src
- automatically generatedt
- automatically generateddst
- automatically generatedpublic static void weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma, int weightType, Mat mask)
joint
- automatically generatedsrc
- automatically generateddst
- automatically generatedr
- automatically generatedsigma
- automatically generatedweightType
- automatically generatedmask
- automatically generatedpublic static void weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma, int weightType)
joint
- automatically generatedsrc
- automatically generateddst
- automatically generatedr
- automatically generatedsigma
- automatically generatedweightType
- automatically generatedpublic static void weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma)
joint
- automatically generatedsrc
- automatically generateddst
- automatically generatedr
- automatically generatedsigma
- automatically generatedpublic static void weightedMedianFilter(Mat joint, Mat src, Mat dst, int r)
joint
- automatically generatedsrc
- automatically generateddst
- automatically generatedr
- automatically generatedGenerated on Wed Oct 9 2019 23:24:43 UTC / OpenCV 4.1.2