Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

gocv

package module

Go to main page

Versions in this module

v1

v1.23.1

Feb 27, 2023

v1.23.0

Feb 4, 2023

v0

v0.0.6

Mar 7, 2023

v0.0.5

Mar 4, 2023

v0.0.4

Mar 4, 2023

v0.0.3

Feb 27, 2023

Changes in this version

+ func BoundingRect2f(contour Point2fVector) image.Rectangle

v0.0.2

Feb 27, 2023

v0.0.1

Feb 27, 2023

Changes in this version

+ const GoCVVersion

+ const IMWriteJpegChromaQuality

+ const IMWriteJpegLumaQuality

+ const IMWriteJpegOptimize

+ const IMWriteJpegProgressive

+ const IMWriteJpegQuality

+ const IMWriteJpegRstInterval

+ const IMWritePamTupletype

+ const IMWritePngBilevel

+ const IMWritePngCompression

+ const IMWritePngStrategy

+ const IMWritePngStrategyDefault

+ const IMWritePngStrategyFiltered

+ const IMWritePngStrategyFixed

+ const IMWritePngStrategyHuffmanOnly

+ const IMWritePngStrategyRle

+ const IMWritePxmBinary

+ const IMWriteWebpQuality

+ const MatChannels1

+ const MatChannels2

+ const MatChannels3

+ const MatChannels4

+ const MatTypeCV16S

+ const MatTypeCV16SC1

+ const MatTypeCV16SC2

+ const MatTypeCV16SC3

+ const MatTypeCV16SC4

+ const MatTypeCV16U

+ const MatTypeCV16UC1

+ const MatTypeCV16UC2

+ const MatTypeCV16UC3

+ const MatTypeCV16UC4

+ const MatTypeCV32F

+ const MatTypeCV32FC1

+ const MatTypeCV32FC2

+ const MatTypeCV32FC3

+ const MatTypeCV32FC4

+ const MatTypeCV32S

+ const MatTypeCV32SC1

+ const MatTypeCV32SC2

+ const MatTypeCV32SC3

+ const MatTypeCV32SC4

+ const MatTypeCV64F

+ const MatTypeCV64FC1

+ const MatTypeCV64FC2

+ const MatTypeCV64FC3

+ const MatTypeCV64FC4

+ const MatTypeCV8S

+ const MatTypeCV8SC1

+ const MatTypeCV8SC2

+ const MatTypeCV8SC3

+ const MatTypeCV8SC4

+ const MatTypeCV8U

+ const MatTypeCV8UC1

+ const MatTypeCV8UC2

+ const MatTypeCV8UC3

+ const MatTypeCV8UC4

+ const MotionAffine

+ const MotionEuclidean

+ const MotionHomography

+ const MotionTranslation

+ const OptflowFarnebackGaussian

+ const OptflowLkGetMinEigenvals

+ const OptflowUseInitialFlow

+ var ErrEmptyByteSlice = errors.New("empty byte array")

+ func AbsDiff(src1, src2 Mat, dst *Mat)

+ func Accumulate(src Mat, dst *Mat)

+ func AccumulateProduct(src1 Mat, src2 Mat, dst *Mat)

+ func AccumulateProductWithMask(src1 Mat, src2 Mat, dst *Mat, mask Mat)

+ func AccumulateSquare(src Mat, dst *Mat)

+ func AccumulateSquareWithMask(src Mat, dst *Mat, mask Mat)

+ func AccumulateWithMask(src Mat, dst *Mat, mask Mat)

+ func AccumulatedWeighted(src Mat, dst *Mat, alpha float64)

+ func AccumulatedWeightedWithMask(src Mat, dst *Mat, alpha float64, mask Mat)

+ func AdaptiveThreshold(src Mat, dst *Mat, maxValue float32, adaptiveTyp AdaptiveThresholdType, ...)

+ func Add(src1, src2 Mat, dst *Mat)

+ func AddWeighted(src1 Mat, alpha float64, src2 Mat, beta float64, gamma float64, dst *Mat)

+ func ApplyColorMap(src Mat, dst *Mat, colormapType ColormapTypes)

+ func ApplyCustomColorMap(src Mat, dst *Mat, customColormap Mat)

+ func ArcLength(curve PointVector, isClosed bool) float64

+ func ArrowedLine(img *Mat, pt1 image.Point, pt2 image.Point, c color.RGBA, thickness int)

+ func ArucoDrawDetectedMarkers(img Mat, markerCorners [][]Point2f, markerIds []int, borderColor Scalar)

+ func ArucoGenerateImageMarker(dictionaryId ArucoDictionaryCode, id int, sidePixels int, img Mat, ...)

+ func BatchDistance(src1 Mat, src2 Mat, dist Mat, dtype MatType, nidx Mat, normType NormType, ...)

+ func BilateralFilter(src Mat, dst *Mat, diameter int, sigmaColor float64, sigmaSpace float64)

+ func BitwiseAnd(src1 Mat, src2 Mat, dst *Mat)

+ func BitwiseAndWithMask(src1 Mat, src2 Mat, dst *Mat, mask Mat)

+ func BitwiseNot(src1 Mat, dst *Mat)

+ func BitwiseNotWithMask(src1 Mat, dst *Mat, mask Mat)

+ func BitwiseOr(src1 Mat, src2 Mat, dst *Mat)

+ func BitwiseOrWithMask(src1 Mat, src2 Mat, dst *Mat, mask Mat)

+ func BitwiseXor(src1 Mat, src2 Mat, dst *Mat)

+ func BitwiseXorWithMask(src1 Mat, src2 Mat, dst *Mat, mask Mat)

+ func BlobFromImages(imgs []Mat, blob *Mat, scaleFactor float64, size image.Point, mean Scalar, ...)

+ func Blur(src Mat, dst *Mat, ksize image.Point)

+ func BorderInterpolate(p int, len int, borderType CovarFlags) int

+ func BoundingRect(contour PointVector) image.Rectangle

+ func BoxFilter(src Mat, dst *Mat, depth int, ksize image.Point)

+ func BoxPoints(rect RotatedRect, pts *Mat)

+ func CalcBackProject(src []Mat, channels []int, hist Mat, backProject *Mat, ranges []float64, ...)

+ func CalcCovarMatrix(samples Mat, covar *Mat, mean *Mat, flags CovarFlags, ctype MatType)

+ func CalcHist(src []Mat, channels []int, mask Mat, hist *Mat, size []int, ranges []float64, ...)

+ func CalcOpticalFlowFarneback(prevImg Mat, nextImg Mat, flow *Mat, pyrScale float64, levels int, winsize int, ...)

+ func CalcOpticalFlowPyrLK(prevImg Mat, nextImg Mat, prevPts Mat, nextPts Mat, status *Mat, err *Mat)

+ func CalcOpticalFlowPyrLKWithParams(prevImg Mat, nextImg Mat, prevPts Mat, nextPts Mat, status *Mat, err *Mat, ...)

+ func CalibrateCamera(objectPoints Points3fVector, imagePoints Points2fVector, imageSize image.Point, ...) float64

+ func Canny(src Mat, edges *Mat, t1 float32, t2 float32)

+ func CartToPolar(x Mat, y Mat, magnitude *Mat, angle *Mat, angleInDegrees bool)

+ func CheckRange(src Mat) bool

+ func Circle(img *Mat, center image.Point, radius int, c color.RGBA, thickness int)

+ func CircleWithParams(img *Mat, center image.Point, radius int, c color.RGBA, thickness int, ...)

+ func ClipLine(imgSize image.Point, pt1 image.Point, pt2 image.Point) bool

+ func ColorChange(src, mask Mat, dst *Mat, red_mul, green_mul, blue_mul float32)

+ func Compare(src1 Mat, src2 Mat, dst *Mat, ct CompareType)

+ func CompareHist(hist1 Mat, hist2 Mat, method HistCompMethod) float32

+ func CompleteSymm(m Mat, lowerToUpper bool)

+ func ConnectedComponents(src Mat, labels *Mat) int

+ func ConnectedComponentsWithParams(src Mat, labels *Mat, conn int, ltype MatType, ...) int

+ func ConnectedComponentsWithStats(src Mat, labels *Mat, stats *Mat, centroids *Mat) int

+ func ConnectedComponentsWithStatsWithParams(src Mat, labels *Mat, stats *Mat, centroids *Mat, conn int, ltype MatType, ...) int

+ func ContourArea(contour PointVector) float64

+ func ConvertScaleAbs(src Mat, dst *Mat, alpha float64, beta float64)

+ func ConvexHull(points PointVector, hull *Mat, clockwise bool, returnPoints bool)

+ func ConvexityDefects(contour PointVector, hull Mat, result *Mat)

+ func CopyMakeBorder(src Mat, dst *Mat, top int, bottom int, left int, right int, bt BorderType, ...)

+ func CornerSubPix(img Mat, corners *Mat, winSize image.Point, zeroZone image.Point, ...)

+ func CountNonZero(src Mat) int

+ func CvtColor(src Mat, dst *Mat, code ColorConversionCode)

+ func DCT(src Mat, dst *Mat, flags DftFlags)

+ func DFT(src Mat, dst *Mat, flags DftFlags)

+ func DetailEnhance(src Mat, dst *Mat, sigma_s, sigma_r float32)

+ func Determinant(src Mat) float64

+ func Dilate(src Mat, dst *Mat, kernel Mat)

+ func DilateWithParams(src Mat, dst *Mat, kernel Mat, anchor image.Point, ...)

+ func DistanceTransform(src Mat, dst *Mat, labels *Mat, distType DistanceTypes, ...)

+ func Divide(src1 Mat, src2 Mat, dst *Mat)

+ func DrawChessboardCorners(image *Mat, patternSize image.Point, corners Mat, patternWasFound bool)

+ func DrawContours(img *Mat, contours PointsVector, contourIdx int, c color.RGBA, thickness int)

+ func DrawContoursWithParams(img *Mat, contours PointsVector, contourIdx int, c color.RGBA, thickness int, ...)

+ func DrawKeyPoints(src Mat, keyPoints []KeyPoint, dst *Mat, color color.RGBA, ...)

+ func DrawMatches(img1 Mat, kp1 []KeyPoint, img2 Mat, kp2 []KeyPoint, matches1to2 []DMatch, ...)

+ func EdgePreservingFilter(src Mat, dst *Mat, filter EdgeFilter, sigma_s, sigma_r float32)

