OpenCV  4.6.0
Open Source Computer Vision
Namespaces | Classes | Typedefs | Enumerations | Functions
cv::ximgproc Namespace Reference

Namespaces

 rl
 
 segmentation
 

Classes

class  AdaptiveManifoldFilter
 Interface for Adaptive Manifold Filter realizations. More...
 
struct  Box
 
class  ContourFitting
 Class for ContourFitting algorithms. ContourFitting match two contours \( z_a \) and \( z_b \) minimizing distance

\[ d(z_a,z_b)=\sum (a_n - s b_n e^{j(n \alpha +\phi )})^2 \]

where \( a_n \) and \( b_n \) are Fourier descriptors of \( z_a \) and \( z_b \) and s is a scaling factor and \( \phi \) is angle rotation and \( \alpha \) is starting point factor adjustement. More...

  class  DisparityFilter  Main interface for all disparity map filters. More...
  class  DisparityWLSFilter  Disparity map filter based on Weighted Least Squares filter (in form of Fast Global Smoother that is a lot faster than traditional Weighted Least Squares filter implementations) and optional use of left-right-consistency-based confidence to refine the results in half-occlusions and uniform areas. More...
  class  DTFilter  Interface for realizations of Domain Transform filter. More...
  class  EdgeAwareInterpolator  Sparse match interpolation algorithm based on modified locally-weighted affine estimator from [206] and Fast Global Smoother as post-processing filter. More...
  class  EdgeBoxes  Class implementing EdgeBoxes algorithm from [301] : More...
  class  EdgeDrawing  Class implementing the ED (EdgeDrawing) [251], EDLines [4], EDPF [5] and EDCircles [6] algorithms. More...
  class  FastBilateralSolverFilter  Interface for implementations of Fast Bilateral Solver. More...
  class  FastGlobalSmootherFilter  Interface for implementations of Fast Global Smoother filter. More...
  class  FastLineDetector  Class implementing the FLD (Fast Line Detector) algorithm described in [139] . More...
  class  GuidedFilter  Interface for realizations of Guided Filter. More...
  class  RFFeatureGetter   class  RICInterpolator  Sparse match interpolation algorithm based on modified piecewise locally-weighted affine estimator called Robust Interpolation method of Correspondences or RIC from [117] and Variational and Fast Global Smoother as post-processing filter. The RICInterpolator is a extension of the EdgeAwareInterpolator. Main concept of this extension is an piece-wise affine model based on over-segmentation via SLIC superpixel estimation. The method contains an efficient propagation mechanism to estimate among the pieces-wise models. More...
  class  RidgeDetectionFilter  Applies Ridge Detection Filter to an input image. Implements Ridge detection similar to the one in Mathematica using the eigen values from the Hessian Matrix of the input image using Sobel Derivatives. Additional refinement can be done using Skeletonization and Binarization. Adapted from [68] and [169]. More...
  class  ScanSegment  Class implementing the F-DBSCAN (Accelerated superpixel image segmentation with a parallelized DBSCAN algorithm) superpixels algorithm by Loke SC, et al. [154] for original paper. More...
  class  SparseMatchInterpolator  Main interface for all filters, that take sparse matches as an input and produce a dense per-pixel matching (optical flow) as an output. More...
  class  StructuredEdgeDetection  Class implementing edge detection algorithm from [59] : More...
  class  SuperpixelLSC  Class implementing the LSC (Linear Spectral Clustering) superpixels algorithm described in [144]. More...
  class  SuperpixelSEEDS  Class implementing the SEEDS (Superpixels Extracted via Energy-Driven Sampling) superpixels algorithm described in [261] . More...
  class  SuperpixelSLIC  Class implementing the SLIC (Simple Linear Iterative Clustering) superpixels algorithm described in [1]. More...
 

Typedefs

typedef std::vector< Box > Boxes
 

Enumerations

enum  AngleRangeOption {
  ARO_0_45 = 0,
  ARO_45_90 = 1,
  ARO_90_135 = 2,
  ARO_315_0 = 3,
  ARO_315_45 = 4,
  ARO_45_135 = 5,
  ARO_315_135 = 6,
  ARO_CTR_HOR = 7,
  ARO_CTR_VER = 8
}
 Specifies the part of Hough space to calculate. More...
 
