imgproc library

Classes

CLAHE

Subdiv2D

Extensions

CLAHEAsync on CLAHE

Subdiv2DAsync on Subdiv2D

Async version of Subdiv2D

Functions

accumulate(InputArray src, InputOutputArray dst, {InputArray? mask}) → Mat

Adds the square of a source image to the accumulator image.

accumulateAsync(InputArray src, InputOutputArray dst, {InputArray? mask}) → Future<Mat>

Adds the square of a source image to the accumulator image.

accumulateProduct(InputArray src1, InputArray src2, InputOutputArray dst, {InputArray? mask}) → Mat

Adds the per-element product of two input images to the accumulator image.

accumulateProductAsync(InputArray src1, InputArray src2, InputOutputArray dst, {InputArray? mask}) → Future<Mat>

Adds the per-element product of two input images to the accumulator image.

accumulateSquare(InputArray src, InputOutputArray dst, {InputArray? mask}) → Mat

Adds the square of a source image to the accumulator image.

accumulateSquareAsync(InputArray src, InputOutputArray dst, {InputArray? mask}) → Future<Mat>

Adds the square of a source image to the accumulator image.

accumulateWeighted(InputArray src, InputOutputArray dst, double alpha, {InputArray? mask}) → Mat

Updates a running average.

accumulateWeightedAsync(InputArray src, InputOutputArray dst, double alpha, {InputArray? mask}) → Future<Mat>

Updates a running average.

adaptiveThreshold(InputArray src, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C, {OutputArray? dst}) → Mat

AdaptiveThreshold applies a fixed-level threshold to each array element.

adaptiveThresholdAsync(InputArray src, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) → Future<Mat>

AdaptiveThreshold applies a fixed-level threshold to each array element.

applyColorMap(InputArray src, int colormap, {OutputArray? dst}) → Mat

ApplyColorMap applies a GNU Octave/MATLAB equivalent colormap on a given image. colormap: ColormapTypes For further details, please see: https:///docs.opencv.org/master/d3/d50/group__imgproc__colormap.html#gadf478a5e5ff49d8aa24e726ea6f65d15

applyColorMapAsync(InputArray src, int colormap) → Future<Mat>

ApplyColorMap applies a GNU Octave/MATLAB equivalent colormap on a given image. colormap: ColormapTypes For further details, please see: https:///docs.opencv.org/master/d3/d50/group__imgproc__colormap.html#gadf478a5e5ff49d8aa24e726ea6f65d15

applyCustomColorMap(InputArray src, InputArray userColor, {OutputArray? dst}) → Mat

ApplyCustomColorMap applies a custom defined colormap on a given image.

applyCustomColorMapAsync(InputArray src, InputArray userColor) → Future<Mat>

ApplyCustomColorMap applies a custom defined colormap on a given image.

approxPolyDP(VecPoint curve, double epsilon, bool closed) → VecPoint

ApproxPolyDP approximates a polygonal curve(s) with the specified precision.

approxPolyDPAsync(VecPoint curve, double epsilon, bool closed) → Future<VecPoint>

ApproxPolyDP approximates a polygonal curve(s) with the specified precision.

arcLength(VecPoint curve, bool closed) → double

ArcLength calculates a contour perimeter or a curve length.

arcLengthAsync(VecPoint curve, bool closed) → Future<double>

ArcLength calculates a contour perimeter or a curve length.

arrowedLine(InputOutputArray img, Point pt1, Point pt2, Scalar color, {int thickness = 1, int line_type = 8, int shift = 0, double tipLength = 0.1}) → Mat

ArrowedLine draws a arrow segment pointing from the first point to the second one.

arrowedLineAsync(InputOutputArray img, Point pt1, Point pt2, Scalar color, {int thickness = 1, int line_type = 8, int shift = 0, double tipLength = 0.1}) → Future<Mat>

ArrowedLine draws a arrow segment pointing from the first point to the second one.

bilateralFilter(Mat src, int diameter, double sigmaColor, double sigmaSpace, {Mat? dst}) → Mat

BilateralFilter applies a bilateral filter to an image.

bilateralFilterAsync(Mat src, int diameter, double sigmaColor, double sigmaSpace) → Future<Mat>

BilateralFilter applies a bilateral filter to an image.

blur(Mat src, (int, int) ksize, {Mat? dst}) → Mat

Blur blurs an image Mat using a normalized box filter.

blurAsync(Mat src, (int, int) ksize) → Future<Mat>

Blur blurs an image Mat using a normalized box filter.

boundingRect(VecPoint points) → Rect

BoundingRect calculates the up-right bounding rectangle of a point set.

boundingRectAsync(VecPoint points) → Future<Rect>

BoundingRect calculates the up-right bounding rectangle of a point set.