+ func Eigen(src Mat, eigenvalues *Mat, eigenvectors *Mat) bool

+ func EigenNonSymmetric(src Mat, eigenvalues *Mat, eigenvectors *Mat)

+ func Ellipse(img *Mat, center, axes image.Point, angle, startAngle, endAngle float64, ...)

+ func EllipseWithParams(img *Mat, center, axes image.Point, angle, startAngle, endAngle float64, ...)

+ func EqualizeHist(src Mat, dst *Mat)

+ func Erode(src Mat, dst *Mat, kernel Mat)

+ func ErodeWithParams(src Mat, dst *Mat, kernel Mat, anchor image.Point, iterations, borderType int)

+ func EstimateNewCameraMatrixForUndistortRectify(k, d Mat, imgSize image.Point, r Mat, p *Mat, balance float64, ...)

+ func Exp(src Mat, dst *Mat)

+ func ExtractChannel(src Mat, dst *Mat, coi int)

+ func FP16BlobFromImage(img Mat, scaleFactor float32, size image.Point, mean float32, swapRB bool, ...) []byte

+ func FastNlMeansDenoising(src Mat, dst *Mat)

+ func FastNlMeansDenoisingColored(src Mat, dst *Mat)

+ func FastNlMeansDenoisingColoredMulti(src []Mat, dst *Mat, imgToDenoiseIndex int, temporalWindowSize int)

+ func FastNlMeansDenoisingColoredMultiWithParams(src []Mat, dst *Mat, imgToDenoiseIndex int, temporalWindowSize int, h float32, ...)

+ func FastNlMeansDenoisingColoredWithParams(src Mat, dst *Mat, h float32, hColor float32, templateWindowSize int, ...)

+ func FastNlMeansDenoisingWithParams(src Mat, dst *Mat, h float32, templateWindowSize int, searchWindowSize int)

+ func FillPoly(img *Mat, pts PointsVector, c color.RGBA)

+ func FillPolyWithParams(img *Mat, pts PointsVector, c color.RGBA, lineType LineType, shift int, ...)

+ func Filter2D(src Mat, dst *Mat, ddepth MatType, kernel Mat, anchor image.Point, ...)

+ func FindChessboardCorners(image Mat, patternSize image.Point, corners *Mat, flags CalibCBFlag) bool

+ func FindChessboardCornersSB(image Mat, patternSize image.Point, corners *Mat, flags CalibCBFlag) bool

+ func FindChessboardCornersSBWithMeta(image Mat, patternSize image.Point, corners *Mat, flags CalibCBFlag, meta *Mat) bool

+ func FindNonZero(src Mat, idx *Mat)

+ func FindTransformECC(templateImage Mat, inputImage Mat, warpMatrix *Mat, motionType int, ...) float64

+ func FisheyeUndistortImage(distorted Mat, undistorted *Mat, k, d Mat)

+ func FisheyeUndistortImageWithParams(distorted Mat, undistorted *Mat, k, d, knew Mat, size image.Point)

+ func FisheyeUndistortPoints(distorted Mat, undistorted *Mat, k, d, r, p Mat)

+ func FitLine(pts PointVector, line *Mat, distType DistanceTypes, param, reps, aeps float64)

+ func Flip(src Mat, dst *Mat, flipCode int)

+ func GaussianBlur(src Mat, dst *Mat, ksize image.Point, sigmaX float64, sigmaY float64, ...)

+ func Gemm(src1, src2 Mat, alpha float64, src3 Mat, beta float64, dst *Mat, flags int)

+ func GetNumThreads() int

+ func GetOptimalDFTSize(vecsize int) int

+ func GetRectSubPix(src Mat, patchSize image.Point, center image.Point, dst *Mat)

+ func GetTextSize(text string, fontFace HersheyFont, fontScale float64, thickness int) image.Point

+ func GetTextSizeWithBaseline(text string, fontFace HersheyFont, fontScale float64, thickness int) (image.Point, int)

+ func GetTickCount() float64

+ func GetTickFrequency() float64

+ func GoodFeaturesToTrack(img Mat, corners *Mat, maxCorners int, quality float64, minDist float64)

+ func GrabCut(img Mat, mask *Mat, r image.Rectangle, bgdModel *Mat, fgdModel *Mat, ...)

+ func GroupRectangles(rects []image.Rectangle, groupThreshold int, eps float64) []image.Rectangle

+ func Hconcat(src1, src2 Mat, dst *Mat)

+ func HoughCircles(src Mat, circles *Mat, method HoughMode, dp, minDist float64)

+ func HoughCirclesWithParams(src Mat, circles *Mat, method HoughMode, dp, minDist, param1, param2 float64, ...)

+ func HoughLines(src Mat, lines *Mat, rho float32, theta float32, threshold int)

+ func HoughLinesP(src Mat, lines *Mat, rho float32, theta float32, threshold int)

+ func HoughLinesPWithParams(src Mat, lines *Mat, rho float32, theta float32, threshold int, ...)

+ func HoughLinesPointSet(points Mat, lines *Mat, linesMax int, threshold int, minRho float32, ...)

+ func IDCT(src Mat, dst *Mat, flags int)

+ func IDFT(src Mat, dst *Mat, flags, nonzeroRows int)

+ func IMDecodeIntoMat(buf []byte, flags IMReadFlag, dest *Mat) error

+ func IMWrite(name string, img Mat) bool

+ func IMWriteWithParams(name string, img Mat, params []int) bool

+ func IlluminationChange(src, mask Mat, dst *Mat, alpha, beta float32)

+ func ImagesFromBlob(blob Mat, imgs []Mat)

+ func InRange(src, lb, ub Mat, dst *Mat)

+ func InRangeWithScalar(src Mat, lb, ub Scalar, dst *Mat)

+ func InitUndistortRectifyMap(cameraMatrix Mat, distCoeffs Mat, r Mat, newCameraMatrix Mat, size image.Point, ...)

+ func Inpaint(src Mat, mask Mat, dst *Mat, inpaintRadius float32, ...)

+ func InsertChannel(src Mat, dst *Mat, coi int)

+ func Integral(src Mat, sum *Mat, sqsum *Mat, tilted *Mat)

+ func Invert(src Mat, dst *Mat, flags SolveDecompositionFlags) float64

+ func InvertAffineTransform(src Mat, dst *Mat)

+ func KMeans(data Mat, k int, bestLabels *Mat, criteria TermCriteria, attempts int, ...) float64

+ func KMeansPoints(points PointVector, k int, bestLabels *Mat, criteria TermCriteria, ...) float64

+ func LUT(src, wbLUT Mat, dst *Mat)

+ func Laplacian(src Mat, dst *Mat, dDepth MatType, size int, scale float64, delta float64, ...)

+ func Line(img *Mat, pt1 image.Point, pt2 image.Point, c color.RGBA, thickness int)

+ func LinearPolar(src Mat, dst *Mat, center image.Point, maxRadius float64, ...)

+ func Log(src Mat, dst *Mat)

+ func LogPolar(src Mat, dst *Mat, center image.Point, m float64, flags InterpolationFlags)

+ func Magnitude(x, y Mat, magnitude *Mat)

+ func MatchShapes(contour1 PointVector, contour2 PointVector, method ShapeMatchModes, ...) float64

+ func MatchTemplate(image Mat, templ Mat, result *Mat, method TemplateMatchMode, mask Mat)

+ func Max(src1, src2 Mat, dst *Mat)

+ func MeanStdDev(src Mat, dst *Mat, dstStdDev *Mat)

+ func MedianBlur(src Mat, dst *Mat, ksize int)

+ func Merge(mv []Mat, dst *Mat)

+ func Min(src1, src2 Mat, dst *Mat)

+ func MinEnclosingCircle(pts PointVector) (x, y, radius float32)

+ func MinMaxIdx(input Mat) (minVal, maxVal float32, minIdx, maxIdx int)

+ func MinMaxLoc(input Mat) (minVal, maxVal float32, minLoc, maxLoc image.Point)

+ func MixChannels(src []Mat, dst []Mat, fromTo []int)

+ func Moments(src Mat, binaryImage bool) map[string]float64

+ func MorphologyEx(src Mat, dst *Mat, op MorphType, kernel Mat)

+ func MorphologyExWithParams(src Mat, dst *Mat, op MorphType, kernel Mat, iterations int, ...)

+ func MulSpectrums(a Mat, b Mat, dst *Mat, flags DftFlags)

+ func Multiply(src1 Mat, src2 Mat, dst *Mat)

+ func MultiplyWithParams(src1 Mat, src2 Mat, dst *Mat, scale float64, dtype MatType)

+ func NMSBoxes(bboxes []image.Rectangle, scores []float32, scoreThreshold float32, ...)

+ func NMSBoxesWithParams(bboxes []image.Rectangle, scores []float32, scoreThreshold float32, ...)

+ func Norm(src1 Mat, normType NormType) float64

+ func NormWithMats(src1 Mat, src2 Mat, normType NormType) float64

+ func Normalize(src Mat, dst *Mat, alpha float64, beta float64, typ NormType)

+ func OpenCVVersion() string

+ func PencilSketch(src Mat, dst1, dst2 *Mat, sigma_s, sigma_r, shade_factor float32)

+ func PerspectiveTransform(src Mat, dst *Mat, tm Mat)

+ func Phase(x, y Mat, angle *Mat, angleInDegrees bool)

+ func PointPolygonTest(pts PointVector, pt image.Point, measureDist bool) float64

+ func PolarToCart(magnitude Mat, degree Mat, x *Mat, y *Mat, angleInDegrees bool)

+ func Polylines(img *Mat, pts PointsVector, isClosed bool, c color.RGBA, thickness int)

+ func Pow(src Mat, power float64, dst *Mat)

+ func PutText(img *Mat, text string, org image.Point, fontFace HersheyFont, ...)

+ func PutTextWithParams(img *Mat, text string, org image.Point, fontFace HersheyFont, ...)

+ func PyrDown(src Mat, dst *Mat, ksize image.Point, borderType BorderType)

+ func PyrUp(src Mat, dst *Mat, ksize image.Point, borderType BorderType)

+ func RandN(mat *Mat, mean, stddev Scalar)

+ func RandShuffle(mat *Mat)

+ func RandShuffleWithParams(mat *Mat, iterFactor float64, rng RNG)

+ func RandU(mat *Mat, low, high Scalar)