enum  EdgeAwareFiltersList {
  DTF_NC,
  DTF_IC,
  DTF_RF,
  GUIDED_FILTER,
  AM_FILTER
}
 
enum  HoughDeskewOption {
  HDO_RAW = 0,
  HDO_DESKEW = 1
}
 Specifies to do or not to do skewing of Hough transform image. More...
 
enum  HoughOp {
  FHT_MIN = 0,
  FHT_MAX = 1,
  FHT_ADD = 2,
  FHT_AVE = 3
}
 Specifies binary operations. More...
 
enum  LocalBinarizationMethods {
  BINARIZATION_NIBLACK = 0,
  BINARIZATION_SAUVOLA = 1,
  BINARIZATION_WOLF = 2,
  BINARIZATION_NICK = 3
}
 Specifies the binarization method to use in cv::ximgproc::niBlackThreshold. More...
 
enum  RulesOption {
  RO_STRICT = 0x00,
  RO_IGNORE_BORDERS = 0x01
}
 Specifies the degree of rules validation. More...
 
enum  SLICType {
  SLIC = 100,
  SLICO = 101,
  MSLIC = 102
}
 
enum  ThinningTypes {
  THINNING_ZHANGSUEN = 0,
  THINNING_GUOHALL = 1
}
 
enum  WMFWeightType {
  WMF_EXP = 1,
  WMF_IV1 = 1 << 1,
  WMF_IV2 = 1 << 2,
  WMF_COS = 1 << 3,
  WMF_JAC = 1 << 4,
  WMF_OFF = 1 << 5
}
 Specifies weight types of weighted median filter. More...
 

Functions

void amFilter (InputArray joint, InputArray src, OutputArray dst, double sigma_s, double sigma_r, bool adjust_outliers=false)
 Simple one-line Adaptive Manifold Filter call. More...
 
void anisotropicDiffusion (InputArray src, OutputArray dst, float alpha, float K, int niters)
 Performs anisotropic diffusion on an image. More...
 
void bilateralTextureFilter (InputArray src, OutputArray dst, int fr=3, int numIter=1, double sigmaAlpha=-1., double sigmaAvg=-1.)
 Applies the bilateral texture filter to an image. It performs structure-preserving texture filter. For more details about this filter see [49]. More...
 
void BrightEdges (Mat &_original, Mat &_edgeview, int contrast=1, int shortrange=3, int longrange=9)
 
void colorMatchTemplate (InputArray img, InputArray templ, OutputArray result)
 Compares a color template against overlapped color image regions. More...
 
double computeBadPixelPercent (InputArray GT, InputArray src, Rect ROI, int thresh=24)
 Function for computing the percent of "bad" pixels in the disparity map (pixels where error is higher than a specified threshold) More...
 
double computeMSE (InputArray GT, InputArray src, Rect ROI)
 Function for computing mean square error for disparity maps. More...
 
void contourSampling (InputArray src, OutputArray out, int nbElt)
 Contour sampling . More...
 
void covarianceEstimation (InputArray src, OutputArray dst, int windowRows, int windowCols)
 Computes the estimated covariance matrix of an image using the sliding window forumlation. More...
 
Ptr< AdaptiveManifoldFilter > createAMFilter (double sigma_s, double sigma_r, bool adjust_outliers=false)
 Factory method, create instance of AdaptiveManifoldFilter and produce some initialization routines. More...
 
Ptr< ContourFitting > createContourFitting (int ctr=1024, int fd=16)
 create ContourFitting algorithm object More...
 
