dartcv_core
library
Extensions
AgastFeatureDetectorAsync
on AgastFeatureDetector
AKAZEAsync
on AKAZE
AlignMTBAsync
on AlignMTB
ArucoDetectorAsync
on ArucoDetector
BackgroundSubtractorKNNAsync
on BackgroundSubtractorKNN
BackgroundSubtractorMOG2Async
on BackgroundSubtractorMOG2
BFMatcherAsync
on BFMatcher
BRISKAsync
on BRISK
CascadeClassifierAsync
on CascadeClassifier
CLAHEAsync
on CLAHE
DoubleFp16Extension
on double
FaceDetectorYNAsync
on FaceDetectorYN
FaceRecognizerSFAsync
on FaceRecognizerSF
FastFeatureDetectorAsync
on FastFeatureDetector
FlannBasedMatcherAsync
on FlannBasedMatcher
GFTTDetectorAsync
on GFTTDetector
HOGDescriptorAsync
on HOGDescriptor
IntFp16Extension
on int
KalmanFilterAsync
on KalmanFilter
KalmanFilter implements a standard Kalman filter http://en.wikipedia.org/wiki/Kalman_filter .
However, you can modify transitionMatrix, controlMatrix, and measurementMatrix
to get an extended Kalman filter functionality.
KAZEAsync
on KAZE
LayerAsync
on Layer
ListDMatchExtension
on List <DMatch >
ListFloatExtension
on List <double >
ListKeyPointExtension
on List <KeyPoint >
ListListCharExtension
on List <List <int > >
ListListDMatchExtension
on List <List <DMatch > >
ListListPoint2fExtension
on List <List <Point2f > >
ListListPoint3fExtension
on List <List <Point3f > >
ListListPointExtension
on List <List <Point > >
ListMatExtension
on List <Mat >
ListPoint2fExtension
on List <Point2f >
ListPoint3fExtension
on List <Point3f >
ListPoint3iExtension
on List <Point3i >
ListPointExtension
on List <Point >
ListRectExtension
on List <Rect >
ListStringExtension
on List <String >
ListUCharExtension
on List <int >
MatAsync
on Mat
MergeMertensAsync
on MergeMertens
MSERAsync
on MSER
NetAsync
on Net
ORBAsync
on ORB
Point2fRecordExtension
on (double , double )
Point3fRecordExtension
on (double , double , double )
PointerCharExtension
on Pointer <Char >
PointerUint16Extension
on Pointer <Uint16 >
PointRecordExtension
on (int , int )
QRCodeDetectorAsync
on QRCodeDetector
RecordScalarExtension
on (double , double , double , double )
RecordSize2fExtension1
on (double , double )
RecordSizeExtension1
on (int , int )
RngAsync
on Rng
SIFTAsync
on SIFT
SimpleBlobDetectorAsync
on SimpleBlobDetector
StitcherAsync
on Stitcher
StringVecExtension
on String
Subdiv2DAsync
on Subdiv2D
Async version of Subdiv2D
TermCriteriaExtension
on (int , int , double )
TrackerMILAsync
on TrackerMIL
Tracker is the base interface for object tracking.
VecPointExtension
on VecPoint
VecVec4fExtension
on List <Vec4f >
VecVec4iExtension
on List <Vec4i >
VecVec6fExtension
on List <Vec6f >
WeChatQRCodeAsync
on WeChatQRCode
Functions
absDiff (Mat src1 , Mat src2 , [Mat ? dst ])
→ Mat
AbsDiff calculates the per-element absolute difference between two arrays
or between an array and a scalar.
absDiffAsync (Mat src1 , Mat src2 )
→ Future <Mat >
AbsDiff calculates the per-element absolute difference between two arrays
or between an array and a scalar.
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.
add (Mat src1 , Mat src2 , {Mat ? dst , int dtype = -1 , Mat ? mask })
→ Mat
Add calculates the per-element sum of two arrays or an array and a scalar.
addAsync (Mat src1 , Mat src2 , {Mat ? mask , int dtype = -1 })
→ Future <Mat >
Add calculates the per-element sum of two arrays or an array and a scalar.
addWeighted (InputArray src1 , double alpha , InputArray src2 , double beta , double gamma , {OutputArray ? dst , int dtype = -1 })
→ Mat
AddWeighted calculates the weighted sum of two arrays.
addWeightedAsync (InputArray src1 , double alpha , InputArray src2 , double beta , double gamma , {int dtype = -1 })
→ Future <Mat >
AddWeighted calculates the weighted sum of two arrays.
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.
arucoDrawDetectedMarkers (Mat img , VecVecPoint2f markerCorners , VecI32 markerIds , Scalar borderColor )
→ void
arucoDrawDetectedMarkersAsync (Mat img , VecVecPoint2f markerCorners , VecI32 markerIds , Scalar borderColor )
→ Future <void >
arucoGenerateImageMarker (PredefinedDictionaryType dictionaryId , int id , int sidePixels , int borderBits , [Mat ? outImg ])
→ Mat
arucoGenerateImageMarkerAsync (PredefinedDictionaryType dictionaryId , int id , int sidePixels , int borderBits )
→ Future <Mat >
batchDistance (InputArray src1 , InputArray src2 , int dtype , {OutputArray ? dist , OutputArray ? nidx , int normType = NORM_L2 , int K = 0 , InputArray ? mask , int update = 0 , bool crosscheck = false })
→ (Mat , Mat )
BatchDistance is a naive nearest neighbor finder.
batchDistanceAsync (InputArray src1 , InputArray src2 , int dtype , {int normType = NORM_L2 , int K = 0 , InputArray ? mask , int update = 0 , bool crosscheck = false })
→ Future <(Mat , Mat ) >
BatchDistance is a naive nearest neighbor finder.
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.
bitwiseAND (InputArray src1 , InputArray src2 , {OutputArray ? dst , InputArray ? mask })
→ Mat
BitwiseAnd computes bitwise conjunction of the two arrays (dst = src1 & src2).
Calculates the per-element bit-wise conjunction of two arrays
or an array and a scalar.
bitwiseANDAsync (InputArray src1 , InputArray src2 , {InputArray ? mask })
→ Future <Mat >
BitwiseAnd computes bitwise conjunction of the two arrays (dst = src1 & src2).
Calculates the per-element bit-wise conjunction of two arrays
or an array and a scalar.
bitwiseNOT (InputArray src , {OutputArray ? dst , InputArray ? mask })
→ Mat
BitwiseNot inverts every bit of an array.
bitwiseNOTAsync (InputArray src , {InputArray ? mask })
→ Future <Mat >
BitwiseNot inverts every bit of an array.
bitwiseOR (InputArray src1 , InputArray src2 , {OutputArray ? dst , InputArray ? mask })
→ Mat
BitwiseOr calculates the per-element bit-wise disjunction of two arrays
or an array and a scalar.
bitwiseORAsync (InputArray src1 , InputArray src2 , {InputArray ? mask })
→ Future <Mat >
BitwiseOr calculates the per-element bit-wise disjunction of two arrays
or an array and a scalar.
bitwiseXOR (InputArray src1 , InputArray src2 , {OutputArray ? dst , InputArray ? mask })
→ Mat
BitwiseXor calculates the per-element bit-wise "exclusive or" operation
on two arrays or an array and a scalar.
bitwiseXORAsync (InputArray src1 , InputArray src2 , {InputArray ? mask })
→ Future <Mat >
BitwiseXor calculates the per-element bit-wise "exclusive or" operation
on two arrays or an array and a scalar.
blobFromImage (InputArray image , {double scalefactor = 1.0 , (int , int ) size = (0, 0) , Scalar ? mean , bool swapRB = false , bool crop = false , int ddepth = MatType.CV_32F })
→ Mat
Creates 4-dimensional blob from image.
Optionally resizes and crops image from center,
subtract mean values, scales values by scalefactor, swap Blue and Red channels.
blobFromImageAsync (InputArray image , {double scalefactor = 1.0 , (int , int ) size = (0, 0) , Scalar ? mean , bool swapRB = false , bool crop = false , int ddepth = MatType.CV_32F })
→ Future <Mat >
blobFromImages (VecMat images , {Mat ? blob , double scalefactor = 1.0 , (int , int ) size = (0, 0) , Scalar ? mean , bool swapRB = false , bool crop = false , int ddepth = MatType.CV_32F })
→ Mat
Creates 4-dimensional blob from series of images.
Optionally resizes and crops images from center,
subtract mean values, scales values by scalefactor,
swap Blue and Red channels.
https://docs.opencv.org/4.x/d6/d0f/group__dnn.html#ga0b7b7c3c530b747ef738178835e1e70f
blobFromImagesAsync (VecMat images , {double scalefactor = 1.0 , (int , int ) size = (0, 0) , Scalar ? mean , bool swapRB = false , bool crop = false , int ddepth = MatType.CV_32F })
→ Future <Mat >
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.
boolCompleter (Completer <bool > completer , VoidPtr p )
→ void
borderInterpolate (int p , int len , int borderType )
→ int
BorderInterpolate computes the source location of an extrapolated pixel.
borderInterpolateAsync (int p , int len , int borderType )
→ Future <int >
BorderInterpolate computes the source location of an extrapolated pixel.
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.
calcCovarMatrix (InputArray samples , InputOutputArray mean , int flags , {OutputArray ? covar , int ctype = MatType.CV_64F })
→ (Mat , Mat )
CalcCovarMatrix calculates the covariance matrix of a set of vectors.
calcCovarMatrixAsync (InputArray samples , InputOutputArray mean , int flags , {int ctype = MatType.CV_64F })
→ Future <(Mat , Mat ) >
CalcCovarMatrix calculates the covariance matrix of a set of vectors.
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
calcOpticalFlowFarneback (InputArray prev , InputArray next , InputOutputArray flow , double pyrScale , int levels , int winsize , int iterations , int polyN , double polySigma , int flags )
→ Mat
Apply computes a foreground mask using the current BackgroundSubtractorMOG2.
calcOpticalFlowFarnebackAsync (InputArray prev , InputArray next , InputOutputArray flow , double pyrScale , int levels , int winsize , int iterations , int polyN , double polySigma , int flags )
→ Future <Mat >
Apply computes a foreground mask using the current BackgroundSubtractorMOG2.
calcOpticalFlowPyrLK (InputArray prevImg , InputArray nextImg , VecPoint2f prevPts , VecPoint2f nextPts , {VecUChar ? status , VecF32 ? err , (int , int ) winSize = (21, 21) , int maxLevel = 3 , (int , int , double ) criteria = (TERM_COUNT + TERM_EPS, 30, 1e-4) , int flags = 0 , double minEigThreshold = 1e-4 })
→ (VecPoint2f , VecUChar ? , VecF32 ? )
CalcOpticalFlowPyrLK calculates an optical flow for a sparse feature set using
the iterative Lucas-Kanade method with pyramids.
calcOpticalFlowPyrLKAsync (InputArray prevImg , InputArray nextImg , VecPoint2f prevPts , VecPoint2f nextPts , {(int , int ) winSize = (21, 21) , int maxLevel = 3 , (int , int , double ) criteria = (TERM_COUNT + TERM_EPS, 30, 1e-4) , int flags = 0 , double minEigThreshold = 1e-4 })
→ Future <(VecPoint2f , VecUChar , VecF32 ) >
CalcOpticalFlowPyrLK calculates an optical flow for a sparse feature set using
the iterative Lucas-Kanade method with pyramids.
calibrateCamera (Contours3f objectPoints , Contours2f imagePoints , (int , int ) imageSize , InputOutputArray cameraMatrix , InputOutputArray distCoeffs , {Mat ? rvecs , Mat ? tvecs , int flags = 0 , (int , int , double ) criteria = (TERM_COUNT + TERM_EPS, 30, 1e-4) })
→ (double , Mat , Mat , Mat , Mat )
calibrateCameraAsync (Contours3f objectPoints , Contours2f imagePoints , (int , int ) imageSize , InputOutputArray cameraMatrix , InputOutputArray distCoeffs , {Mat ? rvecs , Mat ? tvecs , int flags = 0 , (int , int , double ) criteria = (TERM_COUNT + TERM_EPS, 30, 1e-4) })
→ Future <(double , Mat , Mat , Mat , Mat ) >
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
cartToPolar (InputArray x , InputArray y , {OutputArray ? magnitude , OutputArray ? angle , bool angleInDegrees = false })
→ (Mat , Mat )
CartToPolar calculates the magnitude and angle of 2D vectors.
cartToPolarAsync (InputArray x , InputArray y , {bool angleInDegrees = false })
→ Future <(Mat , Mat ) >
CartToPolar calculates the magnitude and angle of 2D vectors.
checkRange (InputArray a , {bool quiet = true , double minVal = -CV_F64_MAX , double maxVal = CV_F64_MAX })
→ (bool , Point )
CheckRange checks every element of an input array for invalid values.
checkRangeAsync (InputArray a , {bool quiet = true , double minVal = -CV_F64_MAX , double maxVal = CV_F64_MAX })
→ Future <(bool , Point ) >
CheckRange checks every element of an input array for invalid values.
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
colorChange (InputArray src , InputArray mask , {double redMul = 1.0 , double greenMul = 1.0 , double blueMul = 1.0 })
→ Mat
ColorChange mix two differently colored versions of an image seamlessly.
For further details, please see:
https://docs.opencv.org/master/df/da0/group__photo__clone.html#ga6684f35dc669ff6196a7c340dc73b98e
colorChangeAsync (InputArray src , InputArray mask , {double redMul = 1.0 , double greenMul = 1.0 , double blueMul = 1.0 })
→ Future <Mat >
compare (InputArray src1 , InputArray src2 , int cmpop , {OutputArray ? dst })
→ Mat
Compare performs the per-element comparison of two arrays
or an array and scalar value.
compareAsync (InputArray src1 , InputArray src2 , int cmpop )
→ Future <Mat >
Compare performs the per-element comparison of two arrays
or an array and scalar value.
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
completeSymm (InputOutputArray m , {bool lowerToUpper = false })
→ Mat
CompleteSymm copies the lower or the upper half of a square matrix to its another half.
completeSymmAsync (InputOutputArray m , {bool lowerToUpper = false })
→ Future <Mat >
CompleteSymm copies the lower or the upper half of a square matrix to its another half.
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.
convertScaleAbs (InputArray src , {OutputArray ? dst , double alpha = 1 , double beta = 0 })
→ Mat
ConvertScaleAbs scales, calculates absolute values, and converts the result to 8-bit.
convertScaleAbsAsync (InputArray src , {double alpha = 1 , double beta = 0 })
→ Future <Mat >
ConvertScaleAbs scales, calculates absolute values, and converts the result to 8-bit.
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.
copyMakeBorder (InputArray src , int top , int bottom , int left , int right , int borderType , {OutputArray ? dst , Scalar ? value })
→ Mat
CopyMakeBorder forms a border around an image (applies padding).
copyMakeBorderAsync (InputArray src , int top , int bottom , int left , int right , int borderType , {Scalar ? value })
→ Future <Mat >
CopyMakeBorder forms a border around an image (applies padding).
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.
countNonZero (Mat src )
→ int
CountNonZero counts non-zero array elements.
countNonZeroAsync (Mat src )
→ Future <int >
CountNonZero counts non-zero array elements.
createBackgroundSubtractorMOG2 ({int history = 500 , double varThreshold = 16 , bool detectShadows = true })
→ BackgroundSubtractorMOG2
NewBackgroundSubtractorMOG2 returns a new BackgroundSubtractor algorithm
of type MOG2. MOG2 is a Gaussian Mixture-based Background/Foreground
Segmentation Algorithm.
createBackgroundSubtractorMOG2Async ({int history = 500 , double varThreshold = 16 , bool detectShadows = true })
→ Future <BackgroundSubtractorMOG2 >
NewBackgroundSubtractorMOG2 returns a new BackgroundSubtractor algorithm
of type MOG2. MOG2 is a Gaussian Mixture-based Background/Foreground
Segmentation Algorithm.
cvAssert (bool condition , [String ? msg ])
→ void
cvRun (Pointer <CvStatus > func () )
→ void
cvRunArena <R > (R computation (Arena arena ), [Allocator wrappedAllocator = calloc , bool keep = false ])
→ R
cvRunAsync <T > (Pointer <CvStatus > func (CvCallback_1 callback ), void onComplete (Completer <T > completer , VoidPtr p ) )
→ Future <T >
cvRunAsync0 <T > (Pointer <CvStatus > func (CvCallback_0 callback ), void onComplete (Completer <T > completer ) )
→ Future <T >
cvRunAsync2 <T > (Pointer <CvStatus > func (CvCallback_2 callback ), void onComplete (Completer <T > completer , VoidPtr p , VoidPtr p1 ) )
→ Future <T >
cvRunAsync3 <T > (Pointer <CvStatus > func (CvCallback_3 callback ), void onComplete (Completer <T > completer , VoidPtr p , VoidPtr p1 , VoidPtr p2 ) )
→ Future <T >
cvRunAsync4 <T > (Pointer <CvStatus > func (CvCallback_4 callback ), void onComplete (Completer <T > completer , VoidPtr p , VoidPtr p1 , VoidPtr p2 , VoidPtr p3 ) )
→ Future <T >
cvRunAsync5 <T > (Pointer <CvStatus > func (CvCallback_5 callback ), void onComplete (Completer <T > completer , VoidPtr p , VoidPtr p1 , VoidPtr p2 , VoidPtr p3 , VoidPtr p4 ) )
→ Future <T >
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.
dct (InputArray src , {OutputArray ? dst , int flags = 0 })
→ Mat
DCT performs a forward or inverse discrete Cosine transform of 1D or 2D array.
dctAsync (InputArray src , {int flags = 0 })
→ Future <Mat >
DCT performs a forward or inverse discrete Cosine transform of 1D or 2D array.
detailEnhance (InputArray src , {double sigmaS = 10 , double sigmaR = 0.15 })
→ Mat
DetailEnhance filter enhances the details of a particular image
For further details, please see:
https://docs.opencv.org/4.x/df/dac/group__photo__render.html#ga0de660cb6f371a464a74c7b651415975
detailEnhanceAsync (InputArray src , {double sigmaS = 10 , double sigmaR = 0.15 })
→ Future <Mat >
determinant (InputArray mtx )
→ double
Determinant returns the determinant of a square floating-point matrix.
determinantAsync (InputArray mtx )
→ Future <double >
Determinant returns the determinant of a square floating-point matrix.
dft (InputArray src , {OutputArray ? dst , int flags = 0 , int nonzeroRows = 0 })
→ Mat
DFT performs a forward or inverse Discrete Fourier Transform (DFT)
of a 1D or 2D floating-point array.
dftAsync (InputArray src , {int flags = 0 , int nonzeroRows = 0 })
→ Future <Mat >
DFT performs a forward or inverse Discrete Fourier Transform (DFT)
of a 1D or 2D floating-point array.
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.
divide (InputArray src1 , InputArray src2 , {OutputArray ? dst , double scale = 1 , int dtype = -1 })
→ Mat
Divide performs the per-element division
on two arrays or an array and a scalar.
divideAsync (InputArray src1 , InputArray src2 , {double scale = 1 , int dtype = -1 })
→ Future <Mat >
Divide performs the per-element division
on two arrays or an array and a scalar.
doubleCompleter (Completer <double > completer , VoidPtr p )
→ void
drawChessboardCorners (InputOutputArray image , (int , int ) patternSize , InputArray corners , bool patternWasFound )
→ Mat
drawChessboardCornersAsync (InputOutputArray image , (int , int ) patternSize , InputArray corners , bool patternWasFound )
→ Future <Mat >
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.
drawKeyPoints (Mat src , VecKeyPoint keypoints , Mat dst , Scalar color , DrawMatchesFlag flag )
→ void
drawKeyPointsAsync (Mat src , VecKeyPoint keypoints , Mat dst , Scalar color , DrawMatchesFlag flag )
→ Future <void >
drawMatches (InputArray img1 , VecKeyPoint keypoints1 , InputArray img2 , VecKeyPoint keypoints2 , VecDMatch matches1to2 , InputOutputArray outImg , {Scalar ? matchColor , Scalar ? singlePointColor , VecChar ? matchesMask , DrawMatchesFlag flags = DrawMatchesFlag.DEFAULT })
→ void
DrawMatches draws matches on combined train and querry images.
drawMatchesAsync (InputArray img1 , VecKeyPoint keypoints1 , InputArray img2 , VecKeyPoint keypoints2 , VecDMatch matches1to2 , InputOutputArray outImg , {Scalar ? matchColor , Scalar ? singlePointColor , VecChar ? matchesMask , DrawMatchesFlag flags = DrawMatchesFlag.DEFAULT })
→ Future <void >
DrawMatches draws matches on combined train and querry images.
edgePreservingFilter (InputArray src , {int flags = 1 , double sigmaS = 60 , double sigmaR = 0.4 })
→ Mat
EdgePreservingFilter filtering is the fundamental operation in image and video processing.
Edge-preserving smoothing filters are used in many different applications.
For further details, please see:
https://docs.opencv.org/4.x/df/dac/group__photo__render.html#gafaee2977597029bc8e35da6e67bd31f7
edgePreservingFilterAsync (InputArray src , {int flags = 1 , double sigmaS = 60 , double sigmaR = 0.4 })
→ Future <Mat >
eigen (InputArray src , {OutputArray ? eigenvalues , OutputArray ? eigenvectors })
→ (bool , Mat , Mat )
Eigen calculates eigenvalues and eigenvectors of a symmetric matrix.
eigenAsync (InputArray src )
→ Future <(bool , Mat , Mat ) >
Eigen calculates eigenvalues and eigenvectors of a symmetric matrix.
eigenNonSymmetric (InputArray src , {OutputArray ? eigenvalues , OutputArray ? eigenvectors })
→ (Mat , Mat )
EigenNonSymmetric calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
eigenNonSymmetricAsync (InputArray src )
→ Future <(Mat , Mat ) >
EigenNonSymmetric calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
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.
estimateAffine2D (VecPoint2f from , VecPoint2f to , {int method = RANSAC , double ransacReprojThreshold = 3 , int maxIters = 2000 , double confidence = 0.99 , int refineIters = 10 , OutputArray ? inliers })
→ (Mat , Mat )
estimateAffine2DAsync (VecPoint2f from , VecPoint2f to , {int method = RANSAC , double ransacReprojThreshold = 3 , int maxIters = 2000 , double confidence = 0.99 , int refineIters = 10 })
→ Future <(Mat , Mat ) >
estimateAffinePartial2D (VecPoint2f from , VecPoint2f to , {int method = RANSAC , double ransacReprojThreshold = 3 , int maxIters = 2000 , double confidence = 0.99 , int refineIters = 10 , OutputArray ? inliers })
→ (Mat , Mat )
estimateAffinePartial2DAsync (VecPoint2f from , VecPoint2f to , {int method = RANSAC , double ransacReprojThreshold = 3 , int maxIters = 2000 , double confidence = 0.99 , int refineIters = 10 })
→ Future <(Mat , Mat ) >
exp (InputArray src , {OutputArray ? dst })
→ Mat
Exp calculates the exponent of every array element.
expAsync (InputArray src )
→ Future <Mat >
Exp calculates the exponent of every array element.
ExtractChannel extracts a single channel from src (coi is 0-based index).
ExtractChannel extracts a single channel from src (coi is 0-based index).
fastNlMeansDenoising (InputArray src , {double h = 3 , int templateWindowSize = 7 , int searchWindowSize = 21 })
→ Mat
FastNlMeansDenoising performs image denoising using Non-local Means Denoising algorithm
http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/
For further details, please see:
https://docs.opencv.org/4.x/d1/d79/group__photo__denoise.html#ga4c6b0031f56ea3f98f768881279ffe93
fastNlMeansDenoisingAsync (InputArray src , {double h = 3 , int templateWindowSize = 7 , int searchWindowSize = 21 })
→ Future <Mat >
fastNlMeansDenoisingColored (InputArray src , {double h = 3 , double hColor = 3 , int templateWindowSize = 7 , int searchWindowSize = 21 })
→ Mat
FastNlMeansDenoisingColored is a modification of fastNlMeansDenoising function for colored images.
For further details, please see:
https://docs.opencv.org/4.x/d1/d79/group__photo__denoise.html#ga21abc1c8b0e15f78cd3eff672cb6c476
fastNlMeansDenoisingColoredAsync (InputArray src , {double h = 3 , double hColor = 3 , int templateWindowSize = 7 , int searchWindowSize = 21 })
→ Future <Mat >
fastNlMeansDenoisingColoredMulti (VecMat srcImgs , int imgToDenoiseIndex , int temporalWindowSize , {double h = 3 , double hColor = 3 , int templateWindowSize = 7 , int searchWindowSize = 21 })
→ Mat
FastNlMeansDenoisingColoredMulti denoises the selected images.
For further details, please see:
https://docs.opencv.org/master/d1/d79/group__photo__denoise.html#gaa501e71f52fb2dc17ff8ca5e7d2d3619
fastNlMeansDenoisingColoredMultiAsync (VecMat srcImgs , int imgToDenoiseIndex , int temporalWindowSize , {double h = 3 , double hColor = 3 , int templateWindowSize = 7 , int searchWindowSize = 21 })
→ Future <Mat >
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.
findChessboardCorners (InputArray image , (int , int ) patternSize , {OutputArray ? corners , int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE })
→ (bool , Mat )
findChessboardCornersAsync (InputArray image , (int , int ) patternSize , {int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE })
→ Future <(bool , Mat ) >
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)
findNonZero (InputArray src , {OutputArray ? idx })
→ Mat
FindNonZero returns the list of locations of non-zero pixels.
findNonZeroAsync (InputArray src )
→ Future <Mat >
FindNonZero returns the list of locations of non-zero pixels.
findTransformECC (InputArray templateImage , InputArray inputImage , InputOutputArray warpMatrix , int motionType , (int , int , double ) criteria , InputArray inputMask , int gaussFiltSize )
→ (double , Mat )
FindTransformECC finds the geometric transform (warp) between two images in terms of the ECC criterion.
findTransformECCAsync (InputArray templateImage , InputArray inputImage , InputOutputArray warpMatrix , int motionType , (int , int , double ) criteria , InputArray inputMask , int gaussFiltSize )
→ Future <(double , Mat ) >
FindTransformECC finds the geometric transform (warp) between two images in terms of the ECC criterion.
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
flip (InputArray src , int flipCode , {OutputArray ? dst })
→ Mat
Flip flips a 2D array around horizontal(0), vertical(1), or both axes(-1).
flipAsync (InputArray src , int flipCode )
→ Future <Mat >
Flip flips a 2D array around horizontal(0), vertical(1), or both axes(-1).
float16 (int w )
→ double
float16Inv (double x )
→ int
floatCompleter (Completer <double > completer , VoidPtr p )
→ void
floodFill (InputOutputArray image , Point seedPoint , Scalar newVal , {InputOutputArray ? mask , Scalar ? loDiff , Scalar ? upDiff , int flags = 4 })
→ (int , Mat , Mat , Rect )
Fills a connected component with the given color.
floodFillAsync (InputOutputArray image , Point seedPoint , Scalar newVal , {InputOutputArray ? mask , Scalar ? loDiff , Scalar ? upDiff , int flags = 4 })
→ Future <(int , Mat , Mat , Rect ) >
Fills a connected component with the given color.
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.
gemm (InputArray src1 , InputArray src2 , double alpha , InputArray src3 , double beta , {OutputArray ? dst , int flags = 0 })
→ Mat
Gemm performs generalized matrix multiplication.
gemmAsync (InputArray src1 , InputArray src2 , double alpha , InputArray src3 , double beta , {int flags = 0 })
→ Future <Mat >
Gemm performs generalized matrix multiplication.
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.
getBlobChannel (Mat blob , int imgidx , int chnidx )
→ Mat
GetBlobChannel extracts a single (2d)channel from a 4 dimensional blob structure
(this might e.g. contain the results of a SSD or YOLO detection,
getBlobChannelAsync (Mat blob , int imgidx , int chnidx )
→ Future <Mat >
getBlobSize (Mat blob )
→ Scalar
GetBlobSize retrieves the 4 dimensional size information in (N,C,H,W) order
getBlobSizeAsync (Mat blob )
→ Future <Scalar >
getBuildInformation ()
→ String
Returns full configuration time cmake output.
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.
getLogLevel ()
→ int
Gets the global logging level.
getNumThreads ()
→ int
Get the number of threads for OpenCV.
getOptimalDFTSize (int vecsize )
→ int
GetOptimalDFTSize returns the optimal Discrete Fourier Transform (DFT) size
for a given vector size.
getOptimalDFTSizeAsync (int vecsize )
→ Future <int >
GetOptimalDFTSize returns the optimal Discrete Fourier Transform (DFT) size
for a given vector size.
getOptimalNewCameraMatrix (InputArray cameraMatrix , InputArray distCoeffs , (int , int ) imageSize , double alpha , {(int , int ) newImgSize = (0, 0) , bool centerPrincipalPoint = false })
→ (Mat , Rect )
GetOptimalNewCameraMatrixWithParams computes and returns the optimal new camera matrix based on the free scaling parameter.
getOptimalNewCameraMatrixAsync (InputArray cameraMatrix , InputArray distCoeffs , (int , int ) imageSize , double alpha , {(int , int ) newImgSize = (0, 0) , bool centerPrincipalPoint = false })
→ Future <(Mat , Rect ) >
GetOptimalNewCameraMatrixWithParams computes and returns the optimal new camera matrix based on the free scaling parameter.
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.
getTickCount ()
→ int
GetTickCount returns the number of ticks.
getTickFrequency ()
→ double
GetTickFrequency returns the number of ticks per second.
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
groupRectangles (VecRect rects , int groupThreshold , double eps )
→ VecRect
groupRectanglesAsync (VecRect rects , int groupThreshold , double eps )
→ Future <VecRect >
hconcat (InputArray src1 , InputArray src2 , {OutputArray ? dst })
→ Mat
Hconcat applies horizontal concatenation to given matrices.
hconcatAsync (InputArray src1 , InputArray src2 )
→ Future <Mat >
Hconcat applies horizontal concatenation to given matrices.
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
idct (InputArray src , {OutputArray ? dst , int flags = 0 })
→ Mat
IDCT calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
idctAsync (InputArray src , {int flags = 0 })
→ Future <Mat >
IDCT calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
idft (InputArray src , {OutputArray ? dst , int flags = 0 , int nonzeroRows = 0 })
→ Mat
IDFT calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
idftAsync (InputArray src , {int flags = 0 , int nonzeroRows = 0 })
→ Future <Mat >
IDFT calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
illuminationChange (InputArray src , InputArray mask , {double alpha = 0.2 , double beta = 0.4 })
→ Mat
IlluminationChange modifies locally the apparent illumination of an image.
For further details, please see:
https://docs.opencv.org/master/df/da0/group__photo__clone.html#gac5025767cf2febd8029d474278e886c7
illuminationChangeAsync (InputArray src , InputArray mask , {double alpha = 0.2 , double beta = 0.4 })
→ Future <Mat >
imagesFromBlob (Mat blob )
→ List <Mat >
ImagesFromBlob Parse a 4D blob and output the images it contains as
2D arrays through a simpler data structure (std::vectorcv::Mat ).
imagesFromBlobAsync (Mat blob )
→ Future <List <Mat > >
imdecode (Uint8List buf , int flags , {Mat ? dst })
→ Mat
imdecode reads an image from a buffer in memory.
The function imdecode reads an image from the specified buffer in memory.
If the buffer is too short or contains invalid data, the function
returns an empty matrix.
@param buf Input array or vector of bytes.
@param flags The same flags as in cv::imread, see cv::ImreadModes.
For further details, please see:
https://docs.opencv.org/master/d4/da8/group__imgcodecs.html#ga26a67788faa58ade337f8d28ba0eb19e
imdecodeAsync (Uint8List buf , int flags )
→ Future <Mat >
imdecode reads an image from a buffer in memory.
The function imdecode reads an image from the specified buffer in memory.
If the buffer is too short or contains invalid data, the function
returns an empty matrix.
@param buf Input array or vector of bytes.
@param flags The same flags as in cv::imread, see cv::ImreadModes.
For further details, please see:
https://docs.opencv.org/master/d4/da8/group__imgcodecs.html#ga26a67788faa58ade337f8d28ba0eb19e
imencode (String ext , InputArray img , {VecI32 ? params })
→ (bool , Uint8List )
IMEncode encodes an image Mat into a memory buffer.
This function compresses the image and stores it in the returned memory buffer,
using the image format passed in in the form of a file extension string.
imencodeAsync (String ext , InputArray img , {VecI32 ? params })
→ Future <(bool , Uint8List ) >
IMEncode encodes an image Mat into a memory buffer.
This function compresses the image and stores it in the returned memory buffer,
using the image format passed in in the form of a file extension string.
imread (String filename , {int flags = IMREAD_COLOR })
→ Mat
IMRead reads an image from a file into a Mat.
The flags param is one of the IMReadFlag flags.
If the image cannot be read (because of missing file, improper permissions,
unsupported or invalid format), the function returns an empty Mat.
imreadAsync (String filename , {int flags = IMREAD_COLOR })
→ Future <Mat >
IMRead reads an image from a file into a Mat.
The flags param is one of the IMReadFlag flags.
If the image cannot be read (because of missing file, improper permissions,
unsupported or invalid format), the function returns an empty Mat.
imwrite (String filename , InputArray img , {VecI32 ? params })
→ bool
IMWrite writes a Mat to an image file.
imwriteAsync (String filename , InputArray img , {VecI32 ? params })
→ Future <bool >
IMWrite writes a Mat to an image file.
initUndistortRectifyMap (InputArray cameraMatrix , InputArray distCoeffs , InputArray R , InputArray newCameraMatrix , (int , int ) size , int m1type , {OutputArray ? map1 , OutputArray ? map2 })
→ (Mat , Mat )
InitUndistortRectifyMap computes the joint undistortion and rectification transformation and represents the result in the form of maps for remap
initUndistortRectifyMapAsync (InputArray cameraMatrix , InputArray distCoeffs , InputArray R , InputArray newCameraMatrix , (int , int ) size , int m1type )
→ Future <(Mat , Mat ) >
InitUndistortRectifyMap computes the joint undistortion and rectification transformation and represents the result in the form of maps for remap
inpaint (InputArray src , InputArray inpaintMask , double inpaintRadius , int flags )
→ Mat
Inpaint reconstructs the selected image area from the pixel near the area boundary.
The function may be used to remove dust and scratches from a scanned photo, or to
remove undesirable objects from still images or video.
For further details, please see:
https://docs.opencv.org/4.x/d7/d8b/group__photo__inpaint.html#gaedd30dfa0214fec4c88138b51d678085
inpaintAsync (InputArray src , InputArray inpaintMask , double inpaintRadius , int flags )
→ Future <Mat >
inRange (InputArray src , InputArray lowerb , InputArray upperb , {OutputArray ? dst })
→ Mat
InRange checks if array elements lie between the elements of two Mat arrays.
inRangeAsync (InputArray src , InputArray lowerb , InputArray upperb )
→ Future <Mat >
InRange checks if array elements lie between the elements of two Mat arrays.
inRangebyScalar (InputArray src , Scalar lowerb , Scalar upperb , {OutputArray ? dst })
→ Mat
InRangeWithScalar checks if array elements lie between the elements of two Scalars
inRangebyScalarAsync (InputArray src , Scalar lowerb , Scalar upperb )
→ Future <Mat >
InRangeWithScalar checks if array elements lie between the elements of two Scalars
insertChannel (InputArray src , InputOutputArray dst , int coi )
→ Mat
InsertChannel inserts a single channel to dst (coi is 0-based index)
(it replaces channel i with another in dst).
insertChannelAsync (InputArray src , InputOutputArray dst , int coi )
→ Future <Mat >
InsertChannel inserts a single channel to dst (coi is 0-based index)
(it replaces channel i with another in dst).
intCompleter (Completer <int > completer , VoidPtr p )
→ void
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
invert (InputArray src , {OutputArray ? dst , int flags = DECOMP_LU })
→ (double , Mat )
Invert finds the inverse or pseudo-inverse of a matrix.
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.
invertAsync (InputArray src , {int flags = DECOMP_LU })
→ Future <(double , Mat ) >
Invert finds the inverse or pseudo-inverse of a matrix.
kmeans (InputArray data , int K , InputOutputArray bestLabels , (int , int , double ) criteria , int attempts , int flags , {OutputArray ? centers })
→ (double , Mat , Mat )
KMeans finds centers of clusters and groups input samples around the clusters.
kmeansAsync (InputArray data , int K , InputOutputArray bestLabels , (int , int , double ) criteria , int attempts , int flags )
→ Future <(double , Mat , Mat ) >
KMeans finds centers of clusters and groups input samples around the clusters.
kmeansByPoints (VecPoint2f pts , int K , InputOutputArray bestLabels , (int , int , double ) criteria , int attempts , int flags , {OutputArray ? centers })
→ (double , Mat , Mat )
KMeansPoints finds centers of clusters and groups input samples around the clusters.
kmeansByPointsAsync (VecPoint2f pts , int K , InputOutputArray bestLabels , (int , int , double ) criteria , int attempts , int flags )
→ Future <(double , Mat , Mat ) >
KMeansPoints finds centers of clusters and groups input samples around the clusters.
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.
log (InputArray src , {OutputArray ? dst })
→ Mat
Log calculates the natural logarithm of every array element.
logAsync (InputArray src )
→ Future <Mat >
Log calculates the natural logarithm of every array element.
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.
LUT (InputArray src , InputArray lut , {OutputArray ? dst })
→ Mat
Performs a look-up table transform of an array. Support CV_8U, CV_8S, CV_16U, CV_16S
LUTAsync (InputArray src , InputArray lut )
→ Future <Mat >
Performs a look-up table transform of an array. Support CV_8U, CV_8S, CV_16U, CV_16S
magnitude (InputArray x , InputArray y , {OutputArray ? magnitude })
→ Mat
Magnitude calculates the magnitude of 2D vectors.
magnitudeAsync (InputArray x , InputArray y )
→ Future <Mat >
Magnitude calculates the magnitude of 2D vectors.
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.
matCompleter (Completer <Mat > completer , VoidPtr p )
→ void
matCompleter2 (Completer <(Mat , Mat ) > completer , VoidPtr p , VoidPtr p1 )
→ void
matCompleter3 (Completer <(Mat , Mat , Mat ) > completer , VoidPtr p , VoidPtr p1 , VoidPtr p2 )
→ void
max (InputArray src1 , InputArray src2 , {OutputArray ? dst })
→ Mat
Max calculates per-element maximum of two arrays or an array and a scalar.
maxAsync (InputArray src1 , InputArray src2 )
→ Future <Mat >
Max calculates per-element maximum of two arrays or an array and a scalar.
meanStdDev (InputArray src , {InputArray ? mask })
→ (Scalar , Scalar )
MeanStdDev calculates a mean and standard deviation of array elements.
meanStdDevAsync (InputArray src , {InputArray ? mask })
→ Future <(Scalar , Scalar ) >
MeanStdDev calculates a mean and standard deviation of array elements.
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.
merge (VecMat mv , {OutputArray ? dst })
→ Mat
Merge creates one multi-channel array out of several single-channel ones.
mergeAsync (VecMat mv )
→ Future <Mat >
Merge creates one multi-channel array out of several single-channel ones.
min (InputArray src1 , InputArray src2 , {OutputArray ? dst })
→ Mat
Min calculates per-element minimum of two arrays or an array and a scalar.
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.
minAsync (InputArray src1 , InputArray src2 )
→ Future <Mat >
Min calculates per-element minimum of two arrays or an array and a scalar.
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.
minMaxIdx (InputArray src , {InputArray ? mask })
→ (double , double , int , int )
MinMaxIdx finds the global minimum and maximum in an array.
minMaxIdxAsync (InputArray src , {InputArray ? mask })
→ Future <(double , double , int , int ) >
MinMaxIdx finds the global minimum and maximum in an array.
minMaxLoc (InputArray src , {InputArray ? mask })
→ (double , double , Point , Point )
MinMaxLoc finds the global minimum and maximum in an array.
minMaxLocAsync (InputArray src , {InputArray ? mask })
→ Future <(double , double , Point , Point ) >
MinMaxLoc finds the global minimum and maximum in an array.
mixChannels (VecMat src , VecMat dst , VecI32 fromTo )
→ VecMat
Copies specified channels from input arrays to the specified channels of output arrays.
mixChannelsAsync (VecMat src , VecMat dst , VecI32 fromTo )
→ Future <VecMat >
Copies specified channels from input arrays to the specified channels of output arrays.
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.
momentsCompleter (Completer <Moments > completer , VoidPtr p )
→ void
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.
mulSpectrums (InputArray a , InputArray b , int flags , {OutputArray ? c , bool conjB = false })
→ Mat
Mulspectrums performs the per-element multiplication of two Fourier spectrums.
mulSpectrumsAsync (InputArray a , InputArray b , int flags , {bool conjB = false })
→ Future <Mat >
Mulspectrums performs the per-element multiplication of two Fourier spectrums.
multiply (InputArray src1 , InputArray src2 , {OutputArray ? dst , double scale = 1 , int dtype = -1 })
→ Mat
Multiply calculates the per-element scaled product of two arrays.
Both input arrays must be of the same size and the same type.
multiplyAsync (InputArray src1 , InputArray src2 , {double scale = 1 , int dtype = -1 })
→ Future <Mat >
Multiply calculates the per-element scaled product of two arrays.
Both input arrays must be of the same size and the same type.
NMSBoxes (VecRect bboxes , VecF32 scores , double scoreThreshold , double nmsThreshold , {double eta = 1.0 , int topK = 0 })
→ List <int >
NMSBoxes performs non maximum suppression given boxes and corresponding scores.
NMSBoxesAsync (VecRect bboxes , VecF32 scores , double scoreThreshold , double nmsThreshold , {double eta = 1.0 , int topK = 0 })
→ Future <List <int > >
norm (InputArray src1 , {int normType = NORM_L2 , InputArray ? mask })
→ double
Norm calculates the absolute norm of an array.
norm1 (InputArray src1 , InputArray src2 , {int normType = NORM_L2 , InputArray ? mask })
→ double
Norm calculates the absolute difference/relative norm of two arrays.
norm1Async (InputArray src1 , InputArray src2 , {int normType = NORM_L2 })
→ Future <double >
Norm calculates the absolute difference/relative norm of two arrays.
normalize (InputArray src , InputOutputArray dst , {double alpha = 1 , double beta = 0 , int normType = NORM_L2 , int dtype = -1 , InputArray ? mask })
→ Mat
Normalize normalizes the norm or value range of an array.
normalizeAsync (InputArray src , InputOutputArray dst , {double alpha = 1 , double beta = 0 , int normType = NORM_L2 , int dtype = -1 , InputArray ? mask })
→ Future <Mat >
Normalize normalizes the norm or value range of an array.
normAsync (InputArray src1 , {int normType = NORM_L2 , InputArray ? mask })
→ Future <double >
Norm calculates the absolute norm of an array.
OcvFinalizer <T extends NativeType > (NativeFinalizerFunctionT <T > func )
→ NativeFinalizer
openCvVersion ()
→ String
get version
PCABackProjectAsync (Mat src , Mat mean , Mat eigenVectors )
→ Future <(Mat , Mat ) >
PCACompute (InputArray data , InputOutputArray mean , {OutputArray ? eigenvectors , OutputArray ? eigenvalues , int maxComponents = 0 })
→ (Mat , Mat , Mat )
PCACompute performs PCA.
PCACompute1Async (InputArray data , InputOutputArray mean , {int maxComponents = 0 })
→ Future <(Mat , Mat ) >
PCACompute2Async (InputArray data , InputOutputArray mean , {double retainedVariance = 0 })
→ Future <(Mat , Mat ) >
PCACompute3Async (InputArray data , InputOutputArray mean , {double retainedVariance = 0 })
→ Future <(Mat , Mat , Mat ) >
PCAComputeAsync (InputArray data , InputOutputArray mean , {int maxComponents = 0 })
→ Future <(Mat , Mat , Mat ) >
PCACompute performs PCA.
PCAProjectAsync (InputArray src , InputArray mean , InputArray eigenVectors )
→ Future <(Mat , Mat ) >
pencilSketch (InputArray src , {double sigmaS = 60 , double sigmaR = 0.07 , double shadeFactor = 0.02 })
→ (Mat , Mat )
PencilSketch pencil-like non-photorealistic line drawing.
For further details, please see:
https://docs.opencv.org/4.x/df/dac/group__photo__render.html#gae5930dd822c713b36f8529b21ddebd0c
pencilSketchAsync (InputArray src , {double sigmaS = 60 , double sigmaR = 0.07 , double shadeFactor = 0.02 })
→ Future <(Mat , Mat ) >
perspectiveTransform (InputArray src , InputArray m , {OutputArray ? dst })
→ Mat
PerspectiveTransform performs the perspective matrix transformation of vectors.
perspectiveTransformAsync (InputArray src , InputArray m )
→ Future <Mat >
PerspectiveTransform performs the perspective matrix transformation of vectors.
phase (InputArray x , InputArray y , {OutputArray ? angle , bool angleInDegrees = false })
→ Mat
Phase calculates the rotation angle of 2D vectors.
phaseAsync (InputArray x , InputArray y , {bool angleInDegrees = false })
→ Future <Mat >
Phase calculates the rotation angle of 2D vectors.
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.
polarToCart (InputArray magnitude , InputArray angle , {OutputArray ? x , OutputArray ? y , bool angleInDegrees = false })
→ (Mat , Mat )
PolatToCart calculates x and y coordinates of 2D vectors from their magnitude and angle.
polarToCartAsync (InputArray magnitude , InputArray angle , {bool angleInDegrees = false })
→ Future <(Mat , Mat ) >
PolatToCart calculates x and y coordinates of 2D vectors from their magnitude and angle.
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.
pow (InputArray src , double power , {OutputArray ? dst })
→ Mat
Pow raises every array element to a power.
powAsync (InputArray src , double power )
→ Future <Mat >
Pow raises every array element to a power.
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.
randn (InputOutputArray dst , Scalar mean , Scalar stddev )
→ Mat
RandN Fills the array with normally distributed random numbers.
randnAsync (InputOutputArray dst , Scalar mean , Scalar stddev )
→ Future <Mat >
RandN Fills the array with normally distributed random numbers.
randShuffle (InputOutputArray dst , {double iterFactor = 1 , Rng ? rng })
→ Mat
RandShuffle Shuffles the array elements randomly.
randShuffleAsync (InputOutputArray dst , {double iterFactor = 1 , Rng ? rng })
→ Future <Mat >
RandShuffle Shuffles the array elements randomly.
randu (InputOutputArray dst , Scalar low , Scalar high )
→ Mat
RandU Generates a single uniformly-distributed random
number or an array of random numbers.
randuAsync (InputOutputArray dst , Scalar low , Scalar high )
→ Future <Mat >
RandU Generates a single uniformly-distributed random
number or an array of random numbers.
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.
rectCompleter (Completer <Rect > completer , VoidPtr p )
→ void
reduce (InputArray src , int dim , int rtype , {OutputArray ? dst , int dtype = -1 })
→ Mat
Reduce reduces a matrix to a vector.
reduceArgMax (InputArray src , int axis , {OutputArray ? dst , bool lastIndex = false })
→ Mat
Finds indices of max elements along provided axis.
reduceArgMaxAsync (InputArray src , int axis , {bool lastIndex = false })
→ Future <Mat >
Finds indices of max elements along provided axis.
reduceArgMin (InputArray src , int axis , {OutputArray ? dst , bool lastIndex = false })
→ Mat
Finds indices of min elements along provided axis.
reduceArgMinAsync (InputArray src , int axis , {bool lastIndex = false })
→ Future <Mat >
Finds indices of min elements along provided axis.
reduceAsync (InputArray src , int dim , int rtype , {int dtype = -1 })
→ Future <Mat >
Reduce reduces a matrix to a vector.
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.
repeat (InputArray src , int ny , int nx , {OutputArray ? dst })
→ Mat
Repeat fills the output array with repeated copies of the input array.
repeatAsync (InputArray src , int ny , int nx )
→ Future <Mat >
Repeat fills the output array with repeated copies of the input array.
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.
rotate (InputArray src , int rotateCode , {OutputArray ? dst })
→ Mat
Rotate rotates a 2D array in multiples of 90 degrees
rotateAsync (InputArray src , int rotateCode )
→ Future <Mat >
Rotate rotates a 2D array in multiples of 90 degrees
rotatedRectCompleter (Completer <RotatedRect > completer , VoidPtr p )
→ void
scalarCompleter (Completer <Scalar > completer , VoidPtr p )
→ void
scaleAdd (InputArray src1 , double alpha , InputArray src2 , {OutputArray ? dst })
→ Mat
Calculates the sum of a scaled array and another array.
scaleAddAsync (InputArray src1 , double alpha , InputArray src2 )
→ Future <Mat >
Calculates the sum of a scaled array and another array.
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.
seamlessClone (InputArray src , InputArray dst , InputArray mask , Point p , int flags )
→ Mat
SeamlessClone blend two image by Poisson Blending.
For further details, please see:
https://docs.opencv.org/master/df/da0/group__photo__clone.html#ga2bf426e4c93a6b1f21705513dfeca49d
seamlessCloneAsync (InputArray src , InputArray dst , InputArray mask , Point p , int flags )
→ Future <Mat >
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.
setIdentity (InputOutputArray mtx , {double s = 1 })
→ Mat
SetIdentity initializes a scaled identity matrix.
For further details, please see:
setIdentityAsync (InputOutputArray mtx , {Scalar ? s })
→ Future <Mat >
SetIdentity initializes a scaled identity matrix.
For further details, please see:
setLogLevel (int logLevel )
→ void
Sets the global logging level.
setNumThreads (int n )
→ void
Set the number of threads for OpenCV.
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
solve (InputArray src1 , InputArray src2 , {OutputArray ? dst , int flags = DECOMP_LU })
→ (bool , Mat )
Solve solves one or more linear systems or least-squares problems.
solveAsync (InputArray src1 , InputArray src2 , {int flags = DECOMP_LU })
→ Future <(bool , Mat ) >
Solve solves one or more linear systems or least-squares problems.
solveCubic (InputArray coeffs , {OutputArray ? roots })
→ (int , Mat )
SolveCubic finds the real roots of a cubic equation.
solveCubicAsync (InputArray coeffs )
→ Future <(int , Mat ) >
SolveCubic finds the real roots of a cubic equation.
solvePoly (InputArray coeffs , {OutputArray ? roots , int maxIters = 300 })
→ (double , Mat )
SolvePoly finds the real or complex roots of a polynomial equation.
solvePolyAsync (InputArray coeffs , {int maxIters = 300 })
→ Future <(double , Mat ) >
SolvePoly finds the real or complex roots of a polynomial equation.
sort (InputArray src , int flags , {OutputArray ? dst })
→ Mat
Sort sorts each row or each column of a matrix.
sortAsync (InputArray src , int flags )
→ Future <Mat >
Sort sorts each row or each column of a matrix.
sortIdx (InputArray src , int flags , {OutputArray ? dst })
→ Mat
SortIdx sorts each row or each column of a matrix.
Instead of reordering the elements themselves, it stores the indices of sorted elements in the output array
sortIdxAsync (InputArray src , int flags )
→ Future <Mat >
SortIdx sorts each row or each column of a matrix.
Instead of reordering the elements themselves, it stores the indices of sorted elements in the output array
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.
split (InputArray m )
→ VecMat
Split creates an array of single channel images from a multi-channel image
Created images should be closed manualy to avoid memory leaks.
splitAsync (InputArray m )
→ Future <VecMat >
Split creates an array of single channel images from a multi-channel image
Created images should be closed manualy to avoid memory leaks.
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.
sqrt (Mat src , {Mat ? dst })
→ Mat
Calculates a square root of array elements.
stylization (InputArray src , {double sigmaS = 60 , double sigmaR = 0.45 })
→ Mat
Stylization aims to produce digital imagery with a wide variety of effects
not focused on photorealism. Edge-aware filters are ideal for stylization,
as they can abstract regions of low contrast while preserving, or enhancing,
high-contrast features.
For further details, please see:
https://docs.opencv.org/4.x/df/dac/group__photo__render.html#gacb0f7324017df153d7b5d095aed53206
stylizationAsync (InputArray src , {double sigmaS = 60 , double sigmaR = 0.45 })
→ Future <Mat >
subtract (InputArray src1 , InputArray src2 , {OutputArray ? dst , InputArray ? mask , int dtype = -1 })
→ Mat
Subtract calculates the per-element subtraction of two arrays or an array and a scalar.
subtractAsync (InputArray src1 , InputArray src2 , {InputArray ? mask , int dtype = -1 })
→ Future <Mat >
Subtract calculates the per-element subtraction of two arrays or an array and a scalar.
sum (Mat src )
→ Scalar
Calculates the sum of array elements.
textureFlattening (InputArray src , InputArray mask , {double lowThreshold = 30 , double highThreshold = 45 , int kernelSize = 3 })
→ Mat
TextureFlattening washes out the texture of the selected region, giving its contents a flat aspect.
For further details, please see:
https://docs.opencv.org/master/df/da0/group__photo__clone.html#gad55df6aa53797365fa7cc23959a54004
textureFlatteningAsync (InputArray src , InputArray mask , {double lowThreshold = 30 , double highThreshold = 45 , int kernelSize = 3 })
→ Future <Mat >
theRNG ()
→ Rng
TheRNG Returns the default random number generator.
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.
throwIfFailed (Pointer <CvStatus > s )
→ void
trace (InputArray mtx )
→ Scalar
Trace returns the trace of a matrix.
traceAsync (InputArray mtx )
→ Future <Scalar >
Trace returns the trace of a matrix.
transform (InputArray src , InputArray m , {OutputArray ? dst })
→ Mat
Transform performs the matrix transformation of every array element.
transformAsync (InputArray src , InputArray m )
→ Future <Mat >
Transform performs the matrix transformation of every array element.
transpose (InputArray src , {OutputArray ? dst })
→ Mat
Transpose transposes a matrix.
transposeAsync (InputArray src )
→ Future <Mat >
Transpose transposes a matrix.
undistort (InputArray src , InputArray cameraMatrix , InputArray distCoeffs , {OutputArray ? dst , InputArray ? newCameraMatrix })
→ Mat
undistortAsync (InputArray src , InputArray cameraMatrix , InputArray distCoeffs , {InputArray ? newCameraMatrix })
→ Future <Mat >
undistortPoints (InputArray src , InputArray cameraMatrix , InputArray distCoeffs , {OutputArray ? dst , InputArray ? R , InputArray ? P , (int , int , double ) criteria = (TERM_COUNT + TERM_EPS, 30, 1e-4) })
→ Mat
undistortPointsAsync (InputArray src , InputArray cameraMatrix , InputArray distCoeffs , {InputArray ? R , InputArray ? P , (int , int , double ) criteria = (TERM_COUNT + TERM_EPS, 30, 1e-4) })
→ Future <Mat >
vconcat (InputArray src1 , InputArray src2 , {OutputArray ? dst })
→ Mat
Vconcat applies vertical concatenation to given matrices.
vconcatAsync (InputArray src1 , InputArray src2 )
→ Future <Mat >
Vconcat applies vertical concatenation to given matrices.
vecF32Completer (Completer <VecF32 > completer , VoidPtr p )
→ void
vecF64Completer (Completer <VecF64 > completer , VoidPtr p )
→ void
vecI32Completer (Completer <VecI32 > completer , VoidPtr p )
→ void
vecPoint2fCompleter (Completer <VecPoint2f > completer , VoidPtr p )
→ void
vecPointCompleter (Completer <VecPoint > completer , VoidPtr p )
→ void
voidCompleter (Completer <void > completer )
→ void
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 ,