boxFilter(Mat src, int depth, (int, int) ksize, {Point? anchor, bool normalize = true, int borderType = BORDER_DEFAULT, Mat? dst}) → Mat

BoxFilter blurs an image using the box filter.

boxFilterAsync(Mat src, int depth, (int, int) ksize) → Future<Mat>

BoxFilter blurs an image using the box filter.

boxPoints(RotatedRect rect, {VecPoint2f? pts}) → VecPoint2f

BoxPoints finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.

boxPointsAsync(RotatedRect rect) → Future<VecPoint2f>

BoxPoints finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.

calcBackProject(VecMat src, VecI32 channels, Mat hist, VecF32 ranges, {Mat? dst, double scale = 1.0}) → Mat

CalcBackProject calculates the back projection of a histogram.

calcBackProjectAsync(VecMat src, VecI32 channels, Mat hist, VecF32 ranges, {double scale = 1.0}) → Future<Mat>

CalcBackProject calculates the back projection of a histogram.

calcHist(VecMat src, VecI32 channels, Mat mask, VecI32 histSize, VecF32 ranges, {Mat? hist, bool accumulate = false}) → Mat

CalcHist Calculates a histogram of a set of images

calcHistAsync(VecMat src, VecI32 channels, Mat mask, VecI32 histSize, VecF32 ranges, {bool accumulate = false}) → Future<Mat>

CalcHist Calculates a histogram of a set of images

canny(Mat image, double threshold1, double threshold2, {OutputArray? edges, int apertureSize = 3, bool l2gradient = false}) → Mat

Canny finds edges in an image using the Canny algorithm. The function finds edges in the input image image and marks them in the output map edges using the Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking. The largest value is used to find initial segments of strong edges. See http:///en.wikipedia.org/wiki/Canny_edge_detector

cannyAsync(Mat image, double threshold1, double threshold2, {int apertureSize = 3, bool l2gradient = false}) → Future<Mat>

Canny finds edges in an image using the Canny algorithm. The function finds edges in the input image image and marks them in the output map edges using the Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking. The largest value is used to find initial segments of strong edges. See http:///en.wikipedia.org/wiki/Canny_edge_detector

circle(InputOutputArray img, Point center, int radius, Scalar color, {int thickness = 1, int lineType = LINE_8, int shift = 0}) → Mat

CircleWithParams draws a circle.

circleAsync(InputOutputArray img, Point center, int radius, Scalar color, {int thickness = 1, int lineType = LINE_8, int shift = 0}) → Future<Mat>

CircleWithParams draws a circle.

clipLine(Rect imgRect, Point pt1, Point pt2) → (bool, Point, Point)

ClipLine clips the line against the image rectangle. For further details, please see: https:///docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#gaf483cb46ad6b049bc35ec67052ef1c2c

clipLineAsync(Rect imgRect, Point pt1, Point pt2) → Future<(bool, Point, Point)>

ClipLine clips the line against the image rectangle. For further details, please see: https:///docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#gaf483cb46ad6b049bc35ec67052ef1c2c

compareHist(Mat hist1, Mat hist2, {int method = 0}) → double

CompareHist Compares two histograms. mode: HistCompMethods For further details, please see: https:///docs.opencv.org/master/d6/dc7/group__imgproc__hist.html#gaf4190090efa5c47cb367cf97a9a519bd

compareHistAsync(Mat hist1, Mat hist2, {int method = 0}) → Future<double>

CompareHist Compares two histograms. mode: HistCompMethods For further details, please see: https:///docs.opencv.org/master/d6/dc7/group__imgproc__hist.html#gaf4190090efa5c47cb367cf97a9a519bd

connectedComponents(Mat image, Mat labels, int connectivity, int ltype, int ccltype) → int

ConnectedComponents computes the connected components labeled image of boolean image.

connectedComponentsAsync(Mat image, int connectivity, int ltype, int ccltype) → Future<(int, Mat)>

ConnectedComponents computes the connected components labeled image of boolean image.

connectedComponentsWithStats(Mat src, Mat labels, Mat stats, Mat centroids, int connectivity, int ltype, int ccltype) → int

ConnectedComponentsWithStats computes the connected components labeled image of boolean image and also produces a statistics output for each label.

connectedComponentsWithStatsAsync(Mat src, int connectivity, int ltype, int ccltype) → Future<(int, Mat, Mat, Mat)>

ConnectedComponentsWithStats computes the connected components labeled image of boolean image and also produces a statistics output for each label.

contourArea(VecPoint contour) → double

ContourArea calculates a contour area.

contourAreaAsync(VecPoint contour) → Future<double>

ContourArea calculates a contour area.

convexHull(VecPoint points, {Mat? hull, bool clockwise = false, bool returnPoints = true}) → Mat

ConvexHull finds the convex hull of a point set.