+ func Rectangle(img *Mat, r image.Rectangle, c color.RGBA, thickness int)

+ func RectangleWithParams(img *Mat, r image.Rectangle, c color.RGBA, thickness int, lineType LineType, ...)

+ func Reduce(src Mat, dst *Mat, dim int, rType ReduceTypes, dType MatType)

+ func Remap(src Mat, dst, map1, map2 *Mat, interpolation InterpolationFlags, ...)

+ func Repeat(src Mat, nY int, nX int, dst *Mat)

+ func Resize(src Mat, dst *Mat, sz image.Point, fx, fy float64, interp InterpolationFlags)

+ func Rotate(src Mat, dst *Mat, code RotateFlag)

+ func SVDCompute(src Mat, w, u, vt *Mat)

+ func ScaleAdd(src1 Mat, alpha float64, src2 Mat, dst *Mat)

+ func Scharr(src Mat, dst *Mat, dDepth MatType, dx int, dy int, scale float64, ...)

+ func SeamlessClone(src, dst, mask Mat, p image.Point, blend *Mat, flags SeamlessCloneFlags)

+ func SelectROI(name string, img Mat) image.Rectangle

+ func SelectROIs(name string, img Mat) []image.Rectangle

+ func SepFilter2D(src Mat, dst *Mat, ddepth MatType, kernelX, kernelY Mat, anchor image.Point, ...)

+ func SetIdentity(src Mat, scalar float64)

+ func SetNumThreads(n int)

+ func SetRNGSeed(seed int)

+ func Sobel(src Mat, dst *Mat, ddepth MatType, dx, dy, ksize int, scale, delta float64, ...)

+ func Solve(src1 Mat, src2 Mat, dst *Mat, flags SolveDecompositionFlags) bool

+ func SolveCubic(coeffs Mat, roots *Mat) int

+ func SolvePoly(coeffs Mat, roots *Mat, maxIters int) float64

+ func Sort(src Mat, dst *Mat, flags SortFlags)

+ func SortIdx(src Mat, dst *Mat, flags SortFlags)

+ func SpatialGradient(src Mat, dx, dy *Mat, ksize MatType, borderType BorderType)

+ func SqBoxFilter(src Mat, dst *Mat, depth int, ksize image.Point)

+ func Stylization(src Mat, dst *Mat, sigma_s, sigma_r float32)

+ func Subtract(src1 Mat, src2 Mat, dst *Mat)

+ func TextureFlattening(src, mask Mat, dst *Mat, lowThreshold, highThreshold float32, kernelSize int)

+ func Threshold(src Mat, dst *Mat, thresh float32, maxvalue float32, typ ThresholdType) (threshold float32)

+ func Transform(src Mat, dst *Mat, tm Mat)

+ func Transpose(src Mat, dst *Mat)

+ func Undistort(src Mat, dst *Mat, cameraMatrix Mat, distCoeffs Mat, newCameraMatrix Mat)

+ func UndistortPoints(src Mat, dst *Mat, ...)

+ func Vconcat(src1, src2 Mat, dst *Mat)

+ func Version() string

+ func WaitKey(delay int) int

+ func WarpAffine(src Mat, dst *Mat, m Mat, sz image.Point)

+ func WarpAffineWithParams(src Mat, dst *Mat, m Mat, sz image.Point, flags InterpolationFlags, ...)

+ func WarpPerspective(src Mat, dst *Mat, m Mat, sz image.Point)

+ func WarpPerspectiveWithParams(src Mat, dst *Mat, m Mat, sz image.Point, flags InterpolationFlags, ...)

+ func Watershed(image Mat, markers *Mat)

+ type AKAZE struct

+ func NewAKAZE() AKAZE

+ func (a *AKAZE) Close() error

+ func (a *AKAZE) Detect(src Mat) []KeyPoint

+ func (a *AKAZE) DetectAndCompute(src Mat, mask Mat) ([]KeyPoint, Mat)

+ type AdaptiveThresholdType int

+ const AdaptiveThresholdGaussian

+ const AdaptiveThresholdMean

+ func (c AdaptiveThresholdType) String() string

+ type AgastFeatureDetector struct

+ func NewAgastFeatureDetector() AgastFeatureDetector

+ func (a *AgastFeatureDetector) Close() error

+ func (a *AgastFeatureDetector) Detect(src Mat) []KeyPoint

+ type AlignMTB struct

+ func NewAlignMTB() AlignMTB

+ func NewAlignMTBWithParams(max_bits int, exclude_range int, cut bool) AlignMTB

+ func (b *AlignMTB) Close() error

+ func (b *AlignMTB) Process(src []Mat, dst *[]Mat)

+ type ArucoDetector struct

+ func NewArucoDetector() ArucoDetector

+ func NewArucoDetectorWithParams(dictionary ArucoDictionary, params ArucoDetectorParameters) ArucoDetector

+ func (a *ArucoDetector) Close() error

+ func (a *ArucoDetector) DetectMarkers(input Mat) (markerCorners [][]Point2f, markerIds []int, rejectedCandidates [][]Point2f)

+ type ArucoDetectorParameters struct

+ func NewArucoDetectorParameters() ArucoDetectorParameters

+ func (ap *ArucoDetectorParameters) GetAdaptiveThreshConstant() float64

+ func (ap *ArucoDetectorParameters) GetAdaptiveThreshWinSizeMax() int

+ func (ap *ArucoDetectorParameters) GetAdaptiveThreshWinSizeMin() int

+ func (ap *ArucoDetectorParameters) GetAdaptiveThreshWinSizeStep() int

+ func (ap *ArucoDetectorParameters) GetAprilTagCriticalRad() float32

+ func (ap *ArucoDetectorParameters) GetAprilTagDeglitch() int

+ func (ap *ArucoDetectorParameters) GetAprilTagMaxLineFitMse() float32

+ func (ap *ArucoDetectorParameters) GetAprilTagMaxNmaxima() int

+ func (ap *ArucoDetectorParameters) GetAprilTagMinClusterPixels() int

+ func (ap *ArucoDetectorParameters) GetAprilTagMinWhiteBlackDiff() int

+ func (ap *ArucoDetectorParameters) GetAprilTagQuadDecimate() float32

+ func (ap *ArucoDetectorParameters) GetAprilTagQuadSigma() float32

+ func (ap *ArucoDetectorParameters) GetCornerRefinementMaxIterations() int

+ func (ap *ArucoDetectorParameters) GetCornerRefinementMethod() int

+ func (ap *ArucoDetectorParameters) GetCornerRefinementMinAccuracy() float64

+ func (ap *ArucoDetectorParameters) GetCornerRefinementWinSize() int

+ func (ap *ArucoDetectorParameters) GetDetectInvertedMarker() bool

+ func (ap *ArucoDetectorParameters) GetErrorCorrectionRate() float64

+ func (ap *ArucoDetectorParameters) GetMarkerBorderBits() int

+ func (ap *ArucoDetectorParameters) GetMaxErroneousBitsInBorderRate() float64

+ func (ap *ArucoDetectorParameters) GetMaxMarkerPerimeterRate() float64

+ func (ap *ArucoDetectorParameters) GetMinCornerDistanceRate() float64

+ func (ap *ArucoDetectorParameters) GetMinDistanceToBorder() int

+ func (ap *ArucoDetectorParameters) GetMinMarkerDistanceRate() float64

+ func (ap *ArucoDetectorParameters) GetMinMarkerPerimeterRate() float64

+ func (ap *ArucoDetectorParameters) GetMinOtsuStdDev() float64

+ func (ap *ArucoDetectorParameters) GetPerspectiveRemoveIgnoredMarginPerCell() float64

+ func (ap *ArucoDetectorParameters) GetPerspectiveRemovePixelPerCell() int

+ func (ap *ArucoDetectorParameters) GetPolygonalApproxAccuracyRate() float64

+ func (ap *ArucoDetectorParameters) SetAdaptiveThreshConstant(adaptiveThreshConstant float64)

+ func (ap *ArucoDetectorParameters) SetAdaptiveThreshWinSizeMax(adaptiveThreshWinSizeMax int)

+ func (ap *ArucoDetectorParameters) SetAdaptiveThreshWinSizeMin(adaptiveThreshWinSizeMin int)

+ func (ap *ArucoDetectorParameters) SetAdaptiveThreshWinSizeStep(adaptiveThreshWinSizeStep int)

+ func (ap *ArucoDetectorParameters) SetAprilTagCriticalRad(aprilTagCriticalRad float32)

+ func (ap *ArucoDetectorParameters) SetAprilTagDeglitch(aprilTagDeglitch int)

+ func (ap *ArucoDetectorParameters) SetAprilTagMaxLineFitMse(aprilTagMaxLineFitMse float32)

+ func (ap *ArucoDetectorParameters) SetAprilTagMaxNmaxima(aprilTagMaxNmaxima int)

+ func (ap *ArucoDetectorParameters) SetAprilTagMinClusterPixels(aprilTagMinClusterPixels int)

+ func (ap *ArucoDetectorParameters) SetAprilTagMinWhiteBlackDiff(aprilTagMinWhiteBlackDiff int)

+ func (ap *ArucoDetectorParameters) SetAprilTagQuadDecimate(aprilTagQuadDecimate float32)

+ func (ap *ArucoDetectorParameters) SetAprilTagQuadSigma(aprilTagQuadSigma float32)

+ func (ap *ArucoDetectorParameters) SetCornerRefinementMaxIterations(cornerRefinementMaxIterations int)

+ func (ap *ArucoDetectorParameters) SetCornerRefinementMethod(cornerRefinementMethod int)

+ func (ap *ArucoDetectorParameters) SetCornerRefinementMinAccuracy(cornerRefinementMinAccuracy float64)

+ func (ap *ArucoDetectorParameters) SetCornerRefinementWinSize(cornerRefinementWinSize int)

+ func (ap *ArucoDetectorParameters) SetDetectInvertedMarker(detectInvertedMarker bool)

+ func (ap *ArucoDetectorParameters) SetErrorCorrectionRate(errorCorrectionRate float64)

+ func (ap *ArucoDetectorParameters) SetMarkerBorderBits(markerBorderBits int)

+ func (ap *ArucoDetectorParameters) SetMaxErroneousBitsInBorderRate(maxErroneousBitsInBorderRate float64)

+ func (ap *ArucoDetectorParameters) SetMaxMarkerPerimeterRate(maxMarkerPerimeterRate float64)