Ptr< DisparityWLSFilter > createDisparityWLSFilter (Ptr< 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. Currently supports only StereoBM and StereoSGBM. More...
 
Ptr< DisparityWLSFilter > createDisparityWLSFilterGeneric (bool use_confidence)
 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. More...
 
Ptr< DTFilter > createDTFilter (InputArray guide, double sigmaSpatial, double sigmaColor, int mode=DTF_NC, int numIters=3)
 Factory method, create instance of DTFilter and produce initialization routines. More...
 
Ptr< EdgeAwareInterpolator > createEdgeAwareInterpolator ()
 Factory method that creates an instance of the EdgeAwareInterpolator. More...
 
Ptr< EdgeBoxes > createEdgeBoxes (float alpha=0.65f, float beta=0.75f, float eta=1, float minScore=0.01f, int maxBoxes=10000, float edgeMinMag=0.1f, float edgeMergeThr=0.5f, float clusterMinMag=0.5f, float maxAspectRatio=3, float minBoxArea=1000, float gamma=2, float kappa=1.5f)
 Creates a Edgeboxes. More...
 
Ptr< EdgeDrawing > createEdgeDrawing ()
 Creates a smart pointer to a EdgeDrawing object and initializes it. More...
 
Ptr< FastBilateralSolverFilter > createFastBilateralSolverFilter (InputArray guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda=128.0, int num_iter=25, double max_tol=1e-5)
 Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines. More...
 
Ptr< FastGlobalSmootherFilter > createFastGlobalSmootherFilter (InputArray guide, double lambda, double sigma_color, double lambda_attenuation=0.25, int num_iter=3)
 Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines. More...
 
Ptr< FastLineDetector > createFastLineDetector (int length_threshold=10, float distance_threshold=1.414213562f, double canny_th1=50.0, double canny_th2=50.0, int canny_aperture_size=3, bool do_merge=false)
 Creates a smart pointer to a FastLineDetector object and initializes it. More...
 
Ptr< GuidedFilter > createGuidedFilter (InputArray guide, int radius, double eps)
 Factory method, create instance of GuidedFilter and produce initialization routines. More...
 
void createQuaternionImage (InputArray img, OutputArray qimg)
 creates a quaternion image. More...
 
Ptr< RFFeatureGetter > createRFFeatureGetter ()
 
Ptr< RICInterpolator > createRICInterpolator ()
 Factory method that creates an instance of the RICInterpolator. More...
 
Ptr< StereoMatcher > createRightMatcher (Ptr< 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. More...
 
cv::Ptr< ScanSegment > createScanSegment (int image_width, int image_height, int num_superpixels, int slices=8, bool merge_small=true)
 Initializes a ScanSegment object. More...
 
Ptr< StructuredEdgeDetection > createStructuredEdgeDetection (const String &model, Ptr< const RFFeatureGetter > howToGetFeatures=Ptr< RFFeatureGetter >())
 
Ptr< SuperpixelLSC > createSuperpixelLSC (InputArray image, int region_size=10, float ratio=0.075f)
 Class implementing the LSC (Linear Spectral Clustering) superpixels. More...
 
Ptr< SuperpixelSEEDS > createSuperpixelSEEDS (int image_width, int image_height, int image_channels, int num_superpixels, int num_levels, int prior=2, int histogram_bins=5, bool double_step=false)
 Initializes a SuperpixelSEEDS object. More...
 
Ptr< SuperpixelSLIC > createSuperpixelSLIC (InputArray image, int algorithm=SLICO, int region_size=10, float ruler=10.0f)
 Initialize a SuperpixelSLIC object. More...
 
void dtFilter (InputArray guide, InputArray src, OutputArray dst, double sigmaSpatial, double sigmaColor, int mode=DTF_NC, int numIters=3)
 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. More...
 
void edgePreservingFilter (InputArray src, OutputArray dst, int d, double threshold)
 Smoothes an image using the Edge-Preserving filter. More...
 
void fastBilateralSolverFilter (InputArray guide, InputArray src, InputArray confidence, OutputArray dst, double sigma_spatial=8, double sigma_luma=8, double sigma_chroma=8, double lambda=128.0, int num_iter=25, double max_tol=1e-5)
 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. More...
 
void fastGlobalSmootherFilter (InputArray guide, InputArray src, OutputArray dst, double lambda, double sigma_color, double lambda_attenuation=0.25, int num_iter=3)
 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. More...
 
void FastHoughTransform (InputArray src, OutputArray dst, int dstMatDepth, int angleRange=ARO_315_135, int op=FHT_ADD, int makeSkew=HDO_DESKEW)
 Calculates 2D Fast Hough transform of an image. More...
 
void fourierDescriptor (InputArray src, OutputArray dst, int nbElt=-1, int nbFD=-1)
 Fourier descriptors for planed closed curves. More...
 
void getDisparityVis (InputArray src, OutputArray dst, double scale=1.0)
 Function for creating a disparity map visualization (clamped CV_8U image) More...
 
void GradientDericheX (InputArray op, OutputArray dst, double alpha, double omega)
 Applies X Deriche filter to an image. More...
 
void GradientDericheY (InputArray op, OutputArray dst, double alpha, double omega)
 Applies Y Deriche filter to an image. More...
 
void GradientPaillouX (InputArray op, OutputArray _dst, double alpha, double omega)
 
void GradientPaillouY (InputArray op, OutputArray _dst, double alpha, double omega)
 Applies Paillou filter to an image. More...
 
void guidedFilter (InputArray guide, InputArray src, OutputArray dst, int radius, double eps, int dDepth=-1)
 Simple one-line Guided Filter call. More...
 
Vec4i HoughPoint2Line (const Point &houghPoint, InputArray srcImgInfo, int angleRange=ARO_315_135, int makeSkew=HDO_DESKEW, int rules=RO_IGNORE_BORDERS)
 Calculates coordinates of line segment corresponded by point in Hough space. More...
 
void jointBilateralFilter (InputArray joint, InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)
 Applies the joint bilateral filter to an image. More...
 
void l0Smooth (InputArray src, OutputArray dst, double lambda=0.02, double kappa=2.0)
 Global image smoothing via L0 gradient minimization. More...
 
void niBlackThreshold (InputArray _src, OutputArray _dst, double maxValue, int type, int blockSize, double k, int binarizationMethod=BINARIZATION_NIBLACK, double r=128)
 Performs thresholding on input images using Niblack's technique or some of the popular variations it inspired. More...
 
Matx23d PeiLinNormalization (InputArray I)
 Calculates an affine transformation that normalize given image using Pei&Lin Normalization. More...
 
void PeiLinNormalization (InputArray I, OutputArray T)
 
void qconj (InputArray qimg, OutputArray qcimg)
 calculates conjugate of a quaternion image. More...
 
void qdft (InputArray img, OutputArray qimg, int flags, bool sideLeft)
 Performs a forward or inverse Discrete quaternion Fourier transform of a 2D quaternion array. More...
 
void qmultiply (InputArray src1, InputArray src2, OutputArray dst)
 Calculates the per-element quaternion product of two arrays. More...
 
void qunitary (InputArray qimg, OutputArray qnimg)
 divides each element by its modulus. More...
 
void RadonTransform (InputArray src, OutputArray dst, double theta=1, double start_angle=0, double end_angle=180, bool crop=false, bool norm=false)
 Calculate Radon Transform of an image. More...
 
int readGT (String src_path, OutputArray dst)
 Function for reading ground truth disparity maps. Supports basic Middlebury and MPI-Sintel formats. Note that the resulting disparity map is scaled by 16. More...
 
void rollingGuidanceFilter (InputArray src, OutputArray dst, int d=-1, double sigmaColor=25, double sigmaSpace=3, int numOfIter=4, int borderType=BORDER_DEFAULT)
 Applies the rolling guidance filter to an image. More...
 
void thinning (InputArray src, OutputArray dst, int thinningType=THINNING_ZHANGSUEN)
 Applies a binary blob thinning operation, to achieve a skeletization of the input image. More...
 
void transformFD (InputArray src, InputArray t, OutputArray dst, bool fdContour=true)
 transform a contour More...
 
void weightedMedianFilter (InputArray joint, InputArray src, OutputArray dst, int r, double sigma=25.5, int weightType=WMF_EXP, InputArray mask=noArray())
 Applies weighted median filter to an image. More...
 

Enumeration Type Documentation

◆ AngleRangeOption

enum cv::ximgproc::AngleRangeOption

Specifies the part of Hough space to calculate.

The enum specifies the part of Hough space to calculate. Each member specifies primarily direction of lines (horizontal or vertical) and the direction of angle changes. Direction of angle changes is from multiples of 90 to odd multiples of 45. The image considered to be written top-down and left-to-right. Angles are started from vertical line and go clockwise. Separate quarters and halves are written in orientation they should be in full Hough space.

Enumerator
ARO_0_45 
Python: cv.ximgproc.ARO_0_45
ARO_45_90 
Python: cv.ximgproc.ARO_45_90
ARO_90_135 
Python: cv.ximgproc.ARO_90_135
ARO_315_0 
Python: cv.ximgproc.ARO_315_0
ARO_315_45 
Python: cv.ximgproc.ARO_315_45
ARO_45_135 
Python: cv.ximgproc.ARO_45_135
ARO_315_135 
Python: cv.ximgproc.ARO_315_135
ARO_CTR_HOR 
Python: cv.ximgproc.ARO_CTR_HOR
ARO_CTR_VER 
Python: cv.ximgproc.ARO_CTR_VER

◆ HoughDeskewOption

enum cv::ximgproc::HoughDeskewOption

Specifies to do or not to do skewing of Hough transform image.

The enum specifies to do or not to do skewing of Hough transform image so it would be no cycling in Hough transform image through borders of image.

Enumerator
HDO_RAW 
Python: cv.ximgproc.HDO_RAW
HDO_DESKEW 
Python: cv.ximgproc.HDO_DESKEW

◆ HoughOp

enum cv::ximgproc::HoughOp

Specifies binary operations.

The enum specifies binary operations, that is such ones which involve two operands. Formally, a binary operation \( f \) on a set \( S \) is a binary relation that maps elements of the Cartesian product \( S \times S \) to \( S \):

\[ f: S \times S \to S \]

Enumerator
FHT_MIN 
Python: cv.ximgproc.FHT_MIN
FHT_MAX 
Python: cv.ximgproc.FHT_MAX
FHT_ADD 
Python: cv.ximgproc.FHT_ADD
FHT_AVE 
Python: cv.ximgproc.FHT_AVE

◆ LocalBinarizationMethods

enum cv::ximgproc::LocalBinarizationMethods

Specifies the binarization method to use in cv::ximgproc::niBlackThreshold.

Enumerator
BINARIZATION_NIBLACK 
Python: cv.ximgproc.BINARIZATION_NIBLACK

Classic Niblack binarization. See [188] .

BINARIZATION_SAUVOLA 
Python: cv.ximgproc.BINARIZATION_SAUVOLA

Sauvola's technique. See [216] .

BINARIZATION_WOLF 
Python: cv.ximgproc.BINARIZATION_WOLF

Wolf's technique. See [279] .

BINARIZATION_NICK 
Python: cv.ximgproc.BINARIZATION_NICK

NICK technique. See [130] .

◆ RulesOption

enum cv::ximgproc::RulesOption

Specifies the degree of rules validation.

The enum specifies the degree of rules validation. This can be used, for example, to choose a proper way of input arguments validation.

Enumerator
RO_STRICT 

Validate each rule in a proper way.

RO_IGNORE_BORDERS 

Skip validations of image borders.

◆ ThinningTypes

enum cv::ximgproc::ThinningTypes
Enumerator
THINNING_ZHANGSUEN 
Python: cv.ximgproc.THINNING_ZHANGSUEN
THINNING_GUOHALL 
Python: cv.ximgproc.THINNING_GUOHALL

◆ WMFWeightType

enum cv::ximgproc::WMFWeightType

Specifies weight types of weighted median filter.

Enumerator
WMF_EXP 
Python: cv.ximgproc.WMF_EXP

\(exp(-|I1-I2|^2/(2*sigma^2))\)

WMF_IV1 
Python: cv.ximgproc.WMF_IV1

\((|I1-I2|+sigma)^-1\)

WMF_IV2 
Python: cv.ximgproc.WMF_IV2

\((|I1-I2|^2+sigma^2)^-1\)

WMF_COS 
Python: cv.ximgproc.WMF_COS

\(dot(I1,I2)/(|I1|*|I2|)\)

WMF_JAC 
Python: cv.ximgproc.WMF_JAC

\((min(r1,r2)+min(g1,g2)+min(b1,b2))/(max(r1,r2)+max(g1,g2)+max(b1,b2))\)

WMF_OFF 
Python: cv.ximgproc.WMF_OFF

unweighted

Function Documentation

◆ BrightEdges()

void cv::ximgproc::BrightEdges ( Mat &  _original,
Mat &  _edgeview,
int  contrast = 1,
int  shortrange = 3,
int  longrange = 9 
)

◆ covarianceEstimation()

void cv::ximgproc::covarianceEstimation ( InputArray  src,
OutputArray  dst,
int  windowRows,
int  windowCols 
)
Python:
cv.ximgproc.covarianceEstimation(src, windowRows, windowCols[, dst]) -> dst

Computes the estimated covariance matrix of an image using the sliding window forumlation.

Parameters
srcThe source image. Input image must be of a complex type.
dstThe destination estimated covariance matrix. Output matrix will be size (windowRows*windowCols, windowRows*windowCols).
windowRowsThe number of rows in the window.
windowColsThe 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.

◆ createScanSegment()

cv::Ptr<ScanSegment> cv::ximgproc::createScanSegment ( int  image_width,
int  image_height,
int  num_superpixels,
int  slices = 8,
bool  merge_small = true 
)
Python:
cv.ximgproc.createScanSegment(image_width, image_height, num_superpixels[, slices[, merge_small]]) -> retval

Initializes a ScanSegment object.

The function initializes a ScanSegment object for the input image. It stores the parameters of the image: image_width and image_height. It also sets the parameters of the F-DBSCAN superpixel algorithm, which are: num_superpixels, threads, and merge_small.

Parameters
image_widthImage width.
image_heightImage height.
num_superpixelsDesired number of superpixels. Note that the actual number may be smaller due to restrictions (depending on the image size). Use getNumberOfSuperpixels() to get the actual number.
slicesNumber of processing threads for parallelisation. Setting -1 uses the maximum number of threads. In practice, four threads is enough for smaller images and eight threads for larger ones.
merge_smallmerge small segments to give the desired number of superpixels. Processing is much faster without merging, but many small segments will be left in the image.

◆ FastHoughTransform()

void cv::ximgproc::FastHoughTransform ( InputArray  src,
OutputArray  dst,
int  dstMatDepth,
int  angleRange = ARO_315_135,
int  op = FHT_ADD,
int  makeSkew = HDO_DESKEW 
)
Python:
cv.ximgproc.FastHoughTransform(src, dstMatDepth[, dst[, angleRange[, op[, makeSkew]]]]) -> dst

Calculates 2D Fast Hough transform of an image.

Parameters
dstThe destination image, result of transformation.
srcThe source (input) image.
dstMatDepthThe depth of destination image
opThe operation to be applied, see cv::HoughOp
angleRangeThe part of Hough space to calculate, see cv::AngleRangeOption
makeSkewSpecifies 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.

◆ HoughPoint2Line()

Vec4i cv::ximgproc::HoughPoint2Line ( const Point &  houghPoint,
InputArray  srcImgInfo,
int  angleRange = ARO_315_135,
int  makeSkew = HDO_DESKEW,
int  rules = RO_IGNORE_BORDERS 
)
Python:
cv.ximgproc.HoughPoint2Line(houghPoint, srcImgInfo[, angleRange[, makeSkew[, rules]]]) -> retval

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

Parameters
houghPointPoint in Hough space.
srcImgInfoThe source (input) image of Hough transform.
angleRangeThe part of Hough space where point is situated, see cv::AngleRangeOption
makeSkewSpecifies to do or not to do image skewing, see cv::HoughDeskewOption
rulesSpecifies strictness of line segment calculating, see cv::RulesOption
Return values
[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.
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.

◆ RadonTransform()

void cv::ximgproc::RadonTransform ( InputArray  src,
OutputArray  dst,
double  theta = 1,
double  start_angle = 0,
double  end_angle = 180,
bool  crop = false,
bool  norm = false 
)
Python:
cv.ximgproc.RadonTransform(src[, dst[, theta[, start_angle[, end_angle[, crop[, norm]]]]]]) -> dst

Calculate Radon Transform of an image.

Parameters
srcThe source (input) image.
dstThe destination image, result of transformation.
thetaAngle resolution of the transform in degrees.
start_angleStart angle of the transform in degrees.
end_angleEnd angle of the transform in degrees.
cropCrop the source image into a circle.
normNormalize 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.

◆ weightedMedianFilter()

void cv::ximgproc::weightedMedianFilter ( InputArray  joint,
InputArray  src,
OutputArray  dst,
int  r,
double  sigma = 25.5,
int  weightType = WMF_EXP,
InputArray  mask = noArray() 
)
Python:
cv.ximgproc.weightedMedianFilter(joint, src, r[, dst[, sigma[, weightType[, mask]]]]) -> dst

Applies weighted median filter to an image.

For more details about this implementation, please see [296]

Parameters
jointJoint 8-bit, 1-channel or 3-channel image.
srcSource 8-bit or floating-point, 1-channel or 3-channel image.
dstDestination image.
rRadius of filtering kernel, should be a positive integer.
sigmaFilter range standard deviation for the joint image.
weightTypeweightType The type of weight definition, see WMFWeightType
maskA 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
Generated on Sun Jun 5 2022 16:20:07 for OpenCV by   doxygen 1.8.13