convexHullAsync(VecPoint points, {Mat? hull, bool clockwise = false, bool returnPoints = true}) → Future<Mat>

ConvexHull finds the convex hull of a point set.

convexityDefects(VecPoint contour, Mat hull, {Mat? convexityDefects}) → Mat

ConvexityDefects finds the convexity defects of a contour.

convexityDefectsAsync(VecPoint contour, Mat hull, {Mat? convexityDefects}) → Future<Mat>

ConvexityDefects finds the convexity defects of a contour.

cornerSubPix(InputArray image, VecPoint2f corners, (int, int) winSize, (int, int) zeroZone, [(int, int, double) criteria = (TERM_COUNT + TERM_EPS, 30, 1e-4)]) → VecPoint2f

CornerSubPix Refines the corner locations. The function iterates to find the sub-pixel accurate location of corners or radial saddle points.

cornerSubPixAsync(InputArray image, VecPoint2f corners, (int, int) winSize, (int, int) zeroZone, [(int, int, double) criteria = (TERM_COUNT + TERM_EPS, 30, 1e-4)]) → Future<VecPoint2f>

CornerSubPix Refines the corner locations. The function iterates to find the sub-pixel accurate location of corners or radial saddle points.

cvtColor(Mat src, int code, {Mat? dst}) → Mat

CvtColor converts an image from one color space to another. It converts the src Mat image to the dst Mat using the code param containing the desired ColorConversionCode color space.

cvtColorAsync(Mat src, int code) → Future<Mat>

CvtColor converts an image from one color space to another. It converts the src Mat image to the dst Mat using the code param containing the desired ColorConversionCode color space.

dilate(Mat src, Mat kernel, {Mat? dst, Point? anchor, int iterations = 1, int borderType = BORDER_CONSTANT, Scalar? borderValue}) → Mat

Dilate dilates an image by using a specific structuring element.

dilateAsync(Mat src, Mat kernel, {Point? anchor, int iterations = 1, int borderType = BORDER_CONSTANT, Scalar? borderValue}) → Future<Mat>

Dilate dilates an image by using a specific structuring element.

distanceTransform(Mat src, int distanceType, int maskSize, int labelType, {Mat? dst, Mat? labels}) → (Mat, Mat)

DistanceTransform Calculates the distance to the closest zero pixel for each pixel of the source image.

distanceTransformAsync(Mat src, int distanceType, int maskSize, int labelType) → Future<(Mat, Mat)>

DistanceTransform Calculates the distance to the closest zero pixel for each pixel of the source image.

drawContours(InputOutputArray image, Contours contours, int contourIdx, Scalar color, {int thickness = 1, int lineType = LINE_8, InputArray? hierarchy, int maxLevel = 0x3f3f3f3f, Point? offset}) → Mat

DrawContours draws contours outlines or filled contours.

drawContoursAsync(InputOutputArray image, Contours contours, int contourIdx, Scalar color, {int thickness = 1, int lineType = LINE_8, InputArray? hierarchy, int maxLevel = 0x3f3f3f3f, Point? offset}) → Future<Mat>

DrawContours draws contours outlines or filled contours.

ellipse(InputOutputArray img, Point center, Point axes, double angle, double startAngle, double endAngle, Scalar color, {int thickness = 1, int lineType = LINE_8, int shift = 0}) → Mat

Ellipse draws a simple or thick elliptic arc or fills an ellipse sector.

ellipseAsync(InputOutputArray img, Point center, Point axes, double angle, double startAngle, double endAngle, Scalar color, {int thickness = 1, int lineType = LINE_8, int shift = 0}) → Future<Mat>

Ellipse draws a simple or thick elliptic arc or fills an ellipse sector.

equalizeHist(Mat src, {Mat? dst}) → Mat

EqualizeHist Equalizes the histogram of a grayscale image.

equalizeHistAsync(Mat src) → Future<Mat>

EqualizeHist Equalizes the histogram of a grayscale image.

erode(Mat src, Mat kernel, {Mat? dst, Point? anchor, int iterations = 1, int borderType = BORDER_CONSTANT, Scalar? borderValue}) → Mat

Erode erodes an image by using a specific structuring element.

erodeAsync(Mat src, Mat kernel, {Mat? dst, Point? anchor, int iterations = 1, int borderType = BORDER_CONSTANT, Scalar? borderValue}) → Future<Mat>

Erode erodes an image by using a specific structuring element.

fillPoly(InputOutputArray img, VecVecPoint pts, Scalar color, {int lineType = LINE_8, int shift = 0, Point? offset}) → Mat

FillPolyWithParams fills the area bounded by one or more polygons.

fillPolyAsync(InputOutputArray img, VecVecPoint pts, Scalar color, {int lineType = LINE_8, int shift = 0, Point? offset}) → Future<Mat>