+ func (ap *ArucoDetectorParameters) SetMinCornerDistanceRate(minCornerDistanceRate float64)

+ func (ap *ArucoDetectorParameters) SetMinDistanceToBorder(minDistanceToBorder int)

+ func (ap *ArucoDetectorParameters) SetMinMarkerDistanceRate(minMarkerDistanceRate float64)

+ func (ap *ArucoDetectorParameters) SetMinMarkerPerimeterRate(minMarkerPerimeterRate float64)

+ func (ap *ArucoDetectorParameters) SetMinOtsuStdDev(minOtsuStdDev float64)

+ func (ap *ArucoDetectorParameters) SetPerspectiveRemoveIgnoredMarginPerCell(perspectiveRemoveIgnoredMarginPerCell float64)

+ func (ap *ArucoDetectorParameters) SetPerspectiveRemovePixelPerCell(perspectiveRemovePixelPerCell int)

+ func (ap *ArucoDetectorParameters) SetPolygonalApproxAccuracyRate(polygonalApproxAccuracyRate float64)

+ type ArucoDictionary struct

+ func GetPredefinedDictionary(dictionaryId ArucoDictionaryCode) ArucoDictionary

+ type ArucoDictionaryCode int

+ const ArucoDict4x4_100

+ const ArucoDict4x4_1000

+ const ArucoDict4x4_250

+ const ArucoDict4x4_50

+ const ArucoDict5x5_100

+ const ArucoDict5x5_1000

+ const ArucoDict5x5_250

+ const ArucoDict5x5_50

+ const ArucoDict6x6_100

+ const ArucoDict6x6_1000

+ const ArucoDict6x6_250

+ const ArucoDict6x6_50

+ const ArucoDict7x7_100

+ const ArucoDict7x7_1000

+ const ArucoDict7x7_250

+ const ArucoDict7x7_50

+ const ArucoDictAprilTag_16h5

+ const ArucoDictAprilTag_25h9

+ const ArucoDictAprilTag_36h10

+ const ArucoDictAprilTag_36h11

+ const ArucoDictArucoOriginal

+ type BFMatcher struct

+ func NewBFMatcher() BFMatcher

+ func NewBFMatcherWithParams(normType NormType, crossCheck bool) BFMatcher

+ func (b *BFMatcher) Close() error

+ func (b *BFMatcher) KnnMatch(query, train Mat, k int) [][]DMatch

+ type BRISK struct

+ func NewBRISK() BRISK

+ func (b *BRISK) Close() error

+ func (b *BRISK) Detect(src Mat) []KeyPoint

+ func (b *BRISK) DetectAndCompute(src Mat, mask Mat) ([]KeyPoint, Mat)

+ type BackgroundSubtractorKNN struct

+ func NewBackgroundSubtractorKNN() BackgroundSubtractorKNN

+ func NewBackgroundSubtractorKNNWithParams(history int, dist2Threshold float64, detectShadows bool) BackgroundSubtractorKNN

+ func (k *BackgroundSubtractorKNN) Apply(src Mat, dst *Mat)

+ func (k *BackgroundSubtractorKNN) Close() error

+ type BackgroundSubtractorMOG2 struct

+ func NewBackgroundSubtractorMOG2() BackgroundSubtractorMOG2

+ func NewBackgroundSubtractorMOG2WithParams(history int, varThreshold float64, detectShadows bool) BackgroundSubtractorMOG2

+ func (b *BackgroundSubtractorMOG2) Apply(src Mat, dst *Mat)

+ func (b *BackgroundSubtractorMOG2) Close() error

+ type BorderType int

+ const BorderConstant

+ const BorderDefault

+ const BorderIsolated

+ const BorderReflect

+ const BorderReflect101

+ const BorderReplicate

+ const BorderTransparent

+ const BorderWrap

+ func (c BorderType) String() string

+ type CLAHE struct

+ func NewCLAHE() CLAHE

+ func NewCLAHEWithParams(clipLimit float64, tileGridSize image.Point) CLAHE

+ func (c *CLAHE) Apply(src Mat, dst *Mat)

+ func (c *CLAHE) Close() error

+ type CalibCBFlag int

+ const CalibCBAccuracy

+ const CalibCBAdaptiveThresh

+ const CalibCBExhaustive

+ const CalibCBFastCheck

+ const CalibCBFilterQuads

+ const CalibCBLarger

+ const CalibCBMarker

+ const CalibCBNormalizeImage

+ func (c CalibCBFlag) String() string

+ type CalibFlag int32

+ const CalibCheckCond

+ const CalibFixIntrinsic

+ const CalibFixK1

+ const CalibFixK2

+ const CalibFixK3

+ const CalibFixK4

+ const CalibFixPrincipalPoint

+ const CalibFixSkew

+ const CalibRecomputeExtrinsic

+ const CalibUseIntrinsicGuess

+ func (c CalibFlag) String() string

+ type CascadeClassifier struct

+ func NewCascadeClassifier() CascadeClassifier

+ func (c *CascadeClassifier) Close() error

+ func (c *CascadeClassifier) DetectMultiScale(img Mat) []image.Rectangle

+ func (c *CascadeClassifier) DetectMultiScaleWithParams(img Mat, scale float64, minNeighbors, flags int, minSize, maxSize image.Point) []image.Rectangle

+ func (c *CascadeClassifier) Load(name string) bool

+ type ColorConversionCode int

+ const ColorBGR555ToBGR

+ const ColorBGR555ToBGRA

+ const ColorBGR555ToGRAY

+ const ColorBGR555ToRGB

+ const ColorBGR555ToRGBA

+ const ColorBGR565ToBGR

+ const ColorBGR565ToBGRA

+ const ColorBGR565ToGray

+ const ColorBGR565ToRGB

+ const ColorBGR565ToRGBA

+ const ColorBGRAToBGR

+ const ColorBGRAToBGR555

+ const ColorBGRAToBGR565

+ const ColorBGRAToGray

+ const ColorBGRAToRGBA

+ const ColorBGRAToYUVI420

+ const ColorBGRAToYUVYV12

+ const ColorBGRToBGR555

+ const ColorBGRToBGR565

+ const ColorBGRToBGRA

+ const ColorBGRToGray

+ const ColorBGRToHLS

+ const ColorBGRToHLSFull

+ const ColorBGRToHSV

+ const ColorBGRToHSVFull

+ const ColorBGRToLab

+ const ColorBGRToLuv

+ const ColorBGRToRGB

+ const ColorBGRToRGBA

+ const ColorBGRToXYZ

+ const ColorBGRToYCrCb

+ const ColorBGRToYUV

+ const ColorBGRToYUVI420

+ const ColorBGRToYUVYV12

+ const ColorBayerBGToBGR

+ const ColorBayerBGToBGRA

+ const ColorBayerBGToBGREA

+ const ColorBayerBGToBGRVNG

+ const ColorBayerBGToGRAY

+ const ColorBayerGBToBGR

+ const ColorBayerGBToBGRA

+ const ColorBayerGBToBGREA

+ const ColorBayerGBToBGRVNG

+ const ColorBayerGBToGRAY

+ const ColorBayerGRToBGR

+ const ColorBayerGRToBGRA

+ const ColorBayerGRToBGREA

+ const ColorBayerGRToBGRVNG

+ const ColorBayerGRToGRAY

+ const ColorBayerRGToBGR

+ const ColorBayerRGToBGRA

+ const ColorBayerRGToBGREA

+ const ColorBayerRGToBGRVNG

+ const ColorBayerRGToGRAY

+ const ColorCOLORCVTMAX

+ const ColorGrayToBGR

+ const ColorGrayToBGR555

+ const ColorGrayToBGR565

+ const ColorGrayToBGRA

+ const ColorHLSToBGR

+ const ColorHLSToBGRFull

+ const ColorHLSToRGB

+ const ColorHLSToRGBFull

+ const ColorHSVToBGR

+ const ColorHSVToBGRFull

+ const ColorHSVToRGB

+ const ColorHSVToRGBFull

+ const ColorLBGRToLab

+ const ColorLBGRToLuv

+ const ColorLRGBToLab

+ const ColorLRGBToLuv

+ const ColorLabToBGR

+ const ColorLabToLBGR

+ const ColorLabToLRGB

+ const ColorLabToRGB

+ const ColorLuvToBGR

+ const ColorLuvToLBGR

+ const ColorLuvToLRGB

+ const ColorLuvToRGB

+ const ColorRGBAToBGR

+ const ColorRGBAToBGR555

+ const ColorRGBAToBGR565

+ const ColorRGBAToGray

+ const ColorRGBAToYUVI420

+ const ColorRGBAToYUVYV12

+ const ColorRGBATomRGBA

+ const ColorRGBToBGR555

+ const ColorRGBToBGR565

+ const ColorRGBToGray

+ const ColorRGBToHLS

+ const ColorRGBToHLSFull

+ const ColorRGBToHSV

+ const ColorRGBToHSVFull

+ const ColorRGBToLab

+ const ColorRGBToLuv

+ const ColorRGBToXYZ

+ const ColorRGBToYCrCb

+ const ColorRGBToYUV

+ const ColorRGBToYUVI420

+ const ColorRGBToYUVYV12

+ const ColorXYZToBGR

+ const ColorXYZToRGB

+ const ColorYCrCbToBGR

+ const ColorYCrCbToRGB

+ const ColorYUVToBGR

+ const ColorYUVToBGRAIYUV

+ const ColorYUVToBGRANV12

+ const ColorYUVToBGRANV21

+ const ColorYUVToBGRAUYVY

+ const ColorYUVToBGRAYUY2

+ const ColorYUVToBGRAYV12

+ const ColorYUVToBGRAYVYU

+ const ColorYUVToBGRIYUV

+ const ColorYUVToBGRNV12

+ const ColorYUVToBGRNV21

+ const ColorYUVToBGRUYVY

+ const ColorYUVToBGRYUY2

+ const ColorYUVToBGRYV12

+ const ColorYUVToBGRYVYU

+ const ColorYUVToGRAY420

+ const ColorYUVToGRAYUYVY

+ const ColorYUVToGRAYYUY2

+ const ColorYUVToRGB

+ const ColorYUVToRGBAIYUV

+ const ColorYUVToRGBANV12

+ const ColorYUVToRGBANV21

+ const ColorYUVToRGBAUYVY

+ const ColorYUVToRGBAYUY2