FillPolyWithParams fills the area bounded by one or more polygons.

filter2D(InputArray src, int ddepth, InputArray kernel, {OutputArray? dst, Point? anchor, double delta = 0, int borderType = BORDER_DEFAULT}) → Mat

Filter2D applies an arbitrary linear filter to an image.

filter2DAsync(InputArray src, int ddepth, InputArray kernel, {Point? anchor, double delta = 0, int borderType = BORDER_DEFAULT}) → Future<Mat>

Filter2D applies an arbitrary linear filter to an image.

findContours(Mat src, int mode, int method) → (Contours, Mat)

FindContours finds contours in a binary image.

findContoursAsync(Mat src, int mode, int method) → Future<(Contours, Mat)>

FindContours finds contours in a binary image.

findHomography(InputArray srcPoints, InputArray dstPoints, {int method = 0, double ransacReprojThreshold = 3, OutputArray? mask, int maxIters = 2000, double confidence = 0.995}) → Mat

FindHomography finds an optimal homography matrix using 4 or more point pairs (as opposed to GetPerspectiveTransform, which uses exactly 4)

findHomographyAsync(InputArray srcPoints, InputArray dstPoints, {int method = 0, double ransacReprojThreshold = 3, int maxIters = 2000, double confidence = 0.995}) → Future<(Mat, Mat)>

FindHomography finds an optimal homography matrix using 4 or more point pairs (as opposed to GetPerspectiveTransform, which uses exactly 4)

fitEllipse(VecPoint points) → RotatedRect

FitEllipse Fits an ellipse around a set of 2D points.

fitEllipseAsync(VecPoint points) → Future<RotatedRect>

FitEllipse Fits an ellipse around a set of 2D points.

fitLine(VecPoint points, int distType, double param, double reps, double aeps, {OutputArray? line}) → Mat

FitLine fits a line to a 2D or 3D point set. distType: DistanceTypes For further details, please see: https:///docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#gaf849da1fdafa67ee84b1e9a23b93f91f

fitLineAsync(VecPoint points, int distType, double param, double reps, double aeps) → Future<Mat>

FitLine fits a line to a 2D or 3D point set. distType: DistanceTypes For further details, please see: https:///docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#gaf849da1fdafa67ee84b1e9a23b93f91f

gaussianBlur(Mat src, (int, int) ksize, double sigmaX, {Mat? dst, double sigmaY = 0, int borderType = BORDER_DEFAULT}) → Mat

GaussianBlur blurs an image Mat using a Gaussian filter. The function convolves the src Mat image into the dst Mat using the specified Gaussian kernel params.

gaussianBlurAsync(Mat src, (int, int) ksize, double sigmaX, {Mat? dst, double sigmaY = 0, int borderType = BORDER_DEFAULT}) → Future<Mat>

GaussianBlur blurs an image Mat using a Gaussian filter. The function convolves the src Mat image into the dst Mat using the specified Gaussian kernel params.

getAffineTransform(VecPoint src, VecPoint dst) → Mat

GetAffineTransform returns a 2x3 affine transformation matrix for the corresponding 3 point pairs as image.Point.

getAffineTransform2f(VecPoint2f src, VecPoint2f dst) → Mat

getAffineTransform2fAsync(VecPoint2f src, VecPoint2f dst) → Future<Mat>

getAffineTransformAsync(VecPoint src, VecPoint dst) → Future<Mat>

GetAffineTransform returns a 2x3 affine transformation matrix for the corresponding 3 point pairs as image.Point.

getGaussianKernel(int ksize, double sigma, {int ktype = 6}) → Mat

GetGaussianKernel returns Gaussian filter coefficients.

getGaussianKernelAsync(int ksize, double sigma, {int ktype = 6}) → Future<Mat>

GetGaussianKernel returns Gaussian filter coefficients.

getPerspectiveTransform(VecPoint src, VecPoint dst, [int solveMethod = DECOMP_LU]) → Mat

GetPerspectiveTransform returns 3x3 perspective transformation for the corresponding 4 point pairs as image.Point.

getPerspectiveTransform2f(VecPoint2f src, VecPoint2f dst, [int solveMethod = DECOMP_LU]) → Mat

GetPerspectiveTransform2f returns 3x3 perspective transformation for the corresponding 4 point pairs as gocv.Point2f.

getPerspectiveTransform2fAsync(VecPoint2f src, VecPoint2f dst, [int solveMethod = DECOMP_LU]) → Future<Mat>

GetPerspectiveTransform2f returns 3x3 perspective transformation for the corresponding 4 point pairs as gocv.Point2f.

getPerspectiveTransformAsync(VecPoint src, VecPoint dst, [int solveMethod = DECOMP_LU]) → Future<Mat>

GetPerspectiveTransform returns 3x3 perspective transformation for the corresponding 4 point pairs as image.Point.

getRectSubPix(InputArray image, (int, int) patchSize, Point2f center, {OutputArray? patch, int patchType = -1}) → Mat

GetRectSubPix retrieves a pixel rectangle from an image with sub-pixel accuracy.

getRectSubPixAsync(InputArray image, (int, int) patchSize, Point2f center, {int patchType = -1}) → Future<Mat>

GetRectSubPix retrieves a pixel rectangle from an image with sub-pixel accuracy.

getRotationMatrix2D(Point2f center, double angle, double scale) → Mat

GetRotationMatrix2D calculates an affine matrix of 2D rotation.

getRotationMatrix2DAsync(Point2f center, double angle, double scale) → Future<Mat>

GetRotationMatrix2D calculates an affine matrix of 2D rotation.

getStructuringElement(int shape, (int, int) ksize, {Point? anchor}) → Mat

GetStructuringElement returns a structuring element of the specified size and shape for morphological operations.

getStructuringElementAsync(int shape, (int, int) ksize, {Point? anchor}) → Future<Mat>

GetStructuringElement returns a structuring element of the specified size and shape for morphological operations.

getTextSize(String text, int fontFace, double fontScale, int thickness) → (Size, int)

GetTextSizeWithBaseline calculates the width and height of a text string including the basline of the text. It returns an image.Point with the size required to draw text using a specific font face, scale, and thickness as well as its baseline.

getTextSizeAsync(String text, int fontFace, double fontScale, int thickness) → Future<(Size, int)>

GetTextSizeWithBaseline calculates the width and height of a text string including the basline of the text. It returns an image.Point with the size required to draw text using a specific font face, scale, and thickness as well as its baseline.

goodFeaturesToTrack(InputArray image, int maxCorners, double qualityLevel, double minDistance, {VecPoint2f? corners, InputArray? mask, int blockSize = 3, int? gradientSize, bool useHarrisDetector = false, double k = 0.04}) → VecPoint2f

GoodFeaturesToTrack determines strong corners on an image. The function finds the most prominent corners in the image or in the specified image region.

goodFeaturesToTrackAsync(InputArray image, int maxCorners, double qualityLevel, double minDistance, {InputArray? mask, int blockSize = 3, int? gradientSize, bool useHarrisDetector = false, double k = 0.04}) → Future<VecPoint2f>

GoodFeaturesToTrack determines strong corners on an image. The function finds the most prominent corners in the image or in the specified image region.

grabCut(InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, {int mode = GC_EVAL}) → (Mat, Mat, Mat)

Grabcut runs the GrabCut algorithm. The function implements the GrabCut image segmentation algorithm. For further details, please see: https:///docs.opencv.org/master/d3/d47/group__imgproc__segmentation.html#ga909c1dda50efcbeaa3ce126be862b37f

grabCutAsync(InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, {int mode = GC_EVAL}) → Future<(Mat, Mat, Mat)>

Grabcut runs the GrabCut algorithm. The function implements the GrabCut image segmentation algorithm. For further details, please see: https:///docs.opencv.org/master/d3/d47/group__imgproc__segmentation.html#ga909c1dda50efcbeaa3ce126be862b37f

HoughCircles(InputArray image, int method, double dp, double minDist, {OutputArray? circles, double param1 = 100, double param2 = 100, int minRadius = 0, int maxRadius = 0}) → Mat

HoughCircles finds circles in a grayscale image using the Hough transform. The only "method" currently supported is HoughGradient. If you want to pass more parameters, please see HoughCirclesWithParams.

HoughCirclesAsync(InputArray image, int method, double dp, double minDist, {double param1 = 100, double param2 = 100, int minRadius = 0, int maxRadius = 0}) → Future<Mat>

HoughCircles finds circles in a grayscale image using the Hough transform. The only "method" currently supported is HoughGradient. If you want to pass more parameters, please see HoughCirclesWithParams.

HoughLines(InputArray image, double rho, double theta, int threshold, {OutputArray? lines, double srn = 0, double stn = 0, double min_theta = 0, double max_theta = CV_PI}) → Mat

HoughLines implements the standard or standard multi-scale Hough transform algorithm for line detection. For a good explanation of Hough transform, see: http:///homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm

HoughLinesAsync(InputArray image, double rho, double theta, int threshold, {double srn = 0, double stn = 0, double min_theta = 0, double max_theta = CV_PI}) → Future<Mat>

HoughLines implements the standard or standard multi-scale Hough transform algorithm for line detection. For a good explanation of Hough transform, see: http:///homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm

HoughLinesP(InputArray image, double rho, double theta, int threshold, {OutputArray? lines, double minLineLength = 0, double maxLineGap = 0}) → Mat