+ const ColorYUVToRGBAYV12

+ const ColorYUVToRGBAYVYU

+ const ColorYUVToRGBIYUV

+ const ColorYUVToRGBNV12

+ const ColorYUVToRGBNV21

+ const ColorYUVToRGBUYVY

+ const ColorYUVToRGBYUY2

+ const ColorYUVToRGBYV12

+ const ColorYUVToRGBYVYU

+ const ColormRGBAToRGBA

+ func (c ColorConversionCode) String() string

+ type ColormapTypes int

+ const ColormapAutumn

+ const ColormapBone

+ const ColormapCool

+ const ColormapHot

+ const ColormapHsv

+ const ColormapJet

+ const ColormapOcean

+ const ColormapParula

+ const ColormapPink

+ const ColormapRainbow

+ const ColormapSpring

+ const ColormapSummer

+ const ColormapWinter

+ func (c ColormapTypes) String() string

+ type CompareType int

+ const CompareEQ

+ const CompareGE

+ const CompareGT

+ const CompareLE

+ const CompareLT

+ const CompareNE

+ func (c CompareType) String() string

+ type ConnectedComponentsAlgorithmType int

+ const CCL_DEFAULT

+ const CCL_GRANA

+ const CCL_WU

+ func (c ConnectedComponentsAlgorithmType) String() string

+ type ConnectedComponentsTypes int

+ const CC_STAT_AREA

+ const CC_STAT_HEIGHT

+ const CC_STAT_LEFT

+ const CC_STAT_MAX

+ const CC_STAT_TOP

+ const CC_STAT_WIDTH

+ func (c ConnectedComponentsTypes) String() string

+ type ContourApproximationMode int

+ const ChainApproxNone

+ const ChainApproxSimple

+ const ChainApproxTC89KCOS

+ const ChainApproxTC89L1

+ func (c ContourApproximationMode) String() string

+ type CovarFlags int

+ const CovarCols

+ const CovarNormal

+ const CovarRows

+ const CovarScale

+ const CovarScrambled

+ const CovarUseAvg

+ func (c CovarFlags) String() string

+ type DMatch struct

+ Distance float64

+ ImgIdx int

+ QueryIdx int

+ TrainIdx int

+ type DftFlags int

+ const DctInverse

+ const DctRows

+ const DftComplexInput

+ const DftComplexOutput

+ const DftForward

+ const DftInverse

+ const DftRealOutput

+ const DftRows

+ const DftScale

+ func (c DftFlags) String() string

+ type DistanceTransformLabelTypes int

+ const DistanceLabelCComp

+ const DistanceLabelPixel

+ func (c DistanceTransformLabelTypes) String() string

+ type DistanceTransformMasks int

+ const DistanceMask3

+ const DistanceMask5

+ const DistanceMaskPrecise

+ func (c DistanceTransformMasks) String() string

+ type DistanceTypes int

+ const DistC

+ const DistFair

+ const DistHuber

+ const DistL1

+ const DistL12

+ const DistL2

+ const DistUser

+ const DistWelsch

+ func (c DistanceTypes) String() string

+ type DrawMatchesFlag int

+ const DrawDefault

+ const DrawOverOutImg

+ const DrawRichKeyPoints

+ const NotDrawSinglePoints

+ func (c DrawMatchesFlag) String() string

+ type EdgeFilter int

+ const NormconvFilter

+ const RecursFilter

+ type FastFeatureDetector struct

+ func NewFastFeatureDetector() FastFeatureDetector

+ func NewFastFeatureDetectorWithParams(threshold int, nonmaxSuppression bool, typ FastFeatureDetectorType) FastFeatureDetector

+ func (f *FastFeatureDetector) Close() error

+ func (f *FastFeatureDetector) Detect(src Mat) []KeyPoint

+ type FastFeatureDetectorType int

+ const FastFeatureDetectorType58

+ const FastFeatureDetectorType712

+ const FastFeatureDetectorType916

+ func (c FastFeatureDetectorType) String() string

+ type FileExt string

+ const GIFFileExt

+ const JPEGFileExt

+ const PNGFileExt

+ type FlannBasedMatcher struct

+ func NewFlannBasedMatcher() FlannBasedMatcher

+ func (f *FlannBasedMatcher) Close() error

+ func (f *FlannBasedMatcher) KnnMatch(query, train Mat, k int) [][]DMatch

+ type GFTTDetector struct

+ func NewGFTTDetector() GFTTDetector

+ func (a *GFTTDetector) Close() error

+ func (a *GFTTDetector) Detect(src Mat) []KeyPoint

+ type GrabCutMode int

+ const GCEval

+ const GCEvalFreezeModel

+ const GCInitWithMask

+ const GCInitWithRect

+ func (c GrabCutMode) String() string

+ type HOGDescriptor struct

+ func NewHOGDescriptor() HOGDescriptor

+ func (h *HOGDescriptor) Close() error

+ func (h *HOGDescriptor) DetectMultiScale(img Mat) []image.Rectangle

+ func (h *HOGDescriptor) DetectMultiScaleWithParams(img Mat, hitThresh float64, winStride, padding image.Point, ...) []image.Rectangle

+ func (h *HOGDescriptor) SetSVMDetector(det Mat) error

+ type HersheyFont int

+ const FontHersheyComplex

+ const FontHersheyComplexSmall

+ const FontHersheyDuplex

+ const FontHersheyPlain

+ const FontHersheyScriptComplex

+ const FontHersheyScriptSimplex

+ const FontHersheySimplex

+ const FontHersheyTriplex

+ const FontItalic

+ func (c HersheyFont) String() string

+ type HistCompMethod int

+ const HistCmpBhattacharya

+ const HistCmpChiSqr

+ const HistCmpChiSqrAlt

+ const HistCmpCorrel

+ const HistCmpHellinger

+ const HistCmpIntersect

+ const HistCmpKlDiv

+ func (c HistCompMethod) String() string

+ type HomographyMethod int

+ const HomograpyMethodAllPoints

+ const HomograpyMethodLMEDS

+ const HomograpyMethodRANSAC

+ type HoughMode int

+ const HoughGradient

+ const HoughMultiScale

+ const HoughProbabilistic

+ const HoughStandard

+ func (c HoughMode) String() string

+ type IMReadFlag int

+ const IMReadAnyColor

+ const IMReadAnyDepth

+ const IMReadColor

+ const IMReadGrayScale

+ const IMReadIgnoreOrientation

+ const IMReadLoadGDAL

+ const IMReadReducedColor2

+ const IMReadReducedColor4

+ const IMReadReducedColor8

+ const IMReadReducedGrayscale2

+ const IMReadReducedGrayscale4

+ const IMReadReducedGrayscale8

+ const IMReadUnchanged

+ type InpaintMethods int

+ const NS

+ const Telea

+ type InterpolationFlags int

+ const InterpolationArea

+ const InterpolationCubic

+ const InterpolationDefault

+ const InterpolationLanczos4

+ const InterpolationLinear

+ const InterpolationMax

+ const InterpolationNearestNeighbor

+ const WarpFillOutliers

+ const WarpInverseMap

+ func (c InterpolationFlags) String() string

+ type KAZE struct

+ func NewKAZE() KAZE

+ func (a *KAZE) Close() error

+ func (a *KAZE) Detect(src Mat) []KeyPoint

+ func (a *KAZE) DetectAndCompute(src Mat, mask Mat) ([]KeyPoint, Mat)

+ type KMeansFlags int

+ const KMeansPPCenters

+ const KMeansRandomCenters

+ const KMeansUseInitialLabels

+ func (c KMeansFlags) String() string

+ type KalmanFilter struct

+ func NewKalmanFilter(dynamParams int, measureParams int) KalmanFilter

+ func NewKalmanFilterWithParams(dynamParams int, measureParams int, controlParams int, matType MatType) KalmanFilter

+ func (kf *KalmanFilter) Close()

+ func (kf *KalmanFilter) Correct(measurement Mat) Mat

+ func (kf *KalmanFilter) GetControlMatrix() Mat

+ func (kf *KalmanFilter) GetErrorCovPost() Mat

+ func (kf *KalmanFilter) GetErrorCovPre() Mat

+ func (kf *KalmanFilter) GetGain() Mat

+ func (kf *KalmanFilter) GetMeasurementMatrix() Mat

+ func (kf *KalmanFilter) GetMeasurementNoiseCov() Mat

+ func (kf *KalmanFilter) GetProcessNoiseCov() Mat

+ func (kf *KalmanFilter) GetStatePost() Mat

+ func (kf *KalmanFilter) GetStatePre() Mat

+ func (kf *KalmanFilter) GetTemp1() Mat

+ func (kf *KalmanFilter) GetTemp2() Mat

+ func (kf *KalmanFilter) GetTemp3() Mat

+ func (kf *KalmanFilter) GetTemp4() Mat

+ func (kf *KalmanFilter) GetTemp5() Mat

+ func (kf *KalmanFilter) GetTransitionMatrix() Mat

+ func (kf *KalmanFilter) Init(dynamParams int, measureParams int)

+ func (kf *KalmanFilter) Predict() Mat

+ func (kf *KalmanFilter) PredictWithParams(control Mat) Mat

+ func (kf *KalmanFilter) SetControlMatrix(controlMatrix Mat)

+ func (kf *KalmanFilter) SetErrorCovPost(errorCovPost Mat)

+ func (kf *KalmanFilter) SetErrorCovPre(errorCovPre Mat)

+ func (kf *KalmanFilter) SetGain(gain Mat)

+ func (kf *KalmanFilter) SetMeasurementMatrix(measurementMatrix Mat)

+ func (kf *KalmanFilter) SetMeasurementNoiseCov(measurementNoiseCov Mat)

+ func (kf *KalmanFilter) SetProcessNoiseCov(processNoiseCov Mat)

+ func (kf *KalmanFilter) SetStatePost(statePost Mat)

+ func (kf *KalmanFilter) SetStatePre(statePre Mat)

+ func (kf *KalmanFilter) SetTransitionMatrix(transitionMatrix Mat)

+ type KeyPoint struct

+ Angle float64

+ ClassID int

+ Octave int

+ Response float64

+ Size float64

+ X float64

+ Y float64

+ type Layer struct

+ func (l *Layer) Close() error

+ func (l *Layer) GetName() string

+ func (l *Layer) GetType() string

+ func (l *Layer) InputNameToIndex(name string) int