HoughLinesP implements the probabilistic Hough transform algorithm for line detection. For a good explanation of Hough transform, see: http:///homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm

HoughLinesPAsync(InputArray image, double rho, double theta, int threshold, {double minLineLength = 0, double maxLineGap = 0}) → Future<Mat>

HoughLinesP implements the probabilistic Hough transform algorithm for line detection. For a good explanation of Hough transform, see: http:///homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm

HoughLinesPointSet(InputArray point, int lines_max, int threshold, double min_rho, double max_rho, double rho_step, double min_theta, double max_theta, double theta_step, {OutputArray? lines}) → Mat

HoughLinesPointSet implements the Hough transform algorithm for line detection on a set of points. For a good explanation of Hough transform, see: http:///homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm

HoughLinesPointSetAsync(InputArray point, int lines_max, int threshold, double min_rho, double max_rho, double rho_step, double min_theta, double max_theta, double theta_step) → Future<Mat>

HoughLinesPointSet implements the Hough transform algorithm for line detection on a set of points. For a good explanation of Hough transform, see: http:///homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm

integral(InputArray src, {OutputArray? sum, OutputArray? sqsum, OutputArray? tilted, int sdepth = -1, int sqdepth = -1}) → (Mat, Mat, Mat)

Integral calculates one or more integral images for the source image. For further details, please see: https:///docs.opencv.org/master/d7/d1b/group__imgproc__misc.html#ga97b87bec26908237e8ba0f6e96d23e28

integralAsync(InputArray src, {int sdepth = -1, int sqdepth = -1}) → Future<(Mat, Mat, Mat)>

Integral calculates one or more integral images for the source image. For further details, please see: https:///docs.opencv.org/master/d7/d1b/group__imgproc__misc.html#ga97b87bec26908237e8ba0f6e96d23e28

invertAffineTransform(InputArray M, {OutputArray? iM}) → Mat

Inverts an affine transformation. The function computes an inverse affine transformation represented by 2×3 matrix M: The result is also a 2×3 matrix of the same type as M.

invertAffineTransformAsync(InputArray M) → Future<Mat>

Inverts an affine transformation. The function computes an inverse affine transformation represented by 2×3 matrix M: The result is also a 2×3 matrix of the same type as M.

laplacian(Mat src, int ddepth, {Mat? dst, int ksize = 1, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT}) → Mat

Laplacian calculates the Laplacian of an image.

laplacianAsync(Mat src, int ddepth, {int ksize = 1, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT}) → Future<Mat>

Laplacian calculates the Laplacian of an image.

line(InputOutputArray img, Point pt1, Point pt2, Scalar color, {int thickness = 1, int lineType = LINE_8, int shift = 0}) → Mat

Line draws a line segment connecting two points.

linearPolar(InputArray src, Point2f center, double maxRadius, int flags, {OutputArray? dst}) → Mat

LinearPolar remaps an image to polar coordinates space.

linearPolarAsync(InputArray src, Point2f center, double maxRadius, int flags) → Future<Mat>

LinearPolar remaps an image to polar coordinates space.

lineAsync(InputOutputArray img, Point pt1, Point pt2, Scalar color, {int thickness = 1, int lineType = LINE_8, int shift = 0}) → Future<Mat>

Line draws a line segment connecting two points.

logPolar(InputArray src, Point2f center, double M, int flags, {OutputArray? dst}) → Mat

LogPolar remaps an image to semilog-polar coordinates space.

logPolarAsync(InputArray src, Point2f center, double M, int flags) → Future<Mat>

LogPolar remaps an image to semilog-polar coordinates space.

matchShapes(VecPoint contour1, VecPoint contour2, int method, double parameter) → double

Compares two shapes. method: ShapeMatchModes For further details, please see: https:///docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gaadc90cb16e2362c9bd6e7363e6e4c317

matchShapesAsync(VecPoint contour1, VecPoint contour2, int method, double parameter) → Future<double>

Compares two shapes. method: ShapeMatchModes For further details, please see: https:///docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gaadc90cb16e2362c9bd6e7363e6e4c317

matchTemplate(Mat image, Mat templ, int method, {OutputArray? result, Mat? mask}) → Mat

MatchTemplate compares a template against overlapped image regions.

matchTemplateAsync(Mat image, Mat templ, int method, {Mat? mask}) → Future<Mat>

MatchTemplate compares a template against overlapped image regions.

medianBlur(Mat src, int ksize, {OutputArray? dst}) → Mat

MedianBlur blurs an image using the median filter.

medianBlurAsync(Mat src, int ksize) → Future<Mat>

MedianBlur blurs an image using the median filter.

minAreaRect(VecPoint points) → RotatedRect

MinAreaRect finds a rotated rectangle of the minimum area enclosing the input 2D point set.

minAreaRectAsync(VecPoint points) → Future<RotatedRect>

MinAreaRect finds a rotated rectangle of the minimum area enclosing the input 2D point set.

minEnclosingCircle(VecPoint points) → (Point2f, double)

MinEnclosingCircle finds a circle of the minimum area enclosing the input 2D point set.

minEnclosingCircleAsync(VecPoint points) → Future<(Point2f, double)>

MinEnclosingCircle finds a circle of the minimum area enclosing the input 2D point set.

moments(Mat src, {bool binaryImage = false}) → Moments

Moments calculates all of the moments up to the third order of a polygon or rasterized shape.

momentsAsync(Mat src, {bool binaryImage = false}) → Future<Moments>

Moments calculates all of the moments up to the third order of a polygon or rasterized shape.

morphologyDefaultBorderValue() → Scalar

MorphologyDefaultBorder returns "magic" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation.

morphologyDefaultBorderValueAsync() → Future<Scalar>

MorphologyDefaultBorder returns "magic" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation.

morphologyEx(Mat src, int op, Mat kernel, {Mat? dst, Point? anchor, int iterations = 1, int borderType = BORDER_CONSTANT, Scalar? borderValue}) → Mat

MorphologyEx performs advanced morphological transformations.

morphologyExAsync(Mat src, int op, Mat kernel, {Mat? dst, Point? anchor, int iterations = 1, int borderType = BORDER_CONSTANT, Scalar? borderValue}) → Future<Mat>

MorphologyEx performs advanced morphological transformations.

phaseCorrelate(InputArray src1, InputArray src2, {InputArray? window}) → (Point2f, double)

Apply phaseCorrelate.

phaseCorrelateAsync(InputArray src1, InputArray src2, {InputArray? window}) → Future<(Point2f, double)>

Apply phaseCorrelate.

pointPolygonTest(VecPoint points, Point2f pt, bool measureDist) → double

PointPolygonTest performs a point-in-contour test.

pointPolygonTestAsync(VecPoint points, Point2f pt, bool measureDist) → Future<double>

PointPolygonTest performs a point-in-contour test.

polylines(InputOutputArray img, VecVecPoint pts, bool isClosed, Scalar color, {int thickness = 1, int lineType = LINE_8, int shift = 0}) → Mat

Polylines draws several polygonal curves.

polylinesAsync(InputOutputArray img, VecVecPoint pts, bool isClosed, Scalar color, {int thickness = 1, int lineType = LINE_8, int shift = 0}) → Future<Mat>

Polylines draws several polygonal curves.

putText(InputOutputArray img, String text, Point org, int fontFace, double fontScale, Scalar color, {int thickness = 1, int lineType = LINE_8, bool bottomLeftOrigin = false}) → Mat

PutTextWithParams draws a text string. It renders the specified text string into the img Mat at the location passed in the "org" param, using the desired font face, font scale, color, and line thinkness.

putTextAsync(InputOutputArray img, String text, Point org, int fontFace, double fontScale, Scalar color, {int thickness = 1, int lineType = LINE_8, bool bottomLeftOrigin = false}) → Future<Mat>

PutTextWithParams draws a text string. It renders the specified text string into the img Mat at the location passed in the "org" param, using the desired font face, font scale, color, and line thinkness.

pyrDown(Mat src, {Mat? dst, (int, int) dstsize = (0, 0), int borderType = BORDER_DEFAULT}) → Mat

PyrDown blurs an image and downsamples it.

pyrDownAsync(Mat src, {(int, int) dstsize = (0, 0), int borderType = BORDER_DEFAULT}) → Future<Mat>

PyrDown blurs an image and downsamples it.

pyrUp(Mat src, {Mat? dst, (int, int) dstsize = (0, 0), int borderType = BORDER_DEFAULT}) → Mat

PyrUp upsamples an image and then blurs it.

pyrUpAsync(Mat src, {Mat? dst, (int, int) dstsize = (0, 0), int borderType = BORDER_DEFAULT}) → Future<Mat>

PyrUp upsamples an image and then blurs it.

rectangle(InputOutputArray img, Rect rect, Scalar color, {int thickness = 1, int lineType = LINE_8, int shift = 0}) → Mat

Rectangle draws a simple, thick, or filled up-right rectangle. It renders a rectangle with the desired characteristics to the target Mat image.

rectangleAsync(InputOutputArray img, Rect rect, Scalar color, {int thickness = 1, int lineType = LINE_8, int shift = 0}) → Future<Mat>

Rectangle draws a simple, thick, or filled up-right rectangle. It renders a rectangle with the desired characteristics to the target Mat image.

remap(InputArray src, InputArray map1, InputArray map2, int interpolation, {OutputArray? dst, int borderMode = BORDER_CONSTANT, Scalar? borderValue}) → Mat