+ func (l *Layer) OutputNameToIndex(name string) int

+ type LineType int

+ const Filled

+ const Line4

+ const Line8

+ const LineAA

+ func (c LineType) String() string

+ type MSER struct

+ func NewMSER() MSER

+ func (a *MSER) Close() error

+ func (a *MSER) Detect(src Mat) []KeyPoint

+ type Mat struct

+ func BlobFromImage(img Mat, scaleFactor float64, size image.Point, mean Scalar, swapRB bool, ...) Mat

+ func EstimateAffine2D(from, to Point2fVector) Mat

+ func EstimateAffine2DWithParams(from Point2fVector, to Point2fVector, inliers Mat, method int, ...) Mat

+ func EstimateAffinePartial2D(from, to Point2fVector) Mat

+ func EstimateAffinePartial2DWithParams(from Point2fVector, to Point2fVector, inliers Mat, method int, ...) Mat

+ func Eye(rows int, cols int, mt MatType) Mat

+ func FindHomography(srcPoints Mat, dstPoints *Mat, method HomographyMethod, ...) Mat

+ func GetAffineTransform(src, dst PointVector) Mat

+ func GetAffineTransform2f(src, dst Point2fVector) Mat

+ func GetBlobChannel(blob Mat, imgidx int, chnidx int) Mat

+ func GetGaussianKernel(ksize int, sigma float64) Mat

+ func GetGaussianKernelWithParams(ksize int, sigma float64, ktype MatType) Mat

+ func GetOptimalNewCameraMatrixWithParams(cameraMatrix Mat, distCoeffs Mat, imageSize image.Point, alpha float64, ...) (Mat, image.Rectangle)

+ func GetPerspectiveTransform(src, dst PointVector) Mat

+ func GetPerspectiveTransform2f(src, dst Point2fVector) Mat

+ func GetRotationMatrix2D(center image.Point, angle, scale float64) Mat

+ func GetStructuringElement(shape MorphShape, ksize image.Point) Mat

+ func HOGDefaultPeopleDetector() Mat

+ func IMDecode(buf []byte, flags IMReadFlag) (Mat, error)

+ func IMRead(name string, flags IMReadFlag) Mat

+ func ImageGrayToMatGray(img *image.Gray) (Mat, error)

+ func ImageToMatRGB(img image.Image) (Mat, error)

+ func ImageToMatRGBA(img image.Image) (Mat, error)

+ func NewMat() Mat

+ func NewMatFromBytes(rows int, cols int, mt MatType, data []byte) (Mat, error)

+ func NewMatFromScalar(s Scalar, mt MatType) Mat

+ func NewMatWithSize(rows int, cols int, mt MatType) Mat

+ func NewMatWithSizeFromScalar(s Scalar, rows int, cols int, mt MatType) Mat

+ func NewMatWithSizes(sizes []int, mt MatType) Mat

+ func NewMatWithSizesFromBytes(sizes []int, mt MatType, data []byte) (Mat, error)

+ func NewMatWithSizesWithScalar(sizes []int, mt MatType, s Scalar) Mat

+ func Ones(rows int, cols int, mt MatType) Mat

+ func Split(src Mat) (mv []Mat)

+ func Zeros(rows int, cols int, mt MatType) Mat

+ func (m *Mat) AddFloat(val float32)

+ func (m *Mat) AddUChar(val uint8)

+ func (m *Mat) Channels() int

+ func (m *Mat) Clone() Mat

+ func (m *Mat) Close() error

+ func (m *Mat) ColRange(start, end int) Mat

+ func (m *Mat) Cols() int

+ func (m *Mat) ConvertFp16() Mat

+ func (m *Mat) ConvertTo(dst *Mat, mt MatType)

+ func (m *Mat) ConvertToWithParams(dst *Mat, mt MatType, alpha, beta float32)

+ func (m *Mat) CopyTo(dst *Mat)

+ func (m *Mat) CopyToWithMask(dst *Mat, mask Mat)

+ func (m *Mat) DataPtrFloat32() ([]float32, error)

+ func (m *Mat) DataPtrFloat64() ([]float64, error)

+ func (m *Mat) DataPtrInt16() ([]int16, error)

+ func (m *Mat) DataPtrInt8() ([]int8, error)

+ func (m *Mat) DataPtrUint16() ([]uint16, error)

+ func (m *Mat) DataPtrUint8() ([]uint8, error)

+ func (m *Mat) DivideFloat(val float32)

+ func (m *Mat) DivideUChar(val uint8)

+ func (m *Mat) ElemSize() int

+ func (m *Mat) Empty() bool

+ func (m *Mat) FromPtr(rows int, cols int, mt MatType, prow int, pcol int) (Mat, error)

+ func (m *Mat) GetDoubleAt(row int, col int) float64

+ func (m *Mat) GetDoubleAt3(x, y, z int) float64

+ func (m *Mat) GetFloatAt(row int, col int) float32

+ func (m *Mat) GetFloatAt3(x, y, z int) float32

+ func (m *Mat) GetIntAt(row int, col int) int32

+ func (m *Mat) GetIntAt3(x, y, z int) int32

+ func (m *Mat) GetSCharAt(row int, col int) int8

+ func (m *Mat) GetSCharAt3(x, y, z int) int8

+ func (m *Mat) GetShortAt(row int, col int) int16

+ func (m *Mat) GetShortAt3(x, y, z int) int16

+ func (m *Mat) GetUCharAt(row int, col int) uint8

+ func (m *Mat) GetUCharAt3(x, y, z int) uint8

+ func (m *Mat) GetVecbAt(row int, col int) Vecb

+ func (m *Mat) GetVecdAt(row int, col int) Vecd

+ func (m *Mat) GetVecfAt(row int, col int) Vecf

+ func (m *Mat) GetVeciAt(row int, col int) Veci

+ func (m *Mat) IsContinuous() bool

+ func (m *Mat) Mean() Scalar

+ func (m *Mat) MeanWithMask(mask Mat) Scalar

+ func (m *Mat) MultiplyFloat(val float32)

+ func (m *Mat) MultiplyMatrix(x Mat) Mat

+ func (m *Mat) MultiplyUChar(val uint8)

+ func (m *Mat) PatchNaNs()

+ func (m *Mat) Ptr() C.Mat

+ func (m *Mat) Region(rio image.Rectangle) Mat

+ func (m *Mat) Reshape(cn int, rows int) Mat

+ func (m *Mat) RowRange(start, end int) Mat

+ func (m *Mat) Rows() int

+ func (m *Mat) SetDoubleAt(row int, col int, val float64)

+ func (m *Mat) SetDoubleAt3(x, y, z int, val float64)

+ func (m *Mat) SetFloatAt(row int, col int, val float32)

+ func (m *Mat) SetFloatAt3(x, y, z int, val float32)

+ func (m *Mat) SetIntAt(row int, col int, val int32)

+ func (m *Mat) SetIntAt3(x, y, z int, val int32)

+ func (m *Mat) SetSCharAt(row int, col int, val int8)

+ func (m *Mat) SetSCharAt3(x, y, z int, val int8)

+ func (m *Mat) SetShortAt(row int, col int, val int16)

+ func (m *Mat) SetShortAt3(x, y, z int, val int16)

+ func (m *Mat) SetTo(s Scalar)

+ func (m *Mat) SetUCharAt(row int, col int, val uint8)

+ func (m *Mat) SetUCharAt3(x, y, z int, val uint8)

+ func (m *Mat) Size() (dims []int)

+ func (m *Mat) Sqrt() Mat

+ func (m *Mat) Step() int

+ func (m *Mat) SubtractFloat(val float32)

+ func (m *Mat) SubtractUChar(val uint8)

+ func (m *Mat) Sum() Scalar

+ func (m *Mat) T() Mat

+ func (m *Mat) ToBytes() []byte

+ func (m *Mat) ToImage() (image.Image, error)

+ func (m *Mat) ToImageYUV() (*image.YCbCr, error)

+ func (m *Mat) ToImageYUVWithParams(ratio image.YCbCrSubsampleRatio) (*image.YCbCr, error)

+ func (m *Mat) Total() int

+ func (m *Mat) Type() MatType

+ type MatType int

+ func (c MatType) String() string

+ type MergeMertens struct

+ func NewMergeMertens() MergeMertens

+ func NewMergeMertensWithParams(contrast_weight float32, saturation_weight float32, exposure_weight float32) MergeMertens

+ func (b *MergeMertens) Close() error

+ func (b *MergeMertens) Process(src []Mat, dst *Mat)

+ type MorphShape int

+ const MorphCross

+ const MorphEllipse

+ const MorphRect

+ func (c MorphShape) String() string

+ type MorphType int

+ const MorphBlackhat

+ const MorphClose

+ const MorphDilate

+ const MorphErode

+ const MorphGradient

+ const MorphHitmiss

+ const MorphOpen

+ const MorphTophat

+ func (c MorphType) String() string

+ type NativeByteBuffer struct

+ func IMEncode(fileExt FileExt, img Mat) (buf *NativeByteBuffer, err error)

+ func IMEncodeWithParams(fileExt FileExt, img Mat, params []int) (buf *NativeByteBuffer, err error)

+ func (buffer *NativeByteBuffer) Close()

+ func (buffer *NativeByteBuffer) GetBytes() []byte

+ func (buffer *NativeByteBuffer) Len() int

+ type Net struct

+ func ReadNet(model string, config string) Net

+ func ReadNetBytes(framework string, model []byte, config []byte) (Net, error)

+ func ReadNetFromCaffe(prototxt string, caffeModel string) Net

+ func ReadNetFromCaffeBytes(prototxt []byte, caffeModel []byte) (Net, error)

+ func ReadNetFromONNX(model string) Net

+ func ReadNetFromONNXBytes(model []byte) (Net, error)

+ func ReadNetFromTensorflow(model string) Net

+ func ReadNetFromTensorflowBytes(model []byte) (Net, error)

+ func ReadNetFromTorch(model string) Net

+ func (net *Net) Close() error

+ func (net *Net) Empty() bool

+ func (net *Net) Forward(outputName string) Mat

+ func (net *Net) ForwardLayers(outBlobNames []string) (blobs []Mat)

+ func (net *Net) GetLayer(layer int) Layer

+ func (net *Net) GetLayerNames() (names []string)

+ func (net *Net) GetPerfProfile() float64

+ func (net *Net) GetUnconnectedOutLayers() (ids []int)