Remap applies a generic geometrical transformation to an image.

remapAsync(InputArray src, InputArray map1, InputArray map2, int interpolation, {int borderMode = BORDER_CONSTANT, Scalar? borderValue}) → Future<Mat>

Remap applies a generic geometrical transformation to an image.

resize(InputArray src, (int, int) dsize, {OutputArray? dst, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR}) → Mat

Resize resizes an image. It resizes the image src down to or up to the specified size, storing the result in dst. Note that src and dst may be the same image. If you wish to scale by factor, an empty sz may be passed and non-zero fx and fy. Likewise, if you wish to scale to an explicit size, a non-empty sz may be passed with zero for both fx and fy.

resizeAsync(InputArray src, (int, int) dsize, {double fx = 0, double fy = 0, int interpolation = INTER_LINEAR}) → Future<Mat>

Resize resizes an image. It resizes the image src down to or up to the specified size, storing the result in dst. Note that src and dst may be the same image. If you wish to scale by factor, an empty sz may be passed and non-zero fx and fy. Likewise, if you wish to scale to an explicit size, a non-empty sz may be passed with zero for both fx and fy.

scharr(Mat src, int ddepth, int dx, int dy, {Mat? dst, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT}) → Mat

Scharr calculates the first x- or y- image derivative using Scharr operator.

scharrAsync(Mat src, int ddepth, int dx, int dy, {double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT}) → Future<Mat>

Scharr calculates the first x- or y- image derivative using Scharr operator.

sepFilter2D(InputArray src, int ddepth, InputArray kernelX, InputArray kernelY, {OutputArray? dst, Point? anchor, double delta = 0, int borderType = BORDER_DEFAULT}) → Mat

SepFilter2D applies a separable linear filter to the image.

sepFilter2DAsync(InputArray src, int ddepth, InputArray kernelX, InputArray kernelY, {Point? anchor, double delta = 0, int borderType = BORDER_DEFAULT}) → Future<Mat>

SepFilter2D applies a separable linear filter to the image.

sobel(Mat src, int ddepth, int dx, int dy, {Mat? dst, int ksize = 3, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT}) → Mat

Sobel calculates the first, second, third, or mixed image derivatives using an extended Sobel operator

sobelAsync(Mat src, int ddepth, int dx, int dy, {int ksize = 3, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT}) → Future<Mat>

Sobel calculates the first, second, third, or mixed image derivatives using an extended Sobel operator

spatialGradient(Mat src, {Mat? dx, Mat? dy, int ksize = 3, int borderType = BORDER_DEFAULT}) → (Mat, Mat)

SpatialGradient calculates the first order image derivative in both x and y using a Sobel operator.

spatialGradientAsync(Mat src, {int ksize = 3, int borderType = BORDER_DEFAULT}) → Future<(Mat, Mat)>

SpatialGradient calculates the first order image derivative in both x and y using a Sobel operator.

sqrBoxFilter(Mat src, int depth, (int, int) ksize, {Point? anchor, bool normalize = true, int borderType = BORDER_DEFAULT, Mat? dst}) → Mat

SqBoxFilter calculates the normalized sum of squares of the pixel values overlapping the filter.

sqrBoxFilterAsync(Mat src, int depth, (int, int) ksize) → Future<Mat>

SqBoxFilter calculates the normalized sum of squares of the pixel values overlapping the filter.

threshold(InputArray src, double thresh, double maxval, int type, {OutputArray? dst}) → (double, Mat)

Threshold applies a fixed-level threshold to each array element.

thresholdAsync(InputArray src, double thresh, double maxval, int type) → Future<(double, Mat)>

Threshold applies a fixed-level threshold to each array element.

warpAffine(InputArray src, InputArray M, (int, int) dsize, {OutputArray? dst, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar? borderValue}) → Mat

WarpAffine applies an affine transformation to an image.

warpAffineAsync(InputArray src, InputArray M, (int, int) dsize, {int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar? borderValue}) → Future<Mat>

WarpAffine applies an affine transformation to an image.

warpPerspective(InputArray src, InputArray M, (int, int) dsize, {OutputArray? dst, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar? borderValue}) → Mat

WarpPerspective applies a perspective transformation to an image. For more parameters please check WarpPerspectiveWithParams.

warpPerspectiveAsync(InputArray src, InputArray M, (int, int) dsize, {int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar? borderValue}) → Future<Mat>

WarpPerspective applies a perspective transformation to an image. For more parameters please check WarpPerspectiveWithParams.

watershed(InputArray image, InputOutputArray markers) → Mat

Watershed performs a marker-based image segmentation using the watershed algorithm.

watershedAsync(InputArray image, InputOutputArray markers) → Future<Mat>

Watershed performs a marker-based image segmentation using the watershed algorithm.