+ func (net *Net) SetInput(blob Mat, name string)

+ func (net *Net) SetPreferableBackend(backend NetBackendType) error

+ func (net *Net) SetPreferableTarget(target NetTargetType) error

+ type NetBackendType int

+ const NetBackendCUDA

+ const NetBackendDefault

+ const NetBackendHalide

+ const NetBackendOpenCV

+ const NetBackendOpenVINO

+ const NetBackendVKCOM

+ func ParseNetBackend(backend string) NetBackendType

+ func (c NetBackendType) String() string

+ type NetTargetType int

+ const NetTargetCPU

+ const NetTargetCUDA

+ const NetTargetCUDAFP16

+ const NetTargetFP16

+ const NetTargetFP32

+ const NetTargetFPGA

+ const NetTargetVPU

+ const NetTargetVulkan

+ func ParseNetTarget(target string) NetTargetType

+ func (c NetTargetType) String() string

+ type NormType int

+ const NormHamming

+ const NormHamming2

+ const NormInf

+ const NormL1

+ const NormL2

+ const NormL2Sqr

+ const NormMinMax

+ const NormRelative

+ const NormTypeMask

+ func (c NormType) String() string

+ type ORB struct

+ func NewORB() ORB

+ func NewORBWithParams(nFeatures int, scaleFactor float32, nLevels int, edgeThreshold int, ...) ORB

+ func (o *ORB) Close() error

+ func (o *ORB) Detect(src Mat) []KeyPoint

+ func (o *ORB) DetectAndCompute(src Mat, mask Mat) ([]KeyPoint, Mat)

+ type ORBScoreType int

+ const ORBScoreTypeFAST

+ const ORBScoreTypeHarris

+ type Point2f struct

+ X float32

+ Y float32

+ func NewPoint2f(x, y float32) Point2f

+ func PhaseCorrelate(src1, src2, window Mat) (phaseShift Point2f, response float64)

+ type Point2fVector struct

+ func NewPoint2fVector() Point2fVector

+ func NewPoint2fVectorFromMat(mat Mat) Point2fVector

+ func NewPoint2fVectorFromPoints(pts []Point2f) Point2fVector

+ func (pfv Point2fVector) At(idx int) Point2f

+ func (pfv Point2fVector) Close()

+ func (pfv Point2fVector) IsNil() bool

+ func (pfv Point2fVector) Size() int

+ func (pfv Point2fVector) ToPoints() []Point2f

+ type Point3f struct

+ X float32

+ Y float32

+ Z float32

+ func NewPoint3f(x, y, z float32) Point3f

+ type Point3fVector struct

+ func NewPoint3fVector() Point3fVector

+ func NewPoint3fVectorFromMat(mat Mat) Point3fVector

+ func NewPoint3fVectorFromPoints(pts []Point3f) Point3fVector

+ func (pfv Point3fVector) Append(point Point3f)

+ func (pfv Point3fVector) At(idx int) Point3f

+ func (pfv Point3fVector) Close()

+ func (pfv Point3fVector) IsNil() bool

+ func (pfv Point3fVector) Size() int

+ func (pfv Point3fVector) ToPoints() []Point3f

+ type PointVector struct

+ func ApproxPolyDP(curve PointVector, epsilon float64, closed bool) PointVector

+ func NewPointVector() PointVector

+ func NewPointVectorFromMat(mat Mat) PointVector

+ func NewPointVectorFromPoints(pts []image.Point) PointVector

+ func (pv PointVector) Append(point image.Point)

+ func (pv PointVector) At(idx int) image.Point

+ func (pv PointVector) Close()

+ func (pv PointVector) IsNil() bool

+ func (pv PointVector) Size() int

+ func (pv PointVector) ToPoints() []image.Point

+ type Points2fVector struct

+ func NewPoints2fVector() Points2fVector

+ func NewPoints2fVectorFromPoints(pts [][]Point2f) Points2fVector

+ func (pvs Points2fVector) Append(pv Point2fVector)

+ func (pvs Points2fVector) At(idx int) Point2fVector

+ func (pvs Points2fVector) Close()

+ func (pvs Points2fVector) IsNil() bool

+ func (pvs Points2fVector) P() C.Points2fVector

+ func (pvs Points2fVector) Size() int

+ func (pvs Points2fVector) ToPoints() [][]Point2f

+ type Points3fVector struct

+ func NewPoints3fVector() Points3fVector

+ func NewPoints3fVectorFromPoints(pts [][]Point3f) Points3fVector

+ func (pvs Points3fVector) Append(pv Point3fVector)

+ func (pvs Points3fVector) At(idx int) Point3fVector

+ func (pvs Points3fVector) Close()

+ func (pvs Points3fVector) IsNil() bool

+ func (pvs Points3fVector) Size() int

+ func (pvs Points3fVector) ToPoints() [][]Point3f

+ type PointsVector struct

+ func FindContours(src Mat, mode RetrievalMode, method ContourApproximationMode) PointsVector

+ func FindContoursWithParams(src Mat, hierarchy *Mat, mode RetrievalMode, method ContourApproximationMode) PointsVector

+ func NewPointsVector() PointsVector

+ func NewPointsVectorFromPoints(pts [][]image.Point) PointsVector

+ func (pvs PointsVector) Append(pv PointVector)

+ func (pvs PointsVector) At(idx int) PointVector

+ func (pvs PointsVector) Close()

+ func (pvs PointsVector) IsNil() bool

+ func (pvs PointsVector) P() C.PointsVector

+ func (pvs PointsVector) Size() int

+ func (pvs PointsVector) ToPoints() [][]image.Point

+ type QRCodeDetector struct

+ func NewQRCodeDetector() QRCodeDetector

+ func (a *QRCodeDetector) Close() error

+ func (a *QRCodeDetector) Decode(input Mat, points Mat, straight_qrcode *Mat) string

+ func (a *QRCodeDetector) Detect(input Mat, points *Mat) bool

+ func (a *QRCodeDetector) DetectAndDecode(input Mat, points *Mat, straight_qrcode *Mat) string

+ func (a *QRCodeDetector) DetectAndDecodeMulti(input Mat, decoded *[]string, points *Mat, qrCodes *[]Mat) bool

+ func (a *QRCodeDetector) DetectMulti(input Mat, points *Mat) bool

+ type RNG struct

+ func TheRNG() RNG

+ func (r *RNG) Fill(mat *Mat, distType RNGDistType, a, b float64, saturateRange bool)

+ func (r *RNG) Gaussian(sigma float64) float64

+ func (r *RNG) Next() uint

+ type RNGDistType int

+ const RNGDistNormal

+ const RNGDistUniform

+ type ReduceTypes int

+ const ReduceAvg

+ const ReduceMax

+ const ReduceMin

+ const ReduceSum

+ func (c ReduceTypes) String() string

+ type RetrievalMode int

+ const RetrievalCComp

+ const RetrievalExternal

+ const RetrievalFloodfill

+ const RetrievalList

+ const RetrievalTree

+ func (c RetrievalMode) String() string

+ type RotateFlag int

+ const Rotate180Clockwise

+ const Rotate90Clockwise

+ const Rotate90CounterClockwise

+ func (c RotateFlag) String() string

+ type RotatedRect struct

+ Angle float64

+ BoundingRect image.Rectangle

+ Center image.Point

+ Height int

+ Points []image.Point

+ Width int

+ func FitEllipse(pts PointVector) RotatedRect

+ func MinAreaRect(points PointVector) RotatedRect

+ type RotatedRect2f struct

+ Angle float64

+ BoundingRect image.Rectangle

+ Center image.Point

+ Height float32

+ Points []Point2f

+ Width float32

+ func MinAreaRect2f(points PointVector) RotatedRect2f

+ type SIFT struct

+ func NewSIFT() SIFT

+ func (d *SIFT) Close() error

+ func (d *SIFT) Detect(src Mat) []KeyPoint

+ func (d *SIFT) DetectAndCompute(src Mat, mask Mat) ([]KeyPoint, Mat)

+ type Scalar struct

+ Val1 float64

+ Val2 float64

+ Val3 float64

+ Val4 float64

+ func GetBlobSize(blob Mat) Scalar

+ func MorphologyDefaultBorderValue() Scalar

+ func NewScalar(v1 float64, v2 float64, v3 float64, v4 float64) Scalar

+ func Trace(src Mat) Scalar

+ type SeamlessCloneFlags int

+ const MixedClone

+ const MonochromeTransfer

+ const NormalClone

+ func (c SeamlessCloneFlags) String() string

+ type ShapeMatchModes int

+ const ContoursMatchI1

+ const ContoursMatchI2

+ const ContoursMatchI3

+ type SimpleBlobDetector struct

+ func NewSimpleBlobDetector() SimpleBlobDetector

+ func NewSimpleBlobDetectorWithParams(params SimpleBlobDetectorParams) SimpleBlobDetector

+ func (b *SimpleBlobDetector) Close() error

+ func (b *SimpleBlobDetector) Detect(src Mat) []KeyPoint

+ type SimpleBlobDetectorParams struct

+ func NewSimpleBlobDetectorParams() SimpleBlobDetectorParams

+ func (p *SimpleBlobDetectorParams) GetBlobColor() int

+ func (p *SimpleBlobDetectorParams) GetFilterByArea() bool

+ func (p *SimpleBlobDetectorParams) GetFilterByCircularity() bool

+ func (p *SimpleBlobDetectorParams) GetFilterByColor() bool

+ func (p *SimpleBlobDetectorParams) GetFilterByConvexity() bool

+ func (p *SimpleBlobDetectorParams) GetFilterByInertia() bool

+ func (p *SimpleBlobDetectorParams) GetMaxArea() float64

+ func (p *SimpleBlobDetectorParams) GetMaxCircularity() float64

+ func (p *SimpleBlobDetectorParams) GetMaxConvexity() float64

+ func (p *SimpleBlobDetectorParams) GetMaxInertiaRatio() float64

+ func (p *SimpleBlobDetectorParams) GetMaxThreshold() float64

+ func (p *SimpleBlobDetectorParams) GetMinArea() float64

+ func (p *SimpleBlobDetectorParams) GetMinCircularity() float64

+ func (p *SimpleBlobDetectorParams) GetMinConvexity() float64

+ func (p *SimpleBlobDetectorParams) GetMinDistBetweenBlobs() float64

+ func (p *SimpleBlobDetectorParams) GetMinInertiaRatio() float64

+ func (p *SimpleBlobDetectorParams) GetMinRepeatability() int

+ func (p *SimpleBlobDetectorParams) GetMinThreshold() float64

+ func (p *SimpleBlobDetectorParams) GetThresholdStep() float64

+ func (p *SimpleBlobDetectorParams) SetBlobColor(blobColor int)

+ func (p *SimpleBlobDetectorParams) SetFilterByArea(filterByArea bool)

+ func (p *SimpleBlobDetectorParams) SetFilterByCircularity(filterByCircularity bool)

+ func (p *SimpleBlobDetectorParams) SetFilterByColor(filterByColor bool)

+ func (p *SimpleBlobDetectorParams) SetFilterByConvexity(filterByConvexity bool)

+ func (p *SimpleBlobDetectorParams) SetFilterByInertia(filterByInertia bool)

+ func (p *SimpleBlobDetectorParams) SetMaxArea(maxArea float64)

+ func (p *SimpleBlobDetectorParams) SetMaxCircularity(maxCircularity float64)

+ func (p *SimpleBlobDetectorParams) SetMaxConvexity(maxConvexity float64)

+ func (p *SimpleBlobDetectorParams) SetMaxInertiaRatio(maxInertiaRatio float64)

+ func (p *SimpleBlobDetectorParams) SetMaxThreshold(maxThreshold float64)

+ func (p *SimpleBlobDetectorParams) SetMinArea(minArea float64)

+ func (p *SimpleBlobDetectorParams) SetMinCircularity(minCircularity float64)

+ func (p *SimpleBlobDetectorParams) SetMinConvexity(minConvexity float64)

+ func (p *SimpleBlobDetectorParams) SetMinDistBetweenBlobs(minDistBetweenBlobs float64)

+ func (p *SimpleBlobDetectorParams) SetMinInertiaRatio(minInertiaRatio float64)

+ func (p *SimpleBlobDetectorParams) SetMinRepeatability(minRepeatability int)

+ func (p *SimpleBlobDetectorParams) SetMinThreshold(minThreshold float64)

+ func (p *SimpleBlobDetectorParams) SetThresholdStep(thresholdStep float64)

+ type SolveDecompositionFlags int

+ const SolveDecompositionCholesky

+ const SolveDecompositionEing

+ const SolveDecompositionLu

+ const SolveDecompositionNormal

+ const SolveDecompositionQr

+ const SolveDecompositionSvd

+ func (c SolveDecompositionFlags) String() string

+ type SortFlags int

+ const SortAscending

+ const SortDescending

+ const SortEveryColumn

+ const SortEveryRow

+ func (c SortFlags) String() string

+ type TemplateMatchMode int

+ const TmCcoeff

+ const TmCcoeffNormed

+ const TmCcorr

+ const TmCcorrNormed

+ const TmSqdiff

+ const TmSqdiffNormed

+ func (c TemplateMatchMode) String() string

+ type TermCriteria struct

+ func NewTermCriteria(typ TermCriteriaType, maxCount int, epsilon float64) TermCriteria

+ type TermCriteriaType int

+ const Count

+ const EPS

+ const MaxIter

+ func (c TermCriteriaType) String() string

+ type ThresholdType int

+ const ThresholdBinary

+ const ThresholdBinaryInv

+ const ThresholdMask

+ const ThresholdOtsu

+ const ThresholdToZero

+ const ThresholdToZeroInv

+ const ThresholdTriangle

+ const ThresholdTrunc

+ func (c ThresholdType) String() string

+ type Trackbar struct

+ func (t *Trackbar) GetPos() int

+ func (t *Trackbar) SetMax(pos int)

+ func (t *Trackbar) SetMin(pos int)

+ func (t *Trackbar) SetPos(pos int)

+ type Tracker interface

+ Close func() error

+ Init func(image Mat, boundingBox image.Rectangle) bool

+ Update func(image Mat) (image.Rectangle, bool)

+ func NewTrackerMIL() Tracker

+ type TrackerMIL struct

+ func (trk TrackerMIL) Close() error

+ func (trk TrackerMIL) Init(img Mat, boundingBox image.Rectangle) bool

+ func (trk TrackerMIL) Update(img Mat) (image.Rectangle, bool)

+ type Vecb []uint8

+ type Vecd []float64

+ type Vecf []float32

+ type Veci []int32

+ type VideoCapture struct

+ func OpenVideoCapture(v interface{}) (*VideoCapture, error)

+ func OpenVideoCaptureWithAPI(v interface{}, apiPreference VideoCaptureAPI) (*VideoCapture, error)

+ func VideoCaptureDevice(device int) (vc *VideoCapture, err error)

+ func VideoCaptureDeviceWithAPI(device int, apiPreference VideoCaptureAPI) (vc *VideoCapture, err error)

+ func VideoCaptureFile(uri string) (vc *VideoCapture, err error)

+ func VideoCaptureFileWithAPI(uri string, apiPreference VideoCaptureAPI) (vc *VideoCapture, err error)

+ func (v *VideoCapture) Close() error

+ func (v *VideoCapture) CodecString() string

+ func (v *VideoCapture) Grab(skip int)

+ func (v *VideoCapture) IsOpened() bool

+ func (v *VideoCapture) Read(m *Mat) bool

+ func (v *VideoCapture) Set(prop VideoCaptureProperties, param float64)

+ func (v *VideoCapture) ToCodec(codec string) float64

+ func (v VideoCapture) Get(prop VideoCaptureProperties) float64

+ type VideoCaptureAPI int

+ const VideoCaptureAVFoundation

+ const VideoCaptureAndroid

+ const VideoCaptureAny

+ const VideoCaptureAravis

+ const VideoCaptureCMU1394

+ const VideoCaptureDC1394

+ const VideoCaptureDshow

+ const VideoCaptureFFmpeg

+ const VideoCaptureFireware

+ const VideoCaptureFirewire

+ const VideoCaptureGPhoto2

+ const VideoCaptureGiganetix

+ const VideoCaptureGstreamer

+ const VideoCaptureIEEE1394

+ const VideoCaptureImages

+ const VideoCaptureIntelMFX

+ const VideoCaptureIntelPerc

+ const VideoCaptureMSMF

+ const VideoCaptureOpenNI

+ const VideoCaptureOpenNI2

+ const VideoCaptureOpenNI2Asus

+ const VideoCaptureOpenNIAsus

+ const VideoCaptureOpencvMjpeg

+ const VideoCapturePvAPI

+ const VideoCaptureQT

+ const VideoCaptureRealsense

+ const VideoCaptureUnicap

+ const VideoCaptureV4L

+ const VideoCaptureV4L2

+ const VideoCaptureVFW

+ const VideoCaptureWinRT

+ const VideoCaptureXINE

+ const VideoCaptureXiAPI

+ func (c VideoCaptureAPI) String() string

+ type VideoCaptureProperties int

+ const VideoCaptureAutoExposure

+ const VideoCaptureAutoFocus

+ const VideoCaptureAutoWB

+ const VideoCaptureBackend

+ const VideoCaptureBacklight

+ const VideoCaptureBitrate

+ const VideoCaptureBrightness

+ const VideoCaptureBufferSize

+ const VideoCaptureChannel

+ const VideoCaptureCodecPixelFormat

+ const VideoCaptureContrast

+ const VideoCaptureConvertRGB

+ const VideoCaptureExposure

+ const VideoCaptureFOURCC

+ const VideoCaptureFPS

+ const VideoCaptureFocus

+ const VideoCaptureFormat

+ const VideoCaptureFrameCount

+ const VideoCaptureFrameHeight

+ const VideoCaptureFrameWidth

+ const VideoCaptureGUID

+ const VideoCaptureGain

+ const VideoCaptureGamma

+ const VideoCaptureHue

+ const VideoCaptureISOSpeed

+ const VideoCaptureIris

+ const VideoCaptureMode

+ const VideoCaptureMonochrome

+ const VideoCapturePan

+ const VideoCapturePosAVIRatio

+ const VideoCapturePosFrames

+ const VideoCapturePosMsec

+ const VideoCaptureRectification

+ const VideoCaptureRoll

+ const VideoCaptureSarDenominator

+ const VideoCaptureSarNumerator

+ const VideoCaptureSaturation

+ const VideoCaptureSettings

+ const VideoCaptureSharpness

+ const VideoCaptureTemperature

+ const VideoCaptureTilt

+ const VideoCaptureTrigger

+ const VideoCaptureTriggerDelay

+ const VideoCaptureWBTemperature

+ const VideoCaptureWhiteBalanceBlueU

+ const VideoCaptureWhiteBalanceRedV

+ const VideoCaptureZoom

+ func (c VideoCaptureProperties) String() string

+ type VideoWriter struct

+ func VideoWriterFile(name string, codec string, fps float64, width int, height int, isColor bool) (vw *VideoWriter, err error)

+ func (vw *VideoWriter) Close() error

+ func (vw *VideoWriter) IsOpened() bool

+ func (vw *VideoWriter) Write(img Mat) error

+ type Window struct

+ func NewWindow(name string) *Window

+ func (w *Window) Close() error

+ func (w *Window) CreateTrackbar(name string, max int) *Trackbar

+ func (w *Window) CreateTrackbarWithValue(name string, value *int, max int) *Trackbar

+ func (w *Window) GetWindowProperty(flag WindowPropertyFlag) float64

+ func (w *Window) IMShow(img Mat)

+ func (w *Window) IsOpen() bool

+ func (w *Window) MoveWindow(x, y int)

+ func (w *Window) ResizeWindow(width, height int)

+ func (w *Window) SelectROI(img Mat) image.Rectangle

+ func (w *Window) SelectROIs(img Mat) []image.Rectangle

+ func (w *Window) SetWindowProperty(flag WindowPropertyFlag, value WindowFlag)

+ func (w *Window) SetWindowTitle(title string)

+ func (w *Window) WaitKey(delay int) int

+ type WindowFlag float32

+ const WindowAutosize

+ const WindowFreeRatio

+ const WindowFullscreen

+ const WindowKeepRatio

+ const WindowNormal

+ func (c WindowFlag) String() string

+ type WindowPropertyFlag int

+ const WindowPropertyAspectRatio

+ const WindowPropertyAutosize

+ const WindowPropertyFullscreen

+ const WindowPropertyOpenGL

+ const WindowPropertyVisible

+ func (c WindowPropertyFlag) String() string